{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting Experimental Results\n",
    "\n",
    "This notebooks analyzes and plots the collected results store in the `reports` folder. The results are stored in CSV files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "palette = ['#83B8FE', '#FFA54C', '#94ED67', '#FF7FFF']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cv_train: (15, 52)\n",
      "test: (9, 34)\n",
      "hparam: (3, 7)\n",
      "majority_vote: (6, 28)\n",
      "ablation: (84, 22)\n",
      "xgboost_cv_train: (15, 24)\n",
      "xgboost_test: (9, 20)\n",
      "xgboost_hparam: (3, 7)\n",
      "xgboost_majority_vote: (3, 19)\n",
      "cellsonehot_cv_train: (15, 52)\n",
      "cellsonehot_test: (9, 34)\n",
      "cellsonehot_hparam: (3, 7)\n",
      "cellsonehot_majority_vote: (6, 28)\n",
      "cellsonehot_ablation: (84, 22)\n",
      "aminoacidcnt_cv_train: (15, 52)\n",
      "aminoacidcnt_test: (9, 34)\n",
      "aminoacidcnt_hparam: (3, 7)\n",
      "aminoacidcnt_majority_vote: (6, 28)\n",
      "aminoacidcnt_ablation: (84, 22)\n"
     ]
    }
   ],
   "source": [
    "active_col = 'Active (Dmax 0.6, pDC50 6.0)'\n",
    "test_split = 0.1\n",
    "n_models_for_test = 3\n",
    "cv_n_folds = 5\n",
    "\n",
    "active_name = active_col.replace(' ', '_').replace('(', '').replace(')', '').replace(',', '')\n",
    "report_base_name = f'{active_name}_test_split_{test_split}'\n",
    "\n",
    "# TODO: Maybe a function to get the experiment dataframes would help...\n",
    "# def get_experiment_df(experiment_name, report, splits=['random', 'uniprot', 'tanimoto']):\n",
    "#     for split in splits:\n",
    "#         df = []\n",
    "#         for report_name in ['cv', 'ablation', 'hparam', 'majority_vote']:\n",
    "#             filename = f'reports/{report_name}_report_{report_base_name}_{split}.csv'\n",
    "#             df.append(pd.read_csv(filename))\n",
    "#         report[experiment_name] = pd.concat(df)\n",
    "#     return report\n",
    "\n",
    "reports = {}\n",
    "for experiment in ['', 'xgboost_', 'cellsonehot_', 'aminoacidcnt_']:\n",
    "    reports[f'{experiment}cv_train'] = pd.concat([\n",
    "        pd.read_csv(f'reports/{experiment}cv_report_{report_base_name}_standard.csv'),\n",
    "        pd.read_csv(f'reports/{experiment}cv_report_{report_base_name}_target.csv'),\n",
    "        pd.read_csv(f'reports/{experiment}cv_report_{report_base_name}_similarity.csv'),\n",
    "    ])\n",
    "    reports[f'{experiment}test'] = pd.concat([\n",
    "        pd.read_csv(f'reports/{experiment}test_report_{report_base_name}_standard.csv'),\n",
    "        pd.read_csv(f'reports/{experiment}test_report_{report_base_name}_target.csv'),\n",
    "        pd.read_csv(f'reports/{experiment}test_report_{report_base_name}_similarity.csv'),\n",
    "    ])\n",
    "    reports[f'{experiment}hparam'] = pd.concat([\n",
    "        pd.read_csv(f'reports/{experiment}hparam_report_{report_base_name}_standard.csv'),\n",
    "        pd.read_csv(f'reports/{experiment}hparam_report_{report_base_name}_target.csv'),\n",
    "        pd.read_csv(f'reports/{experiment}hparam_report_{report_base_name}_similarity.csv'),\n",
    "    ])\n",
    "    reports[f'{experiment}majority_vote'] = pd.concat([\n",
    "        pd.read_csv(f'reports/{experiment}majority_vote_report_{report_base_name}_standard.csv'),\n",
    "        pd.read_csv(f'reports/{experiment}majority_vote_report_{report_base_name}_target.csv'),\n",
    "        pd.read_csv(f'reports/{experiment}majority_vote_report_{report_base_name}_similarity.csv'),\n",
    "    ])\n",
    "    if experiment != 'xgboost_':\n",
    "        reports[f'{experiment}ablation'] = pd.concat([\n",
    "            pd.read_csv(f'reports/{experiment}ablation_report_{report_base_name}_standard.csv'),\n",
    "            pd.read_csv(f'reports/{experiment}ablation_report_{report_base_name}_target.csv'),\n",
    "            pd.read_csv(f'reports/{experiment}ablation_report_{report_base_name}_similarity.csv'),\n",
    "        ])\n",
    "\n",
    "for k, report in reports.items():\n",
    "    print(f'{k}: {report.shape}')\n",
    "    # display(report.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- # # Load the data\n",
    "# reports = {\n",
    "#     'cv_train': pd.concat([\n",
    "#         pd.read_csv(f'reports/cv_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/cv_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/cv_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "#     'test': pd.concat([\n",
    "#         pd.read_csv(f'reports/test_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/test_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/test_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "#     'ablation': pd.concat([\n",
    "#         pd.read_csv(f'reports/ablation_zero_vectors_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/ablation_zero_vectors_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/ablation_zero_vectors_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "#     'hparam': pd.concat([\n",
    "#         pd.read_csv(f'reports/hparam_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/hparam_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/hparam_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "#     'majority_vote': pd.concat([\n",
    "#         pd.read_csv(f'reports/majority_vote_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/majority_vote_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/majority_vote_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "#     'xgboost_cv_train': pd.concat([\n",
    "#         pd.read_csv(f'reports/xgboost_cv_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/xgboost_cv_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/xgboost_cv_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "#     'xgboost_test': pd.concat([\n",
    "#         pd.read_csv(f'reports/xgboost_test_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/xgboost_test_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/xgboost_test_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "#     'xgboost_hparam': pd.concat([\n",
    "#         pd.read_csv(f'reports/xgboost_hparam_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/xgboost_hparam_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/xgboost_hparam_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "#     'xgboost_majority_vote': pd.concat([\n",
    "#         pd.read_csv(f'reports/xgboost_majority_vote_report_{report_base_name}_random.csv'),\n",
    "#         pd.read_csv(f'reports/xgboost_majority_vote_report_{report_base_name}_uniprot.csv'),\n",
    "#         pd.read_csv(f'reports/xgboost_majority_vote_report_{report_base_name}_tanimoto.csv'),\n",
    "#     ]),\n",
    "# } -->\n",
    "(Legacy code here as comment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print CV Folds Parameters\n",
    "\n",
    "Print the dataset characteristics for each fold set per experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{rlrrrllllll}\n",
      "\\toprule\n",
      " \\textbf{Fold} & \\textbf{Study split} &  \\textbf{Train size} &  \\textbf{Val size} &  \\textbf{Test size} & \\textbf{Train active \\%} & \\textbf{Val active \\%} & \\textbf{Test active \\%} & \\textbf{Leaking Uniprot \\%} & \\textbf{Leaking SMILES \\%} & \\textbf{Avg Tanimoto distance} \\\\\n",
      "\\midrule\n",
      "             0 &             standard &                  560 &                140 &                  78 &                   49.6\\% &                 50.0\\% &                  55.1\\% &                      79.1\\% &                      8.8\\% &                          0.379 \\\\\n",
      "             1 &             standard &                  560 &                140 &                  78 &                   49.6\\% &                 50.0\\% &                  55.1\\% &                      80.0\\% &                      8.4\\% &                          0.379 \\\\\n",
      "             2 &             standard &                  560 &                140 &                  78 &                   49.6\\% &                 50.0\\% &                  55.1\\% &                      80.2\\% &                      9.3\\% &                          0.379 \\\\\n",
      "             3 &             standard &                  560 &                140 &                  78 &                   49.8\\% &                 49.3\\% &                  55.1\\% &                      79.3\\% &                      8.6\\% &                          0.379 \\\\\n",
      "             4 &             standard &                  560 &                140 &                  78 &                   49.8\\% &                 49.3\\% &                  55.1\\% &                      79.3\\% &                      7.1\\% &                          0.379 \\\\\n",
      "             0 &               target &                  594 &                108 &                  76 &                   51.3\\% &                 41.7\\% &                  53.9\\% &                       0.0\\% &                      1.0\\% &                          0.390 \\\\\n",
      "             1 &               target &                  559 &                143 &                  76 &                   47.2\\% &                 60.1\\% &                  53.9\\% &                       0.0\\% &                      0.9\\% &                          0.390 \\\\\n",
      "             2 &               target &                  556 &                146 &                  76 &                   46.8\\% &                 61.6\\% &                  53.9\\% &                       0.0\\% &                      1.4\\% &                          0.390 \\\\\n",
      "             3 &               target &                  592 &                110 &                  76 &                   50.3\\% &                 47.3\\% &                  53.9\\% &                       0.0\\% &                      1.2\\% &                          0.390 \\\\\n",
      "             4 &               target &                  507 &                195 &                  76 &                   53.8\\% &                 39.5\\% &                  53.9\\% &                       0.0\\% &                      1.2\\% &                          0.390 \\\\\n",
      "             0 &           similarity &                  601 &                100 &                  77 &                   48.8\\% &                 57.0\\% &                  53.2\\% &                      51.1\\% &                      0.0\\% &                          0.407 \\\\\n",
      "             1 &           similarity &                  568 &                133 &                  77 &                   50.9\\% &                 45.9\\% &                  53.2\\% &                      53.5\\% &                      0.0\\% &                          0.407 \\\\\n",
      "             2 &           similarity &                  572 &                129 &                  77 &                   49.5\\% &                 51.9\\% &                  53.2\\% &                      51.0\\% &                      0.0\\% &                          0.407 \\\\\n",
      "             3 &           similarity &                  563 &                138 &                  77 &                   50.4\\% &                 47.8\\% &                  53.2\\% &                      54.0\\% &                      0.0\\% &                          0.407 \\\\\n",
      "             4 &           similarity &                  500 &                201 &                  77 &                   50.2\\% &                 49.3\\% &                  53.2\\% &                      50.6\\% &                      0.0\\% &                          0.407 \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2599982738.py:35: FutureWarning: In future versions `DataFrame.to_latex` is expected to utilise the base implementation of `Styler.to_latex` for formatting and rendering. The arguments signature may therefore change. It is recommended instead to use `DataFrame.style.to_latex` which also contains additional functionality.\n",
      "  print(tmp.to_latex(index=False, escape=False))\n"
     ]
    },
    {
     "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>train_active_perc</th>\n",
       "      <th>val_active_perc</th>\n",
       "      <th>test_active_perc</th>\n",
       "      <th>perc_leaking_uniprot_train_test</th>\n",
       "      <th>perc_leaking_smiles_train_test</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>split_type</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>similarity</th>\n",
       "      <td>49.950387</td>\n",
       "      <td>50.376493</td>\n",
       "      <td>53.246753</td>\n",
       "      <td>52.049611</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>standard</th>\n",
       "      <td>49.714286</td>\n",
       "      <td>49.714286</td>\n",
       "      <td>55.128205</td>\n",
       "      <td>79.571429</td>\n",
       "      <td>8.428571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>target</th>\n",
       "      <td>49.904115</td>\n",
       "      <td>50.042054</td>\n",
       "      <td>53.947368</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.141854</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            train_active_perc  val_active_perc  test_active_perc  \\\n",
       "split_type                                                         \n",
       "similarity          49.950387        50.376493         53.246753   \n",
       "standard            49.714286        49.714286         55.128205   \n",
       "target              49.904115        50.042054         53.947368   \n",
       "\n",
       "            perc_leaking_uniprot_train_test  perc_leaking_smiles_train_test  \n",
       "split_type                                                                   \n",
       "similarity                        52.049611                        0.000000  \n",
       "standard                          79.571429                        8.428571  \n",
       "target                             0.000000                        1.141854  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cols_to_show = {\n",
    "    'fold': 'Fold',\n",
    "    'split_type': 'Study split',\n",
    "    'train_len': 'Train size',\n",
    "    'val_len': 'Val size',\n",
    "    'test_len': 'Test size',\n",
    "    'train_active_perc': 'Train active %',\n",
    "    'val_active_perc': 'Val active %',\n",
    "    'test_active_perc': 'Test active %',\n",
    "    # 'train_unique_groups': '',\n",
    "    # 'val_unique_groups': '',\n",
    "    'perc_leaking_uniprot_train_test': 'Leaking Uniprot %',\n",
    "    'perc_leaking_smiles_train_test': 'Leaking SMILES %',\n",
    "    'test_avg_tanimoto_dist': 'Avg Tanimoto distance',\n",
    "}\n",
    "# print(reports['cv_train'][cols_to_show].to_markdown(index=False))\n",
    "# Print a subset of columns (that contain the string \"perc_\") as percentages in format: .1%\n",
    "tmp = reports['cv_train'][list(cols_to_show.keys())].copy()\n",
    "for col in tmp.columns:\n",
    "    if 'perc' in col:\n",
    "        tmp[col] = tmp[col].apply(lambda x: f'{x*100:.1f}\\\\%')\n",
    "    if 'dist' in col:\n",
    "        tmp[col] = tmp[col].apply(lambda x: f'{x:.3f}')\n",
    "# Rename columns\n",
    "tmp.rename(columns=cols_to_show, inplace=True)\n",
    "# Rename studies\n",
    "tmp['Study split'] = tmp['Study split'].replace({\n",
    "    'random': 'Standard',\n",
    "    'uniprot': 'Target',\n",
    "    'tanimoto': 'Similarity',\n",
    "})\n",
    "tmp = tmp[list(cols_to_show.values())]\n",
    "tmp.columns = [f\"\\\\textbf{{{col}}}\".replace('%', '\\\\%') for col in tmp.columns]\n",
    "# Print to LaTeX\n",
    "print(tmp.to_latex(index=False, escape=False))\n",
    "\n",
    "# Print the average active % for each study split (for train val and test sets)\n",
    "tmp = reports['cv_train'].groupby(['split_type'])[['train_active_perc', 'val_active_perc', 'test_active_perc', 'perc_leaking_uniprot_train_test', 'perc_leaking_smiles_train_test']].mean()\n",
    "tmp = tmp * 100\n",
    "tmp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot (Raw) Datasets Information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PROTAC-DB: (5388, 89)\n",
      "PROTAC-Pedia: (1203, 43)\n"
     ]
    }
   ],
   "source": [
    "data_dir = 'data'\n",
    "\n",
    "protac_db_df = pd.read_csv(os.path.join(data_dir, 'PROTAC-DB.csv'))\n",
    "protac_pedia_df = pd.read_csv(os.path.join(data_dir, 'PROTAC-Pedia.csv'))\n",
    "print(f'PROTAC-DB: {protac_db_df.shape}')\n",
    "print(f'PROTAC-Pedia: {protac_pedia_df.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['PROTACDB ID', 'PROTAC SMILES', 'Active/Inactive', 'Best PROTAC',\n",
       "       'Cells', 'cLogP', 'Comments', 'Curator', 'Dc50', 'Dmax',\n",
       "       'E3 Binder SMILES', 'E3 Ligase', 'Ec50 of Ligand Cells',\n",
       "       'Ec50 of PROTAC Cells', 'exit_vector', 'Hbond acceptors',\n",
       "       'Hbond donors', 'Ic50 of Ligand', 'Ic50 of PROTAC', 'Ligand Name',\n",
       "       'Ligand SMILES', 'Linker', 'Linker Type', 'linker_ha', 'linker_no',\n",
       "       'linker_rb', 'MW', 'Off Targets Reported', 'PATENT', 'Ligand PDB',\n",
       "       'Ligand ID', 'Pubmed', 'PROTAC Name', 'Proteomics Data Available',\n",
       "       'Secondary Pubmed', 'Status', 'Target',\n",
       "       'Tested A Non Binding E3 Control', 'Tested Competition With Ligand',\n",
       "       'Tested Engagement In Cells', 'Tested Proteaseome Inhibitor', 'Time',\n",
       "       'TPSA'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "protac_pedia_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c3256f8bf45e46b3b22e86a2cd329f98",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "PROTAC-DB:   0%|          | 0/5388 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f3ce4a6e83274c32918790a30b6f6061",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "PROTAC-Pedia:   0%|          | 0/1203 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Canonize SMILES column in both datasets\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import AllChem\n",
    "# Import tqdm for jupyter\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "def canonize_smiles(smiles):\n",
    "    mol = Chem.MolFromSmiles(smiles)\n",
    "    if mol is None:\n",
    "        return None\n",
    "    return Chem.MolToSmiles(mol)\n",
    "\n",
    "tqdm.pandas(desc='PROTAC-DB')\n",
    "protac_db_df['Smiles'] = protac_db_df['Smiles'].progress_apply(canonize_smiles)\n",
    "tqdm.pandas(desc='PROTAC-Pedia')\n",
    "protac_pedia_df['PROTAC SMILES'] = protac_pedia_df['PROTAC SMILES'].progress_apply(canonize_smiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PROTAC-DB unique SMILES: 3270\n",
      "PROTAC-Pedia unique SMILES: 1178\n",
      "PROTAC-DB unique targets: 323\n",
      "PROTAC-Pedia unique targets: 79\n",
      "PROTAC-DB single SMILES: 2451 (45.5%)\n",
      "PROTAC-Pedia single SMILES: 1153 (95.8%)\n",
      "PROTAC-DB single targets: 78 (1.4%)\n",
      "PROTAC-Pedia single targets: 15 (1.2%)\n",
      "Shared SMILES: 807 (24.7%) of PROTAC-DB, (68.5%) of PROTAC-Pedia\n",
      "Shared targets: 0 (0.0%) of PROTAC-DB, (0.0%) of PROTAC-Pedia\n",
      "\\begin{tabular}{lrrrrlrlrl}\n",
      "\\toprule\n",
      "\\textbf{Dataset} &  \\textbf{Length} &  \\textbf{Unique SMILES} &  \\textbf{Unique Targets} &  \\textbf{Shared SMILES} & \\textbf{Shared SMILES \\%} &  \\textbf{Single SMILES} & \\textbf{Single SMILES \\%} &  \\textbf{Single Targets} & \\textbf{Single Targets \\%} \\\\\n",
      "\\midrule\n",
      "       PROTAC-DB &             5388 &                    3270 &                      323 &                    1222 &                    22.7\\% &                    2451 &                    45.5\\% &                       78 &                      1.4\\% \\\\\n",
      "    PROTAC-Pedia &             1203 &                    1178 &                       79 &                     832 &                    69.2\\% &                    1153 &                    95.8\\% &                       15 &                      1.2\\% \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/285611913.py:62: FutureWarning: In future versions `DataFrame.to_latex` is expected to utilise the base implementation of `Styler.to_latex` for formatting and rendering. The arguments signature may therefore change. It is recommended instead to use `DataFrame.style.to_latex` which also contains additional functionality.\n",
      "  print(shared_stats.to_latex(index=False, escape=False))\n"
     ]
    }
   ],
   "source": [
    "# Count the number of unique SMILES in both datasets (and as percentage)\n",
    "protac_db_unique_smiles = protac_db_df['Smiles'].nunique()\n",
    "protac_pedia_unique_smiles = protac_pedia_df['PROTAC SMILES'].nunique()\n",
    "print(f'PROTAC-DB unique SMILES: {protac_db_unique_smiles}')\n",
    "print(f'PROTAC-Pedia unique SMILES: {protac_pedia_unique_smiles}')\n",
    "\n",
    "# Count the number of unique targets in both datasets (and as a percentage)\n",
    "protac_db_unique_targets = protac_db_df['Target'].nunique()\n",
    "protac_pedia_unique_targets = protac_pedia_df['Target'].nunique()\n",
    "print(f'PROTAC-DB unique targets: {protac_db_unique_targets}')\n",
    "print(f'PROTAC-Pedia unique targets: {protac_pedia_unique_targets}')\n",
    "\n",
    "# Count the number of entries in both datasets with a SMILES that appears only once (and show the percentage compare to the total)\n",
    "protac_db_single_smiles = protac_db_df['Smiles'].value_counts().value_counts().get(1, 0)\n",
    "protac_pedia_single_smiles = protac_pedia_df['PROTAC SMILES'].value_counts().value_counts().get(1, 0)\n",
    "print(f'PROTAC-DB single SMILES: {protac_db_single_smiles} ({protac_db_single_smiles / protac_db_df.shape[0]:.1%})')\n",
    "print(f'PROTAC-Pedia single SMILES: {protac_pedia_single_smiles} ({protac_pedia_single_smiles / protac_pedia_df.shape[0]:.1%})')\n",
    "\n",
    "# Count the number of entries in both datasets with a target that appears only once (and show the percentage compare to the total)\n",
    "protac_db_single_targets = protac_db_df['Target'].value_counts().value_counts().get(1, 0)\n",
    "protac_pedia_single_targets = protac_pedia_df['Target'].value_counts().value_counts().get(1, 0)\n",
    "print(f'PROTAC-DB single targets: {protac_db_single_targets} ({protac_db_single_targets / protac_db_df.shape[0]:.1%})')\n",
    "print(f'PROTAC-Pedia single targets: {protac_pedia_single_targets} ({protac_pedia_single_targets / protac_pedia_df.shape[0]:.1%})')\n",
    "\n",
    "# Count the number of shared SMILES between the two datasets\n",
    "protac_db_unique_smiles = set(protac_db_df['Smiles'].unique())\n",
    "protac_pedia_unique_smiles = set(protac_pedia_df['PROTAC SMILES'].unique())\n",
    "shared_smiles = protac_db_unique_smiles.intersection(protac_pedia_unique_smiles)\n",
    "print(f'Shared SMILES: {len(shared_smiles)} ({len(shared_smiles) / len(protac_db_unique_smiles):.1%}) of PROTAC-DB, ({len(shared_smiles) / len(protac_pedia_unique_smiles):.1%}) of PROTAC-Pedia')\n",
    "\n",
    "# Count the number of shared targets between the two datasets\n",
    "protac_db_unique_targets = set(protac_db_df['Target'].unique())\n",
    "protac_pedia_unique_targets = set(protac_pedia_df['Target'].unique())\n",
    "shared_targets = protac_db_unique_targets.intersection(protac_pedia_unique_targets)\n",
    "print(f'Shared targets: {len(shared_targets)} ({len(shared_targets) / len(protac_db_unique_targets):.1%}) of PROTAC-DB, ({len(shared_targets) / len(protac_pedia_unique_targets):.1%}) of PROTAC-Pedia')\n",
    "\n",
    "# Assemble a dataframe of these statistics (and corresponding percentages)\n",
    "shared_stats = pd.DataFrame({\n",
    "    'Dataset': ['PROTAC-DB', 'PROTAC-Pedia'],\n",
    "    'Length': [protac_db_df.shape[0], protac_pedia_df.shape[0]],\n",
    "    'Unique SMILES': [len(protac_db_unique_smiles), len(protac_pedia_unique_smiles)],\n",
    "    'Unique Targets': [len(protac_db_unique_targets), len(protac_pedia_unique_targets)],\n",
    "})\n",
    "# Count the number of entries with a SMILES that is shared\n",
    "protac_db_shared_smiles = protac_db_df['Smiles'].isin(shared_smiles).sum()\n",
    "protac_pedia_shared_smiles = protac_pedia_df['PROTAC SMILES'].isin(shared_smiles).sum()\n",
    "shared_stats['Shared SMILES'] = [protac_db_shared_smiles, protac_pedia_shared_smiles]\n",
    "shared_stats['Shared SMILES %'] = shared_stats['Shared SMILES'] / shared_stats['Length']\n",
    "# Count the number of entries with a SMILES/target that is single\n",
    "shared_stats['Single SMILES'] = [protac_db_single_smiles, protac_pedia_single_smiles]\n",
    "shared_stats['Single SMILES %'] = shared_stats['Single SMILES'] / shared_stats['Length']\n",
    "shared_stats['Single Targets'] = [protac_db_single_targets, protac_pedia_single_targets]\n",
    "shared_stats['Single Targets %'] = shared_stats['Single Targets'] / shared_stats['Length']\n",
    "\n",
    "# Convert all percentages to percentages in a for loop\n",
    "for col in shared_stats.columns:\n",
    "    if '%' in col:\n",
    "        shared_stats[col] = shared_stats[col].apply(lambda x: f'{x*100:.1f}\\\\%')\n",
    "\n",
    "# Print bold headers in Latex\n",
    "shared_stats.columns = [f\"\\\\textbf{{{col}}}\".replace('%', '\\\\%') for col in shared_stats.columns]\n",
    "print(shared_stats.to_latex(index=False, escape=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f415d7f5a10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f415d7f5930>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f415d7f5af0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f415d7f5bd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f415a5be570>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Draw some PROTAC molecules using RDKit\n",
    "from rdkit.Chem import Draw\n",
    "\n",
    "# Draw the first 10 PROTACs from PROTAC-DB\n",
    "protac_db_mols = [Chem.MolFromSmiles(smiles) for smiles in protac_db_df['Smiles'].unique()[:5]]\n",
    "protac_db_mols = [mol for mol in protac_db_mols if mol is not None]\n",
    "protac_db_mols = protac_db_mols[:5]\n",
    "for mol in protac_db_mols:\n",
    "    display(mol)\n",
    "# img = Draw.MolsToGridImage(protac_db_mols, molsPerRow=5, subImgSize=(200, 200))\n",
    "# img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bar Plots of Performance Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional, List, Dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['train_loss', 'train_loss_step', 'train_loss_epoch', 'train_acc',\n",
       "       'train_acc_epoch', 'train_f1_score', 'train_f1_score_epoch',\n",
       "       'train_precision', 'train_precision_epoch', 'train_recall',\n",
       "       'train_recall_epoch', 'train_roc_auc', 'train_roc_auc_epoch',\n",
       "       'test_loss', 'test_acc', 'test_f1_score', 'test_precision',\n",
       "       'test_recall', 'test_roc_auc', 'model_type', 'test_model_id',\n",
       "       'train_len', 'train_active_perc', 'train_inactive_perc',\n",
       "       'train_avg_tanimoto_dist', 'test_len', 'test_active_perc',\n",
       "       'test_inactive_perc', 'test_avg_tanimoto_dist',\n",
       "       'num_leaking_uniprot_train_test', 'num_leaking_smiles_train_test',\n",
       "       'perc_leaking_uniprot_train_test', 'perc_leaking_smiles_train_test',\n",
       "       'split_type'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reports['test'].columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pytorch performances:\n",
      "Metrics: ['Accuracy', 'ROC AUC']\n",
      "Metric: Accuracy\n",
      "Metric: ROC AUC\n",
      "Plotting performance for main part of the paper...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_combined_data(combined_data: pd.DataFrame, title: str, show_plot: bool = False, metrics: List = ['Accuracy']) -> None:\n",
    "    num_metrics = len(metrics)\n",
    "    plt.figure(figsize=(6 * num_metrics, 4)) # 12,6\n",
    "    sns.barplot(\n",
    "        data=combined_data,\n",
    "        x='Metric',\n",
    "        y='Score',\n",
    "        hue='Split Type',\n",
    "        errorbar=('sd', 1),\n",
    "        palette=palette)\n",
    "    plt.title('')\n",
    "    plt.ylabel('')\n",
    "    plt.xlabel('')\n",
    "    plt.ylim(0, 1.0)  # Assuming scores are normalized between 0 and 1\n",
    "    plt.grid(axis='y', alpha=0.5, linewidth=0.5)\n",
    "\n",
    "    # Make the y-axis as percentage\n",
    "    if 'Accuracy' in metrics:\n",
    "        plt.gca().yaxis.set_major_formatter(plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n",
    "    # Plot the legend below the x-axis, outside the plot, and divided in two columns\n",
    "    plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.12), ncol=4)\n",
    "\n",
    "    # For each bar, add the rotated value (as percentage), inside the bar\n",
    "    for i, p in enumerate(plt.gca().patches):\n",
    "        # TODO: For some reasons, there are 4 additional rectangles being\n",
    "        # plotted... I suspect it's because the dummy_df doesn't have the same\n",
    "        # shape as the df containing all the evaluation data...\n",
    "        if p.get_height() < 0.01:\n",
    "            continue\n",
    "\n",
    "        if num_metrics == 1:\n",
    "            if 'Accuracy' in metrics:\n",
    "                value = f'{p.get_height():.1%}'\n",
    "            else:\n",
    "                value = f'{p.get_height():.3f}'\n",
    "        else:\n",
    "            if i % 2 == 0:\n",
    "                value = f'{p.get_height():.1%}'\n",
    "            else:\n",
    "                value = f'{p.get_height():.3f}'\n",
    "        \n",
    "        # print(f'Plotting value: {p.get_height():.5f} -> {value}')\n",
    "        x = p.get_x() + p.get_width() / 2\n",
    "        y = 0.3 # p.get_height() - p.get_height() / 2\n",
    "        plt.annotate(value, (x, y), ha='center', va='center', color='black', fontsize=10, rotation=90, alpha=0.8)\n",
    "\n",
    "    plt.savefig(f'plots/{title}.pdf', bbox_inches='tight')\n",
    "    # plt.savefig(f'plots/{title}.png', bbox_inches='tight')\n",
    "    if show_plot:\n",
    "        plt.show()\n",
    "    else:\n",
    "        plt.close()\n",
    "    \n",
    "    # print(combined_data.to_markdown(index=False))\n",
    "\n",
    "\n",
    "def plot_performance_metrics(\n",
    "        df_cv: pd.DataFrame,\n",
    "        df_test: pd.DataFrame,\n",
    "        df_test_majority: Optional[pd.DataFrame] = None,\n",
    "        title: Optional[str] = None,\n",
    "        show_plot: bool = False,\n",
    "        metrics_to_plot: Dict[str, str] = {\n",
    "            'val_acc': 'Validation Accuracy',\n",
    "            'val_roc_auc': 'Validation ROC AUC',\n",
    "            'test_acc': 'Test Accuracy',\n",
    "            'test_roc_auc': 'Test ROC AUC',\n",
    "        },\n",
    ") -> None:\n",
    "    # Extract and prepare CV data\n",
    "    val_metrics = [k for k in metrics_to_plot.keys() if 'val' in k]\n",
    "    cv_data = df_cv[['model_type', 'fold', 'split_type'] + val_metrics]\n",
    "    cv_data = cv_data.melt(id_vars=['model_type', 'fold', 'split_type'], var_name='Metric', value_name='Score')\n",
    "    cv_data['Metric'] = cv_data['Metric'].replace(metrics_to_plot)\n",
    "    cv_data['Stage'] = cv_data['Metric'].apply(lambda x: 'Validation' if 'Val' in x else 'Test')\n",
    "    # Remove test data from CV data\n",
    "    cv_data = cv_data[cv_data['Stage'] == 'Validation']\n",
    "\n",
    "    # Extract and prepare test data\n",
    "    test_metrics = [k for k in metrics_to_plot.keys() if 'test' in k]\n",
    "    test_data = df_test[['model_type', 'split_type'] + test_metrics]\n",
    "    test_data = test_data.melt(id_vars=['model_type', 'split_type'], var_name='Metric', value_name='Score')\n",
    "    # Add a suffix to the metric name to differentiate from the majority score\n",
    "    test_data['Metric'] = test_data['Metric'].replace({k: f'{v}\\n(Average Score)' for k, v in metrics_to_plot.items()})\n",
    "    test_data['Stage'] = '(Average Score)'\n",
    "\n",
    "    # Combine CV and test data\n",
    "    combined_data = pd.concat([cv_data, test_data], ignore_index=True)\n",
    "\n",
    "    if df_test_majority is not None:\n",
    "        # Extract and prepare test data\n",
    "        test_data_majority = df_test_majority[['model_type', 'split_type'] + test_metrics]\n",
    "        test_data_majority = test_data_majority.melt(id_vars=['model_type', 'split_type'], var_name='Metric', value_name='Score')\n",
    "        # Add a suffix to the metric name to differentiate from the average score\n",
    "        test_data_majority['Metric'] = test_data_majority['Metric'].replace({k: f'{v}\\n(Majority Vote)' for k, v in metrics_to_plot.items()})\n",
    "        test_data_majority['Stage'] = '(Majority Vote)'\n",
    "        combined_data = pd.concat([combined_data, test_data_majority], ignore_index=True)\n",
    "\n",
    "    # Rename 'split_type' values according to a predefined map for clarity\n",
    "    group2name = {\n",
    "        'random': 'Standard Split',\n",
    "        'uniprot': 'Target Split',\n",
    "        'tanimoto': 'Similarity Split',\n",
    "        'standard': 'Standard Split',\n",
    "        'target': 'Target Split',\n",
    "        'similarity': 'Similarity Split',\n",
    "    }\n",
    "    combined_data['Split Type'] = combined_data['split_type'].map(group2name)\n",
    "\n",
    "    # Add dummy model data\n",
    "    dummy_val_acc = []\n",
    "    dummy_test_acc = []\n",
    "    for i, group in enumerate(group2name.keys()):\n",
    "        # Get the majority class in group_df\n",
    "        group_df = df_cv[df_cv['split_type'] == group]\n",
    "        major_col = 'inactive' if group_df['val_inactive_perc'].mean() > 0.5 else 'active'\n",
    "        dummy_val_acc.append(group_df[f'val_{major_col}_perc'].mean())\n",
    "\n",
    "        group_df = df_test[df_test['split_type'] == group]\n",
    "        major_col = 'inactive' if group_df['test_inactive_perc'].mean() > 0.5 else 'active'\n",
    "        dummy_test_acc.append(group_df[f'test_{major_col}_perc'].mean())\n",
    "\n",
    "    dummy_scores = []\n",
    "    for i in range(len(dummy_val_acc)):\n",
    "        metrics = {\n",
    "            'Validation Accuracy': dummy_val_acc[i],\n",
    "            'Test Accuracy\\n(Average Score)': dummy_test_acc[i],\n",
    "        }\n",
    "        # All other metrics are set to 0.5 (i.e., random guessing)\n",
    "        for k, v in metrics_to_plot.items():\n",
    "            if 'acc' not in k:\n",
    "                if 'val' not in k:\n",
    "                    metrics[f'{v}\\n(Average Score)'] = 0.5\n",
    "                    metrics[f'{v}\\n(Majority Vote)'] = 0.5\n",
    "                else:\n",
    "                    metrics[v] = 0.5\n",
    "\n",
    "        if df_test_majority is not None:\n",
    "            metrics['Test Accuracy\\n(Majority Vote)'] = dummy_test_acc[i]\n",
    "\n",
    "        for metric, score in metrics.items():\n",
    "            dummy_scores.append({\n",
    "                'Experiment': i,\n",
    "                'Metric': metric,\n",
    "                'Score': score,\n",
    "                'Split Type': 'Dummy model',\n",
    "            })\n",
    "    dummy_model = pd.DataFrame(dummy_scores)\n",
    "    combined_data = pd.concat([combined_data, dummy_model], ignore_index=True)\n",
    "\n",
    "    # Plotting\n",
    "    metrics = list({k.replace('Test ', '').replace('Validation ', '') for k in metrics_to_plot.values()})\n",
    "    print(f'Metrics: {metrics}')\n",
    "    num_metrics = len(metrics)\n",
    "\n",
    "    plot_combined_data(combined_data, title, show_plot, metrics)\n",
    "\n",
    "    for metric in metrics:\n",
    "        print(f'Metric: {metric}')\n",
    "        # Plot the data for the current metric\n",
    "        metric_data = combined_data[combined_data['Metric'].str.contains(metric)]\n",
    "        plot_combined_data(metric_data, f'{title}_{metric}', show_plot, [metric])\n",
    "\n",
    "    # plt.figure(figsize=(6 * num_metrics, 6)) # 12,6\n",
    "    # sns.barplot(\n",
    "    #     data=combined_data,\n",
    "    #     x='Metric',\n",
    "    #     y='Score',\n",
    "    #     hue='Split Type',\n",
    "    #     errorbar=('sd', 1),\n",
    "    #     palette=palette)\n",
    "    # plt.title('')\n",
    "    # plt.ylabel('')\n",
    "    # plt.xlabel('')\n",
    "    # plt.ylim(0, 1.0)  # Assuming scores are normalized between 0 and 1\n",
    "    # plt.grid(axis='y', alpha=0.5, linewidth=0.5)\n",
    "\n",
    "    # # Make the y-axis as percentage\n",
    "    # plt.gca().yaxis.set_major_formatter(plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n",
    "    # # Plot the legend below the x-axis, outside the plot, and divided in two columns\n",
    "    # plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.08), ncol=4)\n",
    "\n",
    "    # # For each bar, add the rotated value (as percentage), inside the bar\n",
    "    # for i, p in enumerate(plt.gca().patches):\n",
    "    #     # TODO: For some reasons, there are 4 additional rectangles being\n",
    "    #     # plotted... I suspect it's because the dummy_df doesn't have the same\n",
    "    #     # shape as the df containing all the evaluation data...\n",
    "    #     if p.get_height() < 0.01:\n",
    "    #         continue\n",
    "    #     if i % 2 == 0:\n",
    "    #         value = f'{p.get_height():.1%}'\n",
    "    #     else:\n",
    "    #         value = f'{p.get_height():.3f}'\n",
    "        \n",
    "    #     # print(f'Plotting value: {p.get_height():.5f} -> {value}')\n",
    "    #     x = p.get_x() + p.get_width() / 2\n",
    "    #     y = 0.4 # p.get_height() - p.get_height() / 2\n",
    "    #     plt.annotate(value, (x, y), ha='center', va='center', color='black', fontsize=10, rotation=90, alpha=0.8)\n",
    "\n",
    "    # # plt.savefig(f'plots/{title}.pdf', bbox_inches='tight')\n",
    "    # if show_plot:\n",
    "    #     plt.show()\n",
    "\n",
    "    print('Plotting performance for main part of the paper...')\n",
    "\n",
    "    # Plot in the same above the accuracy and the ROC AUC in two different subplots\n",
    "    fig, axes = plt.subplots(1, 2, figsize=(11, 5))\n",
    "    sns.barplot(\n",
    "        data=combined_data[combined_data['Metric'].str.contains('Accuracy')],\n",
    "        x='Metric',\n",
    "        y='Score',\n",
    "        hue='Split Type',\n",
    "        errorbar=('sd', 1),\n",
    "        palette=palette,\n",
    "        ax=axes[0])\n",
    "    sns.barplot(\n",
    "        data=combined_data[combined_data['Metric'].str.contains('ROC AUC')],\n",
    "        x='Metric',\n",
    "        y='Score',\n",
    "        hue='Split Type',\n",
    "        errorbar=('sd', 1),\n",
    "        palette=palette,\n",
    "        ax=axes[1])\n",
    "    # axes[0].set_title('Accuracy')\n",
    "    axes[0].set_ylabel('')\n",
    "    axes[0].set_xlabel('')\n",
    "    axes[0].set_ylim(0, 1.0)\n",
    "    axes[0].grid(axis='y', alpha=0.5, linewidth=0.5)\n",
    "    axes[0].yaxis.set_major_formatter(plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n",
    "    axes[0].legend().remove()\n",
    "\n",
    "    # axes[1].set_title('ROC AUC')\n",
    "    axes[1].set_ylabel('')\n",
    "    axes[1].set_xlabel('')\n",
    "    axes[1].set_ylim(0, 1.0)\n",
    "    axes[1].grid(axis='y', alpha=0.5, linewidth=0.5)\n",
    "    # axes[1].yaxis.set_major_formatter(plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n",
    "    axes[1].legend().remove()\n",
    "\n",
    "    # For each bar in both subplots, add the rotated value (as percentage), inside the bar\n",
    "    for i, ax in enumerate(axes):\n",
    "        for p in ax.patches:\n",
    "            if p.get_height() < 0.01:\n",
    "                continue\n",
    "            if i % 2 == 0:\n",
    "                value = f'{p.get_height():.1%}'\n",
    "            else:\n",
    "                value = f'{p.get_height():.3f}'\n",
    "            \n",
    "            x = p.get_x() + p.get_width() / 2\n",
    "            y = 0.3 # p.get_height() - p.get_height() / 2\n",
    "            ax.annotate(value, (x, y), ha='center', va='center', color='black', fontsize=10, rotation=90, alpha=0.8)\n",
    "\n",
    "    plt.legend(loc='upper center', bbox_to_anchor=(-0.1, -0.15), ncol=4)\n",
    "    plt.savefig(f'plots/{title}.pdf', bbox_inches='tight')\n",
    "    if show_plot:\n",
    "        plt.show()\n",
    "\n",
    "print('Pytorch performances:')\n",
    "plot_performance_metrics(\n",
    "    df_cv=reports['cv_train'],\n",
    "    df_test=reports['test'],\n",
    "    df_test_majority=reports['majority_vote'][reports['majority_vote']['cv_models'].isna()],\n",
    "    title=f'summary_performance-best_models_as_test',\n",
    "    show_plot=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PyTorch Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pytorch performances:\n",
      "Metrics: ['Recall', 'ROC AUC', 'Precision', 'F1 Score', 'Accuracy']\n",
      "Metric: Recall\n",
      "Metric: ROC AUC\n",
      "Metric: Precision\n",
      "Metric: F1 Score\n",
      "Metric: Accuracy\n",
      "Plotting performance for main part of the paper...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Pytorch performances:')\n",
    "plot_performance_metrics(\n",
    "    df_cv=reports['cv_train'],\n",
    "    df_test=reports['test'],\n",
    "    df_test_majority=reports['majority_vote'][reports['majority_vote']['cv_models'].isna()],\n",
    "    title=f'pytorch_performance',\n",
    "    show_plot=False,\n",
    "    metrics_to_plot = {\n",
    "        'val_acc': 'Validation Accuracy',\n",
    "        'val_roc_auc': 'Validation ROC AUC',\n",
    "        'val_f1_score': 'Validation F1 Score',\n",
    "        'val_precision': 'Validation Precision',\n",
    "        'val_recall': 'Validation Recall',\n",
    "        'test_acc': 'Test Accuracy',\n",
    "        'test_roc_auc': 'Test ROC AUC',\n",
    "        'test_f1_score': 'Test F1 Score',\n",
    "        'test_precision': 'Test Precision',\n",
    "        'test_recall': 'Test Recall',\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XGBoost Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XGBoost performances:\n",
      "Metrics: ['Recall', 'ROC AUC', 'Precision', 'F1 Score', 'Accuracy']\n",
      "Metric: Recall\n",
      "Metric: ROC AUC\n",
      "Metric: Precision\n",
      "Metric: F1 Score\n",
      "Metric: Accuracy\n",
      "Plotting performance for main part of the paper...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('XGBoost performances:')\n",
    "plot_performance_metrics(\n",
    "    df_cv=reports['xgboost_cv_train'],\n",
    "    df_test=reports['xgboost_test'],\n",
    "    df_test_majority=reports['xgboost_majority_vote'],\n",
    "    title=f'xgboost_performance',\n",
    "    show_plot=False,\n",
    "    metrics_to_plot = {\n",
    "        'val_acc': 'Validation Accuracy',\n",
    "        'val_roc_auc': 'Validation ROC AUC',\n",
    "        'val_f1_score': 'Validation F1 Score',\n",
    "        'val_precision': 'Validation Precision',\n",
    "        'val_recall': 'Validation Recall',\n",
    "        'test_acc': 'Test Accuracy',\n",
    "        'test_roc_auc': 'Test ROC AUC',\n",
    "        'test_f1_score': 'Test F1 Score',\n",
    "        'test_precision': 'Test Precision',\n",
    "        'test_recall': 'Test Recall',\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cells as One-Hot Encoded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cells as one-hot performances:\n",
      "Metrics: ['Recall', 'ROC AUC', 'Precision', 'F1 Score', 'Accuracy']\n",
      "Metric: Recall\n",
      "Metric: ROC AUC\n",
      "Metric: Precision\n",
      "Metric: F1 Score\n",
      "Metric: Accuracy\n",
      "Plotting performance for main part of the paper...\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5kAAAH0CAYAAAC3o+mLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC0gElEQVR4nOzdd1xV5R8H8M9l770RBFFkKKggiLhFceRIy5HlTNM0M0zLX47U0tQyyxy5tTS1NPfee4MTcYuigMi+IOue3x/krSsg4xwuw8/79eJVZ9zzPOf6vfe533Oe8zwyQRAEEBEREREREUlAo6IrQERERERERNUHk0wiIiIiIiKSDJNMIiIiIiIikgyTTCIiIiIiIpIMk0wiIiIiIiKSDJNMIiIiIiIikgyTTCIiIiIiIpIMk0wiIiIiIiKSDJNMIiIiIiIikgyTTCIiIiIiIpJMqZPMY8eOoUuXLnBwcIBMJsOWLVtUtguCgMmTJ8Pe3h76+voICQnB7du3VfZJTExEv379YGJiAjMzMwwZMgTp6enK7Q8ePECLFi1gaGiIFi1a4MGDByqvf+utt7Bp06bSVp2IiKjKK64dLsyRI0fQqFEj6Orqonbt2li1alW515OIiN5cpU4y5XI5fH19sWDBgkK3z549Gz///DMWL16Ms2fPwtDQEKGhoXjx4oVyn379+uH69evYv38/duzYgWPHjmHYsGHK7WPHjoWjoyMiIiJgb2+Pzz//XLltw4YN0NDQQM+ePUtbdSIioiqvuHb4Vffv30fnzp3RunVrREREYMyYMfjwww+xd+/ecq4pERG9qWSCIAhlfrFMhr///hvdu3cHkH8X08HBAWPHjlUmhikpKbC1tcWqVavQp08fREZGwsvLC+fPn4e/vz8AYM+ePejUqRMeP34MBwcHeHl5Ye7cuejQoQN2796Nzz//HNevX0dycjIaN26MQ4cOwcnJSfzZExERVWGvtsOF+eKLL7Bz505cu3ZNua5Pnz5ITk7Gnj171FBLIiJ602hJebD79+8jNjYWISEhynWmpqYIDAzE6dOn0adPH5w+fRpmZmbKBBMAQkJCoKGhgbNnz+Ltt9+Gr68vDhw4gPbt22Pfvn3w8fEBAIwbNw4jR44sUYKZlZWFrKws5bJCoUBiYiIsLS0hk8kkPGsiIqpKBEFAWloaHBwcoKFR/YcmOH36tEq7DAChoaEYM2ZMka9hG0pERIUpaRsqaZIZGxsLALC1tVVZb2trq9wWGxsLGxsb1UpoacHCwkK5z/fff4+PPvoILi4u8PHxwa+//opjx44hIiICs2bNQq9evXDhwgW0b98eP//8M3R0dArUZebMmZg6daqUp0dERNXIo0ePUKNGjYquRrmLjY0ttF1OTU1FZmYm9PX1C7yGbSgREb1OcW2opEmmVBwdHbFjxw7lclZWFkJDQ7F69Wp88803MDY2RlRUFDp06IBff/0Vn3zySYFjTJgwAWFhYcrllJQUODs749GjRzAxMVHLeRARUeWTmpoKJycnGBsbV3RVKi22oUREVJiStqGSJpl2dnYAgLi4ONjb2yvXx8XFoUGDBsp94uPjVV6Xm5uLxMRE5etfNWPGDLRv3x5+fn4YOnQovvnmG2hra6NHjx44dOhQoUmmrq4udHV1C6w3MTFhA0lERG9Mt087OzvExcWprIuLi4OJiUmhdzEBtqFERPR6xbWhkj6M4urqCjs7Oxw8eFC5LjU1FWfPnkVQUBAAICgoCMnJybh48aJyn0OHDkGhUCAwMLDAMSMjI7Fu3TpMnz4dAJCXl4ecnBwAQE5ODvLy8qQ8BSIiomolKChIpV0GgP379yvbZSIiIqmV+k5meno67ty5o1y+f/8+IiIiYGFhAWdnZ4wZMwbffPMN6tSpA1dXV0yaNAkODg7Kke88PT3RoUMHDB06FIsXL0ZOTg5GjRqFPn36wMHBQaUsQRAwbNgw/PjjjzA0NAQABAcHY+nSpXB3d8eaNWvQt29fEadPRERUtRTXDk+YMAExMTFYs2YNAGD48OH45ZdfMH78eAwePBiHDh3Cxo0bsXPnzoo6BSIiquZKfSfzwoULaNiwIRo2bAgACAsLQ8OGDTF58mQAwPjx4/HJJ59g2LBhaNy4MdLT07Fnzx7o6ekpj7F27Vp4eHigbdu26NSpE5o1a4YlS5YUKGvJkiWwtbXFW2+9pVz39ddf48WLFwgMDETt2rUxcuTIUp80ERFRVVVcO/z06VNER0cr93d1dcXOnTuxf/9++Pr64ocffsCyZcsQGhpaIfUnIqLqT9Q8mVVJamoqTE1NkZKSwudJiIjeYGwPSo/vGRERASVvD6r/BGFERERERESkNkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJaFV0BIiIiIkEQIJfLlcuGhoaQyWQVWCNxqtv5EBGVBpNMIiIiqnByuRzdunVTLm/duhVGRkYVWCNxqtv5EBGVBrvLEhERERERkWSYZBIREREREZFkmGQSERERERGRZJhkEhERERERkWSYZBIREREREZFkmGQSERERERGRZDiFCREREZWL+fuTS7xv9gu5yvKvh1Ogo5dbotd+0s6sFLUiIqLyxiSTiIiIiCqcIAiQy/+92GBoaAiZTFaBNSJ1YwxUH0wyiYiIiKjCyeVydOvWTbm8detWGBkZVWCNSN0YA9UHn8kkIiIiIiIiyTDJJCIiIiIiIskwySQiIiIiIiLJMMkkIiIiIiIiyXDgHyIiIqpw2roG6DRmjcpyZbP07oQS75udoTr9yur7U6FjULKfXUPdZpaqXkRUOb3Jo+UyySQiIqIKJ5PJoKNnWNHVIIlxrlR6k2PgTR4tl91liYiIiIiISDK8k0lEREREJLE3uaskEZNMIiIiIiKJvcldJYnYXZaIiIiIiIgkwzuZRBJi1xgiIiIietMxySSSELvGEBEREVVfnMqoZNhdloiIiIiIiCTDO5lEREREVOG0dQ3QacwalWV6szAGqg8mmURERERU4WQyGXT0DCu6GlSBGAPVB5NMKhIHsSEiIiIiotJikklF4iA2RKXHizNERET0pmOSSUQkIV6cISIiIgDQ1tdEj3mNVJbfFEwyiYiIiCT2Jv+4JKJ8MpmsxFOWVDdv5lmXE3aTIyIiIuDN/nFJRMRvPwmxmxwRERFR9bX07oQS75udkauyvPr+1BJfeBjqNrNU9SKqbJhkEhER0RuDvY6IiMofk0wiIiJ6Y7DXERFR+dOo6AoQERERERFR9cEkk4iIiIiIiCTD7rLFmL8/ucT7Zr+Qqyz/ejgFOnq5Reyt6pN2ZqWoFRERERERUeUk+Z3MvLw8TJo0Ca6urtDX14ebmxumT58OQRCU+wiCgMmTJ8Pe3h76+voICQnB7du3lduzsrLwwQcfwMTEBO7u7jhw4IBKGXPmzMEnn3widdWJiIiqhAULFsDFxQV6enoIDAzEuXPnXrv/vHnzULduXejr68PJyQmfffYZXrx4oabaEhHRm0byO5mzZs3CokWLsHr1anh7e+PChQsYNGgQTE1NMXr0aADA7Nmz8fPPP2P16tVwdXXFpEmTEBoaihs3bkBPTw9LlizBxYsXcfr0aezevRvvvfce4uLiIJPJcP/+fSxduhQXLlyQuupEheLdbCKqTDZs2ICwsDAsXrwYgYGBmDdvHkJDQxEVFQUbG5sC+69btw5ffvklVqxYgaZNm+LWrVsYOHAgZDIZ5s6dWwFnQERE1Z3kdzJPnTqFbt26oXPnznBxccE777yD9u3bK6+yCoKAefPmYeLEiejWrRt8fHywZs0aPHnyBFu2bAEAREZGomvXrvD29sbIkSPx7NkzJCQkAABGjBiBWbNmwcTEROqqExERVXpz587F0KFDMWjQIHh5eWHx4sUwMDDAihUrCt3/1KlTCA4OxnvvvQcXFxe0b98effv2LfbuJxERUVlJnmQ2bdoUBw8exK1btwAAly9fxokTJ9CxY0cAwP379xEbG4uQkBDla0xNTREYGIjTp08DAHx9fXHixAlkZmZi7969sLe3h5WVFdauXQs9PT28/fbbxdYjKysLqampKn9ERERVWXZ2Ni5evKjShmpoaCAkJETZhr6qadOmuHjxojKpvHfvHnbt2oVOnToVWQ7bUCIiEkPy7rJffvklUlNT4eHhAU1NTeTl5eHbb79Fv379AACxsbEAAFtbW5XX2draKrcNHjwYV65cgZeXF6ysrLBx40YkJSVh8uTJOHLkCCZOnIj169fDzc0NK1asgKOjY4F6zJw5E1OnTi2wPiYmplSNpUFuRon31XplX4PcZ9DJlRext6rHj9NLXI66/HeyaiD/vTM0NKyg2lScNzkGqPT4uan80tLSKroKZZaQkIC8vLxC29CbN28W+pr33nsPCQkJaNasGQRBQG5uLoYPH47//e9/RZZTEW2oGKX5/hTzGdVNtixVvcrq8ePHailHHSpjDIhRmhiQZeaovjbFAjrZ2iV6LWOg9CpjDIhRWWOgpG2o5Enmxo0bsXbtWqxbtw7e3t6IiIjAmDFj4ODggAEDBpToGNra2liwYIHKukGDBmH06NEIDw/Hli1bcPnyZcyePRujR4/Gpk2bChxjwoQJCAsLUy6npqbCyckJjo6OpepqmxGZXOJ9BUMBncasUS7n6BogVyYr0Wtr1DArcTnqkp6u+mF1dHR8IyesLk0MZGup/njJ0LJGrlbJfrxUxhig0uPnpvJ70+7KHTlyBDNmzMDChQsRGBiIO3fu4NNPP8X06dMxadKkQl9TEW2oGKX5/hTzGc3Kel6aapVZjRo11FKOOlTGGBCjNDGQraM6JkOWaSIEg5L99GYMlF5ljAExKmsMlLQNlTzJHDduHL788kv06dMHAFC/fn08fPgQM2fOxIABA2BnZwcAiIuLg729vfJ1cXFxaNCgQaHHPHz4MK5fv45ly5Zh3Lhx6NSpEwwNDdGrVy/88ssvhb5GV1cXurq60p5cMWQyGXT0Kvcdi6V3J5R43+wM1S/H1fenQqeEX45D3WaWql5ElRkHf6LKwsrKCpqamoiLi1NZHxcXp2xfXzVp0iR88MEH+PDDDwHkt8tyuRzDhg3DV199BQ2Ngk/OVEQbSkRE1Yfkz2RmZGQUaLA0NTWhUCgAAK6urrCzs8PBgweV21NTU3H27FkEBQUVON6LFy8wcuRI/Prrr8rutzk5+d0PcnJykJeXJ/UpVHqCICA9PV3599/pYYikxFgjqlx0dHTg5+en0oYqFAocPHiw0DYUKLpdBsDPNFE50tbXRI95jZR/2vqaFV0lIrWR/E5mly5d8O2338LZ2Rne3t4IDw/H3LlzMXjwYAD5d/vGjBmDb775BnXq1FFOYeLg4IDu3bsXON706dPRqVMnNGzYEAAQHByMcePGYdCgQfjll18QHBws9SlUenK5HN26dVMub926ld3xqFww1ogqn7CwMAwYMAD+/v4ICAjAvHnzIJfLMWjQIABA//794ejoiJkz83uUdOnSBXPnzkXDhg2V3WUnTZqELl26KJNNIpKeTCYrcQ8woupG8sifP38+Jk2ahI8//hjx8fFwcHDARx99hMmTJyv3GT9+vLKrTnJyMpo1a4Y9e/ZAT09P5VjXrl3Dxo0bERERoVz3zjvv4MiRI2jevDnq1q2LdevWSX0KRERElVbv3r3x7NkzTJ48GbGxsWjQoAH27NmjHAwoOjpa5c7lxIkTIZPJMHHiRMTExMDa2lp5QZiIiKg8SJ5kGhsbY968eZg3b16R+8hkMkybNg3Tpk177bHq1auH27dvq6zT0NDAwoULsXDhQimqS0REVOWMGjUKo0aNKnTbkSNHVJa1tLQwZcoUTJkyRQ01IyIiKodnMomIiIiIiOjNxSSTiIiIiIiIJMMkk4iIiIiIiCTDJJOIiIiIiIgkw3GViYioSIIgQC6XK5cNDQ0hk8kqsEZERERU2THJJCKiInGuVCIiIiotdpclIiIiIiIiyfBOJpGEtHUN0GnMGpVlIiIiIqI3CZNMIgnJZDLo6BlWdDWIiIiIiCoMu8sSERERERGRZJhkEhERERERkWTYXZaKpK2viR7zGqksE9Hr8blcIiIietMxyaQiyWQy6BgwRIhKg8/lEhER0ZuOGQTRG2bp3Qkl3jc7I1dlefX9qSW+8DDUbWap6kVERERE1QOfySQiIiIiIiLJMMkkIiIiIiIiyTDJJCIiIiIiIskwySQiIiIiIiLJMMkkIiIiIiIiyTDJJCIiIiIiIskwySQiIiIiIiLJMMkkIiIiIiIiyTDJJCIiIiIiIskwySQiIiIiIiLJMMkkIiIiIiIiyTDJJCIiIiIiIskwySQiIiIiIiLJMMkkIiIiIiIiyWhVdAWIiIiIxIhfN6TE+8qz8lSWn/05Chm6miV7caBNaapFRPTG4p1MIiIiIiIikgzvZBJRkbT1NdFjXiOVZSIiIiKi12GSSURFkslk0DHg1wQRERERlRy7yxIREREREZFkmGQSERERERGRZJhkEhERERERkWSYZBIREREREZFkmGQSERERERGRZJhkEhERERERkWSYZBIREREREZFkmGQSERERERGRZJhkEhERERERkWS0KroCRESkXkvvTijxvtkZuSrLq+9PhY5ByZqOoW4zS1UvIiIiqh54J5OIiIiIiIgkwySTiIiIiIiIJMMkk4iIiIiIiCTDJJOIiIiIiIgkwySTiIiIiIiIJMMkk4iIiIiIiCTDJJOIiIiIiIgkw3kyiaogQRAgl8uVy4aGhpDJZBVYIyIiIiKifEwyiaoguVyObt26KZe3bt0KIyOjCqwREREREVE+JplERFUQ72YTERFRZcUkk4ioCuLdbCKisuFFOqLyxySTiIiIiN4YvEhHVP44uiwRERERERFJhncyK4n4dUNKvK88K09l+dmfo5Chq1myFwfalKZaREREREREpcI7mURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGY4uS1RJcIRhIiIiovInCALkcrly2dDQEDKZrAJrVP0wySQiIiIiojeGXC5Ht27dlMtbt26FkZFRBdao+mF3WSIiIiIiIpIM72QSEREREVGVxseOKhfeySQiIiIiIiLJlEuSGRMTg/fffx+WlpbQ19dH/fr1ceHCBeV2QRAwefJk2NvbQ19fHyEhIbh9+7Zye1ZWFj744AOYmJjA3d0dBw4cUDn+nDlz8Mknn5RH1YmIiCq9BQsWwMXFBXp6eggMDMS5c+deu39ycjJGjhwJe3t76Orqwt3dHbt27VJTbYmI6E0jeXfZpKQkBAcHo3Xr1ti9ezesra1x+/ZtmJubK/eZPXs2fv75Z6xevRqurq6YNGkSQkNDcePGDejp6WHJkiW4ePEiTp8+jd27d+O9995DXFwcZDIZ7t+/j6VLl6okrURERG+KDRs2ICwsDIsXL0ZgYCDmzZuH0NBQREVFwcamYDeu7OxstGvXDjY2Nvjrr7/g6OiIhw8fwszMTP2VJyKqBAx0NLDsfSeVZZKW5EnmrFmz4OTkhJUrVyrXubq6Kv9fEATMmzcPEydOVI7qtGbNGtja2mLLli3o06cPIiMj0bVrV3h7e6NWrVoYN24cEhISYG1tjREjRmDWrFkwMTGRuupERESV3ty5czF06FAMGjQIALB48WLs3LkTK1aswJdffllg/xUrViAxMRGnTp2CtrY2AMDFxUWdVSYqd3wej0pDJpPBsKT/5lQmkqft27Ztg7+/P959913Y2NigYcOGWLp0qXL7/fv3ERsbi5CQEOU6U1NTBAYG4vTp0wAAX19fnDhxApmZmdi7dy/s7e1hZWWFtWvXQk9PD2+//Xax9cjKykJqaqrKHxERUVWWnZ2NixcvqrShGhoaCAkJUbahr9q2bRuCgoIwcuRI2Nraol69epgxYwby8vIK3R9gG0pEROJIfifz3r17WLRoEcLCwvC///0P58+fx+jRo6Gjo4MBAwYgNjYWAGBra6vyOltbW+W2wYMH48qVK/Dy8oKVlRU2btyIpKQkTJ48GUeOHMHEiROxfv16uLm5YcWKFXB0dCxQj5kzZ2Lq1KkF1sfExJSqsTTIzSjN6ZdZgmbBcyhKhmYugEfK5eeaDsjULNk/pW6yeu4AP378WC3lqANjoGwYA6X3+HF6iff97yTSQP53m6GhYYleq5tsWeJyZJk5qq9NsYBOtnaJXltZYyAtLa2iq1BmCQkJyMvLK7QNvXnzZqGvuXfvHg4dOoR+/fph165duHPnDj7++GPk5ORgypQphb6GbWjh+P1ZeoyBsmEMlF5pYkCMNz0GStqGSp5kKhQK+Pv7Y8aMGQCAhg0b4tq1a1i8eDEGDBhQomNoa2tjwYIFKusGDRqE0aNHIzw8HFu2bMHly5cxe/ZsjB49Gps2bSpwjAkTJiAsLEy5nJqaCicnJzg6Opaqq21GZHKJ9xXDKi+mxPvKX7n6bJn3BIZ5Jbvln2WWU/xOEqhRo4ZaylEHxkDZMAZKr0YNsxLvm56umpA6OjqWeCLprKznJS4nWydX9bWmiRAMStZ0VNYYeNPuyikUCtjY2GDJkiXQ1NSEn58fYmJiMGfOnCKTTLahheP3Z+kxBsqGMVB6pYkBMd70GChpGyp5kmlvbw8vLy+VdZ6enspE0M7ODgAQFxcHe3t75T5xcXFo0KBBocc8fPgwrl+/jmXLlmHcuHHo1KkTDA0N0atXL/zyyy+FvkZXVxe6uroSnBEREVHlYGVlBU1NTcTFxamsj4uLU7avr7K3t4e2tjY0Nf/9Ee3p6YnY2FhkZ2dDR0enwGuqcxvKAT+IiMqf5N+swcHBiIqKUll369Yt1KxZE0D+IEB2dnY4ePCgcntqairOnj2LoKCgAsd78eIFRo4ciV9//RWamprIy8tDTk7+FYScnJzXPlNCRERUnejo6MDPz0+lDVUoFDh48GChbSiQ3y7fuXMHCoVCue7WrVuwt7cvNMGs7l4O+PHyTyaTVXSViIiqHcmTzM8++wxnzpzBjBkzcOfOHaxbtw5LlizByJEjAeR/uY8ZMwbffPMNtm3bhqtXr6J///5wcHBA9+7dCxxv+vTp6NSpExo2bAggv7HcvHkzrly5gl9++QXBwcFSnwJRpffySvzLP16JJ3pzhIWFYenSpVi9ejUiIyMxYsQIyOVy5Wiz/fv3x4QJE5T7jxgxAomJifj0009x69Yt7Ny5EzNmzFC2y0RERFKTvLts48aN8ffff2PChAmYNm0aXF1dMW/ePPTr10+5z/jx4yGXyzFs2DAkJyejWbNm2LNnD/T09FSOde3aNWzcuBERERHKde+88w6OHDmC5s2bo27duli3bp3Up0BU6XHobaI3V+/evfHs2TNMnjwZsbGxaNCgAfbs2aMcDCg6OhoaGv9eeHJycsLevXvx2WefwcfHB46Ojvj000/xxRdfVNQpEBFRNSd5kgkAb731Ft56660it8tkMkybNg3Tpk177XHq1auH27dvq6zT0NDAwoULsXDhQknqSkREVNWMGjUKo0aNKnTbkSNHCqwLCgrCmTNnyrlWRERE+djHjoiIiIiIiCTDJJOIiIiIiIgkUy7dZYmIqHrQ1tdEj3mNVJaJiIiIXodJJhERFUkmk0HHgE0FERERlRy7yxIREREREZFkmGQSERERERGRZJhkEhERERERkWSYZBIREREREZFkOJoDEREREb0xDHQ0sOx9J5VlIpIWk0wiIiIiemPIZDIY6nI6JqLyxCSTiCqcIAiQy+XKZUNDQ8hksgqsEakbY4CIiKj6YJJJRBVOLpejW7duyuWtW7fCyMioAmtUMeLXDSnxvvKsPJXlZ3+OQkZJr8wH2pSmWmrBGCAiIqo+2AmdiIiIiIiIJMMkk4iIiIiIiCTDJJOIiIiIiIgkwySTiIiIiIiIJMOBf4ioXCTPSy7xvvIcucpyyqIU5Grnlui1ZmPMSlErUifGABER0ZuJdzKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDIcXZaIKpyBlgHWdFijskxvFsYAERFR9cEkk4gqnEwmg6G2YUVXgyoQY4CIiKj6YHdZIiIiIiIikgyTTCIiIiIiIpIMk0wiIiIiIiKSDJNMIiIiIiIikgwH/qEKJwgC5HK5ctnQ0BAymawCa0RERERERGXFJJMqnFwuR7du3ZTLW7duhZGRUQXWiIiIiIiIyordZYmIiIiIiEgyvJNJ5SJ5XnKJ95XnyFWWUxalIFc7t9jXmY0xK2WtiIiIiIiovDHJJCIiIqpESnOhtqx4obZyU0cMAIyDyqyqxwCTTKpwBloGWNNhjcoyERERERFVTUwyqcLJZDIYahtWdDWIiIiIiEgCHPiHiIiIiIiIJMMkk4iIiIiIiCTD7rJVkIGOBpa976SyTEREREREVBkwyayCZDIZDHU1K7oaREREREREBfAWGBEREREREUmGSSYRERERERFJhkkmERERERERSYZJJhEREREREUmGSSYRERERERFJhkkmERERERERSYZJJhEREREREUmGSSYRERERERFJhkkmERERERERSYZJJhEREREREUlGq6IrQEREpWego4Fl7zupLBMRERFVBkwyiYiqIJlMBkNdzYquBhEREVEBvPRNREREREREkmGSSURERERERJJhkklERERERESSYZJJREREREREkmGSSURERERERJJhkklERERERESSYZJJREREREREkmGSSURERERERJJhkklERERERESSYZJJREREREREkmGSSURERERERJJhkklERERERESSYZJJREREREREkmGSSURERERERJJhkklERERERESSKfck87vvvoNMJsOYMWOU6168eIGRI0fC0tISRkZG6NmzJ+Li4pTbExMT0aVLFxgZGaFhw4YIDw9XOebIkSPxww8/lHfViYiIKqUFCxbAxcUFenp6CAwMxLlz50r0uvXr10Mmk6F79+7lW0EiInqjlWuSef78efz666/w8fFRWf/ZZ59h+/bt+PPPP3H06FE8efIEPXr0UG7/9ttvkZaWhkuXLqFVq1YYOnSoctuZM2dw9uxZlaSViIjoTbFhwwaEhYVhypQpuHTpEnx9fREaGor4+PjXvu7Bgwf4/PPP0bx5czXVlIiI3lTllmSmp6ejX79+WLp0KczNzZXrU1JSsHz5csydOxdt2rSBn58fVq5ciVOnTuHMmTMAgMjISPTp0wfu7u4YNmwYIiMjAQA5OTkYPnw4Fi9eDE1NzfKqOhERUaU1d+5cDB06FIMGDYKXlxcWL14MAwMDrFixosjX5OXloV+/fpg6dSpq1aqlxtoSEdGbqNySzJEjR6Jz584ICQlRWX/x4kXk5OSorPfw8ICzszNOnz4NAPD19cWhQ4eQm5uLvXv3Ku+Ezp49G61atYK/v3+x5WdlZSE1NVXlj4iIqCrLzs7GxYsXVdpQDQ0NhISEKNvQwkybNg02NjYYMmRIicphG0pERGJolcdB169fj0uXLuH8+fMFtsXGxkJHRwdmZmYq621tbREbGwsA+PLLLzFixAi4ubnBxcUFy5cvx+3bt7F69WqcPn0aw4cPx759++Dv74+lS5fC1NS0QDkzZ87E1KlTC6yPiYkpVWNpkJtR4n3FSNB0VEs5uskmaikn3vD13bakkP44vdzLABgDZaWOGADUEweMgbKprDGQlpZWTjUpfwkJCcjLy4Otra3KeltbW9y8ebPQ15w4cQLLly9HREREicthG1q46vTZYRtaNtUpBgC2oWXxpsdASdtQyZPMR48e4dNPP8X+/fuhp6dXpmOYmppi3bp1KuvatGmDOXPmYO3atbh37x6ioqIwdOhQTJs2rdBBgCZMmICwsDDlcmpqKpycnODo6AgTk5IHR0ZkcpnOobSs8mLUUk6WWY5ayrGR25R7GWY1zMq9DIAxUFbqiAFAPXHAGCibyhoDb9JdubS0NHzwwQdYunQprKysSvw6tqGFq06fHbahZVOdYgBgG1oWb3oMlLQNlTzJvHjxIuLj49GoUSPlury8PBw7dgy//PIL9u7di+zsbCQnJ6vczYyLi4OdnV2hx1y5ciXMzMzQrVs39OjRA927d4e2tjbeffddTJ48udDX6OrqQldXV9JzIyIiqkhWVlbQ1NRUGZEdKLoNvXv3Lh48eIAuXboo1ykUCgCAlpYWoqKi4ObmVuB1bEOJiEgMyZPMtm3b4urVqyrrBg0aBA8PD3zxxRdwcnKCtrY2Dh48iJ49ewIAoqKiEB0djaCgoALHe/bsGaZNm4YTJ04AyE9Yc3LyryDk5OQgLy9P6lMgIiKqlHR0dODn54eDBw8qpyFRKBQ4ePAgRo0aVWB/Dw+PAm3yxIkTkZaWhp9++glOTk7qqDYREb1hJE8yjY2NUa9ePZV1hoaGsLS0VK4fMmQIwsLCYGFhARMTE3zyyScICgpCkyZNChxvzJgxGDt2LBwd8/tZBwcH47fffkP79u2xZMkSBAcHS30KRERElVZYWBgGDBgAf39/BAQEYN68eZDL5Rg0aBAAoH///nB0dMTMmTOhp6dXoE1+2Yvo1fVERERSKZeBf4rz448/QkNDAz179kRWVhZCQ0OxcOHCAvvt3bsXd+7cwW+//aZcN2rUKFy4cAGBgYEICAjAlClT1Fl1IiKiCtW7d288e/YMkydPRmxsLBo0aIA9e/YoBwOKjo6Ghka5ToNNRET0WmpJMo8cOaKyrKenhwULFmDBggWvfV1oaChCQ0NV1hkYGGDjxo1SV5GIiKjKGDVqVKHdY4GCbe6rVq1aJX2FiIiI/oOXOomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJMMomIiIiIiEgyTDKJiIiIiIhIMkwyiYiIiIiISDJaFV2B6iYvLxeJcY8gCApY2DhBS1un3MrKzM6FQiHAUE+73Mqg0mMMUHWU/SIHgkKArkH5xTMRERFVD0wyJfTozhXsWDENirw8KBR50NDQRMf+X6KWd6Ck5TyIT8Wcv8Jx52kKAKCmjTE+79EQ7o5mkpYDAHm5CjyPSYEgCLB0MIWWjqbkZVQn1TEGAPUlGJnZmVAIChjqGpZrOeqSnZUJQaGArn7VPZ9n0cnY9tNxxN57DplMBisnM3T5JBj2ta3KpbzqFgNERERvIiaZIigUCmho/Nvj+PBfv6DzwIlwdm8AALh8YjsObJiHYdP+kLTcn7ZeQdcmrmhZzwG5eQI2n7qLOZsuYenoNpKWE309Fn//cAyKPAUUeQpoaGqg66fN4NaohqTlPE9/jp8P/4zLjy5DIShQz6EeRrUeBQczB0nLKQ/VPQbUlWA8SHiAmXtm4nb8bchkMtS0rIkvQr9AXdu6kpajLglPH2DXmpmIf3QbkMlgZVcTHT74AnbO0p3P87QXWLjjKi7fT4BCALydLfBx53qwt5A2Odu96BT8O3nAq5kr8nLycHb7DWz76QQ+mt9d0nKqWwwQERG9yZhkirD2+4/Rvk8YbJ3dAQCKvFyYWNgotxub2yA3N0d0OVN+P4tRXXxgbaoPAEiVZyPIww56Ovn/fI3dbbHt7H3R5SgUAjQ0ZMrl/cvPo3tYC9SsZwcAuLQ3CrsXn8GoJe+ILuu/Zu+bDU87TwwKGoQcRQ62RGzBN7u+wcL3FkpaTnmobjHwKnUlGHMPzEX3Bt3Rum5r5OTl4K9Lf+G73d9h5cCVkpajLvv+mIuGLbrDw6818nJzcPHQX9i15jsMnijd+fywOQIeTmb4oG1d5OYK2Hb2PmZuvIifh7cQddw/ZxxE6EdNYGKZn6xmpGahToATtHW1oK2rhdp+NXBx900pTkFFdYsBKt75Axvg3rAlTC3t1FLezcdJuBGdiKT0LACAuZEuvJwt4FHDXLIycrJycf34fTyOjEN6UiYgA8ztTOAe4ARXX+kunCbKExH5NBKJGYkAAAsDC3jae8LC0EKyMiqCIAh4dDsCSfExMDK1gItXADQ1y++n6rjlJ/F5j4awNTeQ5Hi52XmQacigqZV/8TnpaSouH7yDlIR0mFobwbdtHZjbGUtSFlA946C8YiA+JRO6WhowNdQFAFx98Bw7zj1AfEombM300SXQFd7O0r1vT249w+OoZ/nfAwCMzPVRo641HNytJSsDqNwxwCRThLbvjsbedd+jRm1fNOsyGEGdBmDNrI9gYeMERV4uEuOi0bbXaNHltGlQA1+sPIUuga7o3sQVXZu4YNj8w6jvYom8PAHh957hnWa1RZezavwOdBzRFPZulgCAvDwFTKz+vStiam2IvJw80eXMPzwfHwZ/CH2d/IQpJjkG07pOg65W/ge/Z8Oe+HTjp6LLUYfqFgPqSjAmbp2IT9t8Cmvj/C/blMwUNHVrCj1tPehp6yHQNRBbI7aKLkdd/v51IkJ6fQpj8/zzyUxPQW2fptDW0YO2jh5cvQMRflzc+SzceRWD2nlC/58LC08S0zHlvcbQ1c7vwv52UC2ELTsh7kQAeLd0w9rJe+HX0QONO3vCv5MHlo7eCmdvO+TlKfDgylM06eYtupzqFgNUeke3/IpjW5fCyb0B6gd1gnuD5tDUkv758qT0LEz74zxuRCfC2lQfFkb5bU1iehZ+3X0dXs4WmNy3Mcz/WV9WiU9SsW7KXuRk50FLRxOpCXLU9quBJ7ef4eKem/AIrInuY1tAQ7PsYy5mZmdi7oG5OBx1GDKZDMa6+QlLWlYaBEFAG482CAsJg562nqhzUZdNC7/EW4MmQlffCJnyFGxaOAGxD29C39AUmRmpMLeugb6f/QQDYzNR5ZyOjC10/dWHz3EmKhY2pvlJZpCnuAsef0zbD/9OHvBs6oJHkXFYO3kfLB1NYFXDDHcvxuDsthvoN7U9anjYFH+w16hOcaCuGPjmj/N4r5U7mnjY4VTkU0xddx5N6trC29kCMc/T8fmyk5jyXmM08RAXA/LkTGyadRiPbsbD1MoQhub5v3XlSZnYnyCHk4cNen7RGoZm+qLKqQoxwCRTBAdXL7w/bhHOHViP32YNR8vuwzBk0ho8fXADgiDAzrmu8kenGC3rOcK/tg2W7b2BT389jtFdfTFzgBUu309AnkJArxa1JbkSGzqsCXYtOAVnb1u07NcQzXv7YvnY7bB0NIEiV0BCTApCh4p/ttDayBrD1w7HsBbDEOwWjNZ1W2PEuhFo4tIEuYpcHL9zHCEeIaLLUYfqFgPqSjBCPEIw9q+x6ObbDT0a9kD3Bt0xZM0Q+NTwQW5eLsIfhaOXXy/R5aiLV+MQbJw/Fg2ad0OjVj3QsGV3rPx2CJxq+0CRl4uHt8LRuI2487Ey0cOohcfwYagXgjzt0Kq+Iz5ZfAwB7rbIVShw8sZTtPUV35XdK9gFtRo44PCai1j1xU50HB6EvlPa4+H1WCjyFGj6dj1JrsRWtxigsmn/3ljcuXISu9bMxME/f4ZX4xDUb9oZ1g6ukpXxy/YrUAgClo1uAydrI5Vtj56l44e/w/HL9iuY1LexqHL2LT8Lt0Y10GF4E8hkMpzafBXR12MxaPZbeP4kBX98vR8n/ryCFn0alP1cjvyCm7E3MePtGfBz9oOmRv5FpjxFHi5FX8L8w/Pxy+Ff8Hn7z0Wdi7rcv3EOuTk50NUHTmxfgeysTHz49e8ws3JAalI8tiyZhBM7VqB93zBR5Xy97lyR2xbuvKb8/73Tu4oqJ+7ec9i45LfFR9aGw69jXbQbHKDcfmTtJRxafQH9Z3YSVU51igN1xcCD+DTUtMlPxNYfvY3B7TzRu0Ud5fatZ+5hzaEo0UnmniVnoBAEDP/lbVg6mqpsex6Tgh3zT2LPkjPoOb61qHKqQgwwyRRJQ1MTTUL7oW6jVti//kfont2LNu+OhrGZtM+sGepp49Nuvrj24Dlmb7qERrWtMbCth7K7pBQc3a0xaE5nnP77GlaM3YE2A/wwYsHbiLn1DIJCgH0dK+UdLjH6NO6DFnVa4KdDP2HP9T0Y3Xo0POw8lM9kftT8I7R0bynBGalHdYoBdSUYreq2gr+LP5YcX4KRf4zEZyGfYXaP2Yh4HIE8RR76Nu4LT3tPCc5IPeo2agUXT38c3bIEa78fiXZ9PsO7I2fj0e0IKBR5CGjXF/Yu4s6nV/M6aO7tgPnbr2JfeDQ+7lwfdR3NcflBAgSFgA9DvdDCW5rueHqGOug4IgiPbsRh208n4Oprj1b9GkFbV7pYq24xQGVTy7sJ6gd1hDw1CdfP7sXV07tx6ejfsHNyR/2mneHh11r0wFkXbsfjhw+bFUgwAcDJ2ggfd66PcctPiioDAB5ei8OHPwZAJst/7CSgixeOrg1HRtoLWDqYot2QAOxffk5Uknns9jHM6D4D9R3rq6zX1NBEY5fGGNd+HP635X9VIrl4VfStCLTsPgxmVvnfYybmNmjZbRj2/vGD6GP71baBhgYw9u2GKnesO07ejkWjWsLFxkR0GUD+Y0eCQgAAPH+cgvZDAlS2+7apjfM7bogup7rGQXnGgKaGDJnZuQCA2KQMNHZXvZvcuI4tlu0V/29zLzwGH3zbsUCCCQCWjqZo/2EAfp+0R3Q5VSEGmGSK9OzJfSTFPYKVgwt6ffI9rp3Zg/U/fgr/tu+iYYvukpWTmpGN2KQMuNqZYOHHLbHu6C18vPAohnesh4C6tpKVo6GpgeB3fOAV7ILdi8/gyuG7CP0wEMaW0jyv8JKDmQNm9ZiF/ZH7MWbjGPRs1BMjWo5QNs5VSXWLAXUkGABgpGuEsJAwXI25ipl7ZsLf2R+DgwdXie49hdHVN0L7vmF4fPcqdq+ZiZoe/mjWZTC0daQ7H3sLQ8wY0AQHIx7h8+Un8XZQLXzUwVvyz01G2gukxKXDuqY5hvzQBSf/uoJlYdvQbnAAavtJN/BXdYsBKjtDE3MEtOuDgHZ98OjOFVw9tQuHNy/A4c0LMGbublHH1tbSgDyr6GfjM7Nzoa0lftpwPUMdZGfmKpdzs3KhUCig+U/3WJua5srns8pKEARoaxbdpVhLQwuCIIgqQ91efn+9yEiDqZXqhTIza0ekpySILmPGgCbYdPIuRi06hk+61Bd9t6ooju7WuH3+EaxqmMHczhhxDxJh6/rvs3FxDxKhJ7JbNlD94kAdMeDjYonDV2JQy84Ubg6muHz/OWrZ/ZsIRtxPgJWJuC6sAKCprYmsjKK/b7Jf5EJTW/xMDVUhBphkinD+4Eac3LECVg61kPwsBs27DoVvs7dQq14QjmxeiBvn9qN937GwdqwlqpxDlx/jxy0RMNDVRnZuHsb3bIT+bTzQqr4jft52BXvDozGyc31YGIv/YRb/MAmJT1Jg7WyO96a2x5VDd7Dmq90I7OoN/04eoo//XymZKWjn2Q6BroFYfHQxRv4xEmPbjYWbtZuk5ZSn6hgD6kowUjJTEJsaC1crVyzptwS/n/0dw34fho9bfowmtZpIVo66ZMpTkPI8FtYOrvjgyyU4s+d3rPluGFr3/Bi1vKU7n9SMbLRt4IQAd1ss2XMdn/56HGO6+6o0lmJcO3oPOxeegq6+NnKzc9F1THO06NMAXs3+ufB08A7aDw2Ekbn4xri6xQCVUhEXR5xq+8Cptg/avvsJbl48LLqYlvUdMWdTOIZ3rIeGblbKeYXlL3IQfjcBv+65htY+4r/bXH3tcWDleXQc3gSaWpo48vsl2LlaKqd+Sk2Qw9BM3Hd0k1pNMPfAXIxrPw51bOqobLsdfxvzDs5DUK0gUWWo2+7fvoOmljYUeblIff5Upau0PDURevrSDJTTM9gNvq5WmPXXRZyJisPwjuIf/XhVy/caYv20/cjJyoN3c1ccWHkeiU9SYVXDDM+fpOD8jkgEv1O/+AMVo7rFgTpiYHB7L4xddgLPU1+gXk1LrNofiVsxyXCyMsLjhHQcvfYEo7v6iC7HK9gV2386jpDBAXD1tVd+/rMysnH/8lMcWHke3s3F/SYEqkYMMMkU4fyBDegxYiac3Rsi5Xks/lrwBXybvQUDI1N06j8BDyIvYNvyqRgyebWocpbvi8TYtxuilY8jbsUk44e/wxHkaQdna2N8PyQYu84/wJglJ7BmrLjnGM9uvY4j68JhU9MMSU/T0PqDRmjYvi5q+9fAgRXnseroXXQa0VT5vEFZXXx4Ed/u+hbJmcmwNLLElLemYHzoeIRHh+Obnd+gSa0mGNh0oHIgoMqsusWAuhKMA5EH8P3+72GoY4is3CxM6DgBA5sORBuPNph7YG5+N+o2oyvF6GglceP8Aexb9z109AyRm5OFTv0nILjzQHj4tcH+9XNx7cwetH13NAxNyn4+l+4+w3cbLyIlIxuWxnr4qo8/xvZoiIh7CZi58SIC3G3Rv62HciCgsjr8+0W8NSoY3s1d8fROAnb8chLuAc6wqmGGD77pgPB9UVj95U6M/FXcKNPVLQaoDIq5yq6rbwjfZm+JLuajjt5QKATM2HgBeQoB2v/cWczJU0BTQ4YOfs4Y2sFLdDltB/jjz5mH8OsnWyCTyWBiaYB3Jvw7rVRG6gs06V5PVBmj24zGt7u+xUe/fwRjPWOY6ZsBAJIzk5GelY7GNRtjdBvxg82pi3dgqPL/a/sEIyc7S2X77YjjsKkh3YXn2g6m+GVESyzedQ0jFhyFAGnv9NTwsEGfye1wYOV5xNx6BgA4+dcVAICxhQFa9GmAgC7iY606xYG6YqCmjTF+/qgFVh2MxJ/H7+BFTh4OXX4MDZkMdWuY4X+9/BDsZS+6nJBBjSEoBGz54SgUCkE50nBergIaGjL4htRB2wH+osupCjHAJFOE/NvQ+VdiZRoFu9q4ePqj/5dLRJfzIicXNazynyVxsDBE1isjvHZq7IIgT/EfjNN/X0PviW3hUt8eyfHpWD91Pxq2rwsDEz10HdMc9yKeYPOcIxi+4G1R5fx86Gf0btwb3Rt0x/kH57HwyEIsfG8hGjo3xK/v/4o1Z9Zg6G9DsWbQGtHnVN6qWwyoK8FYemIpxrcfjzYebRAVF4XZe2cj2C0YzhbOmNdrHnZc2YFR60dh3ZB1os9JHY5vW4rQfuPh6d8GsdFR2PP7bNT2CYalnTP6jJmHyyd2YO0PozBsatnPZ8H2q+jVvDa6BLriwu14/LrrGn4e3gINallhwcctsfbwLYxYcAQrxrQVdS45L3Jh6Zj/fJK5nTFysnJVtjdsXxfuAc6iygCqXwxQ6X3+yyG1lKOjpYlPu/niw1Av3H6SgqT0FwAAcyM91HEwVd7ZFMvQTB8DZ3XG8ycpyMtRwKqGqcpIsp5NXUSXYaJnglk9ZuHh84e4/vQ6kuRJAABzQ3PUc6gHZwvxn0116vjBF6/dHtSpP2Qy8V2Z/0tXOz8eTkfG4vL9BJgaSHtBu4aHDQbO6gx5ygskx6VBUAgwMteHma10U5dUpzhQZww4WBrif738IQgCktKzIAAwNdCBlogRn1+lpaOJjiOC0GaAH57efQ75P13kDc31Ye/2b88GsapCDDDJFKFxSC9sXvQlrGvURlL8YzTvMqTAPto64r+82jV0wsTfzsDH1RK3Y1LQ1tepwD5ih14H8hOml/3i/ztf5ku1GjhgyNwuost5Ln+OoFpB0NXSRWOXxlh49N/5MHW0dPBhsw/R1kPcD2V1qW4xoK4E40XOCzhZ5J+Dg6kDsnJVr1y+5fMWgt2CRZejLjlZL2Bhm38+ZlYOyH3lSqxvs7dQ20fc+SSmv0BAXVvoamvCv44Nft19XblNR0sTg9p5orWPo6gyAKB+azdsmH4AzvXsEHv3Oeq3LHgFWezQ60D1iwGq/Az1tNGglrQDshXG0kGaruuvU9OyJmpa1iz3ciqajq7475qiBHnaiZ6y5HUMTfVgaFq+z5e/CXFQHjEgk8kkebzodXQNdOBSX/zF/+JU5hhgkilCQEgfuHoGIDEuGlYOtWBpVz5XDYZ3rAdfFys8SkhD+4bO8K8jbn6lojTpXg/rpx+Aras5Ep+kolW/RgX2kWLwl6ZuTfH19q8R5BaEazHXEOhScFoUVyvphq8vTwEhfeDi2fifgX+qfgyoK8EI9QrFhL8nwLeGL27F3UI7z3YF9jE3lG6C9PLmHRiKTYsmwLmOL2Kjb8EroOD5GJqIO58mHnaY/scFBHnY4trDRAS4F4wBF1vxIyS2GxyAmvXs8DwmBb5taqNWQ/GJa2GqWwxQ2Vw6+jdiH96Eq1cgPP3b4Pq5fTi7dx0EQUCdBs3QrPNgaGiKHyTjdRLTXmDn+Yf4oE1dUcd5evc59Ax1YG6Xf8fq6pG7uLQnCikJcphZG8Kvkye8m4tv23LycnDizgnceHoDifJ/JmA3tIC3vTeCawe/djCQyiYu+hZ0DYyUo4leP7cPl49vR2pSHEws7NCwRXd4+rcp5iglkyLPwt5L0bgRnYSk9PyLWuZGuvByNkf7Rs4wM5TmjmZOVi5i7z6HnpEurJ3NCmyLPPUAPq3Fz2tdXeJAnTHwOvEpmfjt4E2M7dFQ0uNmv8jBjRMPkBybBiNzfXi1cIWBRAluZY8BJpkiWTvWKjCoS3LCE5iY20raMAZ52iEI5XfFDQCC3q4Ht4aOSIhJgU1NM1jVMCuXcsa1H4ftV7YjOjEaIZ4h6FRP3HxRFc3G0Q02juU/WJE6YkBdCcbHrT6Gr5MvHiU+QgfvDmjsIm5+uorWuufHcKrji8S4R/Bu0gGuntKfT1j3Bth5/gEeJaSjbYMa6OBXfl1hpLhbXZzqFgNUeqd3/4ZzB9bDxdMfhzcvRGpiHM4f3AC/1u9AJpPh4qG/oKmhheC3BpVrPZLSs/D74SjRSeaO+ScQMqgxzO2MEb7/FvYtO4eG7eqgXqtaSIxJxa6FJ5GTlYsGIXWKP1gRHic9xhebv0BCegI87T1hbpB/IeZ2/G1su7wN1sbW+O7t71DDXLpB2srT7t9noXWPj2Fm5YArJ3fi0F/zUb9pZ3gFtENi3CPsW/c9cnNeoH6QuN8JNx8n4X+rz0BPWxMN3ayUj58kpb/A1jP3seH4Hczo3wR1Rc43/TwmBX98vQ8pCXLIZDI4edqg+9iWMLbIH6E/KyMHO+afFJ1kVqc4UFcMFCctIxv7wh+JTjIXj/ob/Wd2hIGxHlIT5FgzYRdeyLNh6WiKpNg0HN94GQNndVZejCqrqhADTDLLwfJpAzBwwjJY2kt3+1pdV+BsXMxFD+xTHG1NbfRo2KNcy1AndV2JfxifhshHSfByNoeztTGin6Xh71P3kJunQBvfGmjoJn7+SkA9CQaA/K6QVWcg4WKJ7Q5bHG0tDXQPEj8iXWmV51XY6hYDVDrXzuxBx/e/gHvDFoh/fAe/zRqOjh98oewJYGHrjGNbfhWdZN6LTXnt9scJ6aKO/1Li0zSY2+f3Jri0OwrthzRGw/b/Jq72ta1w8q8ropLMeQfn5Y/G/P4SGOqqzh8qz5Jj5p6Z+OnQT5jTc06Zy1Cn5GcxMLPOv5gZcXwrWvccpTLYk13Nujizd63oBGPhjqtoUc8Bn3b1KTDlkyAI+GnbFSzceQ0/fdRcVDmH1lyEdU1zDP6hC16kZ2P/inNYM2EX3v+mA0wLmae1rKpTHKgrBk5Hxr52+5NEuajjv/Q8JgVCXv6AUod/uwhjS0N8OK8b9Ax1kJWZg03fHcaRtZfw9lhx88FXhRhgkinCliWTCl0vCAoc/Gu+sh9592HTRZWjritw6urq81J8WjyMdI1goKM6B2duXi6uP7kOXydfycoqL+q6En/+VhymrD0HfV0tZGXnYcp7jTF7Uzjc7EygEIAJq09j5oAgSRLNnKxcXD9+H48j4/LndJMB5nYmcA9wgquvQ/EHkECiPBHbr2zHgKABailPatlZmYi6dBjJz57A0NQSnv5toG8o/jmt1Ixs3ItNRS07E5gY6CBFnoU9F6ORnatAi3oOqGkjfmCJAldh/7cbL9KzJL8KW5yqHgNUPHnqc9jVzE/CbGrUBmQyWNf49w6PrVMdSebHG7HgqOhjlIS2riYyU1/AzMYIqc/lcKij+n3s6G6F5HhxCe21J9ew6L1FBX5UAoChriEGNx2Mj//4WFQZ6qSlo4dMeQpMLe2QlpwAexfVqdLsXTyR+vyp6HLuxabi854NC51TWCaToUfTWvhYgjh5fDMe/aaGwsBEDwYmeuj1VVvsWXwGa/63G+9P7yDZfNPVKQ7UFQNfrzsn+hil9TjqGToOD4KeYf5gP7r62mjexxdb5h4TfeyqEANMMkW4c+UkatT2gallwQd7dXT1oasvzVUrdV2BU0dXHwB4nv4cE7dORFRcFDRkGmjr0Raftv1UmWymvkhF2F9hOPjZQVHlqIO6rsT/fuQWejWvjYEhnjhyJQYz/7yELgEuGNTOEwCwfN8NbDh2W3SSmfgkFeum7EVOdh60dDSRmiBHbb8aeHL7GS7uuQmPwJroPraFyoiJ5SFRnog1Z9ZUmQRjxfSB6Bv2E/QNTZGaFI/1P36KFxlpsLBxQnLCE5ze/Rv6ff6L8pmTsrj5OAkTVp1GRlYuDPW08d3AIHyz/gI0NWRQCAI2Hr+NuUOboY6DmahzKXAV1sIAH/7YVfKrsMWpajFApWdgYoGEpw9gYmGLxPhHEAQFEmMfKufIex77AAbG4nvWGOtr48NQbzQsYtCfh/FpmPT7WdHluDVyxMU9UXhrlBVqetsh8tQD2Lr+OwXPjZMPRF+cMdI1wtOUp0WOW/A09SmMdKW7Y1beXL0CEHFsGzq8Pw5OdXwQFX40/4LDP6IuHRH1vfmSubEuoh4nw9m68Pc/6nEyzCQYPC83Ow8amv/+TpPJZOg4Igh7lpzBbxP3oPtn4n6nvVSd4kBdMWBhpItPuvqgaREj8d95koKRiyS6IPXPb/Xc7LwCU74ZWxoiI+WF6CKqQgwwyRSh88CJOLplMbwD26vcxr9x/gCadRkCK3sXScpR1xU4dXT1AYAlx5dAJpNh4XsLIc+SY8nxJQj7Mwyze86GiV5++UIx86dVFuq6Eh8dn4bxPfOfE2hRzwGz/rqE5t7/fum29a2BfZceiS5n3/KzcGtUAx2GN4FMJsOpzVcRfT0Wg2a/hedPUvDH1/tx4s8raNGngahy7j67+9rtj5LEn4s6JcZFQ5GnAAAc37oURqZWGDBhKXT1jZD9IgNblk7Gie3L8dagwns/lMSq/ZFo7u2Ajzp6Y9f5h5i67hz8atsg7O0GAIAfNodj7eFb+LpfgBSnBKB8r8JWtxig0vP0b4vda75DbZ9gPLx1CQEhvXHk70XIlKdCJpPhzN7f4d5A/MWMOg5meJ72ArbmBoVuT3+RI7oMAGjzgT9WT9iF377aDTs3S5zddgPR12Jh6WSGxJgUxEQ9U5k3syw61euE7/Z8hw+afIBGzo2Uz2ElZSThUvQl/H72d7zdQNw0Y+rUotsw/DH3E6z/cQxsnd1x8dCfeHT7MiztnJEU9xhPHtxA92HTRJfzTrAb5m29jNtPktGwlrUyoUxOz0L4vWfYfeEhhnbwFl2OVQ1TPL37HFZOZirrOwxrAgDYOEOaaXuqUxyoKwbqOJrhdkxKkUlmIT+xy2zt5L3Q1NRAdmY2Ep+kwKbmvxfLUuLToW8s/oJGVYgBJpkiePq3gYOrJ3aunol7186g/XufQ99Q/OiOr1LXFTh1dPUBgIvRFzG963R42OV3iZjvOB9Td0zF2D/H4vt3vgeAQhPqykhdV+IBQIZ/p5fR0dKAod6/H199HS3IJfih9PBaHD78MUD5/gd08cLRteHISHsBSwdTtBsSgP3Lz4lOMof+NhQymazQiwkv11eVGHjVk/s30K7PZ8qeDDp6BgjuNAA7Vn0j6ri3nqRgROf6MNTTxttNa2HZvhvo1Pjf5767NnHFlN8l6g6khquw1TkGqGSCOw+ClrYunt6/AZ+mnRHY/j1YO9bGsa2/Iic7C271giQZ9KdzYxe8yMktcruNqT7G/nOxRgxjSwN8OLcLTm2+itvnHwOCgCe3E5CaIEcNT1v0n9kYDnXETaEyOHgw9LX1seHCBiw6ukj5GREEARaGFujbuC/6NO4j+lzUxdjMCv2/XIKz+/7A3WunIQgCYh/eRFpSPBxr1UPfsJ9hX9Oj+AMVo1uTWjA10MXmU3ex/ewDKP753tGQyVDHwRSf92iIlvXFD3TnHuiM68fvoX6rgg+bdxjWBIJCwKW9UaLLqU5xoK4YeLdZbbzILvp7wMHSELMHNxVdTvPeDf6z5ARtXdURXu9ceAQnL1vR5VSFGGCSKZKppT36jJmH07tWY813Q9G+71jJy1DXFTh1dPUB8h9INtL79xa+jpYOpnWdhq+3f42wP8PwVcevRJehLuq6Em9jpo+Y5+lwsMzve//TR81h85+pROJTMiWZ80nPUAfZmf9+Cedm5UKhUEDzn+6xNjXN85/TFMlEzwTDWgxDI6eC0+QAwIPnD/DV1qoTB8C/F0Zyc7JgaGqpss3IzBoZacmijp+bp4Cudv4AUlqaGtDT1oTpfyZ1NjXQQWpGtqgyXlLHVdjqGANUOhoaGgjq8L7KOk//NpJPV9DM+/Vz1Rkb6KB9I2kGPNMz0kWb/v5o099fkuMVpm9AX/QN6IsnyU+QmPHPtAUGFnAwU88z81LTMzBGy+7D0LL7sHItp5WPI1r5OCI3T4GUf74rTQ10oCXh4x/B7/i8dnvH4UHoODxIkrKqUxyoIwbqu1i+dru+jhZ8XcXPo1vcRfi2A6UbSb2yxwCTTAloaGgg+K1BqOnpj11rZkIQFJIeX11X4NTR1QcA7M3scT/hPpzMnZTrNDU08XWXr/H19q8xYcsE0WWoi7quxHcJcFX+uwMF50M8fytOkknGXX3tcWDleXQc3gSaWpo48vsl2LlaQvefZCY1QQ5DM/HJbB3bOnie/hx2poVPyZKelV5luky/tPHnMGhoaiH7RQaS4h4p72YDQGpinOheDtYm+niaKIfdP13+/tfbT+XCwvO0LJga6hT18hJT11XY6hgDJJ3qdie7PM7Hwcyh0vyYLA/lFQNamhqw/Oe7M08h7e+11ymv86nOcaCO74E8hQKaGuU7zsRLb1oMMMmUUA23+hg4YRmSE57A3Fra+QXVcQVOHV19AKCJSxNsv7IdLeq0UFn/MtGcsn0KEtLFP8eoDuq6Ev9WgMtrtw9u7yVJOW0H+OPPmYfw6ydbIJPJYGJpoHJhISP1BZp0rye6nK4+XZGZU/QdURsTG4wPHS+6HHUJ6thfZVlbVzURv3vtNGrUfv0V7uK09HFAivzfO5WBdVWTszM3Y1HXUXzXbHVdha1uMUCll5uTjePblyP24U3U8m6CwPZ9cXr3bzi7by0gk6F2/aZo1ycMuvoFR08sjUm/nUXL+g5o7u2g7A1QHnKz83Bk7SU8uZ2A2v410LRHfZzYeBmnNl8FANRp7IROI4KUF+2kkJCegO1XtiMmOQaWhpboXL8znC3UMw2VFIqMgf3rAECyGDh/Kw5WJvpwtTOBQiFg3dFb2HnuARLTs2BprIeuga7o3aK26ASgImIAqNpxwBiQRmWMASaZEtPRM1AZFUtq/70CVx7U0dVnSLMheJFT+DNdmhqamNplKp6lPSu38qlohmb6GDirM54/SUFejgJWNUxVRpL1bOoiSTnN67x+hD0TPRN08O4gSVnqENx54Gu3t3p7uOgy+rd5/TMpfVvWgYZG1bnzU91igErv+LZluHnxEDz82+L62b1ITYrDvWun0b7vWMg0NHByx0qc2L4cbXuNFlXOuVtxuHA7Hgt2XEWr+o7o6F8T7o5m0pzEfxz+/SJunHgA7+auuHLoDlKfyXH7wiN0HBEEDZkMR/8Ix5G14QgdGljmMjr83AHrP1wPMwMzPEh4gFHrR8HMwAy1rWvjzL0z2Hp5Kxb0XQA366oxAW2RMdAnTNIYWLzrOsZ0z58WbcPx29hy+h76tnSHs7URHiWkY8OxO5DJgN4txA1sqI4YAKpXHDAGyqYqxACTzHJ0bNtSyFOT0PH98r0av+3sfaTIs/FBm7rF71wJaGpoFjqvz3+3F9WFrqoJP7YFmekpaNqpfKdhkDoGLB3Ez+lI6qWno56v8wu7biIz9QWaixz8iehWxFF06j8BNT380LBFNyyb+gG6DZ2GOj7BAAB9Q1PsXfe96B+XALBoVEtcvP0Mey9FY9eFh3C1NUFHf2e08akBY4nuKNw8/RBdP20GV18H+HX0wKKPN6PnF61RNzD/boK+iR52LTgp6sdldm62shv5spPL4FvDF9O6ToOmhiYUCgW+3f0tlp9Yjhlvz5DknMqbumIgNjkDtv+MY3D4Sgw+6eqDlvXye5w1dreFo6UhFu26JjrBUEcMANUrDhgDZVMVYkA9nZDfUOnJCZJMIFucE9efYn94+Q/3f2HXTRxfH1Hu5Zy8cxJ7r+8t93LU4VbEMVw7W/7noq4YiDobjSuH75R7OdUpBoD8iw2ndq0u1zJORaopBs48ZAyQJDLTU2BuUwMAYGblAJlMQ2U+PHMbR2SmJ0tSlqmBLnoGu2HJJ63x00fN4eFkjlUHbuK9OfswY+MFhN8V33smIzULFg75z16b2xlDJpOpDJZnYW8MeWqW6HJeuh1/G739e0NTI78LsIaGBvo07oNb8bckK6O8qSsGjPW1kZCa34MqRZ4NRwvV+QMdLY3wPFX8qNnqjgGg6scBY0C8yhoDTDLLUaf+E9D70x/LvZzZg5tizdiQci9HXT8ulxxfgtn7Zpd7OerQe/RcDJu6rtzLUVcMHF5zETvmnyz3cqpTDADqudiwfG8kvt8cXq5lAEC/aaEY+es75V5OdYsBKsjY3BYx964DAJ4+iIRMJkPsw0jl9if3I2FkZl3Uy8vMo4Y5xnTzxR/j22NUFx88S3mBL1edFn1cUytDPL6Zn6w+ufUMMhnw5Pa/4wvE3EqAiWXhc3WWlEwmUz4zJoOsQK8gQx1DpL1IE1WGOqkrBoK97PHH0dvIUygQ5GmHbWfvqwwstvXMfdSyF9+DRx0xAFSvOGAMlE1ViAF2l6US6zctVC3lrB5Uvnd8qOyGL1DPxL7VLQZ6j55b7mUsHyPtYFMVrbrFABXk2+wt7Pl9Fq6e3oW46Fto9fZwHN++AolxjyGTARHHt8G/ba9yK19PRwuhjZwR2sgZj56JnwO6Yag7dsw/gcsHbuPp3QS0HdQYR9deQuKTFAAyXNpzE4HdxA2cJggCPlj5AWSQITMnE3ef3VV55upJyhNYGFq85giVi7piYHA7T3yx8hSG/HQIXk4WOHbtCS7dfYYaloZ4kpiBtMxszBggfmoRdcQAUL3igDFQNlUhBphkliN5aiIun9hebs/j9f/hAGYMaIIaVkbF70zlJi83B7cvn8CT+zeQkZY/T5GBsQUca3mjtk8wNLW0izlCycWnZMJITxsGuqof3dw8BW5EJ8JHgjme6M12Zss1eDR1gZkNv1eofPm3eRcGxuZ4ev8G6gd1hKd/W1g51MLJnSuRk/0Cfq3fQZPQ94s/UDHqu1hCu5iR2J2sxcd7YFdvGJrqI+bWM/i2rQ3vFrVgU9McR9eFIycrFwFdvRH8rrhRpl8dcdnRTHUk+xtPb6B57dcPqlWZqCsGDPW0MW9Yc+y5GI3TN2Nha2YAAQJyFQJa+ziic4ALbEz1iz9QMdQRA0D1igPGQNlUhRhgklmO5KmJOLV7jegk8+/T9wpdH5+SgX2XomH+z2izbwfVElXOSw+uPMWjG3FIT8qETEMGM1sj1AlwknwwmMinkbj+9DoS5f9MIGtoAW97b3jae0paTnlKin+MvxZ8gfSUBNi7eMLAOH8KifjHt3H5xDYYm1mj58ffKZ83KKvnaS/w9dpzuBWTDJkMaONTA6O6+CiTzdSMbIxbcQp7p3cVfU6F+X3SHrz1SbNyTzw+2/gZvgj9osoO/PQw6hJi7l5FespzyDQ0YGZpDzefprCwcSr+xWXwNFGOJ4lyWBrrFZg7tawOrr6AQ79dhEs9e/iG1EHdJs7QKsdpH15V1WOASsercQi8Gv/b1d/ZvQGc3X+StIzvhwRLerzXqdeyFuq1/LctrlnPDv1ndJTs+MWNuNy/Sf/Xbq+M1BEDQP7o/G8FuBQ7JZhY5R0DQPWLA8ZA6VWFGGCSKUJ8zN3Xbk+Mk2YQjsW7rsHKRK/A9ASCAByIeAxNTRlkkIlOMuXJmdg44yCe3nkOmUwGQRBg62qBqDMPcei3iwjs6o22A8RPbZIkT8KU7VNw7ck12BjbKG/nJ8oTsTBtIeo51MPULlNhbih+zr/ytn/DPFg5uKL/l0sKzOGUlSnHrjUzcWDjT3h31BxR5SzfewMyAD9/1BzyrFws33sD41ecxMwBQZKNjAgAt85FF7o++kYc7px/BBPr/HN0DxA399LJu4U/13k15ipO3zsNGxMbAECwm/p+HIohT03C379+hdjoKMhkGhAEBWxq1MbtyydwbOtS+Ld5Fy3f/khUGT9vu4wPQ71hoKuFrJw8zP7rEk7c+HdgMR8XS0x9P7DAXe6y6PxxU9w6G41t845D11Ab9VrUQoN27rCpKd1nsrrFABEREf2LSaYIa2YOBWSy/GzvVS/Xi5zUFQA6+dfEzcdJ+PJdP9S0+XeEqo6Tt2PGwCZwsZHmDsa+ZedgZG6Asb+3h6aWJg6uvoAseTaG/NAFD648xebvj8DYwgABXbxElTPv0DwoBAVWDVxVYKLY6MRozNk3B/MOzcPULlNFlaMOT+5dQ79xiwqdJFhX3xDN3hqMtd9/LLqc8LvPMKVfAOrWyP+RX29YM3yz/gLGrzyFWYOaij7+S3/OPKS8wPCqvcvOAsh/2Px/m8XdnZ+0dVKR5cw/PF9ZzsHPDooqR10O/TUfRqaW+GT2NmhqaePo34uR9UKO/l/8iodRl7B9xTQYmVnCr3XZB8zZef4hPmjjAQNdLaw9HIWbj5Mwa1BTeNQww92nKZi9KRx/HL2FIe3FfT4BoLZfDfi2rQN5ciauHL6Dywfu4MKum7B3s0SDdnXg1cxV9ETS1S0GSHrqmgZsxb4bSErPwtgeDcu1nMO/XYQ8ORNvfdKs3MpYemIpkuRJBbrSVVWMgbKpTnHAGCibyhADTDJF0DM0Qcvuw+Ds3qjQ7c9jH2Dz4q9El/NpN1+cuP4U/1t9Br2au6FbE2m6xb7q7qXH6D+zk/LHY+sPGuGHfn8gdFggXHzs0W5wAE7+eUV0knn+wXn81PunAgkmADhbOGNU61H4bONnospQFx19I6Q+fwprB9dCt6c8fwodffFdTOVZuTDS+/fZTh0tTUx5rzGm/3EB41acxJfv+IkuAwDcGjpCpiHDW6OCYWj277MJM3uuwYc/doW1s5kk5TR2aQwNmQbGtx+vcse63bx2WPr+UrhYuUhSjrrcv3EOfcPmKy82NO82FPPHdUXbd0ejZt1GaN3zY5zZs1ZUkvlfZ6Li8GGoFxrUyn8G17umJYZ3rIele69LkmS+ZGimj6C36yPo7fqIvh6LiAO3sX/FeexfcR7j14t7Rqa6xQBJLz05AWlJ8eVeTkLqCzxLySz3ctKeZyD1ubxcy0hIS0B8Wvm/Z+rCGCib6hQHjIGyqQwxwCRTBFunOkhPfg5Ty8KfHcrKTC/8LmcZNPO2R90aZpizKRxno+LxeY8Gkhz3vzS1NZXDIQNQ3mXIy1MAAGp42CA5XvwIfDqaOpBnFf0By8zOhI6mdF1Ay5NP007YteY7BHX8AM51G8Hwn2cy5WlJiI66hDN7fkfDluJHZLUzN8D9uFSVQZ40NTQwqa8/pv9xARN/Oyu6DADoM7kdzm67jhXjdqDDsCao07h8niWc1WMW/rz4J4avG45P23yKpm7S3Y2tCJqa2q98dvK7zCoUuQAAx1r1kJIofs7cl0Ukpr2A6yvPYNayM5GkgZQV0fvC2dsOzt52CB0aiBsn7osup7rFAEmvU/8Jailn/DuFXyiWWtcx5T8Ix4SO6nnP1IUxUDbVKQ4YA2VTGWKASaYIvs26Iie76B91xuY26CDh7X1rU33MGhSE9cdu4+OFRyFAmgT2JSdPGxxbH44uo5tBU0sTR36/BDNbIxj8M7BQRuoL6BuJT/5a1W2F7/Z8h5GtRqKRcyPl3D7yLDkuRV/CwqML0cajakzH0OytwdDW0ce5AxtwZPOif7MAQYCBiQUC2vVFQLs+ossJcLfFrvMP0dzbQWX9y0Rz2rrzSEiV5gpcYFdv1Kxnh60/Hsft84/QbkiAJMd91bt+76KBUwPM2DUDp++dxshWI8ulHHVwdKuHkztXouMHX0JTSxvHty2DmaU99A3zB8vKSEuGnoH4bu2rD9yEro4mNGQyPE97oTLYT2pmNnQlGKCnsO6r/6VroIOG7euKLgeoXjFAZZORnoJrp3fjyf3rkKfmDwJnaGIBB1dv1GvSAQbGZpKUkyLPwt5L0bgRnYSk9PyJ0M2NdOHlbI72jZxhZqgrSTkZqS9w+eBtPL75DPLk/O9kQzN91PCwhk+bOjA01RNdRkpmCnZf243rT64jMeOfgfMMLODt4I0O3h1gZmAmugx1YgyUTXWKA8ZA2VT2GGCSKYJ7g9dfjdA3NEG9Jq8f/am0ZDIZ+rZ0h19tG1x7+ByWRtIEKgC0HdgY677ehx/6/QEA0NbTQs/xrZTbEx4lo37r2qLL+bjlx1AICkzfOR15Qh60NPLDMFeRC02ZJjrW64jhLYaLLkddAtv3RWD7vkhOeKLy5Whm5VDMK0tuUDsPvMjOK3SbpoYGJr/XGAkpLyQrz66WJQZ//xYOrDiPZZ9tk/yCxkt1bOpg8fuLseDIAgz9bWixCU5l1arHCPw5fxzmj8sf3VdbVw/dhnyt3P489iHqBbYXVUZ9F0s8SsjvSeBsY4y4ZNWLCuduxUsywuxXfw8UfYzSqC4xQKX39EEk/lrwBbR1dOFc1w/m/4zCLE9NxKWjm3Fu/x/oOXIW7Gt6iCrn5uMk/G/1Gehpa6Khm5WyR0hS+gtsPXMfG47fwYz+TZTPvJfVk1vP8Me0/dDW1YKLjz0sHfM/j+lJmTi/8yZOb76GPpPbwaFO2aeainwaiS82fwFdbV34OfvByTz/PUvMSMTm8M344/wfmNVjFjzsxL1n6sIYKJvqFAeMgbKpCjHAJLOKcnc0g7ujmaTHNLczxrCfuuHRjTjk5SrgWNcaBib/JrG+betIUo6Olg7CQsLwUfOPcCvulsrVF3dbd+WdzarGzMpB0sTyvzQ1NGCoV/Q8b5oaGrA1N5C0TG1dLXQcEYRb56Lx8GosDEykucL3Kl0tXYSFhOHk3ZOIeBQBU31pp8pRBzMrBwz8ajke370KRW4O7F29YWD073nUDxI/dHlx0zC08XFEu4bl0725vFWHGKDSO/jnfNRt1BLt+oQV6KYtCAL2r5+LQ3/OR7/PF4gqZ+GOq2hRzwGfdvUptJyftl3Bwp3X8NNH4rqx7V12Fp5NXdBxRFCh5exedBr7lp3FwFmdy1zG/MPz0dK9JcJCCn/P5h6Yi/mH52NBX3HvmbowBsqmOsUBY6BsqkIMvH52YirWpaN/Y9eamYi8cAgAcP3cPqyYPhDLpw3AsW1Locgr/O5Tadx+koynif8+w3gg4hHGLDmOfnP24bOlJ3DkSozoMgBg79KzeHonAbUaOqJOYyeVBLM8GOoaoqFzQzSt1RRZuVm4GH0R+27sQ0pmSrmWK7XqFgPR12NV1rkHOKPdkACVgYCklpmdiZTMFOhq6eLIrSNVLgYObvwZsdG34OrZGG71m6okmOUlMzsXey5GY+X+SGw9cw+GetqSTCT99O5zJMWmKZevHrmL1V/uws8f/ok1E3bh+nHxz2MWpqrHAJXes5i78Gv9bqHPActkMvi1fhfxj++ILudebCp6NK1VZDk9mtbC3afi4y3+QRICunoVWU5AVy/E3U8UVcbdZ3fxrl/R79m7fu/iTrz490xdGANlU53igDFQNlUhBphkinB69284vm0ZcrJf4PDmhTi77w8c3rQQno1D4B3YHldP7sLp3WtEl/P95nA8TcoAAOy68BA/bb0Md0cz9G3pjrqOZvhxSwT2XCx8fsPSuLArEr9P2otFH2/Gqc1XkZ5UPqNsDVw1UPkDMj4tHoPXDMbCIwtx8eFFrDq9CoNWDcKT5CflUrbUGANl82oMDFo9qMrGAACEH9uCDT99hmVTP8DZfX8ou01L6cOfDiE1IxsAEJ+SiaE/H8avu6/h0t1nWHMoCh/+dEjlQkRZ7Zh/Aslx+Ulm+P5b2LXoNOxrWyL4nfqwr22FXQtPIuLAbdHlVLcYoNIzNLFA7MPIIrfHPoyEgbH4uVnNjXUR9Ti5yO1Rj5NhZiS+p4ahmT6e3E4ocvuT2wmin8WyMLRA5NOi37PIp5EwN6j8c0y/xBgom+oUB4yBsqkKMcDusiJcO7MHHd//Au4NWyD+8R38Nms4On7wBbwC2gEALGydcWzLrwh+a5Cocp48l8PRIr8L6Y5zDzCiUz10auyi3O7uaIY/jt5CB7+CU4KUVt8p7XD7/COc2XINR9eGo7afIxq0c4ebXw1oaIif8xPInwtTocgfsXbp8aWwMrLC0g+WwkjXCBnZGZi8bTKWn1yOSZ0nSVJeeWIMlM2rMWBtbI1l/ZdVyRh46d2Rs3H32mmcP7gBJ3asQC3vQPg07QRX7ybQ0BB/Pe9RQjryFPnPK67YdwNWJnr4dVQrGOppIyMrF9PWncPKA5H4Xy9/UeUkPk2DuX3+MySXdkeh/ZDGKgP92Ne2wsm/rqBBiLju89UxBqh0/Nv2wt4/fkBs9C3UrNtI+UMyIy0JD6Mu4eqpnWj5tvjn898JdsO8rZdx+0kyGtayVv6QTE7PQvi9Z9h94SGGdvAWXU6Tbt7YtfA0Yu8+h4uPvbL3hzw5Ew+uPEX4/ttoO0Dc57OXXy/8cOAH3Iq/hUbOjZQ/IpMyknAp+hJ2Xt1ZpcY0YAyUTXWKA8ZA2VSFGGCSKYI89Tnsaub/+LKpURuQyWBd49+BcWyd6iA9peirGSWlq62JlIxs2JobICEls8BDyR41zBH7z10usWxqmsPV1wFtBzZG1JmHuHzwNv787hAMTfXh26Y2fNrUhoWD+MFFXrrx9AY+C/kMRrr5D2Ab6BhgQNAAfLPrG8nKKE+MAfGqegy8ZOVQCzU9/NDy7eG4HXEc187sxpYlk2FgbIZ6TTqgXpMOMLepIUlZkY+SMLqrDwz/mTvVQFcLH7SpixkbL4k+trauJjJTX8DMxgipz+VwqGOtst3R3UqSqYz+q7rEAJVOo5ZvQ9/QFBcP/4WI49sgKPIfLZBpaMLWqQ46vP8FPPxaiy6nW5NaMDXQxeZTd7H97AMo/hlcSkMmQx0HU3zeoyFa1ncUXY5/Z0/om+jh3PbruLg7SnkRRUNDA3ZuFujySTC8mhU+p3JJvd3wbZjqm+KvS39h2+VtyPvnPdPU0EQdmzr4IvQLtK4r/j1TF8ZA2VSnOGAMlE1ViAEmmSIYmFgg4ekDmFjYIjH+EQRBgcTYh7B2yA+e57EPJLnF39jdFjvOPUDY2w1Q39USx68/gZv9v898Hb0WA3sLaQfL0dTSgFczV3g1c0XKs3RcPngHVw7exqnNV/G/zQNEH/9lH/Ks3CxYGlqqbLM2skZyRrLoMtSBMVB21SUGXqWpqQUPv9bw8GuN1MQ4XD29G9fO7MHZ/X/g8/kHRR375aMX2Tl5sDRW7W5jZaKPFHmWqOMDgFsjR1zcE4W3RlmhprcdIk89gK2rhXL7jZMPYG5nLLocoPrGAJWcp38bePq3QV5eLjLT87tP6xuZQlNT2p8nrXwc0crHEbl5CqT80+3c1EAHWprSPjXk3dwV3s1dkZerQEZq/ojfBiZ60NSSrpw2Hm3QxqMNcvNylV3OTfVNoSXxe6YujIGyqU5xwBgom8oeA5WjFlWUp39b7F7zHWr7BOPhrUsICOmNI38vQqY8FTKZDGf2/g73Bi1FlzOkvSc+W3oCY5edQB1HM2w6eReX7z+Hs7URHiekI/JREr5+r3zmMgQAU2sjtOjTAM17++L+ZfETygNA2F9h0NLQQkZ2Bh4lPYKr1b9XdeJS42CiL92dsvLEGCi76hIDr2NiYYvgzgPRtNMAPLx5UfTxxq84BS1NDWRk5eJRQrrKlCVxyRkwMRA/j22bD/yxesIu/PbVbti5WeLsthuIvhYLSyczJMakICbqGd6ZIM08tm9CDFDJaGpqwcjUsvgdRdLS1ChwgaY8aGppwNhC2hG/X6WlqQVLo/J/z9SFMVA21SkOGANlU1ljgEmmCMGdB0FLWxdP79+AT9POCGz/Hqwda+PY1l+Rk50Ft3pBop/FA/LvUCz6uBXWH7uNs1GxEAQg6nESnqVkwtvZAj8O9RY9rw+Qn0jINIt+5k4mk6FWA/FTdPRv0l9lWU9b9YN++t5p+Dj6iC5HHRgDZVOdYgDITyY1XnMlVCaTwcVT3DMY/Vq7/2fJFno6ql/fZ6LiUM/FAmIZWxrgw7ldcGrzVdw+/xgQBDy5nYDUBDlqeNqi/8zGouf3AqpfDBAREdG/mGSKoKGhgaAO76use3nLX2pG+tr4MNQLH4Z6SX7sl0Yteafcjv1fA5sOfO324S2rxsPqAGOgrKpTDADAsGl/lHsZ/du8fkLlYRIMWPCSnpEu2vT3R5v+4gcnKEp1iwEiIiL6F6cwISIiIiIiIskwySQiIiIiIiLJMMkkIiIiIiIiyTDJJCIiIiIiIskwySQiIiIiIiLJMMkkIiIiIiIiyTDJJCIiIiIiIskwySQiIiIiIiLJMMkkIiIiIiIiyTDJJCIiIiIiIslInmTOnDkTjRs3hrGxMWxsbNC9e3dERUWp7PPixQuMHDkSlpaWMDIyQs+ePREXF6fcnpiYiC5dusDIyAgNGzZEeHi4yutHjhyJH374QeqqExERVQkLFiyAi4sL9PT0EBgYiHPnzhW579KlS9G8eXOYm5vD3NwcISEhr92fiIhILMmTzKNHj2LkyJE4c+YM9u/fj5ycHLRv3x5yuVy5z2effYbt27fjzz//xNGjR/HkyRP06NFDuf3bb79FWloaLl26hFatWmHo0KHKbWfOnMHZs2cxZswYqatORERU6W3YsAFhYWGYMmUKLl26BF9fX4SGhiI+Pr7Q/Y8cOYK+ffvi8OHDOH36NJycnNC+fXvExMSoueZERPSmkDzJ3LNnDwYOHAhvb2/4+vpi1apViI6OxsWLFwEAKSkpWL58OebOnYs2bdrAz88PK1euxKlTp3DmzBkAQGRkJPr06QN3d3cMGzYMkZGRAICcnBwMHz4cixcvhqamptRVJyIiqvTmzp2LoUOHYtCgQfDy8sLixYthYGCAFStWFLr/2rVr8fHHH6NBgwbw8PDAsmXLoFAocPDgQTXXnIiI3hTl/kxmSkoKAMDCwgIAcPHiReTk5CAkJES5j4eHB5ydnXH69GkAgK+vLw4dOoTc3Fzs3bsXPj4+AIDZs2ejVatW8Pf3L7bcrKwspKamqvwRERFVZdnZ2bh48aJKG6qhoYGQkBBlG1qcjIwM5OTkKNvlwrANJSIiMbTK8+AKhQJjxoxBcHAw6tWrBwCIjY2Fjo4OzMzMVPa1tbVFbGwsAODLL7/EiBEj4ObmBhcXFyxfvhy3b9/G6tWrcfr0aQwfPhz79u2Dv78/li5dClNT0wJlz5w5E1OnTi2wPiYmplSNpUFuRinOuOwSNB3VUo5usolayok3LLzblpTSH6eXexkAY6Cs1BEDgHrigDFQNpU1BtLS0sqpJuUvISEBeXl5sLW1VVlva2uLmzdvlugYX3zxBRwcHFQS1VexDS1cdfrssA0tm+oUAwDb0LJ402OgpG1ouSaZI0eOxLVr13DixIlSvc7U1BTr1q1TWdemTRvMmTMHa9euxb179xAVFYWhQ4di2rRphQ4CNGHCBISFhSmXU1NT4eTkBEdHR5iYlDw4MiKTS1X3srLKU8+zMVlmOWopx0ZuU+5lmNUwK/cyAMZAWakjBgD1xAFjoGwqawy8yXflvvvuO6xfvx5HjhyBnp5ekfuxDS1cdfrssA0tm+oUAwDb0LJ402OgpG1ouSWZo0aNwo4dO3Ds2DHUqFFDud7Ozg7Z2dlITk5WuZsZFxcHOzu7Qo+1cuVKmJmZoVu3bujRowe6d+8ObW1tvPvuu5g8eXKhr9HV1YWurq6k50RERFSRrKysoKmpqTIiO/D6NvSl77//Ht999x0OHDigfAylKGxDiYhIDMmfyRQEAaNGjcLff/+NQ4cOwdXVVWW7n58ftLW1VQYciIqKQnR0NIKCggoc79mzZ5g2bRrmz58PAMjLy0NOTv4VhJycHOTl5Ul9CkRERJWSjo4O/Pz8VNrQl4P4FNaGvjR79mxMnz4de/bsKdG4BkRERGJIfidz5MiRWLduHbZu3QpjY2Plc5ampqbQ19eHqakphgwZgrCwMFhYWMDExASffPIJgoKC0KRJkwLHGzNmDMaOHQtHx/x+1sHBwfjtt9/Qvn17LFmyBMHBwVKfAhERUaUVFhaGAQMGwN/fHwEBAZg3bx7kcjkGDRoEAOjfvz8cHR0xc+ZMAMCsWbMwefJkrFu3Di4uLsp22cjICEZGRhV2HkREVH1JnmQuWrQIANCqVSuV9StXrsTAgQMBAD/++CM0NDTQs2dPZGVlITQ0FAsXLixwrL179+LOnTv47bfflOtGjRqFCxcuIDAwEAEBAZgyZYrUp0BERFRp9e7dG8+ePcPkyZMRGxuLBg0aYM+ePcrBgKKjo6Gh8W9HpUWLFiE7OxvvvPOOynGmTJmCr7/+Wp1VJyKiN4TkSaYgCMXuo6enhwULFmDBggWv3S80NBShoaEq6wwMDLBx40ZRdSQiIqrKRo0ahVGjRhW67ciRIyrLDx48KP8KERER/Ue5z5NJREREREREbw4mmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkGSaZREREREREJBkmmURERERERCQZJplEREREREQkmQpLMhcsWAAXFxfo6ekhMDAQ586dU24LCwuDhYUFnJycsHbtWpXX/fnnn+jSpYu6q0tERFRpvK4NLcyff/4JDw8P6OnpoX79+ti1a5eaakpERG+iCkkyN2zYgLCwMEyZMgWXLl2Cr68vQkNDER8fj+3bt2PdunXYt28fZs+ejQ8//BAJCQkAgJSUFHz11VdYsGBBRVSbiIiowr2uDS3MqVOn0LdvXwwZMgTh4eHo3r07unfvjmvXrqm55kRE9KaokCRz7ty5GDp0KAYNGgQvLy8sXrwYBgYGWLFiBSIjI9GqVSv4+/ujb9++MDExwf379wEA48ePx4gRI+Ds7FwR1SYiIqpwr2tDC/PTTz+hQ4cOGDduHDw9PTF9+nQ0atQIv/zyi5prTkREbwotdReYnZ2NixcvYsKECcp1GhoaCAkJwenTp/Hxxx9jyZIlSEpKwr1795CZmYnatWvjxIkTuHTpEhYuXFiicrKyspCVlaVcTklJAQCkpqaWqr6Z8tLtX1ZpGdlqKSczLav4nSSQ+qL83zeNVPVcI2EMlI06YgBQTxwwBsqmssbAy3ZAEITyqE65Kq4NLczp06cRFhamsi40NBRbtmwpshy2oYWrTp8dtqFlU51iAGAbWhZvegyUuA0V1CwmJkYAIJw6dUpl/bhx44SAgABBEARhypQpgpubm1CvXj1h8+bNQlZWllCvXj3hwoULwvz58wV3d3ehadOmwrVr14osZ8qUKQIA/vGPf/zjH/8K/Xv06FG5tnfloSRt6Ku0tbWFdevWqaxbsGCBYGNjU2Q5bEP5xz/+8Y9/r/srrg1V+53Mkvj666/x9ddfK5enTp2KkJAQaGtr45tvvsHVq1exY8cO9O/fHxcvXiz0GBMmTFC5cqtQKJCYmAhLS0vIZLLyPoVKKTU1FU5OTnj06BFMTEwqujpUARgDxBgABEFAWloaHBwcKroqlRbb0IL42SHGADEGSt6Gqj3JtLKygqamJuLi4lTWx8XFwc7OrsD+N2/exO+//47w8HCsWLECLVq0gLW1NXr16oXBgwcjLS0NxsbGBV6nq6sLXV1dlXVmZmaSnktVZWJi8sZ+MCgfY4De9BgwNTWt6CqUSWnbUACws7Mr1f4A29DXedM/O8QYIMZASdpQtQ/8o6OjAz8/Pxw8eFC5TqFQ4ODBgwgKClLZVxAEfPTRR5g7dy6MjIyQl5eHnJwcAFD+Ny8vT32VJyIiqkClaUNfCgoKUtkfAPbv31/k/kRERGJVSHfZsLAwDBgwAP7+/ggICMC8efMgl8sxaNAglf2WLVsGa2tr5byYwcHB+Prrr3HmzBns3r0bXl5evLJKRERvlOLa0P79+8PR0REzZ84EAHz66ado2bIlfvjhB3Tu3Bnr16/HhQsXsGTJkoo8DSIiqsYqJMns3bs3nj17hsmTJyM2NhYNGjTAnj17YGtrq9wnLi4O3377LU6dOqVcFxAQgLFjx6Jz586wsbHB6tWrK6L6VZauri6mTJlSoAsUvTkYA8QYqPqKa0Ojo6OhofFvR6WmTZti3bp1mDhxIv73v/+hTp062LJlC+rVq1dRp1Al8bNDjAFiDJScTBCq4BjuREREREREVCmp/ZlMIiIiIiIiqr6YZBIREREREZFkmGQSERERERGRZJhklkCrVq0wZswY5bKLiwvmzZv32tfIZDJs2bJFdNlSHYeIiKgisA0lInrzVOsks0uXLujQoUOh244fPw6ZTIYrV66U+rjnz5/HsGHDxFZPxddff40GDRoUWP/06VN07NhR0rKKkpmZCQsLC1hZWSErK0stZVZFMpnstX9ff/21qGOX5gfRRx99BE1NTfz5559lLpPKhnFA1R3b0JJZtWqV8nOvoaEBe3t79O7dG9HR0QX2vX79Onr16gVra2vo6urC3d0dkydPRkZGRoF9w8PD8e6778LW1hZ6enqoU6cOhg4dilu3bhVbpz/++AOampoYOXJkofUtavq3wr57Nm3ahFatWsHU1BRGRkbw8fHBtGnTkJiYWGw9iiqjor87/1ueiYkJGjdujK1btxbYLzMzE1OmTIG7uzt0dXVhZWWFd999F9evXy+wb2pqKr766it4eHhAT08PdnZ2CAkJwebNm1HcGJvF/f4q6rwGDhyI7t27q6y7c+cOBg0ahBo1akBXVxeurq7o27cvLly48Po3RY0YAwVVxxio1knmkCFDsH//fjx+/LjAtpUrV8Lf3x8+Pj6lPq61tTUMDAykqGKx7Ozs1DZM8qZNm+Dt7Q0PD48Kv/IrCAJyc3MrtA5Fefr0qfJv3rx5MDExUVn3+eefq6UeGRkZWL9+PcaPH48VK1aopczXyc7OrugqqBXjoHBvWhxUZ2xDS+7l5z8mJgabNm1CVFQU3n33XZV9zpw5g8DAQGRnZ2Pnzp24desWvv32W6xatQrt2rVT+ezs2LEDTZo0QVZWFtauXYvIyEj8/vvvMDU1xaRJk4qtz/LlyzF+/Hj88ccfePHiRZnP66uvvkLv3r3RuHFj7N69G9euXcMPP/yAy5cv47fffivTMSvLd+fKlSvx9OlTXLhwAcHBwXjnnXdw9epV5fasrCyEhIRgxYoV+Oabb3Dr1i3s2rULubm5CAwMxJkzZ5T7Jicno2nTplizZg0mTJiAS5cu4dixY+jduzfGjx+PlJSU19ZFqt9fFy5cgJ+fH27duoVff/0VN27cwN9//w0PDw+MHTu2zMeVGmOgoGoZA0I1lpOTI9ja2grTp09XWZ+WliYYGRkJixYtEhISEoQ+ffoIDg4Ogr6+vlCvXj1h3bp1Kvu3bNlS+PTTT5XLNWvWFH788Ufl8q1bt4TmzZsLurq6gqenp7Bv3z4BgPD3338r9xk/frxQp04dQV9fX3B1dRUmTpwoZGdnC4IgCCtXrhQAqPytXLlSEAShwHGuXLkitG7dWtDT0xMsLCyEoUOHCmlpacrtAwYMELp16ybMmTNHsLOzEywsLISPP/5YWdbrtGrVSli8eLGwaNEioV27dgW2X7t2TejcubNgbGwsGBkZCc2aNRPu3Lmj3L58+XLBy8tL0NHREezs7ISRI0cKgiAI9+/fFwAI4eHhyn2TkpIEAMLhw4cFQRCEw4cPCwCEXbt2CY0aNRK0tbWFw4cPC3fu3BG6du0q2NjYCIaGhoK/v7+wf/9+lXq9ePFCGD9+vFCjRg1BR0dHcHNzE5YtWyYoFArBzc1NmDNnjsr+4eHhAgDh9u3bxb4nxVm5cqVgamqqsm7p0qWCh4eHoKurK9StW1dYsGCBcltWVpYwcuRIwc7OTtDV1RWcnZ2FGTNmCIKQH1f/jYGaNWu+tuxVq1YJTZo0EZKTkwUDAwMhOjpaZXtR78tLr/v3fDXmBUEQunXrJgwYMEC5XLNmTWHatGnCBx98IBgbGyu3vS7WX9q2bZvg7+8v6OrqCpaWlkL37t0FQRCEqVOnCt7e3gXO1dfXV5g4ceJr34+KxDhgHFRHbENL1oYW9vn/+eefBQBCSkqKIAiCoFAoBC8vL8Hf31/Iy8tT2TciIkKQyWTCd999JwiCIMjlcsHKykr5eXhVUlJSkXURBEG4d++eoK+vLyQnJwuBgYHC2rVri63vS/99v86ePSsAEObNm1emepRERX13vhoXqampAgDhp59+Uq777rvvBJlMJkRERKi8Ni8vT/D39xe8vLwEhUIhCIIgjBgxQjA0NBRiYmIKlJWWlibk5OS89n0o7vfXq/V96WW8CkJ+jHl7ewt+fn4FYkwQpPn3Kg+MgXzVMQaqdZIpCIIwbtw4wc3NTRkEgiAIK1asUH4BP378WJgzZ44QHh4u3L17V/j5558FTU1N4ezZs8r9X9dA5uXlCfXq1RPatm0rRERECEePHhUaNmxYIBimT58unDx5Urh//76wbds2wdbWVpg1a5YgCIKQkZEhjB07VvD29haePn0qPH36VMjIyBAEQTWo0tPTBXt7e6FHjx7C1atXhYMHDwqurq4qP/gGDBggmJiYCMOHDxciIyOF7du3CwYGBsKSJUte+z7duXNH0NXVFRITE4Xnz58Lenp6woMHD5TbHz9+LFhYWAg9evQQzp8/L0RFRQkrVqwQbt68KQiCICxcuFDQ09MT5s2bJ0RFRQnnzp1TvkelSTJ9fHyEffv2CXfu3BGeP38uRERECIsXLxauXr0q3Lp1S5g4caKgp6cnPHz4UHmsXr16CU5OTsLmzZuFu3fvCgcOHBDWr18vCIIgfPvtt4KXl5fKuY4ePVpo0aLFa9+Pknr1y/H3338X7O3thU2bNgn37t0TNm3aJFhYWAirVq0SBEEQ5syZIzg5OQnHjh0THjx4IBw/flz5gyw+Pl754+jp06dCfHz8a8tu3ry58MsvvwiCIAg9e/YUpk2bprL9de9Lcf+eJU0uTExMhO+//164c+eOMjF5XawLgiDs2LFD0NTUFCZPnizcuHFDiIiIUDYQjx49EjQ0NIRz584p97906ZIgk8mEu3fvvvb9qEiMA8ZBdcU2tPg29NXPf1xcnNC6dWtBU1NTSE9PFwQhP34BFEjAX2rXrp3g6+srCIIgbN68WQAgnDp1qsgyX2fSpEnCO++8IwiCIMyfP19o06bNa+v7X/99v0aPHi0YGRmV6CJ1WVXUd+d/zzMnJ0f48ccfBQDCokWLlPv4+PgI7du3L/T1a9euVf6uycvLE8zNzYVhw4aV6T0o7vfXq/X9r/8mGMXFWGXFGKi+MVDtk8zIyEiVZEYQ8n+Uvf/++0W+pnPnzsLYsWOVy69rIPfu3StoaWmpXLnYvXt3kcHw0pw5cwQ/Pz/l8pQpU5QNzH/99zhLliwRzM3NlY2WIAjCzp07BQ0NDSE2NlYQhPxgq1mzppCbm6vc59133xV69+5dZF0EQRD+97//qVw17datmzBlyhTl8oQJEwRXV9ciGxsHBwfhq6++KnRbaZLMLVu2vLaegiAI3t7ewvz58wVBEISoqCgBQIG7my/FxMSo/ODJzs4WrKyslF9WYr365ejm5lbgwz19+nQhKChIEARB+OSTT4Q2bdqo/GD7r+Li5qVbt24J2trawrNnzwRBEIS///5bcHV1VR63uPeluH/PkiYXRV1p/69XYz0oKEjo169fkft37NhRGDFihHL5k08+EVq1alVsORWJccA4qK7Yhhbfhr68k2poaCgYGBgo76KMHj1auc/69esLtIP/NXr0aEFfX18QBEGYNWuWAEBITEwsssyi5OXlCU5OTsq29NmzZ4KOjo5w7949lfqWJMns2LGj4OPjU+o6lEZFfXcCEPT09ARDQ0NBQ0NDACC4uLgIz58/V+6jp6dX4PvvpZc/5jds2CDExcUJAIS5c+cWW25hivv99bK+xSUYGzZsEAAIly5dKlM9KgpjoPrGQLV+JhMAPDw80LRpU+WzSnfu3MHx48cxZMgQAEBeXh6mT5+O+vXrw8LCAkZGRti7d2+hD+wXJjIyEk5OTnBwcFCuCwoKKrDfhg0bEBwcDDs7OxgZGWHixIklLuO/Zfn6+sLQ0FC5Ljg4GAqFAlFRUcp13t7e0NTUVC7b29sjPj6+yOPm5eVh9erVeP/995Xr3n//faxatQoKhQIAEBERgebNm0NbW7vA6+Pj4/HkyRO0bdu2VOdTGH9/f5Xl9PR0fP755/D09ISZmRmMjIwQGRmpfO8iIiKgqamJli1bFno8BwcHdO7cWfnvv337dmRlZRV4VkYKcrkcd+/exZAhQ2BkZKT8++abb3D37l0A+Q9oR0REoG7duhg9ejT27dtXprJWrFiB0NBQWFlZAQA6deqElJQUHDp0CEDx78vr/j1L49V/L6D4WI+IiHhtrAwdOlT5HFF2djbWrVuHwYMHi6qnOjEO8r3pcVBdsA0tvg0FAGNjY0RERODChQv44Ycf0KhRI3z77bcF9hOKGfyjpPsUZf/+/ZDL5ejUqRMAwMrKCu3atSvT89pi6lEW6vzuBIAff/wRERER2L17N7y8vLBs2TJYWFio7FPe/14l+f1VUur+9yoPjIF81SUGqn2SCeQPXrBp0yakpaVh5cqVcHNzU/7omjNnDn766Sd88cUXOHz4MCIiIhAaGirp4BWnT59Gv3790KlTJ+zYsQPh4eH46quvym2AjFd/MMpkstcG6t69exETE4PevXtDS0sLWlpa6NOnDx4+fIiDBw8CAPT19Yt8/eu2AYCGRn6Y/Tf4c3JyCt33v40/AHz++ef4+++/MWPGDBw/fhwRERGoX7++8r0rrmwA+PDDD7F+/XpkZmZi5cqV6N27d7kMOpGeng4AWLp0KSIiIpR/165dUz4c3qhRI9y/fx/Tp09HZmYmevXqhXfeeadU5bz8Qtq5c6fy38vAwACJiYnKHxLFvS8l+Td79cuqsH+zV/+9ShLrxZXdpUsX6Orq4u+//8b27duRk5NT6veoIjEOGAfVDdvQ17ehQP5npXbt2vD09ERYWBiaNGmCESNGKLe7u7sDyE90CxMZGanc5+V/b968Weq6L1++HImJidDX11d+L+zatQurV69WnoOJiQnkcnmBc0pOTgYAmJqaKutx7969Ittrqanru/MlOzs71K5dG+3bt1f+NvjvxQR3d/fX/nu93Mfa2hpmZmZl+vcqye8vIP8iRmEDxyQnJ6v8ewFli5vKgjFQvWLgjUgye/XqBQ0NDaxbtw5r1qzB4MGDIZPJAAAnT55Et27d8P7778PX1xe1atUq0fDgL3l6euLRo0d4+vSpct1/R5sCgFOnTqFmzZr46quv4O/vjzp16uDhw4cq++jo6CAvL6/Ysi5fvgy5XK5cd/LkSWhoaKBu3bolrvOrli9fjj59+qh8oCMiItCnTx8sX74cAODj44Pjx48X2tgYGxvDxcVF5cPwX9bW1gCg8h5FRESUqG4nT57EwIED8fbbb6N+/fqws7PDgwcPlNvr168PhUKBo0ePFnmMTp06wdDQEIsWLcKePXvK7W6Ira0tHBwccO/ePdSuXVvlz9XVVbmfiYkJevfujaVLl2LDhg3YtGmTcih4bW3tYuNg165dSEtLQ3h4uMq/1x9//IHNmzcjOTm52Pfldf+eQP6/2X//vfLy8nDt2rVi34OSxLqPj0+RsQIAWlpaGDBgAFauXImVK1eiT58+JbqYUFkwDhgH1Q3b0NL78ssvsWHDBly6dAkA0KBBA3h4eODHH38skNxdvnwZBw4cQN++fQEA7du3h5WVFWbPnl3osV8mg696/vw5tm7divXr16t8J4SHhyMpKUl5x6du3brIzc0t0A6/rOvLH6rvvfce0tPTsXDhwlLVo6zU9d1ZmICAAPj5+ancfe7Tpw8OHDiAy5cvq+yrUCjw448/wuv/7d15WBXVGwfwL9uVy3pZBYFEFlnUAEFzCTUMNYvMcLcMQUswQhLXXMBdE/cKNdnKJVfyV2EuuSCmogIuICRCauKGkiGiCO/vDx5GhstyZXV5P8/D8zDbOWdmzp0zZ+acM46OcHJygrKyMoYNG4aNGzfi+vXrcmEXFBRUO1q+IvdfQNk5O336tGjbkpISpKamCufL2dkZjo6OCA8Pr/KhSEOfr8bAeeAlywPN00q36fn5+ZGenh6pqKiI+n4EBweThYUFJSYmUlpaGo0ZM4Z0dHSE9s1EtQ9a4OjoSJ6enpSSkkJHjhwhV1dXUdvpn3/+mVRVVWnz5s106dIlWrlyJenr64vaoG/cuJE0NTUpOTmZbt++TUVFRUQkboP94MEDMjU1JW9vbzp37hz98ccfZGVlJTdoQcW0ExEFBQVRz549qzwut27dIjU1NYqPj5db9ttvv1GLFi0oLy+P7ty5QwYGBsIAIZmZmRQbGysMEBIdHU3q6uq0cuVKyszMpNOnT9OqVauEsLp06ULu7u6UlpZGhw4dos6dO1fZJ7PyyFcDBw4kZ2dnSk5OppSUFPLy8iJtbW3R+fDx8SELCwvatWsXXb58mQ4ePEg//fSTKJzp06eTRCIhBweHKo9DXVXuS7B+/XqSSqW0cuVKysjIoLNnz1JkZCSFh4cTEVF4eDht2rSJ0tPTKSMjg/z8/MjExEQYBczW1pb8/f0pNze32v44AwYMqLJ/UElJCZmYmAiDwNR0XGo7nxEREaShoUG//PILpaen09ixY0lHR0euL17FESKJFMvrBw8eJGVlZWHAl7NnzwqjKpbLzMwkFRUVUlFRoePHj9d+IpoZ54PlojS8qvngZcZlaM9qj011fRyHDBlC7777rjCdmJhIGhoa9MEHH9CJEyfo77//pq1bt5KFhQV169ZNSDMRUVxcHKmpqZGXlxft27ePsrOzKSkpiSZNmlRt/9Dly5eTqalplX3VhgwZIgwGRETUp08fcnJyov3799Ply5cpPj6e7Ozs5MKePHkyqaio0KRJk+jYsWOUk5ND+/fvp0GDBlU76uyzaI5rJ1HV/dvK73muXbtGREQPHz6kN954gywsLGjr1q30999/08mTJ+mDDz4gTU1N+vPPP4Vt8/LyyN7enszNzSkmJoYuXLhAmZmZtGHDBrKxsalyVE9F77+IiDZt2kRSqZS++eYbyszMpOTkZPL19SVdXV2hPzFR2YjA2tra1K1bN/r1118pKyuLUlNTad68eQ024GFD4zzw8uaBV6aSeezYMQJA/fv3F83Py8ujAQMGkJaWFhkbG9OMGTNo1KhRCheQRGWDa7z55pskkUiobdu2tGfPHrnMO2nSJDIwMCAtLS0aOnQoLV++XPSjKioqIm9vb5LJZA0y/HpFNRWQS5cuJZlMVuXAH48ePSKZTCYM55yamkp9+vQhDQ0N0tbWJnd3d9FIjxEREWRnZ0dqampkampKgYGBwrK0tDTq2rUrSaVScnZ2Foaor62SmZ2dTW+99RZJpVKysLCgNWvWyJ2Phw8fUnBwMJmampJEIiEbGxuKjIwUhZOVlUUAaMmSJVUeh7qq6uZi48aN5OzsTBKJhPT09KhHjx60c+dOIiobeMLZ2Zk0NTVJR0eHevfuLeqgvXv3brKxsSFVVdUqh96+ceMGqaqq0tatW6tMj7+/P7m4uBBR7celpvP5+PFj8vf3J319fTI2NqaFCxdWOeBL5coFUe15nYhox44dwjEyNDSkDz/8UC4cd3f3Kj9j8TzifLBcLg2vYj54mXEZ2rPaY1NdJfPPP/8kAKKRds+ePUve3t6kr69PampqZG1tTTNmzKAHDx7IbZ+UlEQffvghGRkZUYsWLcjGxoY+/fTTaj+/1aFDBwoICKhy2U8//UQSiUQYJOzevXv0xRdfkLW1NUmlUrK1taXJkyeLjkXFbXv06EHa2tqkqalJr7/+Os2ZM6fRPmHSmNfOclVVMEpLS8ne3l404NiDBw/oq6++IhsbG1JTUyN9fX3hIUVl+fn5NHXqVLK1tSWJREItW7akt99+m3bt2lVlxf9Z7r/Kj4urqytpa2tTy5YtqX///pSamiq3bUZGBo0aNYpatWpFEomEWrduTcOHD39uBoOpjPPAy5sHlIies16ijDWChIQE9O7dG1evXkXLli2bOzmsFkQEW1tbBAQE4Msvv2zu5LBmwvmAMcYYezGpNncCGGtMjx49wu3btxEaGorBgwdzBfMFcPv2bWzZsgU3btzA6NGjmzs5rJlwPmCMMcZeXFzJZC+1zZs3w8/PD87OzoiNjW3u5DAFGBsbw9DQEOvWrYOenl5zJ4c1E84HjDHG2IuLm8syxhhjjDHGGGswr8QnTBhjjDHGGGOMNQ2uZDJWjby8PBgbG4u+y8meL8OGDUN4eHiTxtkU+SI0NBTOzs71Dic6Ohoymaze4TxPIiIi4OXl1dzJYIzVgsvQ5x+XoTXjMrSemnQsW8ZeIMHBwTRmzJgql/Xp04eUlZXp5MmTTZyqpvfgwQOaOnUqWVlZUYsWLcjQ0JB69OhBcXFxzZ00OnfuHOnp6VF+fn6TxVk5X2RnZxMAUlZWFr6tVe769eukoqJCACg7O1vhOP777z+6c+dOvdNaWFhIN2/eFKZnz55NTk5O9Qpz+/btVe5rORsbGwoODq41nLqm5dGjR9SqVSs6cuTIM2/LGGs6XIaW4TJUjMvQV6cM5TeZjFWhsLAQGzZsgJ+fn9yyK1eu4NixY/j8888RGRnZ6Gl5/Phxo8dRk3HjxmHnzp1YvXo1Ll68iD179mDQoEHIy8trtDgV3ef27dvD2toaP/74Y6OlpaKa8oWZmZnc4FIxMTEwMzN75ni0tLRgYGBQ53QCQHFxMaRSKYyNjesVTmXvv/8+DAwMEBMTI7fsyJEjuHTpUpXHp6FIJBKMGDECq1atarQ4GGP1w2XoU1yGPsVl6CtWhjZ6NZaxF9C2bdvIyMioymWhoaE0bNgwSk9PJ11dXSosLCSiso/fAqD09HTR+suWLSMrKyth+ty5c9SvXz/S1NQkY2Nj+uijj4QPZBOVfbh8/PjxFBQURAYGBtSrVy8iIgoPD6f27duThoYGmZubk7+/v9yHs9etW0fm5uYklUrpgw8+oPDwcLmPHMfFxZGLiwu1aNGC2rRpQ6GhoVRcXFztsdDV1aXo6Ogaj1dRURFNnjyZzM3NSSKRkLW1NX3//ffC8kOHDlGnTp1IIpGQiYkJTZkyRRRndftc27EiIgoLC6M333yzxvQ1lKryRflT2BkzZpCtra1oWdu2bWnmzJmip7BPnjwhX19fsrS0JHV1dWrbti2tWLFCtF3lJ5QlJSUUFhZGZmZmJJFIyMnJieLj4+XSsGXLFurRowe1aNGCoqKiRB+5joqKIgCiv6ioKBo9ejS9++67ovgfP35MRkZGonNY0Zdffim3r0RlH7J/4403iIjo77//pvfff580NTVJW1ubBg8eTDdu3KgxLURlH4n38/MjQ0ND0tbWprfeeotSUlJE8Rw+fJgkEonw22OMPV+4DH2Ky9CnuAwt86qUoVzJZKwKX3zxBfXr109ufmlpKbVu3Zp++eUXIiJydXWl2NhYYbmbmxvNmDFDtI2rq6sw7969e2RkZETTpk2j9PR0OnPmDHl6etJbb70lrN+zZ0/S0tKiSZMm0cWLF+nixYtERLR8+XL6448/KDs7mw4cOEB2dnbk7+8vbHf06FFSVlamr7/+mjIyMuibb74hfX19UQF55MgR0tHRoejoaMrKyqK9e/eSpaUlhYaGVnss7OzsaMiQIXT//v1q1xkyZAhZWFjQzp07KSsri/bv309btmwhIqJr166RhoYGBQQEUHp6Ou3atYsMDQ1p9uzZNe6zIseKiCg+Pp4kEgkVFRVVm76GUlW+KC+cTp48SYaGhpSQkEBERAkJCWRkZEQnT54UFZCPHz+mWbNmUVJSEl2+fJl+/PFH0tDQoJ9++kkIs3IBuWzZMtLR0aHNmzfTxYsXafLkyaSmpkaZmZmiNFhaWtKOHTvo8uXLdP36dVEBWVhYSBMnTqR27dpRbm4u5ebmUmFhISUmJpKKigpdv35diG/nzp2kqakpdwNW7sKFCwSADh8+LMz777//SFNTk9atW0clJSXk7OxMb775Jp06dYqOHz9Orq6u1LNnzxrTQkT09ttvk5eXFyUlJVFmZiZNnDiRDAwMKC8vT4jrwYMHpKysTAcPHlT85DHGmgyXoU9xGfoUl6FlXpUylCuZjFVhwIAB5OvrKzd/7969ZGRkJDxBXL58ufCjL5+2trYWpis/mZ07dy716dNHFObVq1cJAGVkZBBRWWHh4uJSaxq3bdtGBgYGwvTQoUPlnqaNHDlSVED27t2bFixYIFrnhx9+IFNT02rjOXz4MJmbm5Oamhq5ubnRhAkT6OjRo3L7uG/fviq3nz59OtnZ2VFpaakw75tvviEtLS0qKSmpdp8VOVZERKmpqQSAcnJyqt2HhlJVvigvnJKTk2nChAk0evRoIiIaPXo0BQcHU3Jycq39ScaPH0/e3t7CdOUCslWrVjR//nzRNp06daKAgABRGio/za1YQFYVbjlHR0davHixMO3l5UU+Pj7VppeIqEuXLvTJJ58I0xs2bCANDQ26f/8+7d27l1RUVOjKlSvC8vJCtbwPVlVpSUhIIB0dHbmbHWtra1q7dq1onp6eXq1vBxhjzYPL0Ke4DH2Ky9CnXoUylPtkMlaFhw8fQl1dXW5+ZGQkhg4dClVVVQDA8OHDkZiYiKysLABlI7Xl5OTg+PHjAICNGzeiY8eOsLe3BwCkpqbi4MGD0NLSEv7Kl5WHAQCurq5yce/fvx+9e/eGmZkZtLW18fHHHyMvLw+FhYUAgIyMDHTu3Fm0TeXp1NRUzJkzRxT/2LFjkZubK4RTWY8ePXD58mUcOHAAgwYNwoULF+Du7o65c+cCAFJSUqCiooKePXtWuX16ejq6du0KJSUlYV737t1RUFCAa9euVbvPih4rqVQKANWmvyFVly/K+fr6Ytu2bbhx4wa2bdsGX1/fKtf75ptv4OrqCiMjI2hpaWHdunW4cuVKlevev38f169fR/fu3UXzu3fvjvT0dNE8Nze3Z9yjMmPGjEFUVBQA4ObNm4iPj6827eV8fX2xfft2/PfffwDKfhuDBw+GtrY20tPTYWFhAQsLC2F9R0dHyGQyuTRXlJqaioKCAhgYGIjOe3Z2tuicA2XnvSnOOWPs2XEZ+hSXoU9xGfrUq1CGqjZq6Iy9oAwNDXHv3j3RvLt372LXrl0oLi7Gd999J8wvKSlBZGQk5s+fDxMTE3h4eGDTpk3o0qULNm3aBH9/f2HdgoICeHl5YfHixXJxmpqaCv9ramqKluXk5OC9996Dv78/5s+fD319fRw9ehR+fn54/PgxNDQ0FNqvgoIChIWF4cMPP5RbVtOFX01NDe7u7nB3d8eUKVMwb948zJkzB1OmTBEKqPqqvM+KHqu7d+8CAIyMjBokHTWpKl9U1KFDB9jb22P48OFwcHBA+/btkZKSIlpny5YtCAkJQXh4OLp27QptbW18/fXXOHHiRL3TV/kYKmrUqFGYOnUq/vzzTxw7dgxt2rSBu7t7jdsMGzYMwcHB2Lp1K3r06IHExEQsXLiwTvGXKygogKmpKQ4dOiS3rPIw8nfv3m2Sc84Ye3ZchopxGVqGy9CnXoUylCuZjFXBxcVFbrS1jRs3wtzcHHFxcaL5e/fuRXh4OObMmQMVFRWMHDkSkydPxvDhw3H58mUMGzZMWLdjx47YsWMHLC0thSe5ijh9+jRKS0sRHh4OZeWyBghbt24VrWNnZ4ekpCTRvMrTHTt2REZGBmxsbBSOuyqOjo548uQJioqK0KFDB5SWluLw4cN4++235dZ1cHDAjh07QETCk9jExERoa2vD3Ny82jgUPVbnz5+Hubk5DA0N67VPiqgqX1Tm6+uLgIAA0U1URYmJiejWrRsCAgKEeZWfMFako6ODVq1aITExUfSkOzExUe4pe20kEglKSkrk5hsYGOCDDz5AVFQU/vzzT4wePbrWsLS1tTF48GBERkYiKysLbdu2FQpVBwcHXL16FVevXhWexKalpSE/Px+Ojo7VpqVjx464ceMGVFVVYWlpWW3cWVlZKCoqgouLi6K7zhhrQlyG1ozL0OpxGfoSlaGN2hiXsRfU2bNnSVVVle7evSvMc3JyoilTpsitm5+fTxKJRBjI4P79+ySVSsnJyYl69+4tWveff/4hIyMjGjRoEJ08eZIuXbpEe/bsIR8fH3ry5AkRlfWtCAoKEm2XkpIi9BfIysqi2NhYMjMzIwB07949Ino6aEF4eDhlZmZSREQEGRgYkEwmE8LZs2cPqaqqUmhoKJ0/f57S0tJo8+bN9NVXX1V7LHr27EkRERF06tQpys7Opl9//ZXs7OzIw8NDWMfHx4csLCxo165ddPnyZTp48KDQCb980ILx48dTeno6xcXFVTloQeV9VuRYEZWNxlZV35/GUFW+qNifhIiouLiYbt++LfQ5qtyfZOXKlaSjo0N79uyhjIwMmjFjBuno6Ij6VlTua7F8+XLS0dGhLVu20MWLF2nKlClVDlpQnoZylfuTbNy4kTQ1NSk5OZlu374t6rexd+9ekkgkpKKiQv/8849CxyMhIYEAkJ6eHi1atEiYX1paSs7OzuTu7k6nT5+mEydOiAYtqC4tpaWl9Oabb5KTkxP9/vvvlJ2dTYmJiTR9+nRKSkoS7VfF0SYZY88XLkOf4jL0KS5DxV72MpQrmYxVo3PnzhQREUFERKdOnRJ1uK7snXfeoYEDBwrTQ4YMIQAUGRkpt25mZiYNHDiQZDIZSaVSsre3pwkTJgid+qsqLIjKRkczNTUlqVRKffv2pdjYWFEBSVQ2/LqZmZkw/Pq8efPIxMREFM6ePXuoW7duJJVKSUdHhzp37kzr1q2r9jgsWLCAunbtSvr6+qSurk5WVlb0xRdfiD50/PDhQwoODiZTU1OSSCRkY2Mj2ndFhl+vap9rO1YPHz4kXV1d+vPPP6tNf0OrmC+Iqi+cylUuIIuKisjHx4d0dXVJJpORv78/TZ06tcYCsqSkhEJDQ8nMzIzU1NSqHX69tgKyqKiIvL29SSaTiYY8J3o66mP//v2f6XjY2dnJjaxHVPPw6zWl5f79+xQYGEitWrUiNTU1srCwoJEjR4oGQOjTpw8tXLjwmdLJGGtaXIaW4TJUjMtQsZe5DOVKJmPV+OWXX8jBwUEYve1FNGbMmCb7/lVz+Pbbb8nT07NJ42yKfDF16lTq3r17o4Vflf/++490dHRox44dTRrvszp//jwZGxtTfn5+cyeFMVYDLkOff1yGNhwuQ+Vxn0zGqvHuu+/ir7/+wj///CMa4et5tnTpUnh6ekJTUxPx8fGIiYnBt99+29zJajRqampYvXp1k8bZmPmCiIRRCJuqv2FpaSnu3LmD8PBwyGQyvP/++00Sb13l5uYiNjYWurq6zZ0UxlgNuAx9/nEZWn9chlZPiYio0WNhjDWJIUOG4NChQ/jvv/9gZWWFwMBAjBs3rrmTxRSUn5+Pli1bolOnTti4cSNat27d6HHm5OSgTZs2MDc3R3R0NHr37t3ocTLG2POIy9AXG5ehzxeuZDLGGGOMMcYYazDKzZ0AxhhjjDHGGGMvD65kMsYYY4wxxhhrMFzJZIwxxhhjjDHWYLiSyRhjjDHGGGOswXAlkzHGGGOMMcZYg+FKJmOMMcYYY4yxBsOVTMYYY4wxxhhjDYYrmYwxxhhjjDHGGgxXMhljjDHGGGOMNRiuZDLGGGOMMcYYazBcyWSMMcYYY4wx1mC4kskYY4wxxhhjrMFwJZMxxhhjjDHGWIPhSiZjjDHGGGOMsQbDlUzGGGOMMcYYYw2GK5mMMcYYY4wxxhoMVzIZY4wxxhhjjDUYrmQyxhhjjDHGGGswXMlkjDHGGGOMMdZguJLJGGOMMcYYY6zBcCWTMcYYY4wxxliD4UomY4wxxhhjjLEGw5VMxhhjjDHGGGMNRrW5E8DYsygpKUFxcXFzJ4MxxhhjjNWBmpoaVFRUmjsZrJFxJZO9EIgIN27cQH5+fnMnhTHGGGOM1YNMJoOJiQmUlJSaOymskXAlk70QyiuYxsbG0NDQ4IsSY4wxxtgLhohQWFiIW7duAQBMTU2bOUWssXAlkz33SkpKhAqmgYFBcyeHMcYYY4zVkVQqBQDcunULxsbG3HT2JcUD/7DnXnkfTA0NjWZOCWOMMcYYq6/yezoeZ+PlxZVM9sLgJrKMMcYYYy8+vqd7+XElkzHGGGOMMcZYg+FKJmOvkJycHCgpKSElJeWFCruiQ4cOQUlJSRhpODo6GjKZrFHjZC+X0NBQODs7C9M+Pj744IMPmi09LyMlJSXExcXVK4zK56VXr16YMGFCvcIE5M//88bS0hIrVqwQphviWDJWX896naxcVrNXDw/8w15oq/flN1lcgZ6yZ97m9u3bmDVrFn799VfcvHkTenp6cHJywqxZs9C9e3cAZTcQu3bteiVucrOzs/HVV1/h0KFDuHv3LgwNDeHq6orFixfD3t6+TmEOHToU/fv3F6ZDQ0MRFxfX6JXd6tza5Nek8RmP2KDwurU1T5o9ezZCQ0PrmaK6UfR3cPjwYYSFhSElJQVFRUUwMzNDt27dsH79ekgkkjrFvXLlShCRMN2rVy84OzuLbvSb0vqsaU0a31jrhc+0viLXtdzcXOjp6dUrXZXPS0MJCQlBYGCgMO3j44P8/Px6V+RKSkrw9ddfIzo6Gn///TekUilsbW0xduxYjBkzps7hVjyWOTk5aNOmDZKTk5utopy/Ir9J45NNkD3T+j4+PoiJiQEAqKqqQl9fH6+//jqGDx8OHx8fKCvz+xXGmgJXMhlrRN7e3nj8+DFiYmJgZWWFmzdv4sCBA8jLy2vupNXZ48eP63QzX1xcDE9PT9jZ2WHnzp0wNTXFtWvXEB8fX68nnVKpVBipjtUsNzdX+P+nn37CrFmzkJGRIczT0tJ6pvDqmhfqKi0tDf369UNgYCBWrVoFqVSKv/76Czt27EBJSUmdw9XV1W3AVL78FLmumZiY1Duehj4vRISSkhJoaWk9c15XRFhYGNauXYs1a9bAzc0N9+/fx6lTp3Dv3r16hdsQx/JV069fP0RFRaGkpAQ3b97Enj17EBQUhO3bt2P37t1QVeXbX8YaGz/OYayR5OfnIyEhAYsXL8Zbb72F1q1bo3Pnzpg2bRref/99AGXNogBg4MCBUFJSEqazsrIwYMAAtGzZElpaWujUqRP2798vCt/S0hILFiyAr68vtLW18dprr2HdunWidU6ePAkXFxeoq6vDzc0NycnJouUlJSXw8/NDmzZtIJVKYWdnh5UrV4rWKW8iM3/+fLRq1Qp2dnYKhV3ZhQsXkJWVhW+//RZdunRB69at0b17d8ybNw9dunQB8LTJ7ZYtW9CtWzeoq6ujffv2OHz4cLXhVmwuGx0djbCwMKSmpkJJSQlKSkqIjo6uMV2vEhMTE+FPV1cXSkpKwvSDBw8wcuTIWvPc3LlzMWrUKOjo6ODTTz8FAKxfvx4WFhbQ0NDAwIEDsWzZMrkmzD///DM6duwIdXV1WFlZISwsDE+ePBHCBeR/B5Xt3bsXJiYmWLJkCdq3bw9ra2v069cP69evFx40lOeHuLg42NraQl1dHX379sXVq1erPS4Vm4H5+Pjg8OHDWLlypZCHcnJynu1Av8QUua4B4iae5b/rrVu3wt3dHVKpFJ06dUJmZiaSkpLg5uYGLS0tvPPOO7h9+7YQRm3N83744Qe4ublBW1sbJiYmGDFihPDtPeBpc734+Hi4urqiRYsWOHr0qKi5bGhoKGJiYvDzzz8L5/vQoUPw8PDA559/Lorv9u3bkEgkOHDgQJXp2b17NwICAjB48GC0adMGTk5O8PPzQ0hIiLBOr1698Pnnn+Pzzz+Hrq4uDA0NMXPmzBrf2FY8lm3atAEAuLi4QElJCb169ap2u1dZixYtYGJiAjMzM3Ts2BHTp0/Hzz//jPj4eKFMqKqLR35+vpAHgKd56Pfff4eLiwukUik8PDxw69YtxMfHw8HBATo6OhgxYgQKCwuFcHr16oXAwEBMmDABenp6aNmyJdavX48HDx5g9OjR0NbWho2NDeLj4wGUPQCxsbHB0qVLRfuRkpICJSUlXLp0qcr9LP+NLFiwAC1btoRMJsOcOXPw5MkTTJo0Cfr6+jA3N0dUVJRou3PnzsHDwwNSqRQGBgb49NNPUVBQICwvKSnBl19+CZlMBgMDA0yePFkuj5aWlmLhwoXC/YOTkxO2b9/+TOeJvdy4kslYIyl/Wh4XF4dHjx5VuU5SUhIAICoqCrm5ucJ0QUEB+vfvjwMHDiA5ORn9+vWDl5cXrly5Ito+PDxcqOAFBATA399feDNVUFCA9957D46Ojjh9+jRCQ0NFNztAWSFhbm6Obdu2IS0tDbNmzcL06dOxdetW0XoHDhxARkYG9u3bh19++UWhsCszMjKCsrIytm/fXutbp0mTJmHixIlITk5G165d4eXlpdDb36FDh2LixIlo164dcnNzkZubi6FDh9a6HVM8zy1duhROTk5ITk7GzJkzkZiYiHHjxiEoKAgpKSnw9PTE/PnzRdskJCRg1KhRCAoKQlpaGtauXYvo6Ghhvep+B5WZmJggNzcXR44cqXFfCgsLMX/+fMTGxiIxMRH5+fkYNmyYQsdh5cqV6Nq1K8aOHSvkIQsLC4W2fRUocl2rzuzZszFjxgycOXMGqqqqGDFiBCZPnoyVK1ciISEBly5dwqxZsxQOr7i4GHPnzkVqairi4uKQk5MDHx8fufWmTp2KRYsWIT09Ha+//rpoWUhICIYMGYJ+/foJ57tbt24YM2YMNm3aJNrHH3/8EWZmZvDw8KgyPSYmJvjjjz9EFeWqxMTEQFVVFSdPnsTKlSuxbNkyfP/99wrt88mTJwEA+/fvR25uLnbu3KnQdgzw8PCAk5NTnY5ZaGgo1qxZg2PHjuHq1asYMmQIVqxYgU2bNuHXX3/F3r17sXr1atE2MTExMDQ0xMmTJxEYGAh/f38MHjwY3bp1w5kzZ9CnTx98/PHHKCwshJKSEnx9feUqg1FRUejRowdsbGyqTdsff/yB69ev48iRI1i2bBlmz56N9957D3p6ejhx4gTGjRuHzz77DNeuXQMAPHjwAH379oWenh6SkpKwbds27N+/X/RQJTw8HNHR0YiMjMTRo0dx9+5d7Nq1SxTvwoULERsbi4iICFy4cAHBwcH46KOPanwozF4tXMlkrJGoqqoiOjoaMTExkMlk6N69O6ZPn46zZ88K6xgZGQEAZDIZTExMhGknJyd89tlnaN++PWxtbTF37lxYW1tj9+7dojj69++PgIAA2NjYYMqUKTA0NMTBgwcBAJs2bUJpaSk2bNiAdu3a4b333sOkSZNE26upqSEsLAxubm5o06YNRo4cidGjR8tVMjU1NfH999+jXbt2aNeunUJhV2ZmZoZVq1Zh1qxZ0NPTg4eHB+bOnYvLly/Lrfv555/D29sbDg4O+O6776Crq4sNG2rveyiVSqGlpQVVVVXhDR03pVWMonnOw8MDEydOhLW1NaytrbF69Wq88847CAkJQdu2bREQEIB33nlHtE1YWBimTp2KTz75BFZWVvD09MTcuXOxdu1aANX/DiobPHgwhg8fjp49e8LU1BQDBw7EmjVrcP/+fdF6xcXFWLNmDbp27QpXV1fExMTg2LFjwg16TXR1dSGRSKChoSHkIf5Q+FOKXNeqExISgr59+8LBwQFBQUE4ffo0Zs6cie7du8PFxQV+fn7C9UsRvr6+eOedd2BlZYUuXbpg1apViI+PF72RAYA5c+bA09MT1tbW0NfXFy3T0tKCVCoV3nyZmJhAIpHgww8/BFD2Br5cdHQ0fHx8qu3bvGzZMty+fRsmJiZ4/fXXMW7cOOFNVUUWFhZYvnw57OzsMHLkSAQGBmL58uUK7XP5b8PAwAAmJiZy+8NqZm9vX6eWCfPmzRPl08OHD+O7776Di4sL3N3dMWjQILm86+TkhBkzZsDW1hbTpk2Duro6DA0NMXbsWNja2mLWrFnIy8sTfjs+Pj7IyMgQrlPFxcXYtGkTfH19a0ybvr4+Vq1aBTs7O/j6+sLOzg6FhYWYPn26ELdEIsHRo0cBlN0bFBUVITY2Fu3bt4eHhwfWrFmDH374ATdv3gQArFixAtOmTcOHH34IBwcHREREiJqvP3r0CAsWLEBkZCT69u0LKysr+Pj44KOPPhKu64xxJZOxRuTt7Y3r169j9+7d6NevHw4dOoSOHTvW2oSzoKAAISEhcHBwgEwmg5aWFtLT0+XeKlV8Kl/e9LG8uVj5U3t1dXVhna5du8rF9c0338DV1RVGRkbQ0tLCunXr5OLp0KGDqO+domFXNn78eNy4cQMbN25E165dsW3bNrRr1w779u0TrVcxLFVVVbi5uSE9Pb3W8FndKZrn3NzcRNMZGRno3LmzaF7l6dTUVMyZM0d4C6alpSW8KazYxKw2KioqiIqKwrVr17BkyRKYmZlhwYIFwpvrcqqqqujUqZMwbW9vD5lMxnmogdT1ulbxetWyZUsAZdeWivMqNnetzenTp+Hl5YXXXnsN2tra6NmzJwDUmmcVoa6ujo8//hiRkZEAgDNnzuD8+fNVvikt5+joiPPnz+P48ePw9fXFrVu34OXlJTfoT5cuXUQV1a5du+Kvv/6qV79iphgiqtP3GSvnXQ0NDVhZWYnmVc67FbdRUVGBgYGBXH4HIGzXqlUrvPvuu0Ke+9///odHjx5h8ODBNaatXbt2osGMWrZsKYqnPO6K9wZOTk7Q1NQU1unevTtKS0uRkZGBf//9F7m5uXjjjTeE5eXlcLlLly6hsLAQnp6eout6bGwssrKyakwve3VwJZOxRqaurg5PT0/MnDkTx44dg4+PD2bPnl3jNiEhIdi1axcWLFiAhIQEpKSkoEOHDnj8+LFoPTU1NdG0kpISSktLFU7bli1bEBISAj8/P+zduxcpKSkYPXq0XDwVC6P60tbWhpeXF+bPn4/U1FS4u7tj3rx5DRY+qxtF81xd8kJBQYEwImz537lz5/DXX3+JHlQoyszMDB9//DHWrFmDCxcuoKioCBEREc8cDqu7ulzXKl6vym/0K89T9PpV3uRPR0cHGzduRFJSktCcr6GuX2PGjMG+fftw7do1REVFwcPDA61bt65xG2VlZXTq1AkTJkzAzp07ER0djQ0bNiA7O7tOaWANKz09XejXWl4xq9jXsLi4uMrtKudTRcreqtap6jdQcbsxY8Zgy5YtePjwIaKiojB06FBoaGjUuE+1xVNd+uqjvLXAr7/+Krqup6Wlcb9MJuBKJmNNzNHREQ8ePBCm1dTU5J5gJyYmwsfHBwMHDkSHDh1gYmLyzE18HBwccPbsWRQVFQnzjh8/LhdPt27dEBAQABcXF9jY2Cj0FFKRsBWhpKQEe3t70fGoHNaTJ09w+vRpODg4KBSmRCLhNwJ1UNc8Z2dnJ9eHsvJ0x44dkZGRARsbG7m/8hu9qn4HitDT04OpqakoDz158gSnTp0SpjMyMpCfn895qBFVvq41tosXLyIvLw+LFi2Cu7s77O3tn+ktaEXVne8OHTrAzc0N69evV6jZYlUcHR0BQHRsTpw4IVrn+PHjsLW1VahZdnmLEs6fz+6PP/7AuXPn4O3tDeBp0+OKrSCa69NX5fr37w9NTU1899132LNnT53yXG0cHByQmpoqypOJiYlQVlaGnZ0ddHV1YWpqKsqn5eVwOUdHR7Ro0QJXrlyRu6ZzH3ZWjiuZjDWSvLw8eHh44Mcff8TZs2eRnZ2Nbdu2YcmSJRgwYICwnqWlJQ4cOIAbN24IQ93b2tpi586dSElJQWpqKkaMGPHMTyFHjBgBJSUljB07Fmlpafjtt9/kRq6ztbXFqVOn8PvvvyMzMxMzZ86sdtCVZw27spSUFAwYMADbt29HWloaLl26hA0bNiAyMlJ0PICyJry7du3CxYsXMX78eNy7d0/hwtbS0hLZ2dlISUnBnTt3nnlwkldVXfNcYGAgfvvtNyxbtgx//fUX1q5di/j4eFGTtFmzZiE2NhZhYWG4cOEC0tPTsWXLFsyYMUNYp6rfQWVr166Fv78/9u7di6ysLFy4cAFTpkzBhQsX4OXlJaynpqaGwMBAnDhxAqdPn4aPjw+6dOki14y3OpaWljhx4gRycnJw586dBn0D8KJT9LrW2F577TVIJBKsXr0aly9fxu7duzF37tw6hWVpaYmzZ88iIyMDd+7cEb3NGjNmDBYtWgQiwsCBA2sMZ9CgQVi+fDlOnDiBv//+G4cOHcL48ePRtm1b0XeAr1y5gi+//BIZGRnYvHkzVq9ejaCgIIXSamxsDKlUij179uDmzZv4999/67TPL7tHjx7hxo0b+Oeff3DmzBksWLAAAwYMwHvvvYdRo0YBKOvD36VLF2FQqMOHD4uuSc1BRUUFPj4+mDZtGmxtbRXqhvKsRo4cCXV1dXzyySc4f/48Dh48iMDAQHz88cdCE96goCAsWrQIcXFxuHjxIgICAkSfGtPW1kZISAiCg4MRExODrKwsnDlzBqtXrxa+UcoYfyiIvdACPWXNnYRqaWlp4Y033sDy5cuRlZWF4uJiWFhYYOzYsZg+fbqwXnh4OL788kusX78eZmZmyMnJwbJly+Dr64tu3brB0NAQU6ZMkRvcRJH4//e//2HcuHFwcXGBo6MjFi9eLDzFBYDPPvsMycnJGDp0KJSUlDB8+HAEBARUOVjFs4Zdmbm5OSwtLREWFiYMHV8+HRwcLFp30aJFWLRoEVJSUmBjY4Pdu3fD0NBQof329vbGzp078dZbbyE/Px9RUVE19qNqaMYjah+g6HlU1zzXvXt3REREICwsDDNmzEDfvn0RHByMNWvWCOv07dsXv/zyC+bMmYPFixdDTU0N9vb2or5qVf0OKuvcuTOOHj2KcePG4fr169DS0kK7du0QFxcn9McDAA0NDUyZMgUjRozAP//8A3d3d4UGjioXEhKCTz75BI6Ojnj48CGys7Or/axKYxhrvbDJ4npWil7XGpuRkRGio6Mxffp0rFq1Ch07dsTSpUtFn1FR1NixY3Ho0CG4ubmhoKAABw8eFD4NMnz4cEyYMAHDhw+vtWl33759sXnzZixcuBD//vsvTExM4OHhgdDQUNF3GUeNGoWHDx+ic+fOUFFRQVBQkPA5oNqoqqpi1apVmDNnDmbNmgV3d3fhcxtNRTZB1qTx1cWePXtgamoKVVVV6OnpwcnJCatWrcInn3wi6r8YGRkJPz8/uLq6ws7ODkuWLEGfPn2aMeWAn58fFixYgNGjRzdK+BoaGvj9998RFBSETp06QUNDA97e3li2bJmwzsSJE5GbmyscL19fXwwcOFD0UGPu3LkwMjLCwoULcfnyZchkMuFzMYwBgBLV9HEmxp4DRUVFyM7ORps2berUf4u9OHJyctCmTRskJycL37FjL56xY8fi4sWLSEhIaPK4o6OjMWHCBNFTd8bqKicnB9bW1khKSkLHjh3rHV6vXr3g7OyMFStW1D9x7KWUkJCA3r174+rVq8KbxZcR39u9/PhNJmOMsXpZunQpPD09oampifj4eMTExODbb79t7mQxVmfFxcXIy8vDjBkz0KVLlwapYDJWk0ePHuH27dsIDQ3F4MGDX+oKJns1cJ9Mxhhj9XLy5El4enqiQ4cOiIiIwKpVq+Q+28DYiyQxMRGmpqZISkrikYtZk9i8eTNat26N/Px8LFmypLmTw1i9cXNZ9tzjJhWMMcYYYy8Pvrd7+fGbTMYYY4wxxhhjDYYrmeyFwS/dGWOMMcZefHxP9/LjSiZ77qmpqQEACgsLmzkljDHGGGOsvsrv6crv8djLh0eXZc89FRUVyGQy3Lp1C0DZN54qfuidMcYYY4w9/4gIhYWFuHXrFmQyGVRUVJo7SayR8MA/7IVARLhx4wZ/+44xxhhj7AUnk8lgYmLCLw1eYlzJZC+UkpISFBcXN3cyGGOMMcZYHaipqfEbzFcAVzIZY4wxxhhjjDUYHviHMcYYY4wxxliD4UomY4wxxhhjjLEGw5VMxhhjjDHGGGMNhiuZjDHGGGOMMcYaDFcyGWOMMcYYY4w1GK5kMsYYY4wxxhhrMFzJZIwxxhhjjDHWYP4P6hOO3/I+qvgAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1100x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Cells as one-hot performances:')\n",
    "plot_performance_metrics(\n",
    "    df_cv=reports['cellsonehot_cv_train'],\n",
    "    df_test=reports['cellsonehot_test'],\n",
    "    df_test_majority=reports['cellsonehot_majority_vote'],\n",
    "    title=f'cellsonehot_performance',\n",
    "    show_plot=False,\n",
    "    metrics_to_plot = {\n",
    "        'val_acc': 'Validation Accuracy',\n",
    "        'val_roc_auc': 'Validation ROC AUC',\n",
    "        'val_f1_score': 'Validation F1 Score',\n",
    "        'val_precision': 'Validation Precision',\n",
    "        'val_recall': 'Validation Recall',\n",
    "        'test_acc': 'Test Accuracy',\n",
    "        'test_roc_auc': 'Test ROC AUC',\n",
    "        'test_f1_score': 'Test F1 Score',\n",
    "        'test_precision': 'Test Precision',\n",
    "        'test_recall': 'Test Recall',\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Proteins as Amino-Acid Counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proteins as amino-acid counts performances:\n",
      "Metrics: ['Recall', 'ROC AUC', 'Precision', 'F1 Score', 'Accuracy']\n",
      "Metric: Recall\n",
      "Metric: ROC AUC\n",
      "Metric: Precision\n",
      "Metric: F1 Score\n",
      "Metric: Accuracy\n",
      "Plotting performance for main part of the paper...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Proteins as amino-acid counts performances:')\n",
    "plot_performance_metrics(\n",
    "    df_cv=reports['aminoacidcnt_cv_train'],\n",
    "    df_test=reports['aminoacidcnt_test'],\n",
    "    df_test_majority=reports['aminoacidcnt_majority_vote'],\n",
    "    title=f'aminoacidcnt_performance',\n",
    "    show_plot=False,\n",
    "    metrics_to_plot = {\n",
    "        'val_acc': 'Validation Accuracy',\n",
    "        'val_roc_auc': 'Validation ROC AUC',\n",
    "        'val_f1_score': 'Validation F1 Score',\n",
    "        'val_precision': 'Validation Precision',\n",
    "        'val_recall': 'Validation Recall',\n",
    "        'test_acc': 'Test Accuracy',\n",
    "        'test_roc_auc': 'Test ROC AUC',\n",
    "        'test_f1_score': 'Test F1 Score',\n",
    "        'test_precision': 'Test Precision',\n",
    "        'test_recall': 'Test Recall',\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compare Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2462072186.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  tmp['Experiment'] = r\n",
      "/tmp/ipykernel_1899217/2462072186.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  tmp['Experiment'] = r\n",
      "/tmp/ipykernel_1899217/2462072186.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  tmp['Experiment'] = r\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Experiment                    | Study      |   Test Accuracy |   Test ROC AUC |\n",
      "|:------------------------------|:-----------|----------------:|---------------:|\n",
      "| Baseline                      | Standard   |        0.782051 |       0.845847 |\n",
      "| Baseline                      | Target     |        0.526316 |       0.595819 |\n",
      "| Baseline                      | Similarity |        0.779221 |       0.854336 |\n",
      "| Cells as one-hot              | Standard   |        0.820513 |       0.875083 |\n",
      "| Cells as one-hot              | Target     |        0.618421 |       0.61324  |\n",
      "| Cells as one-hot              | Similarity |        0.74026  |       0.842141 |\n",
      "| Proteins as amino-acid counts | Standard   |        0.705128 |       0.828571 |\n",
      "| Proteins as amino-acid counts | Target     |        0.605263 |       0.543554 |\n",
      "| Proteins as amino-acid counts | Similarity |        0.74026  |       0.815718 |\n",
      "--------------------------------------------------------------------------------\n",
      "Comparison of the best models majority vote:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsQAAAHoCAYAAABO0/lTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACSVUlEQVR4nOzdd1QUVxsG8GfpvXdEQQQLKipYELso9t5N7B1biCXGbqImGluMxl5j/+zGjl0RFcGKiAWxABZ6LzvfH8SNG0CB3aW4z+8cTsLM7L137i6v787ce0ckCIIAIiIiIiIlpVLSDSAiIiIiKklMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqZVoQnzp0iV07NgRNjY2EIlEOHTokNR+QRAwa9YsWFtbQ1tbG15eXggLC5M6JiYmBv3794eBgQGMjIwwdOhQJCUlSfaHh4ejSZMm0NXVRZMmTRAeHi71+g4dOmD//v2KOkUiojLhS/E4LxcuXECdOnWgqamJSpUqYcuWLQpvJxGRIpRoQpycnAxXV1esWrUqz/2LFi3C77//jjVr1iAgIAC6urrw9vZGWlqa5Jj+/fvjwYMHOHPmDI4dO4ZLly5hxIgRkv3ff/89bG1tERwcDGtra0yaNEmyb8+ePVBRUUH37t0Vd5JERGXAl+Lxfz1//hzt27dH8+bNERwcjIkTJ2LYsGE4deqUgltKRKQAQikBQDh48KDkd7FYLFhZWQmLFy+WbIuLixM0NTWFXbt2CYIgCA8fPhQACDdv3pQcc+LECUEkEgmvX78WBEEQqlatKpw4cUIQBEE4fvy4UK1aNUEQBCE2NlaoVKmSEBERoehTIyIqU/4bj/MyZcoUwcXFRWpb7969BW9vbwW2jIhIMdRKOB/P1/PnzxEVFQUvLy/JNkNDQ9SvXx/+/v7o06cP/P39YWRkBHd3d8kxXl5eUFFRQUBAALp27QpXV1ecPXsWrVu3xunTp1GzZk0AwOTJk+Hj4wM7O7sCtSc9PR3p6emS38ViMWJiYmBqagqRSCSnsyYi+pcgCEhMTISNjQ1UVErXlA9/f3+p+AwA3t7emDhxYr6vYRwlouJW0DhaahPiqKgoAIClpaXUdktLS8m+qKgoWFhYSO1XU1ODiYmJ5JjffvsNI0eOhL29PWrWrIm1a9fi0qVLCA4Oxq+//opevXrh1q1baN26NX7//XdoaGjk2Z6FCxdi7ty58j5NIqIvevnyJcqVK1fSzZASFRWVZ3xOSEhAamoqtLW1c72GcZSISsqX4mipTYjlxdbWFseOHZP8np6eDm9vb2zduhU///wz9PX1ERoaijZt2mDt2rUYN25cnuVMmzYNvr6+kt/j4+NRvnx5vHz5EgYGBgo/DyJSPgkJCbCzs4O+vn5JN0UuGEeJqLgVNI6W2oTYysoKABAdHQ1ra2vJ9ujoaNSqVUtyzNu3b6Vel5WVhZiYGMnr/2vBggVo3bo13NzcMHz4cPz8889QV1dHt27dcO7cuXwTYk1NTWhqaubabmBgwEBORApVGocTWFlZITo6WmpbdHQ0DAwM8rw6DDCOElHJ+VIcLV2D0j7h4OAAKysr+Pn5SbYlJCQgICAAHh4eAAAPDw/ExcUhMDBQcsy5c+cgFotRv379XGWGhIRg586d+OmnnwAA2dnZyMzMBABkZmYiOztbkadERPTV8PDwkIrPAHDmzBlJfCYiKktK9ApxUlISnjx5Ivn9+fPnCA4OhomJCcqXL4+JEyfi559/hpOTExwcHDBz5kzY2NigS5cuAICqVauiTZs2GD58ONasWYPMzEyMHTsWffr0gY2NjVRdgiBgxIgRWLZsGXR1dQEAnp6eWL9+PZydnbFt2zb07du32M6diKg0+VI8njZtGl6/fo1t27YBAEaNGoU//vgDU6ZMwZAhQ3Du3Dns3bsXf//9d0mdAhFR0ZXkEhfnz58XAOT6GThwoCAIOUuvzZw5U7C0tBQ0NTWFli1bCqGhoVJlfPjwQejbt6+gp6cnGBgYCIMHDxYSExNz1bVmzRqhe/fuUtuio6OFli1bCvr6+kLPnj2F5OTkArc9Pj5eACDEx8cX/sSJiAqgOOPMl+LxwIEDhaZNm+Z6Ta1atQQNDQ2hYsWKwubNmwtVJ+MoESlaQeOMSBAEoSQS8bIuISEBhoaGiI+P59g3IlKIrz3OfO3nR0Qlr6BxptSOISYiIiIiKg5MiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpMiImIiIhIqTEhJiIiIiKlxoSYiIiIiJQaE2IiIiIiUmpqJd0AIiIiKn1WnolTeB3jWhkpvA6iguAVYiIiIiJSakyIiYiIiEipMSEmIiIiIqXGhJiIiIiIlBoTYiIiIiJSakyIiYiIiEipMSEmIiIiIqXGdYiJiIiKwfqn04qlnuGOC4ulHqKvCa8QExEREZFSY0JMREREREqNQyaIiKhU4yOEiUjReIWYiIiIiJQarxATERHRV6s4JjNyImPZxyvERERERKTUmBATERERkVJjQkxERERESo0JMREREREpNU6qIyIiIioluMxgyeAVYiIiIiJSakyIiYiIiEipccgEfZV4y4mIiIgKileIiYiIiEip8QoxEREREclVWXtCIK8QExEREZFSK9UJcXZ2NmbOnAkHBwdoa2vD0dERP/30EwRBkBwjCAJmzZoFa2traGtrw8vLC2FhYZL96enp+Pbbb2FgYABnZ2ecPXtWqo7Fixdj3LhxxXZORESl1apVq2Bvbw8tLS3Ur18fN27c+Ozxy5cvR+XKlaGtrQ07Ozt89913SEtLK6bWEhHJT6keMvHrr7/izz//xNatW+Hi4oJbt25h8ODBMDQ0xPjx4wEAixYtwu+//46tW7fCwcEBM2fOhLe3Nx4+fAgtLS2sW7cOgYGB8Pf3x4kTJ9CvXz9ER0dDJBLh+fPnWL9+PW7dulXCZ0pEVLL27NkDX19frFmzBvXr18fy5cvh7e2N0NBQWFhY5Dp+586d+OGHH7Bp0yY0bNgQjx8/xqBBgyASibB06dISOAMioqIr1VeIr127hs6dO6N9+/awt7dHjx490Lp1a8lVC0EQsHz5csyYMQOdO3dGzZo1sW3bNrx58waHDh0CAISEhKBTp05wcXGBj48P3r17h/fv3wMARo8ejV9//RUGBgYldYpERKXC0qVLMXz4cAwePBjVqlXDmjVroKOjg02bNuV5/LVr1+Dp6Yl+/frB3t4erVu3Rt++fb94VZmIqDQq1Qlxw4YN4efnh8ePHwMA7ty5gytXrqBt27YAgOfPnyMqKgpeXl6S1xgaGqJ+/frw9/cHALi6uuLKlStITU3FqVOnYG1tDTMzM+zYsQNaWlro2rVrgdqSnp6OhIQEqR8ioq9BRkYGAgMDpWKpiooKvLy8JLH0vxo2bIjAwEBJAvzs2TMcP34c7dq1y7cexlEiKq1K9ZCJH374AQkJCahSpQpUVVWRnZ2N+fPno3///gCAqKgoAIClpaXU6ywtLSX7hgwZgrt376JatWowMzPD3r17ERsbi1mzZuHChQuYMWMGdu/eDUdHR2zatAm2trZ5tmXhwoWYO3duru2vX79mUC+FdLJSFF7Hq1dJCq+DlFtiYmKx1PP+/XtkZ2fnGUsfPXqU52v69euH9+/fo1GjRhAEAVlZWRg1ahR+/PHHfOspahz9Wv6eNeNMFV4HALx69Uou5bDfC05efQ6w3wujIP1e0DhaqhPivXv3YseOHdi5cydcXFwQHByMiRMnwsbGBgMHDixQGerq6li1apXUtsGDB2P8+PEICgrCoUOHcOfOHSxatAjjx4/H/v378yxn2rRp8PX1lfyekJAAOzs72NracshFKZQSEqfwOsqVM1J4HaTcSvOX7QsXLmDBggVYvXo16tevjydPnmDChAn46aefMHPmzDxfU9Q4+rX8Paenf1B4HQBQrlw5uZTDfi84efU5wH4vjIL0e0HjaKlOiCdPnowffvgBffr0AQDUqFEDL168wMKFCzFw4EBYWVkBAKKjo2FtbS15XXR0NGrVqpVnmefPn8eDBw+wYcMGTJ48Ge3atYOuri569eqFP/74I9+2aGpqQlNTU34nR0RUSpiZmUFVVRXR0dFS26OjoyVx9r9mzpyJb7/9FsOGDQOQE5+Tk5MxYsQITJ8+HSoquUfkMY4SUWlVqscQp6Sk5AqqqqqqEIvFAAAHBwdYWVnBz89Psj8hIQEBAQHw8PDIVV5aWhp8fHywdu1ayRCMzMxMAEBmZiays7MVeDZERKWThoYG3NzcpGKpWCyGn59fnrEUyD8+A5BaGpOIqCwo1VeIO3bsiPnz56N8+fJwcXFBUFAQli5diiFDhgAARCIRJk6ciJ9//hlOTk6SZddsbGzQpUuXXOX99NNPaNeuHWrXrg0A8PT0xOTJkzF48GD88ccf8PT0LM7TIyIqNXx9fTFw4EC4u7ujXr16WL58OZKTkzF48GAAwIABA2Bra4uFC3OeDNWxY0csXboUtWvXlgyZmDlzJjp27ChJjImIyopSnRCvXLkSM2fOxJgxY/D27VvY2Nhg5MiRmDVrluSYKVOmSG7TxcXFoVGjRjh58iS0tLSkyrp//z727t2L4OBgybYePXrgwoULaNy4MSpXroydO3cW16kREZUqvXv3xrt37zBr1ixERUWhVq1aOHnypGSiXUREhNQV4RkzZkAkEmHGjBl4/fo1zM3NJRcxiIjKGpHAe1tFkpCQAENDQ8THx3NSXSm08kycwusY18pI4XWQcvva40xBz+9r+Xte/3SawusAgOGOC+VSDvu94OTV5wD7vTAK0u8FjTOl+grx1+Br+WATERERfa2YEFOBlJZvekRERETyVqpXmSAiIiIiUjQmxERERESk1JgQExEREZFSY0JMREREREqNCTERERERKTUmxERERESk1JgQExEREZFSY0JMREREREqNCTERERERKTUmxERERESk1JgQExEREZFSY0JMREREREqNCTERERERKTUmxERERESk1NRKugFElL/1T6cpvI7hjgsVXkdZw34nIlIuvEJMREREREqNCTERERERKTUmxERERESk1JgQExEREZFSY0JMREREREqNCTERERERKTUmxERERESk1JgQExEREZFSY0JMREREREqNCTERERERKTUmxERERESk1JgQExEREZFSUyvpBhDR12PlmTiF1zGulZHC6yAiIuXCK8REREREpNSYEBMRERGRUmNCTERERERKjQkxERERESk1JsREREREpNSYEBMRERGRUmNCTERERERKjQkxERERESk1JsREREREpNSYEBMRERGRUmNCTERERERKjQkxERERESk1JsREREREpNSYEBMRERGRUmNCTERERERKjQkxERERESk1JsREREREpNSYEBMRERGRUmNCTERERERKjQkxERERESk1JsREREREpNSYEBMRERGRUmNCTERERERKjQkxERERESk1JsREREREpNSYEBMRERGRUmNCTERERERKjQkxERERESk1JsREREREpNSYEBMRERGRUmNCTERERERKjQkxERERESk1JsREREREpNTUCvuC2bNnY8iQIahQoYIi2kNUZrzdOVTxldS3UHwdVOYEBgZi0qRJOHz4MAwMDKT2xcfHo0uXLli+fDlcXV1LqIVERGVLoa8QHz58GI6OjmjZsiV27tyJ9PR0RbSLiIjysWTJErRo0SJXMgwAhoaGaNWqFRYvXlwCLSMiKpsKfYU4ODgYQUFB2Lx5MyZMmAAfHx/06dMHQ4YMQd26dRXRRiIi+kRAQAB++OGHfPd37NgRGzZsKMYWERUN77RRaVGkMcS1a9fG77//jjdv3mDjxo149eoVPD09UbNmTaxYsQLx8fFya+Dr16/xzTffwNTUFNra2qhRowZu3bol2S8IAmbNmgVra2toa2vDy8sLYWFhkv3p6en49ttvYWBgAGdnZ5w9e1aq/MWLF2PcuHFyay8RkaK9fv0a+vr6+e7X09NDZGRkoctdtWoV7O3toaWlhfr16+PGjRufPT4uLg4+Pj6wtraGpqYmnJ2dcfz48ULXS0RU0mSaVCcIAjIzM5GRkQFBEGBsbIw//vgDdnZ22LNnj8yNi42NhaenJ9TV1XHixAk8fPgQS5YsgbGxseSYRYsW4ffff8eaNWsQEBAAXV1deHt7Iy0tDQCwbt06BAYGwt/fHyNGjEC/fv0gCAIA4Pnz51i/fj3mz58vc1uJiIqLubk5QkND893/6NEjmJmZFarMPXv2wNfXF7Nnz8bt27fh6uoKb29vvH37Ns/jMzIy0KpVK4SHh+N///sfQkNDsX79etja2haqXiKi0qDQQyaAnAkdmzdvxq5du6CpqYkBAwZg1apVqFSpEgBg5cqVGD9+PHr37i1T43799VfY2dlh8+bNkm0ODg6S/xcEAcuXL8eMGTPQuXNnAMC2bdtgaWmJQ4cOoU+fPggJCUGnTp3g4uKCihUrYvLkyXj//j3Mzc0xevRo/Prrr3mOwyOi0om3WAEvLy/Mnz8fbdq0ybVPEATMnz8fXl5ehSpz6dKlGD58OAYPHgwAWLNmDf7++29s2rQpz+EZmzZtQkxMDK5duwZ1dXUAgL29feFPhoioFCj0FeIaNWqgQYMGeP78OTZu3IiXL1/il19+kSTDANC3b1+8e/dO5sYdOXIE7u7u6NmzJywsLFC7dm2sX79esv/58+eIioqSCvyGhoaoX78+/P39AQCurq64cuUKUlNTcerUKVhbW8PMzAw7duyAlpYWunbtWqC2pKenIyEhQeqHiKgkzJgxA/fu3UP9+vWxd+9e3LlzB3fu3MGePXtQv3593L9/H9OnTy9weRkZGQgMDJSKpSoqKvDy8pLE0v86cuQIPDw84OPjA0tLS1SvXh0LFixAdnZ2vvUwjhJRaVXoK8S9evXCkCFDPntbzMzMDGKxWKaGAcCzZ8/w559/wtfXFz/++CNu3ryJ8ePHQ0NDAwMHDkRUVBQAwNLSUup1lpaWkn1DhgzB3bt3Ua1aNZiZmWHv3r2IjY3FrFmzcOHCBcyYMQO7d++Go6MjNm3alO95LVy4EHPnzs21/fXr158N6jpZKUU9/QJ79SpJ4XVoxpkqvI5Xr17Jrazi6Pf3qoq/NawZp/i7F+z33EpLvycmJua53dHREWfPnsWgQYPQp08fiEQiADlXh6tVq4YzZ85IXaT4kvfv3yM7OzvPWPro0aM8X/Ps2TOcO3cO/fv3x/Hjx/HkyROMGTMGmZmZmD17dp6vYRxVfBwF5Pc3zb/ngitrcfRr+bzLEkf/q9AJ8cyZMwv7kiITi8Vwd3fHggULAORM5rt//z7WrFmDgQMHFqgMdXV1rFq1Smrb4MGDMX78eAQFBeHQoUO4c+cOFi1ahPHjx2P//v15ljNt2jT4+vpKfk9ISICdnR1sbW0/O+QiJSSuQO2URblyRgqvIz39g8LrKFeunNzKKo5+N8t+rfA60o0yFV4H+z230tLvn0sS3d3dcf/+fQQFBeHJkycQBAHOzs6oVauWHFuZP7FYDAsLC6xbtw6qqqpwc3PD69evsXjx4nwT4tIcRzUufa/wOtKLaSiOvP6m+fdccGUtjipT3lDQO1GFHjLRvXt3/Prrr7m2L1q0CD179ixscZ9lbW2NatWqSW2rWrUqIiIiAABWVlYAgOjoaKljoqOjJfv+6/z583jw4AHGjh2LCxcuoF27dtDV1UWvXr1w4cKFfNuiqakJAwMDqR8iopJWu3Zt9OzZE7169SpyMmxmZgZVVdVCxVJra2s4OztDVVVVsq1q1aqIiopCRkZGnq9hHCWi0qrQV4gvXbqEOXPm5Nretm1bLFmyRB5tkvD09Mw1k/rx48eSp+Q5ODjAysoKfn5+kn8IEhISEBAQgNGjR+cqLy0tDT4+PtixYwdUVVWRnZ0tWXEiMzPzs2PfiIhKi27duuW53dDQEM7Ozhg2bBjMzc0LXJ6Ghgbc3Nzg5+eHLl26AMi5Auzn54exY8fm+RpPT0/s3LkTYrEYKio511YeP34Ma2traGhoFO6EiIhKWKGvECclJeUZ7NTV1eU+QeK7777D9evXsWDBAjx58gQ7d+7EunXr4OPjAwAQiUSYOHEifv75Zxw5cgT37t3DgAEDYGNjIwnqn/rpp5/Qrl071K5dG0BOQD9w4ADu3r2LP/74A56ennJtPxGRIhgaGub5ExcXh/Xr16Ny5cq4f/9+ocr09fXF+vXrsXXrVoSEhGD06NFITk6WrDoxYMAATJs2TXL86NGjERMTgwkTJuDx48f4+++/sWDBAkl8JiIqSwp9hbhGjRrYs2cPZs2aJbV99+7duYY3yKpu3bo4ePAgpk2bhnnz5sHBwQHLly9H//79JcdMmTIFycnJGDFiBOLi4tCoUSOcPHkSWlpaUmXdv38fe/fuRXBwsGRbjx49cOHCBTRu3BiVK1fGzp075dp+IiJF+HQpyv8Si8UYPnw4pk2bhqNHjxa4zN69e+Pdu3eYNWsWoqKiUKtWLZw8eVIy0S4iIkJyJRgA7OzscOrUKXz33XeoWbMmbG1tMWHCBEydOrXoJ0ZEVEKKNKmuW7duePr0KVq0aAEA8PPzw65du7Bv3z65N7BDhw7o0KFDvvtFIhHmzZuHefPmfbac6tWrSz3BDshZVmj16tVYvXq1XNpKRFTSVFRUMH78eLRt27bQrx07dmy+QyTymmPh4eGB69evF7oeIqLSptAJcceOHXHo0CEsWLAA//vf/6CtrY2aNWvi7NmzaNq0qSLaSEREhaCrq4uUFMUv3URE9LUo0pPq2rdvj/bt28u7LUREJAdnzpyBs7NzSTeDiKjMKFJCTEREJefIkSN5bo+Pj0dgYCA2bNiADRs2FHOriIjKrkInxNnZ2Vi2bBn27t2LiIiIXOtNxsTEyK1xRESUW16r6ACAvr4+KleujA0bNqBPnz7F2ygiojKs0Anx3LlzsWHDBnz//feYMWMGpk+fjvDwcBw6dCjXyhNERCR/YrG4pJtARPRVKfQ6xDt27MD69evx/fffQ01NDX379sWGDRswa9YszjYmIioF4uLi8Mcff5R0M4iIyoxCJ8RRUVGoUaMGAEBPTw/x8fEAcpZH+/vvv+XbOiIiKjA/Pz/069cP1tbWmD17dkk3h4iozCh0QlyuXDlERkYCABwdHXH69GkAwM2bN6GpqSnf1hER0We9fPlS8uCi1q1bQyQS4eDBg4iKiirpphERlRmFToi7du0KPz8/AMC4ceMwc+ZMODk5YcCAARgyZIjcG0hERNIyMzOxb98+eHt7o3LlyggODsbixYuhoqKC6dOno02bNlBXVy/pZhIRlRmFnlT3yy+/SP6/d+/eqFChAq5duwYnJyd07NhRro0jIqLcbG1tUaVKFXzzzTfYvXs3jI2NAQB9+/Yt4ZYREZVNhUqIMzMzMXLkSMycORMODg4AgAYNGqBBgwYKaRwREeWWlZUFkUgEkUgEVVXVkm4OEVGZV6ghE+rq6ti/f7+i2kJERAXw5s0bjBgxArt27YKVlRW6d++OgwcPQiQSlXTTiIjKpEKPIe7SpQsOHTqkgKYQEVFBaGlpoX///jh37hzu3buHqlWrYvz48cjKysL8+fNx5swZZGdnl3QziYjKjEKPIXZycsK8efNw9epVuLm5QVdXV2r/+PHj5dY4IiL6PEdHR/z888+YN28eTp06hY0bN6JDhw7Q19fH+/fvS7p5RERlQqET4o0bN8LIyAiBgYEIDAyU2icSiZgQExGVABUVFbRt2xZt27bFu3fvsH379pJuEhGVUm93DlV8JfUtFF+HHBU6IX7+/Lki2kFERHJibm4OX1/fkm4GEVGZUegxxEREREREX5NCXyH+0sM3Nm3aVOTGEBEREREVt0InxLGxsVK/Z2Zm4v79+4iLi0OLFi3k1jAiIiIiouJQ6IT44MGDubaJxWKMHj0ajo6OcmkUERF9XkJCAvT09KCiIj3yLTs7G8nJyTAwMCihlhERlT1yGUOsoqICX19fLFu2TB7FERHRZxw8eBDu7u5IS0vLtS8tLQ1169bF0aNHS6BlRERlU6GvEOfn6dOnyMrKkldxVAhcPoVIufz555+YMmUKdHR0cu3T1dXF1KlT8ccff6Bjx44l0DoiorKn0Anxf5fyEQQBkZGR+PvvvzFw4EC5NYyIiPJ2//59rF69Ot/9TZo0wYwZM4qxRUREZVuhE+KgoCCp31VUVGBubo4lS5Z8cQUKIiKSXWxs7GfvyGVmZuaaAE1ERPkrdEJ8/vx5RbSDiIgKyN7eHrdu3UKVKlXy3H/r1i1UqFChmFtFRFR2FXpS3fPnzxEWFpZre1hYGMLDw+XRJiIi+oxu3bph+vTpiI6OzrUvKioKM2bMQPfu3UugZUREZVOhE+JBgwbh2rVrubYHBARg0KBB8mgTERF9xg8//AB9fX04OTlhzJgxWLFiBVasWIHRo0fD2dkZenp6+OGHH0q6mUREZUaRxhB7enrm2t6gQQOMHTtWLo0iIqL86evr4+rVq5g2bRr27NkjGS9sZGSEb775BvPnz4e+vn4Jt5KIqOwodEIsEomQmJiYa3t8fDyys7Pl0igiIvo8Q0NDrF69GqtWrcL79+8hCALMzc0hEolKumlERGVOoYdMNGnSBAsXLpRKfrOzs7Fw4UI0atRIro0jIqLPu3fvHi5evIhLly7h/v37Jd0cIqIyqdBXiH/99Vc0adIElStXRuPGjQEAly9fRkJCAs6dOyf3BhIRUW43btzA0KFD8fDhQwiCACDnDp6Liws2btyIunXrlnALiYjKjkJfIa5WrRru3r2LXr164e3bt0hMTMSAAQPw6NEjVK9eXRFtJCKiTzx8+BAtW7aEtrY2/vrrL9y+fRu3b9/G9u3boampiZYtW+Lhw4cl3UwiojKjSI9utrGxwYIFC+TdFiIiKoA5c+agVatW2L9/v9SY4Vq1aqFv377o1q0b5syZg71795ZgK4mIyo5CJ8SbN2+Gnp4eevbsKbV93759SElJ4eObiYgU7Pz58zhx4kSeE+hEIhF+/PFHtGvXrgRaRkRUNhV6yMTChQthZmaWa7uFhQWvGhMRFYPExERYWlrmu9/KyirP1YCIiChvhU6IIyIi4ODgkGt7hQoVEBERIZdGERFR/ipUqIAbN27kuz8gIICPbiYiKoRCJ8QWFha4e/duru137tyBqampXBpFRET569OnD3x9ffNcZu3evXuYNGkSevfuXQItIyIqmwo9hrhv374YP3489PX10aRJEwDAxYsXMWHCBPTp00fuDSQiImnTpk3D2bNnUatWLbRq1QpVq1aFIAgICQnB2bNnUa9ePfz4448l3UwiojKj0AnxTz/9hPDwcLRs2RJqajkvF4vFGDBgAObPny/3BhIRkTQtLS2cP38ey5Ytw65du3Dx4kUAgLOzM37++Wd899130NTULOFWEhGVHYVOiDU0NLBnzx78/PPPCA4Ohra2NmrUqMHxakRExUhDQwNTp07F1KlTS7opRERlXqHHEH/k5OSEnj17okOHDjA2Nsaff/4Jd3d3ebaNiIiKIDIyEmPHji3pZhARlRlFejDHR+fPn8emTZtw4MABGBoaomvXrvJqFxERfcaDBw9w/vx5aGhooFevXjAyMsL79+/x888/Y+3atahYsWJJN5GIqMwodEL8+vVrbNmyBZs3b0ZcXBxiY2Oxc+dO9OrVK89F4omISL6OHDmCHj16ICsrCwCwaNEirF+/Hr169YKbmxsOHjyINm3alHAriYjKjgIPmdi/fz/atWuHypUrIzg4GEuWLMGbN2+goqKCGjVqMBkmIiomP//8M3x8fJCQkIClS5fi2bNnGD9+PI4fP46TJ08yGSYiKqQCJ8S9e/dG7dq1ERkZiX379qFz587Q0NBQZNuIiCgPoaGh8PHxgZ6eHsaNGwcVFRUsW7YMdevWLemmERGVSQVOiIcOHYpVq1ahTZs2WLNmDWJjYxXZLiIiykdiYiIMDAwAAKqqqtDW1uaYYSIiGRR4DPHatWuxfPly7N27F5s2bcLEiRPh7e0NQRAgFosV2UYiIvqPU6dOwdDQEEDOWvB+fn65nlzXqVOnkmgaEVGZU6hJddra2hg4cCAGDhyIsLAwbN68Gbdu3YKnpyfat2+PHj16oFu3bopqKxER/WPgwIFSv48cOVLqd5FIhOzs7OJsEhFRmSXTOsQLFizAy5cv8ddffyElJQV9+/aVZ9uIiCgPYrH4iz9MhomICk6mdYgBQEVFBR07dkTHjh3x9u1bebSJiIiIiKjYFPkKcV4sLCzkWRwRERERkcLJNSEmIiIiIiprmBATERERkVJjQkxERERESq3QCXHFihXx4cOHXNvj4uK4MDwRUTFiPCYiko9CJ8Th4eF5LueTnp6O169fy6VRRET0ZYzHRETyUeBl144cOSL5/0+fkAQA2dnZ8PPzg729vVwbR0REuTEeExHJV4ET4i5dugDIefrRf5+QpK6uDnt7eyxZskSujSMiotwYj4mI5KvACbFYLAYAODg44ObNmzAzM1NYo4iIKH+Mx0RE8lXoJ9U9f/4817a4uDgYGRnJoz1ERFRAjMdERPJR6El1v/76K/bs2SP5vWfPnjAxMYGtrS3u3Lkj18YREVH+GI+JiOSj0AnxmjVrYGdnBwA4c+YMzp49i5MnT6Jt27aYPHmy3BtIRER5YzwmIpKPQg+ZiIqKkgTgY8eOoVevXmjdujXs7e1Rv359uTeQiIjyxnhMRCQfhb5CbGxsjJcvXwIATp48CS8vLwCAIAh5rodJRESKwXhMRCQfhb5C3K1bN/Tr1w9OTk748OED2rZtCwAICgpCpUqV5N5AIiLKG+MxEZF8FDohXrZsGezt7fHy5UssWrQIenp6AIDIyEiMGTNG7g0kIqK8MR4TEclHoYdMqKurY9KkSVixYgVq164t2f7dd99h2LBhcm3cf/3yyy8QiUSYOHGiZFtaWhp8fHxgamoKPT09dO/eHdHR0ZL9MTEx6NixI/T09FC7dm0EBQVJlenj48MF7ImoTJJ3PF61ahXs7e2hpaWF+vXr48aNGwV63e7duyESiSQPDCEiKmsKnRADwPbt29GoUSPY2NjgxYsXAIDly5fj8OHDcm3cp27evIm1a9eiZs2aUtu/++47HD16FPv27cPFixfx5s0bdOvWTbJ//vz5SExMxO3bt9GsWTMMHz5csu/69esICAiQSrCJiMoSecXjPXv2wNfXF7Nnz8bt27fh6uoKb29vvH379rOvCw8Px6RJk9C4ceMinwMRUUkrdEL8559/wtfXF23btkVcXJxk4oaRkRGWL18u7/YBAJKSktC/f3+sX78exsbGku3x8fHYuHEjli5dihYtWsDNzQ2bN2/GtWvXcP36dQBASEgI+vTpA2dnZ4wYMQIhISEAgMzMTIwaNQpr1qyBqqqqQtpNRKRI8ozHS5cuxfDhwzF48GBUq1YNa9asgY6ODjZt2pTva7Kzs9G/f3/MnTsXFStWlOVUiIhKVKET4pUrV2L9+vWYPn26VCLp7u6Oe/fuybVxH/n4+KB9+/aSGdQfBQYGIjMzU2p7lSpVUL58efj7+wMAXF1dce7cOWRlZeHUqVOSK8yLFi1Cs2bN4O7uXqA2pKenIyEhQeqHiKgkySseZ2RkIDAwUCqWqqiowMvLSxJL8zJv3jxYWFhg6NChBaqHcZSISqsiPbr507FqH2lqaiI5OVkujfrU7t27cfv2bdy8eTPXvqioKGhoaOR6TKmlpSWioqIAAD/88ANGjx4NR0dH2NvbY+PGjQgLC8PWrVvh7++PUaNG4fTp03B3d8f69ethaGiYZzsWLlyIuXPn5tr++vXrzwZ1nayUQpxt0bxXtVV4HZpxBgqv49WrV3Iri/1ecOz33EpLvycmJn52v7zi8fv375GdnQ1LS0up7ZaWlnj06FGer7ly5Qo2btyI4ODgAtfDOKr4zxUgv79p9nvBMY7mVlr6/Utx9KNCJ8QODg4IDg5GhQoVpLafPHkSVatWLWxxn/Xy5UtMmDABZ86cgZaWVpHKMDQ0xM6dO6W2tWjRAosXL8aOHTvw7NkzhIaGYvjw4Zg3b16+E+ymTZsGX19fye8JCQmws7ODra0tDAzyf9NTQuKK1O7CMMt+rfA60o0yFV5HuXLl5FYW+73g2O+5lZZ+/9IV1OKMx59KTEzEt99+i/Xr18PMzKzAr2McVfznCpDf3zT7veAYR3MrLf1e0DtRBU6I582bh0mTJsHX1xc+Pj5IS0uDIAi4ceMGdu3ahYULF2LDhg0FLa5AAgMD8fbtW9SpU0eyLTs7G5cuXcIff/yBU6dOISMjA3FxcVJXiaOjo2FlZZVnmZs3b4aRkRE6d+6Mbt26oUuXLlBXV0fPnj0xa9asfNuiqakJTU1NuZ0bEVFRyTsem5mZQVVVVWqFHiD/WPr06VOEh4ejY8eOkm1isRgAoKamhtDQUDg6OuZ6HeMoEZVWBU6I586di1GjRmHYsGHQ1tbGjBkzkJKSgn79+sHGxgYrVqxAnz595Nq4li1b5hoHN3jwYFSpUgVTp06FnZ0d1NXV4efnh+7duwMAQkNDERERAQ8Pj1zlvXv3DvPmzcOVK1cA5CTXmZk532AyMzP5ZCciKhPkHY81NDTg5uYGPz8/ydJpYrEYfn5+GDt2bK7jq1Spkis2z5gxA4mJiVixYoXkcdJERGVFgRNiQRAk/9+/f3/0798fKSkpSEpKgoWFhUIap6+vj+rVq0tt09XVhampqWT70KFD4evrCxMTExgYGGDcuHHw8PBAgwYNcpU3ceJEfP/997C1zRk74+npie3bt6N169ZYt24dPD09FXIeRETypIh47Ovri4EDB8Ld3R316tXD8uXLkZycjMGDBwMABgwYAFtbWyxcuBBaWlq5YvPHu3T/3U5EVBYUagyxSCSS+l1HRwc6OjpybVBhLVu2DCoqKujevTvS09Ph7e2N1atX5zru1KlTePLkCbZv3y7ZNnbsWNy6dQv169dHvXr1MHv27OJsOhFRkck7Hvfu3Rvv3r3DrFmzEBUVhVq1auHkyZOSiXYRERFQUSnS0vVERKVeoRJiZ2fnXEH4v2JiYmRq0JdcuHBB6nctLS2sWrUKq1at+uzrvL294e3tLbVNR0cHe/fulXcTiYgUThHxeOzYsXkOkQByx97/2rJlS6HqIiIqTQqVEM+dOzffZcmIiKj4MB4TEclPoRLiPn36KGy8MBERFRzjMRGR/BR4QNiXbs0REVHxYDwmIpKvAifEn85qJiKiksN4TEQkXwUeMvFx0XUiIipZjMdERPLFNXSIiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUWqEe3Uz0tcrOzkJM9EsIghgmFnZQU9eQex3xyel49CoWYjHgXM4Ipvpacq+D8paakQWxWICulnpJN4WIiEohJsSlUEZ6KgSxGJraugqrozgShIy0TAhiAZo68k8u5enlk7s4tmkexNnZEIuzoaKiirYDfkBFl/pyq+PygzdYejAY5cz0kJUtxqv3SfDpUBNt3MrLrQ7KLfxtAhb/LwhPIuMBABUs9DGpW2042xqVbMOIiKhUYUJciryPDMfxbQvx9mUYIBLBzKoC2nw7FVblK8utjuJIEN5FxOHIisuIevYBIpEIZnZG6DjOE9aVzORWhyzEYjFUVP4dLXT+f3+g/aAZKO9cCwBw58pRnN2zHCPm7SpyHSnpWdDR/PfPa/u5UPw+sgnszPUAAAGhUVh26I5cE+LEmBSc3hCAF/ejIIgFlKtigdbD6sPYSl9udchTUvwH+O37HS/D7kAQi2FbsTpa9BwLIzMbudWx4vBddGrggKbVbZCVLeDAtadYvP821o9vIbc6ylq/ExFRbkyIS5HTu5aidpMuqOLWHNlZmQg89z8c3/YLhszYLLc6iiNBOPHnNbi3q4JqjRyQnZmNgKMPcWTFFYxc2UVudchix29j0LqPLyzLOwMAxNlZMDCxkOzXN7ZAVlamTHWM/fMihnlXQ8Oq1gAANVUVxCenSxLi2KQMqKnKdwj/339chY2zOZr0qY3srGzcOv4Ih5ZexOBFHeRaj7yc/GsRrO2rwrP9YGRnZSLo4iEc2/wzvpm8ushlzv4rAGM71oS5oTYAICE5Ax5VrKClkRPq6jpb4kjAc7m0/6Oy1u9fm6zMDIhUVKCqmvMex757jfv+J5AQ+xYGJpao4dFW5i9ZGVnZUBGJJH+zbz4k49TtCLyNT4WlkTa865SHtYli7uj9NfMkOoxrBCMLPYWUL09x798g7t0b6BqawtzGQS5lJqRk4FlUAipaGcBARwPxyek4GRiBjCwxmlS3QQUL+XzxFIsFqKiI8tye+CEZhualq/9fhN7G66f3kBT/ASIVFRiZWsOxZkOYWNgprM7f9gdhUKsqMDPQlrmshPfJUNNQhY5BztDBiAdRuH3qMRLeJcHQQg9ubaugXBWLL5QiX0yIS9DBtTPg1WsC9I3NAQCpSfGoVLMh1DW0oK6hBQeX+gi6fFimOoojQdi3wA/eIxvAwDTnH4SUhHQ41bODuqYa1DXVUMmtHAJPPJKpDnlq2XM8Tu38DeUquaJRxyHwaDcQ234dCRMLO4izsxATHYGWvcbLVMeCgR5YefQuTt9+ibEda2B0u+qYv+cWxAKQLRZDJBJhcrfaMtVxekMAmn1TBxr/DHuJiUxA96nNof7Plel6Haph2/QTMtUhT377VqJxp2HQ0Mz5LMa9e43Ow+dBXUMTAODWvDt2LZ8gUx0tapXD1M3X0LG+A7o0cECnBvYYsfI8atibIjtbQNCzd+jRqJJMdZS1fv/a/W/VFNRu2hWVazfF66f3sGfl9zCxsIOpVQU8fxCAwHP70HPcb7CtWL3Idfy49To61XdAk+o2ePDiA6Zs9kc5M12UN9fHjcdvsf/qU/wyuCFcypsUuY7HNyLy3B7xMBpPbr6EgXlOfHWuVzqGWZ3ZvQxNu4yEhpYOMjPScXzbAoTduQIIAiASwa5STXQdOR8aWjpFruPRq1hM2+KPlPQs6Gqp45dBHvh59y2oqoggFgTsvRyGpcMbwcnGqMh1pKdk4O8/riHs1ktoaKujjndlNO7tCpV/vvykxKdh1cj9+PHAwCLXIU/JCbE4uHY6oiJCIRKpQBDEsChXCWF3ruDS4fVwb9ETTbuOlKmOZ1HxeW73u/MKHlWtkGCSAQCoaGVY5Dr2LzqPRj1d4VTXDqEBEdj/63k4uZdDuaoWiHmTgO3TT6LHD83hVFdxCf5/MSEuQdXqemHvyu9Rq3Fn1GnWDbWbdsHm+UNhV6kmxNlZePE4CHVb9JKpjuJIEFyaOmLHrFNwa1sFddtXhXu7Klg//jDKu1ghO1uM8LuRaNDZRaY65MnGoRq+mfwnbpzdje2/jkLTLiMwdOY2RIY/hCAIsCpfWfIlpaisjHUwf0ADnL/7CpM2XkWXBhWxxdcLbz4kI1sswM5cD5rqqjLVoW+qg03fH0OLgW5wrlce1Ro5YPOUv1HJzRbZWWKEXo9A9aYVZapDnvSNzCX9XammJyq7NceOxaPh4NIA4uwshN25jGp1vWSqo2l1W7hXssCGUw8xYe1ljO/kioUDzXDn+XtkiwX0alIJVcoZy3YeZazfv3ZvXz2BuW1Of18+uhG1G3dB8+5jJPsvH92Ii4fWoZ/v70Wu42lkPCpaGQAANp99hI717TGq7b8J9pazIdhw6iGWDW9U5Dr2LTwHkUgEQRBy7Tu1IQAAIBKJSk1idufqMTRsNwgaWjrwP7kNkeEh6DXuN1jbV8Xbl2E4vu0XXD/1F5p0HlHkOracCUFjFxuMbOuC4zdfYO7OG3CrZAHfrrUAAEsOBGHH+ceY079ekeu4uDMI0S9i0GliY6QlZ+Dq3juIevYB3ac2h9o/MTqv96SknPvfSugZmmLcoiNQVVPHxYNrkJ6WjAFT1+JF6G0c3TQPekamcGveo8h1jF51Md9983bdlPz/qZ86FbmOdxFxMLMzAgBc238Xzb6pg4bdakj23/o7BJd2BTMhVhaV6zSDfVV3XDy0Djt+80GrPt+hp88ivAwLhlicjXqt+sLavqpMdRRHglDN0x4Va9ng/LZAbJn6N9qO8kDf2a3x4kEUxNliNOxaHTbOsiWY8qaiqooG3v1RuU4znNm9DJoBp9Ci53joG8l3nHPzmuVQ18kS604+wOSNVzGhsysq2RT9W/WnPLrWQBUPe5xadx13zz1B6+H1YeNkJhnL2mKgO6o2rCCXuuShXqs+cK7dBGf3rMD96yfRsud4WFeokjOGWBCjaZeRcK7dVOZ6dLXUMaGzK+6Hf8Ci/bdRp5I5BrWsIrkrIquy1u9fO7E4G4I4J2GJiX6JFj3GSu2v3qANbp/fL1Md2WIB4n+SopfvkjC6nfTV5ta1y+PgtWcy1eFY2xYiFRE6jPWErtG/t6QXdt+GYcs6wby8kUzly90nSeKze/5o2mUkyjvn3PWydayB5t3H4OKhtTIlxI/fxGN0+xrQ1VJH14YVseH0Q7Sr++/fVqcGDpj9142inwOA0IAIdJrQGBWqWwEAKtcvjz0/n8Xe+X7o9WNLADlfREqL5w9voK/vSsmk+8adh2Pl5E5o2XM8KlSug+bdx+D6yR0yJcQOlgYwM9TCiDYu0FT750sBgMHL/DB/YAPYymF4kIqKCBlpOUMT46KT4FjHVmq/Yx1b+G0LlLmeQrWpWGujXDS19dC6ry+adRuNE9sW4v71k6jRsB3cW/SUORn+6GOCMKKNCxbtv41TQRFo41Ye3T0dZU6GP9LS1UDb0R7wGlQXR1ZcwZ1zYajl5YT6nVxKXTIMAO/ePMfjoEsQxNnoNe43ONZoiN3LJiDo0iG51XEjNBr/u/IEj9/EwbdrLQz1roZf9t3GupMPkJ6ZLZc6jK300WdWK1T2qIDt008i/l0yvAbXReth9VHN075UBXIAMDKzQQ+fX+Fcqwl2L5+IhJhoNOs2Gi16jEXlOs3k0t6ElAw8fh0HBysDrB7TFDqaahiz+iJuhEbL4QxylLV+/5pZ21fF03vXAOR8vt69fiq1/92rp9DSlW2caZVyxrj+KCqnPhMdPItKkNr/NCoeetqyrabTZ1Yr2Ne0xqbJxxB286VMZRWXj5/zpIQYmNlI3xUxt3VEYuxbmcrPyhZL7qSpqapAS10Vhp+sWmSoo4GElAyZ6khJSIeB2b8Jno6BFvrNaY2MtEzs+fksMtOzZCpf3lRV1aXiy8dhE2JxTjttK1ZHfEykTHWsHNUEtia6+GnXTSSmZsLSWAdWxjlDX0z0NWFprANL46IPhQGACtWt8OBSznBNq4omeHE/Smp/+P0oGJjKVkdhMSEuYanJ8YiKCIW5jQO+/WEdNLR0sO2XEXj24Lrc6iiOBCElMQ2RT97DvIIxhi7pCE0dDWzwPYInga/kVoe83PTbix2LR+PG2d3YuWQc7lw5huoN2qD/5NWIDA/Bjt988O61bFd71py4j98OBCH0dRxWHL6Dv86HwtXBDKvHNIWGmgrGrLqIm4/l0/8piWmo0dQRQxZ3QPSzD9gy9W9Eh8fIpWxFSE2OR7V6rfDNlD8R/eoJdvzmg7f/SWKK6tydV+i/+DRmbg/AN7+dwc3HbzGgRRXM6V8Pe688wU+7byImMU0udZW1fv9aNeowBNdP/YWrf29BFfcWOH/gT1w+uhEPb57F1WObcXLnYtRu0lWmOgZ6VcGui2HYdu4Rmte0xdoT97HlbAjO3XmFbX6PsPRgMDo3sJf5XOp3ckHPaS1wblsgjq++VuqSsf+6cmwTzu9fDZFIBcnxH6T2pSUnQE1DtrXWzQ20ERmTLPn9x95uMPlk/fYPiekw1JXti4ihmS4+vJYeM6upo4G+s1sjMyML+389L1P58mbrWB1X/96MjPRUZGdn4fKRDTAytYa2bs6dx5TEOGjpGMhUh7qaCka3r4ERbVwwe0cAdl18DLFYvsNGmn/rhuCzj3Fk+WXYVbXExR23cXj5JVzZdwdHll/GqXUBaNi9xpcLkiMOmShBD2+exemdv0FDSxdZmeloN2AaPNsPQhW3Fjize6nktrKuQdEnapy78wrLDgVDR1MdGVnZmNK9Dga0qIJmNWzx+5G7OBUUAZ/2NaSCTGHdv/gMf6++Bk1tdWRlZKHTxMZo0qcWqjWyx4k113HXL+e2sp6x7DNT5eHm2T3oNnohyjvXRvyHKPxv1VS4NuoAHT1DtBswDeEht3Bk41wMnbW1yHWcCXqJhQM94GxrhISUDExYexnfNK8MdTUVDPKqimY1bbHi8F3UdbYsch3P77zBoaWXkJKQBn0THXSb3AwdxjVC+L1IHFpyCZXcy6FJn1qSyV4l7cWjQBzbMh+pSXHQMzRFx6Gz0fabKYh4HIRjm3+Go0sDNGw/SDLJrig2ng7B911ro1lNWzx+HYclB4PgUdUK5c318dtQTxy/GY6J665g2/dFH6tc1vr9a2dbsTq6j/kFFw78icjwEABAwKkdAAA9Q1N4thso0+1jAHApb4KfBzTAuhMP8OhVLABg18UwAICpvha+bVEZ3Ro6ylTHR1YVTTHktw44u+kmNnx3BAJKz/jVT5WrVBMx0TkTAU2tyiMhRvoL/rMHATCztpepjqY1bRCf/O8V4PqVraT2X38Uhcq2st3ldKhlgzt+YajkVk5qu6a2OvrOaoWdc07LVL68Nes2GvtWTsbKyTnjd9U1tdB56BzJ/g9RL1C9fmu51FXX2RIrRzXBkoPBuPn4qlzK/MjMzgiDf22PCzuD4H/wPjLSsnD/4jOoqKjAxskMXb9vgsoNinfoGSN2Cbp8ZD28+09BVfcWiIoIxcm/FqFSTU+YWpVHn4nLcefKMexYMhYj5u4sch3FkSCc/ysQHcZ6wqWxAyKfvMexP67CuV55mJUzwrc/t0HQ6VBs/eFv+KyV7R8lecmZIJFzy0mkkvsmiX1Vdwz4YZ1MdWipqyEqNgXOtkZ4F58KdTXpeuwtDGSagAMAp9YFwKNrdbi1rYJnQa9xZtMNDF7UAfY1rDF0SUdc2XsHG3yPYPSqbjLVIy9n9/6Oel69UatJF4SH3MT5/avxzeTVKO9cGwOmroX/iW3Y9stwDJ21rch1pGVmoZxZzvJINia6uYamtKtrD49/lsIrqrLW78rAtmJ19J+0CimJcYh7/waCIIaeoSkMTWV7rz/lUt4EK0Y2RlxyOiJjUiAWBJjqa0luJcuTuqYa2o72wOMbEXhxLwo6BkX/kqgofSYu/+z+qnVbwqWBt0x1DGhR5bP7+zZ1ynOptMJo0qcWEmNS8tynqaOBfnNaI+pZ6bnzY2Rmg0HTN+LV03sQZ2XC2sEFOnr/zkup4dFWrvWZ6Gth/oAGOOj/DAY6GtDRlN/DvIytDdD1+6YQBAHJcWkQBAE6BlpQVSuZwQtMiEtQZnoaTCxzZlAamdkgKyNdar9row6oVNNTpjqKI0HITMuCqW3OLRpjK/1ct/lqt65capYKAoC6Xr1w4M8fYF6uEmLfvkLjjkNzHSPLVUoAGNKqChbvv43Vf99DemY2JneXbYm1vCTFpqCSezmoa6qhYm1bnN387+xfNQ1VNPumDqo1ls9aoPKQnPABFat7QF1DE/ZV6+L8gX/XG1ZT10DjTsNQxb2lTHW0qm2HGduvo6aDKcJex6Ola+4ZysZ6sr23Za3flYmOvhF09I0AKG5lACNdTRjpFk+C6lyvfKmKnYUhzwfs5EceE2W19TWhrZ/7/RQEASKRCJo6GpIJd6WFuoYWHKrWLdY6u3pURFcPxayeIxKJSsUdZCbEJcilvjf2/zkN5Z1cERXxGNXqtcp1jK6BbLeDiiNBqNHcEXt+Oovy1a0Q9fQDajTNfevw01nTJa2eVx84VK2HmOgImNlUhKmV/P/BaVnLDnWdLfEmJhnlTPWgpy3/R2Q71bPDgUUX4FTXDi9D3sLxP7f8AMCignwmTcqDY42GOLJxDhxreOD10/t5Phpb1sX8R7WtDld7M7x8n4jWtcvD3Un+C7uXtX5XVksntMagaRtgai2f267pmdk4f/c1Hrz4gA+J6RCJci4yeFS1Qh1H+U8czkjLxMMr4YiLSoSesTaqNXGAjgxD2+TNb+/vcK7TDHaVapZYG97Gp2K73yN8L+Oa7nn5pcd2DF/eSbI0WGmSmZGO6JePoaWjn2tYSmZGOh4HXYBLfdmuzudlwJKzWDCwgeQimyIlvE/GpV1B6DBOtjuphcGEuAQ17z4Gdk6uiIl+CZcGbRTyja84EoRWQ+qhQnUrfHgdD9cWlVCxtu2XX1TCzG0rStYuVRQDHQ0Y6OSe8PHxyoOs2vt4Iuj0Y3x4FY/qTSuilpeTzGUqUpv+k3HnylF8iI5AtbpeqOHRTiH1eFS1ggcUd0WnrPX71+78/ryfbCgIYgSc2SmZbPTp2sSF9fpDEqZu9kdGZjbU1VTxPiEVdZ0tEPoqFkdvPIdnNWv82MsNqnkMwSqoNWMPYsDCttDR10LC+2Rs+/EE0pLSYWpriNioRFzeeweDfm1fah4JHnTpEIIuH4aRmQ1qeLRD9QbeMs13KYrElAycDnopU0J8ZlPey7YJgoBr++9B+5/hKq2GFH2tY3mKiY7Avj+m5KzgIRKhXMUa6DBkJvQMTQEAGWnJOPHXIpkS4oP+eU8qfxufgtO3I2D8zxczRV0xBoDUxHTcPf+UCbEykXVIREEoOkEASs/Tk+QhIfYtrv69BW2/mVLkMjKysrH5zCOEvopF/cqW6N3ECTsuPMaeSzkTcRpUscSETq7Q1Sr6lWM1dVXUbS+fpfmKg6qaOuo0K95xtakZWbh47w0iY5Jhoq+J5jXL5fklpTDKWr9/7QLP/w/mto6SdVklBAExURFQ09CU+Qvo6r/vo66TBcZ3qgmRSIQ9l8JwN/wDfh/VBK/eJ2HaVn/suPD4i2NeP+fD63gI2TnDPM5vD4S+iQ6GLesELV0NpKdmYv8v53Fhx210/V72tbrlpafPIjy974+bfntw5dgmVHSpj5oN28HBpQFUZPhy8JF/SNRn97/5ZAWKorpx9CEsHUyg+Z+4IAgCPryOh9p7NZSmVRQvHV4PMxsHfDt1LdJTEnFu/yrsXDoOfSYsg4FJ0Sdpf2rN8fswM9DKNT5bEICzwa+gqiqCCCKZEuL8nsz4UWxUYpHLLiomxCVM0bc+3sanQlNNBYb/jHm7F/4Bx26E4218KiyNtNGxvoNMjxuVtDU9Cw8uP8erkGgkxaYCIsDYygDO9ezg4Kr4sWTylJacgAcBp2RKiDedCcHFu6/RrGY5nAl6ibfxqbj+KBoTOtWEiooIW/0eYcvZR/DpINuyMlmZ2XgcEIHXoe+QFJcKANAz0oZtFQs417OTPGmpNBIEAS/DghH79jX0DE1gX60eVFVlC0nDVpzD0uGNYKCjgbfxqfh+wxUkpWainJke3sQkY8f5x1gxsjGsZVxYviz3+9emcadhuHP1GJp1G40KletIti8Z3wptvp0q80oHAHD3+Xv86fPvOtndGjpiy9lHSEjJQDkzPYxuVx1/Hr8vU0L8qVeh79B2lAe0/llSTFNbHY37uOLQ0ktyKV9ezGwqokIVNzTtOgphwZdx//oJHFo3Czr6RqjeoA2qN2gDY4vcQ4oKas5O2R66URDNv6mDoNOP4TWoLuxr/jufZmH3begwrlGpeyDK62cP0Gvcb9DRM4SOniG6jVqAM7uXYdey8eg9YRnUZVzqDgDauVfAo1ex+KGnGypY/HtHou2so1gwqAHsLWRb1g34/JMZPyru9dyZEJeg4rj18fOum+jXzBkNqljhWkgk5u68iQaVLeFS3gSvPyRh0oarmN2vLhpUKfoV5Jg3Cdg5+xQyM7KhpqGKhPfJqORWDm/C3iHw5CNUqV8BXb5vInk2fEl7cvfzy8fEvX8jcx2X70dico86qONojk717TFomR9m96uLhv9MYDTQ0cCyQ3dkSohj3iRg17wzSIpJgY2zOXQNcwJh1PMY3D4VCn1THfSZ2QomNrIHL3nYv/oHdBg8A5raekhNjsf+1dMQ9eIRtHUNkZqSAGPzcuj73QrJpKiiePk+Cdn/rJe56fRDmOprYY1PM+hqqSMlPQvzdt7A5rMh+LGXe5HrKGv9/rWr37ofyjvXxvFtC1GxugeadB4u8xer/9LTUkdqxr+ThdMzsyEWBKj+cwXNwdIAMYnp+b284P5JALIysnNNMtI31UVKvHzW0JY3VVU1VHFrjipuzZEQE417/idw//pJBJzZhUkr/YpcromeJsZ1qimJm//15E08fP7M/zHDBdGwe03Y17DG4RWX4eRuh+bfupXYKgcFkZWZDhWVf79wi0QitO7ri7N7V2D38oloP2iGzHVM6OyKKw8i8ePW6+jV2BGdG8h/aISesQ7ajGyAyvXzvrsc9ewDNk06Jvd6P4cJcQkqjlsf4W8TJd/wdl8Mw5BWVdG7yb9jHg9ff4Zt50JlSohPbwyAY51yaDOqAUQiEa4duIeIB1EYvKgDPryJx645Z3Bl31006VNL1tORi0PrZub8w/O5WegyfjNNSElHOdOcq5DWJrpQEYlg88lVSVtTPcQny/YP6Mm112FR3gjDlnbMdbsvPSUDR5Zfxsl119FvjnzWpJTV84c3kJWZCU1t4MrRTchIT8WwOX/ByMwGCbFvcWjdTFw5tgmt+/rKpb6Ql7EY36mmZFiKjqYavm1RGQv23pap3LLW78rA2r4qvp2yBmf3rsD2X0fKJSn4VJ1K5lh74gHGd6oJdVUVbDoTAkdrQ8ln6218qlxWntgx6xRUVVWQkZqBmDfxUpMz498m5bkaQmljYGIJz/aD0LDdQLx4JNujd51sjRD2Oj7fhFheFxBtnM0x5LeOOLX2OjZNOorO3zWRT8EKYGpZHlEvQ3NNFvXqNQEAcHDtdLnU08jFGpXLGWHx/iAEhL7FpG615FLuR9aOpoh6+iHfhPhLV48VgQlxCSqOWx+qKiLJlY2o2BTUdZaeVFfXyRIbTj2UqY4X96MxbFk9ye2Neh2r4eKOIKQkpsHUxhCthtbDmY03Sk1CrGtgAq8+38Epn/Hb0S/DsH3RKJnqsDDUwcOIWFgY6eDRq1iIRMCjV3Gwt8y5avjoZSzMDGRbeePlo7cYvKh9rqQMyFk/s2m/Otg89W+Z6lCUiMfBaNplhGRpJgNjCzTtPAKndi2RueyP/0hmZGbD9D+z8s0MtGX+IlKW+/1rpqGlg3YDpiHk1jnsWzkJgiCWW9nDvF0wZ8cNDP8956ll5obamNPv30lW8ckZ6NlItgdzNO5d65Pf7KD+n/Ven9x6Cbtq8rlQIg8GJpafvesnEolgX7Xod2IAoGejSkjLyP9pfTamulg0pKFMdXykqa2OThMb48Hl59g5+3SxJ2MFVcm1ER7dOgeXerm/cHv1mgBBLMadK0flUpe5oTZ+HeyB3ZfCMGb1Rbk+JKZBF5fPPonR2Fof3/zURm71FQQT4hJUHLc+atqb4vzd16hoZQhHG0Pcef4BFa3+XcQ7+Pl7mRMzLV0NZKT++8HOSs+CWCyG6j/B0qKCcc644lLCsnxlREeE5psQi7509bgA2tWtgN8OBOFk4As8fhOPEW1csOVsCF69T4JIBBy7EY7unrL9A6qlo474t0n5LvEV9zYRWjryX+5NFh+/NKWlJMLwP+uUGpnbIin+vcx1TNl0DWqqKkhJz8LL90mSLyEAEB2XIvOkurLY78qkqnsL2DpWR/TLMBgYy2dVHWM9TawY2Riv3ichK1sMO3M9qRUlmlSXfZ7Ely4YtBxUvOvOfsmIebsUXkcNe9PP7tfWUIOrg5lc63Rp7AC7qhaIfPoBBuayzTVQhAbe/T+7v1Wf79Cqz3dyq08kEqFvU2e4VbLA/RcfYKonn6X/yrt8/q60hpZ6sa//zIS4BBXHrY8hravh+w1X8CEhDdUrmGLLmRA8fh0HOzM9vHqfhIv332B8J9nWkXRwtcbZzTfRdlQDqKqp4sJft2HlYCq5gpbwPhm6RqVn/cy6Xr2RmZ5/gm5kbote45fKVEd3T0cY62ki5GUsvN3Ko3nNcnCwMsDWs4+QnpmNrg0rol9TZ5nqqNXKGUdWXEajXq6wr2kNXcOcLzbJ8akIvxuJq/vuwr2UrYZwYvsvUFVThzg7CwkfIqXWHU5OiIGWtmxLSvVv/mmfWuZauP96aDSq28s2ibQs9ruyMTC2gIGxhdyv8hXH+qt5kddSjcVF0e3NFotlWuLuSwzMdGFgpltqrxLnR5H97mxrBGdbI4WU/V8l9XlnQlyCiuPWRwULffw+sgm2+IVg3+UnSMvMxrk7r6AiEqFyOSP82MsNntVke1Jdy4Hu2LfwHNaOOwSRSAQDUx30mNZCsj8lIQ0NulSXqQ55+tJC8hqa2ijvXEvmelq4lkML139nWLs6mGGpjI9r/lTTfrWhrqWG6wfv4+zmm5IAIggC9Iy04dGtOjy6yraKhTx9Ojm0Uk1PZP7nyYxhwZdhUU62q+ZfmuU/oo2LTOUDZa/fv3ZZmRm4fHQjol48QkWXBqjfui/8T2xHwJmcR95XqtEQrfr45l6WTQbvE1Jx/OYLvP6QDBN9LbR1L4/y5rJ9mcvKyMaFHbfxJuw9KrmXQ8NuNXBl7x1cO3APAOBU1w7tRnvkOVSnJBRHv998HA0zA204WBlALBaw8+Jj/H0jHDFJ6TDV10Kn+g7o3aSSTMkT+/3LlOXzzoS4BBXXrQ8bU1382MsdgiAgNikdAgBDHQ2oyWnVB10jbQz6tT0+vIlHdqYYZuUMpcaWVW1oL5d6KLeG3WqgYbcaiI1KRPI/y3/pGmmXmsX7P9X226mf3e/RbgBEotI7u/tTZanfv3aXj2zAo8BzqOLeEg8CTiEhNhrP7vujdR9fiFRUcPXYZlw5uhEte40vch0d5x7D9kmtYKSrifC3Cfhu3RUY6mrA0doQN0KjcezGc6wY2VhqOFphnf8rEA+vhMOlsQPunnuChHfJCLv1Em1He0BFJMLFXUG4sCMI3sNzP+GxJBRHv685/gATu7gCAPZcDsMh/2fo29QZ5c318PJ9EvZcegKRCFITxQuL/Z6bsn7emRArEZFIBBMFPvrT1KbofxylSdClQ0hNikfDdgMVVsem0w8Rm5Qut0eOGlvpl/lkTENT8Y/3PhLwHPHJGfi2RWW5lPc19HtZ9zj4ItoNmIYKVdxQu0lnbJj7LToPnyeZI6Cta4hTO3+TKUHIyBJLphVsPh2CGvammN2vLlRVVCAWC/jlf4HYfOYRfvq26P94P/J/gU4TGsHB1QZubavgzzEH0H1qc8ksfG0DLRxfdbXUJGbF0e9RcSmwNMqJC+fvvsa4TjXRtHrOk1DrOlvC1lQXfx6/L1NCzH7PTVk/72XjcoySCrp0CNeOb1VoHddCInEm6KVC6wgNiMDd808UWoc8PQ6+hPsBpxRax/uENETFpii0jrLW72F3r+KBgvv9ygN+3r82qUnxkoc/GJnZQCRSkaxeAgDGFrZITYqTW31PIhPQs1ElyRhWFRURejVyQtgb2epISUiXrF1tbKUPkUgk9WXLxFofyQlyWOtYToqj3/W11fE+IWft5fjkDNiaSI/htjXVw4cE2dZmZr9/njJ93pkQl2LFkZhtPBWC3w4EKbSO89sCcWzl5x+GUZr0Hr8UI+buVGgdU3rUweKhin1sd1nr90uH1uHEX4sUWseiIQ2x7XsvhdZR1vq9rNM3tsTrZw8AAJHhIRCJRIh6ESLZ/+Z5CPSMzGWu5+MwVZEI0NWSvrmqq6WGpNRMmco3NNPFq0fvAABvHr+DSAS8Cft31ZXXj9/DwFRHpjrkqTj63bOaNXZdDEO2WAyPqlY4EvBcaqLb4evPUdFatjuT7Pe8KePnnUMmSrHeMq50UBAbJ7b48kEyGrWqq8LroNzKWr8PnaXYuyHFpaz1e1nn2qgDTv71K+75H0d0xGM06zoKl49uQkz0K4hEQPDlI3Bv2UvmegYv84NIJEJqehaeRSVIjZ98E5MMYxkfmlHb2xnHVl7BnbNhiHz6Hi0H18XFHbcR8yYegAi3Tz5C/c6lZ3JycfT7kFZVMXXzNQxdcQ7V7Exw6f4b3H76DuVMdfEmJgWJqRlYMNBDpjrY73lTxs87E2JSWgmxb6GlrQcNLelvodnZWXjz7AHsnFwVVndMYhr+vvlCbmNZ6V+ZWWJcC4lEyMtYxCTl3E410dNC1fLGaFjFGuql+LGsVHjuLXpCR98Ykc8fooZHW1R1bwkzm4q4+vdmZGakwa15DzTw/kamOr7vWkvq90+fOgnkPBVR1tV66ndyga6hNl4/fgfXlpXg0qQiLCoY4+LOIGSmZ6FeJxd49pRtiUx5Ko5+19VSx/IRjXEyMAL+j6JgaaQDAQKyxAKa17RF+3r2sDCUbe4B+z03Zf28MyEuYW9fPUH0y8ewc6oFIzMbvHvzHMGXDkEQBDi5NoJDtXpfLqQAxGIBKiq5l6YRiwW8T0iFhVHRb0088g+HY51yUNcsGx+npPgPOLR2BqJePoYIIlSt2xJevSZIEuO05ATs+d0Xk1b6KawNsUnp+Ot8qEIS4r9mnkSHcY1gZFEya6Z+SWR4CN48f4DkhBgAOU8OtHFwgbW97Gv3vv6QhB+3XseHhDRUsTOWPE73SWQ8jt0Ih5lhCOYPaABbU/n3TWnv969ZtbpeqFb336Ew5Z1robzzCrmV37pO3o+X/eib5vL5O67etCKqN60o+b1CdSsMWNBWLmUrgqL7HQDUVFXQoZ49OtSzl2u5n2K/S1PWz3vZyGC+Uo+DLuHopnnQ1NFDdmYGuoz4CYc3zoFV+cpQUVHBgT9/RNsBP0h98AsrOS0TSw8FI+BRNHQ01dC+rj2+aeEsGSAfl5yOb5ecxamfOhW5jv2LLkBTWx1VGzmglpcTbJ1lH7+kSJcOrwNEIvSftAoZqcm4eHgd9vzuix4+i6Ct+89TzWRckP1ZVPxn9796nyRT+QDw+EZEntsjHkbjyc2XkqcsOdf7fHArLskJsTi8YTbePLsPfWML6BqY/LM9Bomxq2FTsTo6D5sLXYO8nwBXECuP3IW9hT5Wj2kKXS3pp8Ulp2Vi0f9u44+j97BwUNFvs5a1ficioi9jQlyCrp/6Cw3bD4JHm28QcuscDm+cA/cWPdGw7QAAwM2ze3Dz7B6ZEuKtfo/wPCoBU3rUQVJaJnZeeIywyDjM7ltPrreO63eujscBEdhy5jHM7Yzg6uWEGs0doaPAZd6K6sWjQHQZ8ROsK+Q8xKGf40oc2TgXe3//Hr3G/5ZzkIxPyRm96qKszfyifQvPQSQS5fk0pVMbAgDkLLX34wHFLR9XGGf3LocgiDFk5haYWEonizHRETj512Kc3bscnYfNLXIdDyJisHJUk1zJMJBz+3WQV1WMX3upyOUDZa/fld2lI+uRnBCLtt9MUVgd8l5GMS/ntwciOS4VHcbJ7+E+isR+Lxns96JjQlyCYt6+RLW6LQEAVdya4/i2hXCq+e+b71SrsczLrl19GIUpPWpLnvfuWdUKM7cHYNZfAZj7jXyGYwBAHW9nNO7tisgn7xF8NgyX99zB+e234VzXDrVaO6NiLZsvF1JM0tOSoanz721tNXUNdBk+D0c2zsGeFb5oP1D2R2bra6tjmLcLalc0y3P/i7eJmPlXgEx1ONa2hUhFhA5jPaFr9O84uoXdt2HYsk4wL28kU/nyFv7wJvp8tyJXMgwAJpbl0aLnWOxZLtuDaHS11BEVmwJ7S4M890fFpuSZLBdGWet3ZZcU9x6JsW8VWsf7hDS8i8//cfDykPghBQkfkhVahzyx30sG+73omBCXIA0tXaQmJ8DQ1BppKYkQxNlITU6Q7E9Nioe6lmzLjiSkpEtNOjDU1cTCQR74cdt1zNgWgO+6yHfimHUlM1hXMoPX4Lp45P8CwWfDsHveGRiY6WLsuh5yrauojEyt8f71c5hY2Em2qaiqotPQOTiycQ4OrJkmcx1ONkb4kJgGS+O837+kNNmWrAGAPrNaIeDIA2yafAxtRjSAU127L7+oBKmqayA9Nf8Al5GWClV12R7T2datAhbtD0L/Zs6o7WgmGUMcl5yOoKfvsfPiY3Ru4CBTHWWt35VduwGy/z1/yZQedRReR6eJjRVehzyx30sG+73omBCXoAqV6+DsnhWo07QrHt2+APuq7rh8ZD3afDMVIhFw8dBa2FZ0kakOC0MdvHyXBOtPZonqaqlj4UAPTNvqj7k7b8p6Gnk+R15dUw01mjmiRjNHxLxJwN1zpedBBQ4uDXDn6lE4124itf1jUnx4w2wkxr3P59UF076uPdIys/Ldb2GonWsmb1HU7+SCCtWtcHjZZYTdfIlWQ+V31V/eKtdphhPbf0Hz7j6oULkONLVzPpPpqcl4EXobFw6sRlU32ZYBHOhVBVoaqth35QnWnXwgtc9YTxO9G1dCr8ZFf6rVR2Wp35VBSlI87vufyHOyZvUGbaCjbyRzHfHJ6Th1OwIPI2IRm5TzwABjPU1UK2+M1nXKS758ySIlIQ13/MLw6tE7qUeCl6tijpotnKBrWLqGoLHfSwb7XTGYEJegZl1H4e+tC3Bm9zLYOlZHxyGzcOXoJmz+eRAgEsHIzAbe/SfLVEedSuY4dTsC9SpbSm3X0VTDggENMG2Lv0zlA8hzLOWnTGwM0OwbxX+jLKjGHYciMyPvpxupqKqi87C5SIx7J1MdjVw+vySNvo7GF2fyFpRVRVMM+a0Dzm66iQ3fHYEA2SYEKkrzbmMgiMU4tvkniMXZUFXNCT/Z2VlQUVFFDY+2aNp1lMz19G7ihN5NnBAZk4yYfwK5iZ6m1JdCeSgr/f61iwwPwf9WTYW6hibKV3aD8T93fpITYnD74gHcOLML3X1+lcwZKIpHr2Lx49br0FJXRW1HM5QzyxlyFZuUhsPXn2PP5SdYMKABKpcr+oTQN4/fYde8M1DXVIN9TWuY2uYM+0mKTcXNvx/B/8B99JnVCjZOeQ/DKm7s95LBflccJsQlSNfABL3G/Sa1rWWv8XBr0QOZGekwtSwPFVVVmeoY0KIyPiTmnfzpaqlj4SAPPIn8/IoIX+Kztgd0Stk36M9RUVWVXJ3Mb7+hqVUxtkh26ppqaDvaA49vRODFvSjoGMj+7V3e1NQ10LqvL5p2GYmoiFCkJMYCyPk7sLRz/ux7UhTWJrpyT4L/qyz0+9fOb99KVK7TFK36+Oa6WyUIAs7sXopz+1ai/6RVRa5j9bF7aFLdBhM61cyzjhVH7mL13/exYmTRb/Oe2hCAqg3t0Xa0R551nPjTH6c3BGDQr+2LXIc8sd9LBvtdcbhCfQny2/s7Xj65m2u7kZkNzG0cZE6GgZwrkZ9OMErNyMLJwAhsPhOCw9efIVssSCbcFVXA4Qd4+TBa1qYWq9sXD+L4toUIuXUOAPDgxmls+mkQNs4biEtH1kOcnS1T+WFv4hAZ8+942bPBLzFx3WX0X3wa362/ggt3X8tUPgCcWh+AiAdRUtuc65VHq6H1pCZ7lRYfP++a2rqoULkOqrq3RFX3lijvXFtuyTD7Xfm8e/0Ubs175jl0SyQSwa15T7x9JduQrWdRCejWsGK+dXRrWBFPZbyw8DY8FvU6Vcu3jnqdqiH6eYxMdcgT+71ksN8Vh1eIS1DQpUMIunwYRmY2qOHRDtUbeEvWZpWXYSvOYenwRjDQ0cDb+FR8v+EKklIzUc5MD29ikrHj/GOsGNlYpitpt46HIPDEIxhb6cPVywk1m1eCnnHpTQz8T2zHjbO7YV/VHecPrEZCTDRu+u2BW/MeEIlECDz3P6iqqMGzw+Ai1/HbgSCMbFsd1ia6OH7rBf78+x7auleAVy07vHqfhGWHgpGWmY02bkUfNlHW+r04Pu/sd+Wja2CCqBchMLXK+z2NehECHf2i39oFAGN9TYS+ikN5c/0894e+ioORnmx3B3SNtPEm7D3Myhnluf9N2PtSNZaV/V4y2O+Kw4S4hPX0WYSn9/1x028PrhzbhIou9VGzYTs4uDSAiorsF/Bfvk9CtjhnbOOm0w9hqq+FNT7NoKuljpT0LMzbeQObz4bgx17uMtXTd3YrhN18ieuH7uPijiBUcrNFrVbOcHQrl+cT8krS/esn0fabqXCu3QRvXz3B9l9Hoe23U1GtXisAOUuAXTq0VqaE+M2HZNj+8yXj2I1wjG5XHe3q2kv2O9saYdfFxzIlZkDZ6ndA8Z939rvycW/ZC6d2LUFUxGNUqFxHkgykJMbiReht3Lv2t8xj03t4OmL54TsIexOH2hXNJclAXFI6gp69w4lbLzC8jWwToBt0dsHx1f6IevoB9jWtJXcbkuNSEX43EkFnwtByoGxxWp7Y7yWD/a44TIhLmJlNRVSo4oamXUchLPgy7l8/gUPrZkFH3wjVG7RB9QZtYGxRTi51hbyMxfhONSXrsOpoquHbFpWxYO9tmcu2qGAMB1cbtBxUF6HXX+COXxj2/XIOuobacG1RCTVbVIKJTd5rwxa35IQPsKqQ8+hJi3KVAJEI5uUqSfZb2jkhKV62VSY01VURn5IBS2MdvI9PzTX5oEo5Y0TFpshUB1C2+h1Q/Oed/a586jTtCm1dQwSe/x+CLx+BIM4Z7iRSUYWlnRPafDMVVdyay1RH5wYVYaijiQPXnuJoQDjE/0wkVhGJ4GRjiEndaqNpDVuZ6nBvXxXaBlq4cfQBAk+EQiwW59ShogIrRxN0HOeJao1kWzJQntjvJYP9rjhMiEsJVVU1VHFrjipuzZEQE417/idw//pJBJzZhUkr/WQq++MQnYzMbJj+58lxZgbaiE9Ol6n8T6mqqaBaIwdUa+SA+HdJuOP3BHf9wnDtwL1S8+QuHQMTvI8Mh4GJJWLevoQgiBET9QLmNjl/fB+iwmW+5VTX2RLHboTDt2st1HAwxeUHb+BobSjZf/H+a7lO+CoL/f4pRX3e2e/Kqap7C1R1b4Hs7CykJuWMbdTWM5SsZCIPzWraollNW2RlixGfkgEAMNTRgJqq/KbiuDR2gEtjB2RniZGSkDMZWsdAC6pyfKqoPLHfSwb7XTGYEJdCBiaW8Gw/CA3bDcSLR4Eylzdl0zWoqaogJT0LL98nSU2yi45LgYGObA9DyI+huR6a9KmFxr1d8fxOpELqKIqq7i1xYtsvqFTTEy8e30Y9r964cPBPpCYnQCQS4fqpv+Bcq6lMdQxtXRXfrb+C7zdcgZOtEfZffYo7zz+gvLkeXr1PQsjLWMzpp5i1a0trv+dHnp939rtyU1VVg56hqULrUFNVyXVhQd5U1VSgbyLbQ5mKE/u9ZLDf5YsJcQkyMLGEyme+bYlEIthXlW0MTf/mzp/8ZgktDem3/HpoNKrbyzaxydBcDyLV/MdNikSiUvXoZs/2g6GmronI5w9Rs2F71G/dD+a2lXDp8FpkZqTDsbqHTOOHgZwr73+OaYbdl8IQEBoFQQBCX8XiXXwqXMqbYNlwF5nWcATKXr8Xx+ed/U5EREXBhLgEjZi3S+F1DGjx+cW5R8g4MB5AqXkkc0GpqKjAo803Uts+3oKSJz1tdQzzroZh3tXkWu5HZa3fi+PzDrDfiYio8ErnABkiIiIiomLChJiIiIiIlBoTYiIiIiJSakyIiYiIiEipMSEmIiIiIqXGhJiIiIiIlBoTYiIiIiJSakyIiYiIiEipMSEmIiIiIqXGhJiIiIiIlFqpTogXLlyIunXrQl9fHxYWFujSpQtCQ0OljklLS4OPjw9MTU2hp6eH7t27Izo6WrI/JiYGHTt2hJ6eHmrXro2goCCp1/v4+GDJkiXFcj5ERKXZqlWrYG9vDy0tLdSvXx83btzI99j169ejcePGMDY2hrGxMby8vD57PBFRaVaqE+KLFy/Cx8cH169fx5kzZ5CZmYnWrVsjOTlZcsx3332Ho0ePYt++fbh48SLevHmDbt26SfbPnz8fiYmJuH37Npo1a4bhw4dL9l2/fh0BAQGYOHFicZ4WEVGps2fPHvj6+mL27Nm4ffs2XF1d4e3tjbdv3+Z5/IULF9C3b1+cP38e/v7+sLOzQ+vWrfH69etibjkRkexKdUJ88uRJDBo0CC4uLnB1dcWWLVsQERGBwMBAAEB8fDw2btyIpUuXokWLFnBzc8PmzZtx7do1XL9+HQAQEhKCPn36wNnZGSNGjEBISAgAIDMzE6NGjcKaNWugqqpaYudIRFQaLF26FMOHD8fgwYNRrVo1rFmzBjo6Oti0aVOex+/YsQNjxoxBrVq1UKVKFWzYsAFisRh+fn7F3HIiItmV6oT4v+Lj4wEAJiYmAIDAwEBkZmbCy8tLckyVKlVQvnx5+Pv7AwBcXV1x7tw5ZGVl4dSpU6hZsyYAYNGiRWjWrBnc3d0LVHd6ejoSEhKkfoiIvgYZGRkIDAyUiqUqKirw8vKSxNIvSUlJQWZmpiQ+54VxlIhKK7WSbkBBicViTJw4EZ6enqhevToAICoqChoaGjAyMpI61tLSElFRUQCAH374AaNHj4ajoyPs7e2xceNGhIWFYevWrfD398eoUaNw+vRpuLu7Y/369TA0NMyz/oULF2Lu3Lm5tr9+/fqzQV0nK6WIZ1xw71VtFV6HZpyBwut49eqV3Mpivxcc+z230tLviYmJCm8HALx//x7Z2dmwtLSU2m5paYlHjx4VqIypU6fCxsZGKqn+L8ZRxX+uAPn9TbPfC45xNLfS0u8FjaNlJiH28fHB/fv3ceXKlUK9ztDQEDt37pTa1qJFCyxevBg7duzAs2fPEBoaiuHDh2PevHn5TrCbNm0afH19Jb8nJCTAzs4Otra2MDDI/01PCYkrVHuLwixb8WP20o0yFV5HuXLl5FYW+73g2O+5lZZ+LytXUH/55Rfs3r0bFy5cgJaWVr7HMY4q/nMFyO9vmv1ecIyjuZWWfi9oHC0TCfHYsWNx7NgxXLp0SerkrayskJGRgbi4OKmrxNHR0bCyssqzrM2bN8PIyAidO3dGt27d0KVLF6irq6Nnz56YNWtWvm3Q1NSEpqam3M6JiKi0MDMzg6qqqtQKPcDnY+lHv/32G3755RecPXtWMiQtP4yjRFRaleoxxIIgYOzYsTh48CDOnTsHBwcHqf1ubm5QV1eXmsQRGhqKiIgIeHh45Crv3bt3mDdvHlauXAkAyM7ORmZmzjeYzMxMZGdnK/BsiIhKJw0NDbi5uUnF0o8T5PKKpR8tWrQIP/30E06ePFng+RhERKVRqb5C7OPjg507d+Lw4cPQ19eXjAs2NDSEtrY2DA0NMXToUPj6+sLExAQGBgYYN24cPDw80KBBg1zlTZw4Ed9//z1sbXPGznh6emL79u1o3bo11q1bB09Pz2I9PyKi0sLX1xcDBw6Eu7s76tWrh+XLlyM5ORmDBw8GAAwYMAC2trZYuHAhAODXX3/FrFmzsHPnTtjb20vis56eHvT09ErsPIiIiqJUJ8R//vknAKBZs2ZS2zdv3oxBgwYBAJYtWwYVFRV0794d6enp8Pb2xurVq3OVderUKTx58gTbt2+XbBs7dixu3bqF+vXro169epg9e7bCzoWIqDTr3bs33r17h1mzZiEqKgq1atXCyZMnJRPtIiIioKLy703FP//8ExkZGejRo4dUObNnz8acOXOKs+lERDIr1QmxIAhfPEZLSwurVq3CqlWrPnuct7c3vL29pbbp6Ohg7969MrWRiOhrMXbsWIwdOzbPfRcuXJD6PTw8XPENIiIqJqV6DDERERERkaIxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipcaEmIiIiIiUGhNiIiIiIlJqTIiJiIiISKkxISYiIiIipfbVJMSrVq2Cvb09tLS0UL9+fdy4cUOyz9fXFyYmJrCzs8OOHTukXrdv3z507NixuJtLRFTqfC6O5mXfvn2oUqUKtLS0UKNGDRw/fryYWkpEJF9fRUK8Z88e+Pr6Yvbs2bh9+zZcXV3h7e2Nt2/f4ujRo9i5cydOnz6NRYsWYdiwYXj//j0AID4+HtOnT8eqVatK+AyIiErW5+JoXq5du4a+ffti6NChCAoKQpcuXdClSxfcv3+/mFtORCS7ryIhXrp0KYYPH47BgwejWrVqWLNmDXR0dLBp0yaEhISgWbNmcHd3R9++fWFgYIDnz58DAKZMmYLRo0ejfPnyJXwGREQl63NxNC8rVqxAmzZtMHnyZFStWhU//fQT6tSpgz/++KOYW05EJDu1km6ArDIyMhAYGIhp06ZJtqmoqMDLywv+/v4YM2YM1q1bh9jYWDx79gypqamoVKkSrly5gtu3b2P16tUFqic9PR3p6emS3+Pj4wEACQkJn31davLn98tDYkqGwutITUz/8kEy+lJfFgb7veDY77mVln7/eIwgCApty5fiaF78/f3h6+srtc3b2xuHDh3Ktx7GUcV/rgD5/U2z3wuOcTS30tLvBY6jQhn3+vVrAYBw7do1qe2TJ08W6tWrJwiCIMyePVtwdHQUqlevLhw4cEBIT08XqlevLty6dUtYuXKl4OzsLDRs2FC4f/9+vvXMnj1bAMAf/vCHP8X+8/LlyxKPo/+lrq4u7Ny5U2rbqlWrBAsLi3zrYRzlD3/4U1I/X4qjZf4KcUHMmTMHc+bMkfw+d+5ceHl5QV1dHT///DPu3buHY8eOYcCAAQgMDMyzjGnTpkldDRGLxYiJiYGpqSlEIpGiT0GuEhISYGdnh5cvX8LAwKCkm6M02O8loyz3uyAISExMhI2NTUk3RS4YR0lW7PeSUZb7vaBxtMwnxGZmZlBVVUV0dLTU9ujoaFhZWeU6/tGjR/jrr78QFBSETZs2oUmTJjA3N0evXr0wZMgQJCYmQl9fP9frNDU1oampKbXNyMhIrudS3AwMDMrcB/trwH4vGWW13w0NDRVeR2HjKABYWVkV6niAcZTkh/1eMspqvxckjpb5SXUaGhpwc3ODn5+fZJtYLIafnx88PDykjhUEASNHjsTSpUuhp6eH7OxsZGZmAoDkv9nZ2cXXeCKiUqAwcfQjDw8PqeMB4MyZM/keT0RUmpX5K8RAzjrDAwcOhLu7O+rVq4fly5cjOTkZgwcPljpuw4YNMDc3l6w77OnpiTlz5uD69es4ceIEqlWrVuavVhARFcWX4uiAAQNga2uLhQsXAgAmTJiApk2bYsmSJWjfvj12796NW7duYd26dSV5GkRERfJVJMS9e/fGu3fvMGvWLERFRaFWrVo4efIkLC0tJcdER0dj/vz5uHbtmmRbvXr18P3336N9+/awsLDA1q1bS6L5xU5TUxOzZ8/OdeuSFIv9XjLY7wXzpTgaEREBFZV/byo2bNgQO3fuxIwZM/Djjz/CyckJhw4dQvXq1UvqFIoVP1clg/1eMpSh30WCoOD1fIiIiIiISrEyP4aYiIiIiEgWTIiJiIiISKkxISYiIiIipcaEmCTs7e2xfPlyye8ikeizj2Gl3ObMmYNatWpJfh80aBC6dOlSYu0hvgdUvBhHZcc4Wvoow3vAhLiUGDRoEEQikeTH1NQUbdq0wd27d0usTZGRkWjbtm2J1V/coqKiMG7cOFSsWBGampqws7NDx44dc621Sp/36WdZQ0MDlSpVwrx585CVlSVzuUUJyCtWrMCWLVtkqpvKBsbRksc4Kh+Mo8WPCXEp0qZNG0RGRiIyMhJ+fn5QU1NDhw4dSqw9VlZWX/USK58KDw+Hm5sbzp07h8WLF+PevXs4efIkmjdvDh8fn5JuXpnz8bMcFhaG77//HnPmzMHixYvzPDYjI0OhbTE0NOT64kqEcbTkMI7KF+No8WJCXIpoamrCysoKVlZWqFWrFn744Qe8fPkS7969AwBMnToVzs7O0NHRQcWKFTFz5kzJE/YA4M6dO2jevDn09fVhYGAANzc33Lp1S7L/ypUraNy4MbS1tWFnZ4fx48cjOTk53/Z8eqsvPDwcIpEIBw4cQPPmzaGjowNXV1f4+/tLvaawdZQWY8aMgUgkwo0bN9C9e3c4OzvDxcUFvr6+uH79uuS4uLg4DBs2DObm5jAwMECLFi1w586dAtfzv//9DzVq1IC2tjZMTU3h5eWVb/9kZ2dj6NChcHBwgLa2NipXrowVK1ZIHXPhwgXUq1cPurq6MDIygqenJ168eFG0TpCjj5/lChUqYPTo0fDy8sKRI0cA/HuFYv78+bCxsUHlypUBAPfu3UOLFi0kfTNixAgkJSUByLmFunXrVhw+fFhy1eTChQsAgJcvX6JXr14wMjKCiYkJOnfujPDwcElb/ntFpFmzZhg/fjymTJkCExMTWFlZYc6cOZL9giBgzpw5KF++PDQ1NWFjY4Px48fne65Pnz5F586dYWlpCT09PdStWxdnz56VOmb16tVwcnKClpYWLC0t0aNHDxl6lz6HcbTkMI7KF+No8cZRJsSlVFJSEv766y9UqlQJpqamAAB9fX1s2bIFDx8+xIoVK7B+/XosW7ZM8pr+/fujXLlyuHnzJgIDA/HDDz9AXV0dQM6HrU2bNujevTvu3r2LPXv24MqVKxg7dmyh2jV9+nRMmjQJwcHBcHZ2Rt++fSW3cORVR3GLiYnByZMn4ePjA11d3Vz7P/1W3LNnT7x9+xYnTpxAYGAg6tSpg5YtWyImJuaL9URGRqJv374YMmQIQkJCcOHCBXTr1g35LQUuFotRrlw57Nu3Dw8fPsSsWbPw448/Yu/evQCArKwsdOnSBU2bNsXdu3fh7++PESNGQCQSFa0jFEhbW1vqCoafnx9CQ0Nx5swZHDt2DMnJyfD29oaxsTFu3ryJffv24ezZs5LPzqRJk9CrVy+pq38NGzZEZmYmvL29oa+vj8uXL+Pq1avQ09NDmzZtPnvFZOvWrdDV1UVAQAAWLVqEefPm4cyZMwCA/fv3Y9myZVi7di3CwsJw6NAh1KhRI9+ykpKS0K5dO/j5+SEoKAht2rRBx44dERERAQC4desWxo8fj3nz5iE0NBQnT55EkyZN5NGt9AWMo8WHcVTxGEcVHEcFKhUGDhwoqKqqCrq6uoKurq4AQLC2thYCAwPzfc3ixYsFNzc3ye/6+vrCli1b8jx26NChwogRI6S2Xb58WVBRURFSU1MFQRCEChUqCMuWLZPsByAcPHhQEARBeP78uQBA2LBhg2T/gwcPBABCSEhIgesojQICAgQAwoEDBz573OXLlwUDAwMhLS1Narujo6Owdu1aQRAEYfbs2YKrq6tk38CBA4XOnTsLgiAIgYGBAgAhPDy8yG318fERunfvLgiCIHz48EEAIFy4cKHI5SnCp+csFouFM2fOCJqamsKkSZMk+y0tLYX09HTJa9atWycYGxsLSUlJkm1///23oKKiIkRFReUq96Pt27cLlStXFsRisWRbenq6oK2tLZw6dSrP1zVt2lRo1KiRVDl169YVpk6dKgiCICxZskRwdnYWMjIyitwHLi4uwsqVKwVBEIT9+/cLBgYGQkJCQpHLo4JhHC05jKPyxTha/HGUV4hLkebNmyM4OBjBwcG4ceMGvL290bZtW8mtmz179sDT0xNWVlbQ09PDjBkzJN+eAMDX1xfDhg2Dl5cXfvnlFzx9+lSy786dO9iyZQv09PQkP97e3hCLxXj+/HmB21izZk3J/1tbWwMA3r59K9c6iptQwIc13rlzB0lJSTA1NZU6x+fPn0v1dX5cXV3RsmVL1KhRAz179sT69esRGxv72desWrUKbm5uMDc3h56eHtatWyd5z01MTDBo0CB4e3ujY8eOWLFiBSIjIwt0Lop27Ngx6OnpQUtLC23btkXv3r2lbqfVqFEDGhoakt9DQkLg6uoqdWXJ09MTYrEYoaGh+dZz584dPHnyBPr6+pL3w8TEBGlpaZ99Tz79HAM5n+WPn+OePXsiNTUVFStWxPDhw3Hw4MHPTmRJSkrCpEmTULVqVRgZGUFPTw8hISGS96lVq1aoUKECKlasiG+//RY7duxASkpKvuWRbBhHSwbjqPwxjhZvHGVCXIro6uqiUqVKqFSpEurWrYsNGzYgOTkZ69evh7+/P/r374927drh2LFjCAoKwvTp06VuZ8yZMwcPHjxA+/btce7cOVSrVg0HDx4EkPNhGzlypOQfiuDgYNy5cwdhYWFwdHQscBs/3joEILmlJBaL5VpHcXNycoJIJMKjR48+e1xSUhKsra2lzi84OBihoaGYPHnyF+tRVVXFmTNncOLECVSrVg0rV65E5cqV8/1Hbvfu3Zg0aRKGDh2K06dPIzg4GIMHD5Z6zzdv3gx/f380bNgQe/bsgbOzs9RYvZLyMSkJCwtDamqq5NbaR3ndUi2KpKQkuLm55XpPHj9+jH79+uX7uk8/x0DOZ/nj59jOzg6hoaFYvXo1tLW1MWbMGDRp0kRqnOmnJk2ahIMHD2LBggW4fPkygoODUaNGDcn7pK+vj9u3b2PXrl2wtrbGrFmz4Orqiri4OLn0AUljHC0ZjKPyxzhavHFUTW4lkdyJRCKoqKggNTUV165dQ4UKFTB9+nTJ/rwG/Ts7O8PZ2Rnfffcd+vbti82bN6Nr166oU6cOHj58iEqVKimsvcVRhyKYmJjA29sbq1atwvjx43MFmbi4OBgZGaFOnTqIioqCmpoa7O3ti1SXSCSCp6cnPD09MWvWLFSoUAEHDx6Er69vrmOvXr2Khg0bYsyYMZJteX1br127NmrXro1p06bBw8MDO3fuRIMGDYrUPnn5mJQUVNWqVbFlyxYkJydL+v/q1atQUVGRTBbR0NBAdna21Ovq1KmDPXv2wMLCAgYGBnJrv7a2Njp27IiOHTvCx8cHVapUwb1791CnTp1cx169ehWDBg1C165dAeT84/LpZBQAUFNTg5eXF7y8vDB79mwYGRnh3Llz6Natm9zaTHljHC0ejKPyxzgaLnWMouMorxCXIunp6YiKikJUVBRCQkIwbtw4JCUloWPHjnByckJERAR2796Np0+f4vfff5dctQCA1NRUjB07FhcuXMCLFy9w9epV3Lx5E1WrVgWQM7P62rVrGDt2rOQb5+HDh+U6UaM46lCUVatWITs7G/Xq1cP+/fsRFhaGkJAQ/P777/Dw8AAAeHl5wcPDA126dMHp06cRHh6Oa9euYfr06VKz0PMTEBCABQsW4NatW4iIiMCBAwfw7t07yXv0X05OTrh16xZOnTqFx48fY+bMmbh586Zk//PnzzFt2jT4+/vjxYsXOH36NMLCwvItrzTr378/tLS0MHDgQNy/fx/nz5/HuHHj8O2338LS0hJAzgMP7t69i9DQULx//x6ZmZno378/zMzM0LlzZ1y+fBnPnz/HhQsXMH78eLx69apIbdmyZQs2btyI+/fv49mzZ/jrr7+gra2NChUq5Hm8k5MTDhw4ILmS169fP8lVEiDntufvv/+O4OBgvHjxAtu2bYNYLJb8A0XyxThachhHSxbjqGx4hbgUOXnypGQ8mb6+PqpUqYJ9+/ahWbNmAIDvvvsOY8eORXp6Otq3b4+ZM2dKxhOpqqriw4cPGDBgAKKjo2FmZoZu3bph7ty5AHLG+ly8eBHTp09H48aNIQgCHB0d0bt3b7m1vzjqUJSKFSvi9u3bmD9/Pr7//ntERkbC3Nwcbm5u+PPPPwHkXJU4fvw4pk+fjsGDB+Pdu3ewsrJCkyZNJMHmcwwMDHDp0iUsX74cCQkJqFChApYsWZLvov0jR45EUFAQevfuDZFIhL59+2LMmDE4ceIEAEBHRwePHj3C1q1b8eHDB1hbW8PHxwcjR46UX8cUEx0dHZw6dQoTJkxA3bp1oaOjg+7du2Pp0qWSY4YPH44LFy7A3d0dSUlJOH/+PJo1a4ZLly5h6tSp6NatGxITE2Fra4uWLVsW+UqHkZERfvnlF/j6+iI7Oxs1atTA0aNHJasU/NfSpUsxZMgQNGzYEGZmZpg6dSoSEhKkyjtw4ADmzJmDtLQ0ODk5YdeuXXBxcSlS++jzGEdLDuNoyWIclY1IKOhIeCIiIiKirxCHTBARERGRUmNCTERERERKjQkxERERESk1JsREREREpNSYEBOVoPDwcIhEIgQHB5d0U4iIyiTGUZIHJsREXwF7e3ssX768pJuRL39/f6iqqqJ9+/afPW7Xrl1QVVWFj49PMbVMdlu2bIGRkVFJN4OIZMQ4WnJKQxxlQkxECrdx40aMGzcOly5dwps3bz573JQpU7Br1y6kpaUVYwuJiEo3xlEFE4hIEARBSEtLE8aNGyeYm5sLmpqagqenp3Djxg1BEATh/PnzAgDh7Nmzgpubm6CtrS14eHgIjx49kirj0KFDQu3atQVNTU3BwcFBmDNnjpCZmZlvnc+fPxcACPv37xeaNWsmaGtrCzVr1hSuXbsmddz//vc/oVq1aoKGhoZQoUIF4bfffpPsa9q0qQBA6qc0SUxMFPT09IRHjx4JvXv3FubPn5/ncc+ePRO0tbWFuLg4oX79+sKOHTu+WHZsbKwwYsQIwcLCQtDU1BRcXFyEo0ePSvZ/rt8EQRAACAcPHpTaZmhoKGzevFkQhC+/Px8/F5/+zJ49WxAEQVi1apVQqVIlQVNTU7CwsBC6d+9ewB4jKrsYRxWDcVTxcbR0veNEJWj8+PGCjY2NcPz4ceHBgwfCwIEDBWNjY+HDhw+SP9j69esLFy5cEB48eCA0btxYaNiwoeT1ly5dEgwMDIQtW7YIT58+FU6fPi3Y29sLc+bMybfOj4GiSpUqwrFjx4TQ0FChR48eQoUKFST/ANy6dUtQUVER5s2bJ4SGhgqbN28WtLW1JcHmw4cPQrly5YR58+YJkZGRQmRkpEL7qbA2btwouLu7C4IgCEePHhUcHR0FsVic67iZM2cKPXr0EARBEFauXCm0aNHis+VmZ2cLDRo0EFxcXITTp08LT58+FY4ePSocP35cEIQv95sgFDyQ5/f+pKenC8uXLxcMDAwkfZ+YmCjcvHlTUFVVFXbu3CmEh4cLt2/fFlasWFHEHiQqOxhHFYNxVPFxlAkxkSAISUlJgrq6utS36YyMDMHGxkZYtGiR1JWNj/7++28BgJCamioIgiC0bNlSWLBggVS527dvF6ytrfOt92Og2LBhg2TbgwcPBABCSEiIIAiC0K9fP6FVq1ZSr5s8ebJQrVo1ye8VKlQQli1bVvgTLwYNGzYUli9fLgiCIGRmZgpmZmbC+fPnpY7Jzs4W7OzshEOHDgmCIAjv3r0TNDQ0hGfPnuVb7qlTpwQVFRUhNDQ0z/0F6beCBvLPvT+bN28WDA0NpcrYv3+/YGBgICQkJOTbfqKvDeOo4jCOKh7HEBMBePr0KTIzM+Hp6SnZpq6ujnr16iEkJESyrWbNmpL/t7a2BgC8ffsWAHDnzh3MmzcPenp6kp/hw4cjMjISKSkpGDVqlNS+T32u3JCQEKl2AYCnpyfCwsKQnZ0tj9NXmNDQUNy4cQN9+/YFAKipqaF3797YuHGj1HFnzpxBcnIy2rVrBwAwMzNDq1atsGnTpnzLDg4ORrly5eDs7Jznfnn22+fen7y0atUKFSpUQMWKFfHtt99ix44dSElJKVSdRGUN46hiMI4WTxxVU1jJRF8hdXV1yf+LRCIAgFgsBgAkJSVh7ty56NatW67XaWlpYd68eZg0aVKhyy3LNm7ciKysLNjY2Ei2CYIATU1N/PHHHzA0NJQcFxMTA21tbclxYrEYd+/exdy5c6Gikvu7+6fHFpVIJIIgCFLbMjMzcx1X2PdHX18ft2/fxoULF3D69GnMmjULc+bMwc2bN0t8JjVRSWMcLRzG0eKJo7xCTATA0dERGhoauHr1qmRbZmYmbt68iWrVqhWojDp16iA0NBSVKlXK9aOiogILCwupbQVVtWpVqXYBwNWrV+Hs7AxVVVUAgIaGRqm7ypGVlYVt27ZhyZIlCA4OlvzcuXMHNjY22LVrFwDgw4cPOHz4MHbv3i11XFBQEGJjY3H69Ok8y69ZsyZevXqFx48f57m/IP1mbm6OyMhIyf6wsLBCX4HIr+/V1NTg5eWFRYsW4e7duwgPD8e5c+cKVTZRWcI4Kn+Mo8UYR4tlYAZRGTBhwgTBxsZGOHHihNRkkJiYGMnYt9jYWMnxQUFBAgDh+fPngiAIwsmTJwU1NTVhzpw5wv3794WHDx8Ku3btEqZPn55vnR/HVgUFBUm2xcbGCgAk48MCAwOlJjVs2bIl16SGVq1aCZ06dRJevXolvHv3To69UnQHDx4UNDQ0hLi4uFz7pkyZIpkgsmzZMsHa2jrPCSK9evWSTBDJS7NmzYTq1asLp0+fFp49eyYcP35cOHHihCAIBeu3Pn36CFWrVhVu374t3Lx5U2jRooWgrq6ea+zb596fq1evSsZFvnv3TkhOThaOHj0qrFixQggKChLCw8OF1atXCyoqKsL9+/cL2YtEZQvjqHwxjhZfHGVCTPSP1NRUYdy4cYKZmVm+ywV9LpALQk4wb9iwoaCtrS0YGBgI9erVE9atW5dvnQUJFILw77I36urqQvny5YXFixdLlePv7y/UrFlT0NTULDXLBXXo0EFo165dnvsCAgIEAMKdO3eEGjVqCGPGjMnzuD179ggaGhr5/uP04cMHYfDgwYKpqamgpaUlVK9eXTh27Jhk/5f67fXr10Lr1q0FXV1dwcnJSTh+/Hiek0G+9P6MGjVKMDU1lSwXdPnyZaFp06aCsbGxZImhPXv2FKDXiMo2xlH5YhwtvjgqEoT/DPwgIiIiIlIiHEP8//buPybq+o8D+PMTHB1wKG6RpIFAKUlD8jysYE1kY6DLjNgsaNkFXCnTYXVTIzg4mH7BEQ77MYVKSGOGLX5EsrKbbIQ1UTmsQDSDNdclxHJ1Mj3k7vuH4yPHj+4AuTPu+djYeN+9P6/PGz6f993r3vf+fN5ERERE5NKYEBMRERGRS2NCTEREREQujQkxEREREbk0JsRERERE5NKYEBMRERGRS2NCTEREREQujQkxEREREbk0JsRERERE5NKYEBMRERGRS2NCTEREREQujQkxEREREbk0JsRERERE5NKYEBMRERGRS3N3dgOI7kZmsxkmk8nZzSAickkSiQRubm7Obga5ECbERKOYTCZ0d3fDbDY7uylERC7L19cX/v7+EATB2U0hF8CEmGgEi8UCg8EANzc3BAQE4J57OKuIiMiRLBYLBgYG0NvbCwB44IEHnNwicgVMiIlGuHnzJgYGBrBgwQJ4eXk5uzlERC7J09MTANDb24v777+f0ydoxnH4i2iEoaEhAICHh4eTW0JE5NqGByUGBwed3BJyBUyIicbBOWtERM7F12FyJCbEREREROTSmBAT0R3X09MDQRCg1+v/U7GJ7laCIKC2tnZaMZRKJZ599lmxHBMTg23btk0rJgDk5eXhsccem3YcImfiRXVEdnj3+FWH7m9rnO+kt+nr64NGo8FXX32FK1euYN68eYiIiIBGo0F0dDQEQUBNTY3VGyJNTm9VmkP3d3/KR3bXtfX1cm5uLvLy8qbZoqlx9rlXfukth+5P9dD/Jr2Nrf5rMBgwb968abWrtLQUFotlWjHGo1arsXXrVrGsVCpx9erVaSfwRI7EhJholkhKSoLJZEJlZSVCQkJw5coV6HQ69Pf3O7tpU2IymXhx4yQYDAbx988++wwajQZdXV3iYzKZbFLx+P93LFv919/ff9r7mDt37rRjjGSxWDA0NASZTDbp84vobsMpE0SzwNWrV9Hc3IyioiKsXr0aixYtwsqVK/HWW2/hmWeeQVBQEAAgMTERgiCI5UuXLmH9+vWYP38+ZDIZIiMj8e2331rFDgoKwu7du5GamgofHx8EBgairKzMqs6pU6ewfPlySKVSKBQKtLW1WT0/NDSEtLQ0BAcHw9PTE6GhoSgtLbWqM/x17q5du7BgwQKEhobaFZtu8ff3F3/mzp0LQRDE8rVr1/Diiy/aPM4FBQXYuHEj5syZg1dffRUAUF5ejoCAAHh5eSExMRElJSXw9fW12raurg5yuRxSqRQhISHQarW4efOmGBcYe+7Rbbb6L2A9ZWJ42lB1dTWeeuopeHp6IjIyEhcuXEBraysUCgVkMhnWrFmDvr4+cT+jp0yMdujQISgUCvj4+MDf3x8pKSnivYABoKmpCYIgoLGxEStWrMC9996L7777zmrKRF5eHiorK1FXVwdBECAIApqamhAbG4stW7ZY7a+vrw8eHh7Q6XR35h9JNA1MiIlmgeERmtraWty4cWPM862trQCAgwcPwmAwiGWj0Yi1a9dCp9Ohra0NCQkJWLduHX777Ter7d955x0xGc3IyMDmzZvF0Uej0Yinn34aYWFhOHPmDPLy8qBWq622N5vNePDBB3H06FF0dHRAo9EgKysL1dXVVvV0Oh26urpw/PhxNDQ02BWbbLP3OBcXFyMiIgJtbW3IyclBS0sLNm3ahMzMTOj1esTFxWHXrl1W2zQ3N2Pjxo3IzMxER0cHDhw4gIqKCrHeROce3War/04kNzcX2dnZOHv2LNzd3ZGSkoLt27ejtLQUzc3N+OWXX6DRaOyONzg4iIKCArS3t6O2thY9PT1QKpVj6u3cuROFhYXo7OzEsmXLrJ5Tq9XYsGEDEhISYDAYYDAYEBUVhfT0dFRVVVn9fYcPH8bChQsRGxtrdxuJZgqnTBDNAu7u7qioqIBKpcL+/fshl8uxatUqvPDCC1i2bBn8/PwA3F4KdVhERAQiIiLEckFBAWpqalBfX281mrN27VpkZGQAAHbs2IG9e/fixIkTCA0NRVVVFcxmMz766CNIpVI8+uijuHz5MjZv3ixuL5FIoNVqxXJwcDC+//57VFdXY8OGDeLj3t7e+PDDD8Wv6svKymzGJtvsPc6xsbF48803xfLbb7+NNWvWiB9ClixZgpMnT6KhoUGso9VqsXPnTrz88ssAgJCQEBQUFGD79u3Izc2d8Nyj22z134mo1WrEx8cDADIzM5GcnAydTofo6GgAQFpaGioqKuxuR2pqqvh7SEgI9u3bh8jISBiNRqspEfn5+YiLixs3hkwmg6enJ27cuGF1vJ977jls2bIFdXV1Yp+vqKiAUqnk7dXorsARYqJZIikpCb///jvq6+uRkJCApqYmyOXyf31DNBqNUKvVWLp0KXx9fSGTydDZ2Tlm5HDkm/LwV/HDX6UOjxJJpVKxzpNPPjlmX++//z5WrFgBPz8/yGQylJWVjdlPeHi41bxVe2PTv7P3OCsUCqtyV1cXVq5cafXY6HJ7ezvy8/PFUU6ZTAaVSgWDwYCBgYGZ+YNmoan035H9cv78+QBu9aGRj42c8mDLmTNnsG7dOgQGBsLHxwerVq0CAJvniT2kUileeuklfPzxxwCAs2fP4qeffhp3BJrIGZgQE80iUqkUcXFxyMnJwcmTJ6FUKpGbmzthfbVajZqaGuzevRvNzc3Q6/UIDw+HyWSyqieRSKzKgiDAbDbb3a4jR45ArVYjLS0N33zzDfR6PV555ZUx+/H29rY7JtnP3uM8lf+/0WiEVquFXq8Xf3788UdcvHjR6oMM2TbZ/juyXw6Pso5+zN5+eu3aNcTHx2POnDn49NNP0draipqaGgC4Y/00PT0dx48fx+XLl3Hw4EHExsZi0aJFU4pFdKdxygTRLBYWFiZeiCORSMSlqYe1tLRAqVQiMTERwK3kpqenZ1L7WLp0KQ4dOoTr16+LCdAPP/wwZj9RUVHitAvg1gV9dyI22TbV4xwaGjpmzu/oslwuR1dXFx5++OEJ44x37pFtI/vvTDt//jz6+/tRWFiIgIAAAMDp06enFMvDw2Pc4x0eHg6FQoHy8nJUVVXhvffem1abie4kjhATzQL9/f2IjY3F4cOHce7cOXR3d+Po0aPYs2cP1q9fD+DW1f46nQ5//PEH/vrrLwDA4sWL8cUXX0Cv16O9vR0pKSmTGvkFgJSUFAiCAJVKhY6ODhw7dgzFxcVWdRYvXozTp0/j66+/xoULF5CTk2PXxVX2xCbbpnqct27dimPHjqGkpAQXL17EgQMH0NjYaDXnU6PR4JNPPoFWq8XPP/+Mzs5OHDlyBNnZ2WKd8c49us2e/jvTAgMD4eHhgXfffRe//vor6uvrUVBQMKVYQUFBOHfuHLq6uvDnn39icHBQfC49PR2FhYWwWCziBzSiuwFHiInsMJWFMhxJJpPh8ccfx969e3Hp0iUMDg4iICAAKpUKWVlZAG7dKeKNN95AeXk5Fi5ciJ6eHpSUlCA1NRVRUVG47777sGPHDvz999+T3veXX36JTZs2Yfny5QgLC0NRURGSkpLEOq+99hra2trw/PPPQxAEJCcnIyMjA42NjdOO7UiTWSjjbjLV4xwdHY39+/dDq9UiOzsb8fHxeP31161G9uLj49HQ0ID8/HwUFRVBIpHgkUceQXp6ulhnvHPPkaayUIYj2dN/Z5qfnx8qKiqQlZWFffv2QS6Xo7i4WLzt22SoVCo0NTVBoVDAaDTixIkTiImJAQAkJydj27ZtSE5O5pQauqsIlplYtoboP+r69evo7u5GcHAwX6yJxqFSqXD+/Hk0Nzc7uyn0H9TT04OHHnoIra2tkMvl/1qXr8fkSBwhJiKiCRUXFyMuLg7e3t5obGxEZWUlPvjgA2c3i/5jBgcH0d/fj+zsbDzxxBM2k2EiR2NCTEREEzp16hT27NmDf/75R7w37cjpEET2aGlpwerVq7FkyRJ8/vnnzm4O0RhMiImIaEKjVxMkmoqYmBhwhibdzXiXCSIiIiJyaUyIicbBkQwiIufi6zA5EhNiohHc3NwAjF2ZiYiIHGt46e/RK2USzQTOISYawd3dHV5eXujr64NEIsE99/AzIxGRI1ksFgwMDKC3txe+vr7iQAXRTOJ9iIlGMZlM6O7unvSKbUREdOf4+vrC39/famVEopnChJhoHGazmdMmiIicRCKRcGSYHIoJMRERERG5NE6QJCIiIiKXxoSYiIiIiFwaE2IiIiIicmlMiImIiIjIpTEhJiIiIiKXxoSYiIiIiFwaE2IiIiIicmn/B77gznXlBKHLAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 800x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = []\n",
    "for r in ['majority_vote', 'cellsonehot_majority_vote', 'aminoacidcnt_majority_vote']:\n",
    "    tmp = reports[r]\n",
    "    tmp = tmp[tmp['cv_models'].isna()]\n",
    "    tmp['Experiment'] = r\n",
    "    df.append(tmp)\n",
    "df = pd.concat(df)\n",
    "# Rename split_type to paper names\n",
    "df['split_type'] = df['split_type'].replace({\n",
    "    'random': 'Standard',\n",
    "    'uniprot': 'Target',\n",
    "    'tanimoto': 'Similarity',\n",
    "    'standard': 'Standard',\n",
    "    'target': 'Target',\n",
    "    'similarity': 'Similarity',\n",
    "})\n",
    "# Rename columns to paper names\n",
    "df.rename(columns={\n",
    "    'split_type': 'Study',\n",
    "    'test_acc': 'Test Accuracy',\n",
    "    'test_roc_auc': 'Test ROC AUC',\n",
    "}, inplace=True)\n",
    "# Rename experiment names to paper names\n",
    "df['Experiment'] = df['Experiment'].replace({\n",
    "    'majority_vote': 'Baseline',\n",
    "    'cellsonehot_majority_vote': 'Cells as one-hot',\n",
    "    'aminoacidcnt_majority_vote': 'Proteins as amino-acid counts',\n",
    "})\n",
    "print(df[['Experiment', 'Study', 'Test Accuracy', 'Test ROC AUC']].to_markdown(index=False))\n",
    "df['Experiment'] = df['Experiment'] = df['Experiment'].replace({\n",
    "    'Cells as one-hot': 'Cells as\\none-hot',\n",
    "    'Proteins as amino-acid counts': 'Proteins as\\nAA counts',\n",
    "})\n",
    "\n",
    "def plot_comparison_df(df, filename=None):\n",
    "    # Plot the test accuracy and ROC AUC in two bar-plots side by side, with Study as hue\n",
    "    _, axes = plt.subplots(1, 2, figsize=(8, 5))\n",
    "    sns.barplot(\n",
    "        data=df,\n",
    "        x='Experiment',\n",
    "        y='Test Accuracy',\n",
    "        hue='Study',\n",
    "        errorbar=('sd', 1),\n",
    "        palette=palette[:3],\n",
    "        ax=axes[0])\n",
    "    # Set ax[0] y-axis to percentage\n",
    "    axes[0].yaxis.set_major_formatter(plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n",
    "    # Set ax[0] y-axis limit from 0 to 100\n",
    "    axes[0].set_ylim(0, 1.0)\n",
    "    # Remove the x-axis label\n",
    "    axes[0].set_xlabel('')\n",
    "    axes[0].grid(axis='y', alpha=0.5, linewidth=0.5)\n",
    "\n",
    "    sns.barplot(\n",
    "        data=df,\n",
    "        x='Experiment',\n",
    "        y='Test ROC AUC',\n",
    "        hue='Study',\n",
    "        errorbar=('sd', 1),\n",
    "        palette=palette[:3],\n",
    "        ax=axes[1])\n",
    "    axes[1].set_ylim(0, 1.0)\n",
    "    # Remove the legend from the first plot\n",
    "    axes[0].legend().remove()\n",
    "    # Set the legend outside the plot in the middle of the two subplots (3 columns)\n",
    "    axes[1].legend(loc='upper center', bbox_to_anchor=(-0.15, -0.12), ncol=3)\n",
    "    # Remove the x-axis label\n",
    "    axes[1].set_xlabel('')\n",
    "    axes[1].grid(axis='y', alpha=0.5, linewidth=0.5)\n",
    "\n",
    "    # Add values to the bar plots rotated 90 degrees at 0.5 height\n",
    "    for i, ax in enumerate(axes):\n",
    "        for p in ax.patches:\n",
    "            if p.get_height() < 0.01:\n",
    "                continue\n",
    "            if i % 2 == 0:\n",
    "                value = f'{p.get_height():.1%}'\n",
    "            else:\n",
    "                value = f'{p.get_height():.3f}'\n",
    "            \n",
    "            x = p.get_x() + p.get_width() / 2\n",
    "            y = 0.3\n",
    "            ax.annotate(value, (x, y), ha='center', va='center', color='black', fontsize=10, rotation=90, alpha=0.8)\n",
    "\n",
    "    if filename is not None:\n",
    "        plt.savefig(f'plots/{filename}.pdf', bbox_inches='tight')\n",
    "        # plt.savefig(f'plots/{filename}.png', bbox_inches='tight')\n",
    "    plt.show()\n",
    "\n",
    "print('-' * 80)\n",
    "print('Comparison of the best models majority vote:')\n",
    "plot_comparison_df(df, 'embedding_comparison_majority_vote')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Experiment                    | Study      |   Test Accuracy |   Test ROC AUC |\n",
      "|:------------------------------|:-----------|----------------:|---------------:|\n",
      "| Baseline                      | Similarity |        0.800866 |       0.857498 |\n",
      "| Baseline                      | Standard   |        0.786325 |       0.851163 |\n",
      "| Baseline                      | Target     |        0.618421 |       0.588386 |\n",
      "| Cells as one-hot              | Similarity |        0.748918 |       0.826107 |\n",
      "| Cells as one-hot              | Standard   |        0.807692 |       0.864895 |\n",
      "| Cells as one-hot              | Target     |        0.622807 |       0.604413 |\n",
      "| Proteins as amino-acid counts | Similarity |        0.753247 |       0.810298 |\n",
      "| Proteins as amino-acid counts | Standard   |        0.747863 |       0.831672 |\n",
      "| Proteins as amino-acid counts | Target     |        0.578947 |       0.540999 |\n",
      "--------------------------------------------------------------------------------\n",
      "Comparison of the best models mean values:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = []\n",
    "for r in ['test', 'cellsonehot_test', 'aminoacidcnt_test']:\n",
    "    tmp = reports[r]\n",
    "    tmp['Experiment'] = r\n",
    "    df.append(tmp)\n",
    "df = pd.concat(df)\n",
    "# Rename split_type to paper names\n",
    "df['split_type'] = df['split_type'].replace({\n",
    "    'random': 'Standard',\n",
    "    'uniprot': 'Target',\n",
    "    'tanimoto': 'Similarity',\n",
    "    'standard': 'Standard',\n",
    "    'target': 'Target',\n",
    "    'similarity': 'Similarity',\n",
    "})\n",
    "# Rename columns to paper names\n",
    "df.rename(columns={\n",
    "    'split_type': 'Study',\n",
    "    'test_acc': 'Test Accuracy',\n",
    "    'test_roc_auc': 'Test ROC AUC',\n",
    "}, inplace=True)\n",
    "# Group by experiment and split type then get the mean\n",
    "df = df.groupby(['Experiment', 'Study']).mean(['Test Accuracy', 'Test ROC AUC']).reset_index()\n",
    "# Rename experiment names to paper names\n",
    "df['Experiment'] = df['Experiment'].replace({\n",
    "    'test': 'Baseline',\n",
    "    'cellsonehot_test': 'Cells as one-hot',\n",
    "    'aminoacidcnt_test': 'Proteins as amino-acid counts',\n",
    "})\n",
    "# Order df by Experiment\n",
    "df = df.sort_values(['Experiment'])\n",
    "# Order Study by ['Standard', 'Target', 'Similarity']\n",
    "df['Study'] = pd.Categorical(df['Study'], ['Standard', 'Target', 'Similarity'])\n",
    "\n",
    "print(df[['Experiment', 'Study', 'Test Accuracy', 'Test ROC AUC']].to_markdown(index=False))\n",
    "df['Experiment'] = df['Experiment'] = df['Experiment'].replace({\n",
    "    'Cells as one-hot': 'Cells as\\none-hot',\n",
    "    'Proteins as amino-acid counts': 'Proteins as\\nAA counts',\n",
    "})\n",
    "\n",
    "print('-' * 80)\n",
    "print('Comparison of the best models mean values:')\n",
    "plot_comparison_df(df, 'embedding_comparison_mean')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ablation Studies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for standard CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for target CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for similarity CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for standard CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for target CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for similarity CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for standard CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for target CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Plotting ablation study for similarity CV split\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1899217/2296657062.py:75: UserWarning: The palette list has more values (4) than needed (1), which may not be intended.\n",
      "  sns.barplot(data=final_df,\n"
     ]
    }
   ],
   "source": [
    "def plot_ablation_study(report, title=''):\n",
    "    # Define the ablation study combinations\n",
    "    ablation_study_combinations = [\n",
    "        'disabled smiles',\n",
    "        'disabled poi',\n",
    "        'disabled e3',\n",
    "        'disabled cell',\n",
    "        'disabled poi e3',\n",
    "        'disabled poi e3 smiles',\n",
    "        'disabled poi e3 cell',\n",
    "    ]\n",
    "\n",
    "    for group in report['split_type'].unique():\n",
    "        print('-' * 80)\n",
    "        print(f'Plotting ablation study for {group} CV split')\n",
    "        print('-' * 80)\n",
    "        baseline = report[report['disabled_embeddings'].isna()].copy()\n",
    "        baseline = baseline[baseline['split_type'] == group]\n",
    "        baseline['disabled_embeddings'] = 'all embeddings enabled'\n",
    "        # metrics_to_show = ['val_acc', 'test_acc']\n",
    "        metrics_to_show = ['test_acc']\n",
    "        # baseline = baseline.melt(id_vars=['fold', 'disabled_embeddings'], value_vars=metrics_to_show, var_name='metric', value_name='score')\n",
    "        baseline = baseline.melt(id_vars=['disabled_embeddings'], value_vars=metrics_to_show, var_name='metric', value_name='score')\n",
    "\n",
    "        ablation_dfs = []\n",
    "        for disabled_embeddings in ablation_study_combinations:\n",
    "            tmp = report[report['disabled_embeddings'] == disabled_embeddings].copy()\n",
    "            tmp = tmp[tmp['split_type'] == group]\n",
    "            # tmp = tmp.melt(id_vars=['fold', 'disabled_embeddings'], value_vars=metrics_to_show, var_name='metric', value_name='score')\n",
    "            tmp = tmp.melt(id_vars=['disabled_embeddings'], value_vars=metrics_to_show, var_name='metric', value_name='score')\n",
    "            ablation_dfs.append(tmp)\n",
    "        ablation_df = pd.concat(ablation_dfs)\n",
    "\n",
    "        dummy_test_df = pd.DataFrame()\n",
    "        tmp = report[report['split_type'] == group]\n",
    "        dummy_test_df['score'] = tmp[['test_active_perc', 'test_inactive_perc']].max(axis=1)\n",
    "        dummy_test_df['metric'] = 'test_acc'\n",
    "        dummy_test_df['disabled_embeddings'] = 'dummy'\n",
    "\n",
    "        # dummy_df = pd.concat([dummy_val_df, dummy_test_df])\n",
    "        dummy_df = dummy_test_df\n",
    "\n",
    "        final_df = pd.concat([dummy_df, baseline, ablation_df])\n",
    "\n",
    "        final_df['metric'] = final_df['metric'].map({\n",
    "            'val_acc': 'Validation Accuracy',\n",
    "            'test_acc': 'Test Accuracy',\n",
    "            'val_roc_auc': 'Val ROC-AUC',\n",
    "            'test_roc_auc': 'Test ROC-AUC',\n",
    "        })\n",
    "\n",
    "        final_df['disabled_embeddings'] = final_df['disabled_embeddings'].map({\n",
    "            'all embeddings enabled': 'All embeddings enabled',\n",
    "            'dummy': 'Dummy model',\n",
    "            'disabled smiles': 'Disabled PROTAC information',\n",
    "            'disabled e3': 'Disabled E3 information',\n",
    "            'disabled poi': 'Disabled POI information',\n",
    "            'disabled cell': 'Disabled cell information',\n",
    "            'disabled poi e3': 'Disabled E3 and POI info',\n",
    "            'disabled poi e3 smiles': 'Disabled compound, E3, and POI info\\n(only cell information left)',\n",
    "            'disabled poi e3 cell': 'Disabled cell, E3, and POI info\\n(only PROTAC information left)',\n",
    "        })\n",
    "\n",
    "        # Print final_df to latex\n",
    "        tmp  = final_df.groupby(['disabled_embeddings', 'metric']).mean().round(3)\n",
    "        # Remove fold column to tmp\n",
    "        tmp = tmp.reset_index() #.drop('fold', axis=1)\n",
    "\n",
    "        # print('DF to plot:\\n', tmp.to_markdown(index=False))\n",
    "\n",
    "        fig, ax = plt.subplots(figsize=(3, 5))\n",
    "        \n",
    "        # fig, ax = plt.subplots()\n",
    "\n",
    "        sns.barplot(data=final_df,\n",
    "            y='disabled_embeddings',\n",
    "            x='score',\n",
    "            hue='metric',\n",
    "            ax=ax,\n",
    "            errorbar=('sd', 1),\n",
    "            palette=sns.color_palette(palette, len(palette)),\n",
    "            saturation=1,\n",
    "        )\n",
    "\n",
    "        # ax.set_title(f'{group.replace(\"random\", \"standard\")} CV split')\n",
    "        ax.grid(axis='x', alpha=0.5)\n",
    "        ax.tick_params(axis='y', rotation=0)\n",
    "        ax.set_xlim(0, 1.0)\n",
    "        ax.xaxis.set_major_formatter(plt.matplotlib.ticker.PercentFormatter(1, decimals=0))\n",
    "        ax.set_ylabel('')\n",
    "        ax.set_xlabel('')\n",
    "\n",
    "        # Plot the legend below the x-axis, outside the plot\n",
    "        ax.legend(loc='upper center', bbox_to_anchor=(0.02, -0.1))\n",
    "\n",
    "        # For each bar, add the rotated value (as percentage), inside the bar\n",
    "        for i, p in enumerate(plt.gca().patches):\n",
    "            # TODO: For some reasons, there is an additional bar being added at\n",
    "            # the end of the plot... it's not in the dataframe\n",
    "            if i == len(plt.gca().patches) - 1:\n",
    "                continue\n",
    "            value = '{:.1f}%'.format(100 * p.get_width())\n",
    "            y = p.get_y() + p.get_height() / 2\n",
    "            x = 0.2 # p.get_height() - p.get_height() / 2\n",
    "            plt.annotate(value, (x, y), ha='center', va='center', color='black', fontsize=10, alpha=0.8)\n",
    "\n",
    "        plt.savefig(f'plots/{title}{group}.pdf', bbox_inches='tight')\n",
    "        plt.close()\n",
    "\n",
    "for experiment in ['', 'cellsonehot_', 'aminoacidcnt_']:\n",
    "    reports[f'{experiment}test']['disabled_embeddings'] = pd.NA\n",
    "    experiment_name = 'pytorch_' if experiment == '' else experiment\n",
    "    plot_ablation_study(\n",
    "        pd.concat([\n",
    "            reports[f'{experiment}ablation'],\n",
    "            reports[f'{experiment}test'],\n",
    "        ]),\n",
    "        title=f'{experiment_name}ablation_study_'\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Others"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/cephyr/users/ribes/Alvis/PROTAC-Degradation-Predictor\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "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>Compound ID</th>\n",
       "      <th>Uniprot</th>\n",
       "      <th>Smiles</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>InChI</th>\n",
       "      <th>InChI Key</th>\n",
       "      <th>Molecular Weight</th>\n",
       "      <th>Heavy Atom Count</th>\n",
       "      <th>Ring Count</th>\n",
       "      <th>Rotatable Bond Count</th>\n",
       "      <th>...</th>\n",
       "      <th>Name</th>\n",
       "      <th>Assay (DC50/Dmax)</th>\n",
       "      <th>Exact Mass</th>\n",
       "      <th>XLogP3</th>\n",
       "      <th>Target (Parsed)</th>\n",
       "      <th>POI Sequence</th>\n",
       "      <th>E3 Ligase Uniprot</th>\n",
       "      <th>E3 Ligase Sequence</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>Active - OR</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C73H88ClF3N10O10S4/c1-47(49-13-15-51(...</td>\n",
       "      <td>SXPDUCVNMGMWBJ-FMZBIETASA-N</td>\n",
       "      <td>1486.282</td>\n",
       "      <td>101</td>\n",
       "      <td>10</td>\n",
       "      <td>24</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C74H90ClF3N10O10S4/c1-48(50-13-15-52(...</td>\n",
       "      <td>HQKUMELJMUNTTF-NMKDNUEVSA-N</td>\n",
       "      <td>1500.309</td>\n",
       "      <td>102</td>\n",
       "      <td>10</td>\n",
       "      <td>25</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C75H92ClF3N10O10S4/c1-49(51-16-18-53(...</td>\n",
       "      <td>ATQCEJKUPSBDMA-QARNUTPLSA-N</td>\n",
       "      <td>1514.336</td>\n",
       "      <td>103</td>\n",
       "      <td>10</td>\n",
       "      <td>26</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C76H94ClF3N10O10S4/c1-50(52-17-19-54(...</td>\n",
       "      <td>FNKQAGMHNFFSEI-DTTPTBRMSA-N</td>\n",
       "      <td>1528.363</td>\n",
       "      <td>104</td>\n",
       "      <td>10</td>\n",
       "      <td>27</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C77H96ClF3N10O10S4/c1-51(53-18-20-55(...</td>\n",
       "      <td>PXVFFBGSTYQHRO-REQIQPEASA-N</td>\n",
       "      <td>1542.390</td>\n",
       "      <td>105</td>\n",
       "      <td>10</td>\n",
       "      <td>28</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2136</th>\n",
       "      <td>2342</td>\n",
       "      <td>O60885</td>\n",
       "      <td>Cc1ncsc1-c1ccc(CNC(=O)[C@@H]2C[C@@H](O)CN2C(=O...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C50H61ClN8O8S2/c1-29-31(3)69-49-42(29...</td>\n",
       "      <td>VRVWHAZIBGEPEK-DPSJZEHMSA-N</td>\n",
       "      <td>1001.673</td>\n",
       "      <td>69</td>\n",
       "      <td>7</td>\n",
       "      <td>20</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of BRD4 long in HEK293 cells after...</td>\n",
       "      <td>1000.374231</td>\n",
       "      <td>6.76</td>\n",
       "      <td>BRD4 long</td>\n",
       "      <td>MSAESGPGTRLRNLPVMGDGLETSQMSTTQAQAQPQPANAASTNPP...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>HEK293</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2137</th>\n",
       "      <td>2887</td>\n",
       "      <td>Q05397</td>\n",
       "      <td>CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCCOCCOCCO...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C58H75F3N10O10S/c1-37(39-12-14-40(15-...</td>\n",
       "      <td>FOOHAGZPIHCYKX-ZSFXBAAMSA-N</td>\n",
       "      <td>1161.359</td>\n",
       "      <td>82</td>\n",
       "      <td>7</td>\n",
       "      <td>27</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of FAK in A549 cells after 24 h tr...</td>\n",
       "      <td>1160.534044</td>\n",
       "      <td>6.81</td>\n",
       "      <td>FAK</td>\n",
       "      <td>MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2138</th>\n",
       "      <td>2889</td>\n",
       "      <td>Q05397</td>\n",
       "      <td>CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCCOCC(=O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C54H67F3N10O8S/c1-33(35-12-14-36(15-1...</td>\n",
       "      <td>RDCVMTUYWQXPEC-FSHOLZCKSA-N</td>\n",
       "      <td>1073.253</td>\n",
       "      <td>76</td>\n",
       "      <td>7</td>\n",
       "      <td>21</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of FAK in A549 cells after 24 h tr...</td>\n",
       "      <td>1072.481615</td>\n",
       "      <td>7.11</td>\n",
       "      <td>FAK</td>\n",
       "      <td>MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2139</th>\n",
       "      <td>2890</td>\n",
       "      <td>Q05397</td>\n",
       "      <td>CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCC(=O)N[C...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C52H63F3N10O7S/c1-31(33-12-14-34(15-1...</td>\n",
       "      <td>SLSLLSIRBMAERC-MGVZSLQJSA-N</td>\n",
       "      <td>1029.200</td>\n",
       "      <td>73</td>\n",
       "      <td>7</td>\n",
       "      <td>18</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of FAK in A549 cells after 24 h tr...</td>\n",
       "      <td>1028.455400</td>\n",
       "      <td>7.26</td>\n",
       "      <td>FAK</td>\n",
       "      <td>MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2140</th>\n",
       "      <td>2891</td>\n",
       "      <td>Q05397</td>\n",
       "      <td>CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCC(=O)N[C@H...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C51H61F3N10O6S/c1-30(32-12-14-33(15-1...</td>\n",
       "      <td>ASRIXACKPXMNKY-FCFVTTBASA-N</td>\n",
       "      <td>999.174</td>\n",
       "      <td>71</td>\n",
       "      <td>7</td>\n",
       "      <td>16</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of FAK in A549 cells after 24 h tr...</td>\n",
       "      <td>998.444835</td>\n",
       "      <td>7.31</td>\n",
       "      <td>FAK</td>\n",
       "      <td>MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2141 rows × 35 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Compound ID Uniprot                                             Smiles  \\\n",
       "0               1  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "1               2  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "2               3  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "3               4  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "4               5  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "...           ...     ...                                                ...   \n",
       "2136         2342  O60885  Cc1ncsc1-c1ccc(CNC(=O)[C@@H]2C[C@@H](O)CN2C(=O...   \n",
       "2137         2887  Q05397  CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCCOCCOCCO...   \n",
       "2138         2889  Q05397  CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCCOCC(=O)...   \n",
       "2139         2890  Q05397  CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCC(=O)N[C...   \n",
       "2140         2891  Q05397  CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCC(=O)N[C@H...   \n",
       "\n",
       "     E3 Ligase                                              InChI  \\\n",
       "0          VHL  InChI=1S/C73H88ClF3N10O10S4/c1-47(49-13-15-51(...   \n",
       "1          VHL  InChI=1S/C74H90ClF3N10O10S4/c1-48(50-13-15-52(...   \n",
       "2          VHL  InChI=1S/C75H92ClF3N10O10S4/c1-49(51-16-18-53(...   \n",
       "3          VHL  InChI=1S/C76H94ClF3N10O10S4/c1-50(52-17-19-54(...   \n",
       "4          VHL  InChI=1S/C77H96ClF3N10O10S4/c1-51(53-18-20-55(...   \n",
       "...        ...                                                ...   \n",
       "2136       VHL  InChI=1S/C50H61ClN8O8S2/c1-29-31(3)69-49-42(29...   \n",
       "2137       VHL  InChI=1S/C58H75F3N10O10S/c1-37(39-12-14-40(15-...   \n",
       "2138       VHL  InChI=1S/C54H67F3N10O8S/c1-33(35-12-14-36(15-1...   \n",
       "2139       VHL  InChI=1S/C52H63F3N10O7S/c1-31(33-12-14-34(15-1...   \n",
       "2140       VHL  InChI=1S/C51H61F3N10O6S/c1-30(32-12-14-33(15-1...   \n",
       "\n",
       "                        InChI Key  Molecular Weight  Heavy Atom Count  \\\n",
       "0     SXPDUCVNMGMWBJ-FMZBIETASA-N          1486.282               101   \n",
       "1     HQKUMELJMUNTTF-NMKDNUEVSA-N          1500.309               102   \n",
       "2     ATQCEJKUPSBDMA-QARNUTPLSA-N          1514.336               103   \n",
       "3     FNKQAGMHNFFSEI-DTTPTBRMSA-N          1528.363               104   \n",
       "4     PXVFFBGSTYQHRO-REQIQPEASA-N          1542.390               105   \n",
       "...                           ...               ...               ...   \n",
       "2136  VRVWHAZIBGEPEK-DPSJZEHMSA-N          1001.673                69   \n",
       "2137  FOOHAGZPIHCYKX-ZSFXBAAMSA-N          1161.359                82   \n",
       "2138  RDCVMTUYWQXPEC-FSHOLZCKSA-N          1073.253                76   \n",
       "2139  SLSLLSIRBMAERC-MGVZSLQJSA-N          1029.200                73   \n",
       "2140  ASRIXACKPXMNKY-FCFVTTBASA-N           999.174                71   \n",
       "\n",
       "      Ring Count  Rotatable Bond Count  ...  Name  \\\n",
       "0             10                    24  ...   NaN   \n",
       "1             10                    25  ...   NaN   \n",
       "2             10                    26  ...   NaN   \n",
       "3             10                    27  ...   NaN   \n",
       "4             10                    28  ...   NaN   \n",
       "...          ...                   ...  ...   ...   \n",
       "2136           7                    20  ...   NaN   \n",
       "2137           7                    27  ...   NaN   \n",
       "2138           7                    21  ...   NaN   \n",
       "2139           7                    18  ...   NaN   \n",
       "2140           7                    16  ...   NaN   \n",
       "\n",
       "                                      Assay (DC50/Dmax)   Exact Mass XLogP3  \\\n",
       "0                                                   NaN          NaN    NaN   \n",
       "1                                                   NaN          NaN    NaN   \n",
       "2                                                   NaN          NaN    NaN   \n",
       "3                                                   NaN          NaN    NaN   \n",
       "4                                                   NaN          NaN    NaN   \n",
       "...                                                 ...          ...    ...   \n",
       "2136  Degradation of BRD4 long in HEK293 cells after...  1000.374231   6.76   \n",
       "2137  Degradation of FAK in A549 cells after 24 h tr...  1160.534044   6.81   \n",
       "2138  Degradation of FAK in A549 cells after 24 h tr...  1072.481615   7.11   \n",
       "2139  Degradation of FAK in A549 cells after 24 h tr...  1028.455400   7.26   \n",
       "2140  Degradation of FAK in A549 cells after 24 h tr...   998.444835   7.31   \n",
       "\n",
       "      Target (Parsed)                                       POI Sequence  \\\n",
       "0                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "1                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "2                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "3                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "4                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "...               ...                                                ...   \n",
       "2136        BRD4 long  MSAESGPGTRLRNLPVMGDGLETSQMSTTQAQAQPQPANAASTNPP...   \n",
       "2137              FAK  MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...   \n",
       "2138              FAK  MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...   \n",
       "2139              FAK  MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...   \n",
       "2140              FAK  MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...   \n",
       "\n",
       "      E3 Ligase Uniprot                                 E3 Ligase Sequence  \\\n",
       "0                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "1                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "3                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "4                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "...                 ...                                                ...   \n",
       "2136             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2137             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2138             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2139             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2140             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "\n",
       "     Cell Line Identifier Active - OR  \n",
       "0                  MOLT-4         NaN  \n",
       "1                  MOLT-4         NaN  \n",
       "2                  MOLT-4         NaN  \n",
       "3                  MOLT-4         NaN  \n",
       "4                  MOLT-4        True  \n",
       "...                   ...         ...  \n",
       "2136               HEK293        True  \n",
       "2137            A549 Cas9       False  \n",
       "2138            A549 Cas9       False  \n",
       "2139            A549 Cas9        True  \n",
       "2140            A549 Cas9        True  \n",
       "\n",
       "[2141 rows x 35 columns]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "import protac_degradation_predictor as pdp\n",
    "\n",
    "protac_df = pdp.load_curated_dataset()\n",
    "protac_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from rdkit import Chem\n",
    "\n",
    "def canon_smiles(smi):\n",
    "    mol = Chem.MolFromSmiles(smi)\n",
    "    if mol is None:\n",
    "        return None\n",
    "    return Chem.MolToSmiles(mol)\n",
    "\n",
    "# Canonicalize SMILES\n",
    "protac_df['canon_smiles'] = protac_df['Smiles'].apply(lambda x: canon_smiles(x))\n",
    "# Check that all canon_smiles is equal to the Smiles column\n",
    "protac_df['canon_smiles'].equals(protac_df['Smiles'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "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>Compound ID</th>\n",
       "      <th>Uniprot</th>\n",
       "      <th>Smiles</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>InChI</th>\n",
       "      <th>InChI Key</th>\n",
       "      <th>Molecular Weight</th>\n",
       "      <th>Heavy Atom Count</th>\n",
       "      <th>Ring Count</th>\n",
       "      <th>Rotatable Bond Count</th>\n",
       "      <th>...</th>\n",
       "      <th>Name</th>\n",
       "      <th>Assay (DC50/Dmax)</th>\n",
       "      <th>Exact Mass</th>\n",
       "      <th>XLogP3</th>\n",
       "      <th>Target (Parsed)</th>\n",
       "      <th>POI Sequence</th>\n",
       "      <th>E3 Ligase Uniprot</th>\n",
       "      <th>E3 Ligase Sequence</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>Active - OR</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C73H88ClF3N10O10S4/c1-47(49-13-15-51(...</td>\n",
       "      <td>SXPDUCVNMGMWBJ-FMZBIETASA-N</td>\n",
       "      <td>1486.282</td>\n",
       "      <td>101</td>\n",
       "      <td>10</td>\n",
       "      <td>24</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C74H90ClF3N10O10S4/c1-48(50-13-15-52(...</td>\n",
       "      <td>HQKUMELJMUNTTF-NMKDNUEVSA-N</td>\n",
       "      <td>1500.309</td>\n",
       "      <td>102</td>\n",
       "      <td>10</td>\n",
       "      <td>25</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C75H92ClF3N10O10S4/c1-49(51-16-18-53(...</td>\n",
       "      <td>ATQCEJKUPSBDMA-QARNUTPLSA-N</td>\n",
       "      <td>1514.336</td>\n",
       "      <td>103</td>\n",
       "      <td>10</td>\n",
       "      <td>26</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C76H94ClF3N10O10S4/c1-50(52-17-19-54(...</td>\n",
       "      <td>FNKQAGMHNFFSEI-DTTPTBRMSA-N</td>\n",
       "      <td>1528.363</td>\n",
       "      <td>104</td>\n",
       "      <td>10</td>\n",
       "      <td>27</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C77H96ClF3N10O10S4/c1-51(53-18-20-55(...</td>\n",
       "      <td>PXVFFBGSTYQHRO-REQIQPEASA-N</td>\n",
       "      <td>1542.390</td>\n",
       "      <td>105</td>\n",
       "      <td>10</td>\n",
       "      <td>28</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2136</th>\n",
       "      <td>2342</td>\n",
       "      <td>O60885</td>\n",
       "      <td>Cc1ncsc1-c1ccc(CNC(=O)[C@@H]2C[C@@H](O)CN2C(=O...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C50H61ClN8O8S2/c1-29-31(3)69-49-42(29...</td>\n",
       "      <td>VRVWHAZIBGEPEK-DPSJZEHMSA-N</td>\n",
       "      <td>1001.673</td>\n",
       "      <td>69</td>\n",
       "      <td>7</td>\n",
       "      <td>20</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of BRD4 long in HEK293 cells after...</td>\n",
       "      <td>1000.374231</td>\n",
       "      <td>6.76</td>\n",
       "      <td>BRD4 long</td>\n",
       "      <td>MSAESGPGTRLRNLPVMGDGLETSQMSTTQAQAQPQPANAASTNPP...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>HEK293</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2137</th>\n",
       "      <td>2887</td>\n",
       "      <td>Q05397</td>\n",
       "      <td>CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCCOCCOCCO...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C58H75F3N10O10S/c1-37(39-12-14-40(15-...</td>\n",
       "      <td>FOOHAGZPIHCYKX-ZSFXBAAMSA-N</td>\n",
       "      <td>1161.359</td>\n",
       "      <td>82</td>\n",
       "      <td>7</td>\n",
       "      <td>27</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of FAK in A549 cells after 24 h tr...</td>\n",
       "      <td>1160.534044</td>\n",
       "      <td>6.81</td>\n",
       "      <td>FAK</td>\n",
       "      <td>MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2138</th>\n",
       "      <td>2889</td>\n",
       "      <td>Q05397</td>\n",
       "      <td>CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCCOCC(=O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C54H67F3N10O8S/c1-33(35-12-14-36(15-1...</td>\n",
       "      <td>RDCVMTUYWQXPEC-FSHOLZCKSA-N</td>\n",
       "      <td>1073.253</td>\n",
       "      <td>76</td>\n",
       "      <td>7</td>\n",
       "      <td>21</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of FAK in A549 cells after 24 h tr...</td>\n",
       "      <td>1072.481615</td>\n",
       "      <td>7.11</td>\n",
       "      <td>FAK</td>\n",
       "      <td>MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2139</th>\n",
       "      <td>2890</td>\n",
       "      <td>Q05397</td>\n",
       "      <td>CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCC(=O)N[C...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C52H63F3N10O7S/c1-31(33-12-14-34(15-1...</td>\n",
       "      <td>SLSLLSIRBMAERC-MGVZSLQJSA-N</td>\n",
       "      <td>1029.200</td>\n",
       "      <td>73</td>\n",
       "      <td>7</td>\n",
       "      <td>18</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of FAK in A549 cells after 24 h tr...</td>\n",
       "      <td>1028.455400</td>\n",
       "      <td>7.26</td>\n",
       "      <td>FAK</td>\n",
       "      <td>MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2140</th>\n",
       "      <td>2891</td>\n",
       "      <td>Q05397</td>\n",
       "      <td>CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCC(=O)N[C@H...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C51H61F3N10O6S/c1-30(32-12-14-33(15-1...</td>\n",
       "      <td>ASRIXACKPXMNKY-FCFVTTBASA-N</td>\n",
       "      <td>999.174</td>\n",
       "      <td>71</td>\n",
       "      <td>7</td>\n",
       "      <td>16</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Degradation of FAK in A549 cells after 24 h tr...</td>\n",
       "      <td>998.444835</td>\n",
       "      <td>7.31</td>\n",
       "      <td>FAK</td>\n",
       "      <td>MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2141 rows × 35 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Compound ID Uniprot                                             Smiles  \\\n",
       "0               1  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "1               2  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "2               3  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "3               4  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "4               5  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "...           ...     ...                                                ...   \n",
       "2136         2342  O60885  Cc1ncsc1-c1ccc(CNC(=O)[C@@H]2C[C@@H](O)CN2C(=O...   \n",
       "2137         2887  Q05397  CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCCOCCOCCO...   \n",
       "2138         2889  Q05397  CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCCOCC(=O)...   \n",
       "2139         2890  Q05397  CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCOCC(=O)N[C...   \n",
       "2140         2891  Q05397  CNC(=O)c1ccccc1Nc1cc(Nc2ccc(N3CCN(CCC(=O)N[C@H...   \n",
       "\n",
       "     E3 Ligase                                              InChI  \\\n",
       "0          VHL  InChI=1S/C73H88ClF3N10O10S4/c1-47(49-13-15-51(...   \n",
       "1          VHL  InChI=1S/C74H90ClF3N10O10S4/c1-48(50-13-15-52(...   \n",
       "2          VHL  InChI=1S/C75H92ClF3N10O10S4/c1-49(51-16-18-53(...   \n",
       "3          VHL  InChI=1S/C76H94ClF3N10O10S4/c1-50(52-17-19-54(...   \n",
       "4          VHL  InChI=1S/C77H96ClF3N10O10S4/c1-51(53-18-20-55(...   \n",
       "...        ...                                                ...   \n",
       "2136       VHL  InChI=1S/C50H61ClN8O8S2/c1-29-31(3)69-49-42(29...   \n",
       "2137       VHL  InChI=1S/C58H75F3N10O10S/c1-37(39-12-14-40(15-...   \n",
       "2138       VHL  InChI=1S/C54H67F3N10O8S/c1-33(35-12-14-36(15-1...   \n",
       "2139       VHL  InChI=1S/C52H63F3N10O7S/c1-31(33-12-14-34(15-1...   \n",
       "2140       VHL  InChI=1S/C51H61F3N10O6S/c1-30(32-12-14-33(15-1...   \n",
       "\n",
       "                        InChI Key  Molecular Weight  Heavy Atom Count  \\\n",
       "0     SXPDUCVNMGMWBJ-FMZBIETASA-N          1486.282               101   \n",
       "1     HQKUMELJMUNTTF-NMKDNUEVSA-N          1500.309               102   \n",
       "2     ATQCEJKUPSBDMA-QARNUTPLSA-N          1514.336               103   \n",
       "3     FNKQAGMHNFFSEI-DTTPTBRMSA-N          1528.363               104   \n",
       "4     PXVFFBGSTYQHRO-REQIQPEASA-N          1542.390               105   \n",
       "...                           ...               ...               ...   \n",
       "2136  VRVWHAZIBGEPEK-DPSJZEHMSA-N          1001.673                69   \n",
       "2137  FOOHAGZPIHCYKX-ZSFXBAAMSA-N          1161.359                82   \n",
       "2138  RDCVMTUYWQXPEC-FSHOLZCKSA-N          1073.253                76   \n",
       "2139  SLSLLSIRBMAERC-MGVZSLQJSA-N          1029.200                73   \n",
       "2140  ASRIXACKPXMNKY-FCFVTTBASA-N           999.174                71   \n",
       "\n",
       "      Ring Count  Rotatable Bond Count  ...  Name  \\\n",
       "0             10                    24  ...   NaN   \n",
       "1             10                    25  ...   NaN   \n",
       "2             10                    26  ...   NaN   \n",
       "3             10                    27  ...   NaN   \n",
       "4             10                    28  ...   NaN   \n",
       "...          ...                   ...  ...   ...   \n",
       "2136           7                    20  ...   NaN   \n",
       "2137           7                    27  ...   NaN   \n",
       "2138           7                    21  ...   NaN   \n",
       "2139           7                    18  ...   NaN   \n",
       "2140           7                    16  ...   NaN   \n",
       "\n",
       "                                      Assay (DC50/Dmax)   Exact Mass XLogP3  \\\n",
       "0                                                   NaN          NaN    NaN   \n",
       "1                                                   NaN          NaN    NaN   \n",
       "2                                                   NaN          NaN    NaN   \n",
       "3                                                   NaN          NaN    NaN   \n",
       "4                                                   NaN          NaN    NaN   \n",
       "...                                                 ...          ...    ...   \n",
       "2136  Degradation of BRD4 long in HEK293 cells after...  1000.374231   6.76   \n",
       "2137  Degradation of FAK in A549 cells after 24 h tr...  1160.534044   6.81   \n",
       "2138  Degradation of FAK in A549 cells after 24 h tr...  1072.481615   7.11   \n",
       "2139  Degradation of FAK in A549 cells after 24 h tr...  1028.455400   7.26   \n",
       "2140  Degradation of FAK in A549 cells after 24 h tr...   998.444835   7.31   \n",
       "\n",
       "      Target (Parsed)                                       POI Sequence  \\\n",
       "0                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "1                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "2                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "3                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "4                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "...               ...                                                ...   \n",
       "2136        BRD4 long  MSAESGPGTRLRNLPVMGDGLETSQMSTTQAQAQPQPANAASTNPP...   \n",
       "2137              FAK  MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...   \n",
       "2138              FAK  MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...   \n",
       "2139              FAK  MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...   \n",
       "2140              FAK  MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESN...   \n",
       "\n",
       "      E3 Ligase Uniprot                                 E3 Ligase Sequence  \\\n",
       "0                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "1                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "3                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "4                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "...                 ...                                                ...   \n",
       "2136             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2137             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2138             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2139             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2140             P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "\n",
       "     Cell Line Identifier Active - OR  \n",
       "0                  MOLT-4         NaN  \n",
       "1                  MOLT-4         NaN  \n",
       "2                  MOLT-4         NaN  \n",
       "3                  MOLT-4         NaN  \n",
       "4                  MOLT-4        True  \n",
       "...                   ...         ...  \n",
       "2136               HEK293        True  \n",
       "2137            A549 Cas9       False  \n",
       "2138            A549 Cas9       False  \n",
       "2139            A549 Cas9        True  \n",
       "2140            A549 Cas9        True  \n",
       "\n",
       "[2141 rows x 35 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Compound ID</th>\n",
       "      <th>Uniprot</th>\n",
       "      <th>Smiles</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>InChI</th>\n",
       "      <th>InChI Key</th>\n",
       "      <th>Molecular Weight</th>\n",
       "      <th>Heavy Atom Count</th>\n",
       "      <th>Ring Count</th>\n",
       "      <th>Rotatable Bond Count</th>\n",
       "      <th>...</th>\n",
       "      <th>Name</th>\n",
       "      <th>Assay (DC50/Dmax)</th>\n",
       "      <th>Exact Mass</th>\n",
       "      <th>XLogP3</th>\n",
       "      <th>Target (Parsed)</th>\n",
       "      <th>POI Sequence</th>\n",
       "      <th>E3 Ligase Uniprot</th>\n",
       "      <th>E3 Ligase Sequence</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>Active - OR</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C73H88ClF3N10O10S4/c1-47(49-13-15-51(...</td>\n",
       "      <td>SXPDUCVNMGMWBJ-FMZBIETASA-N</td>\n",
       "      <td>1486.282</td>\n",
       "      <td>101.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C74H90ClF3N10O10S4/c1-48(50-13-15-52(...</td>\n",
       "      <td>HQKUMELJMUNTTF-NMKDNUEVSA-N</td>\n",
       "      <td>1500.309</td>\n",
       "      <td>102.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C75H92ClF3N10O10S4/c1-49(51-16-18-53(...</td>\n",
       "      <td>ATQCEJKUPSBDMA-QARNUTPLSA-N</td>\n",
       "      <td>1514.336</td>\n",
       "      <td>103.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>26.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C76H94ClF3N10O10S4/c1-50(52-17-19-54(...</td>\n",
       "      <td>FNKQAGMHNFFSEI-DTTPTBRMSA-N</td>\n",
       "      <td>1528.363</td>\n",
       "      <td>104.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>27.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>VHL</td>\n",
       "      <td>InChI=1S/C78H98ClF3N10O10S4/c1-52(54-19-21-56(...</td>\n",
       "      <td>DKBAKHBUQPFQDO-PXKQGBTKSA-N</td>\n",
       "      <td>1556.417</td>\n",
       "      <td>106.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>29.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...</td>\n",
       "      <td>P40337</td>\n",
       "      <td>MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1896</th>\n",
       "      <td>384</td>\n",
       "      <td>Q07820</td>\n",
       "      <td>O=C(CCCCC(=O)NCCN1C(=O)c2cccc3c(Sc4ccc(Br)cc4)...</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>InChI=1S/C45H45BrN6O8S/c46-27-15-17-28(18-16-2...</td>\n",
       "      <td>BORXNUWYWZOREQ-UHFFFAOYSA-N</td>\n",
       "      <td>909.860</td>\n",
       "      <td>61.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>19.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>908.220296</td>\n",
       "      <td>5.98</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MFGLKRNAVIGLNLYCGGAGLGAGSGGATRPGGRLLATEKEASARR...</td>\n",
       "      <td>Q96SW2</td>\n",
       "      <td>MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...</td>\n",
       "      <td>HeLa</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1897</th>\n",
       "      <td>910</td>\n",
       "      <td>Q9UBN7</td>\n",
       "      <td>O=C(CCCCCCC(=O)N/N=C/c1ccc(OCCOCCOCCn2cc(CNc3c...</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>InChI=1S/C37H45N9O10/c47-31-15-14-30(35(50)40-...</td>\n",
       "      <td>MHILTYZXXFOWJH-WVKHYPTHSA-N</td>\n",
       "      <td>775.820</td>\n",
       "      <td>56.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>23.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>775.328939</td>\n",
       "      <td>1.00</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MTSTGQDSTTTRQRRSRQNPQSPPQDSSVTSKRNIKKGAVPRSIPN...</td>\n",
       "      <td>Q96SW2</td>\n",
       "      <td>MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...</td>\n",
       "      <td>MM1.S</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1898</th>\n",
       "      <td>2544</td>\n",
       "      <td>O60760</td>\n",
       "      <td>O=C1CCC(N2C(=O)c3cccc(N4CCN(C(=O)C5CCN(c6ccc(N...</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>InChI=1S/C40H38N8O7/c49-33-14-13-32(36(51)44-3...</td>\n",
       "      <td>KQNXUQJGOJWQGL-UHFFFAOYSA-N</td>\n",
       "      <td>742.793</td>\n",
       "      <td>55.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>...</td>\n",
       "      <td>PROTAC(H-PGDS)-7</td>\n",
       "      <td>Degradation of HPGDS in KU812 cells after 6/24...</td>\n",
       "      <td>742.286346</td>\n",
       "      <td>2.77</td>\n",
       "      <td>HPGDS</td>\n",
       "      <td>MPNYKLTYFNMRGRAEIIRYIFAYLDIQYEDHRIEQADWPEIKSTL...</td>\n",
       "      <td>Q96SW2</td>\n",
       "      <td>MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...</td>\n",
       "      <td>Ku812</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1899</th>\n",
       "      <td>1214</td>\n",
       "      <td>P14174</td>\n",
       "      <td>O=C1CCC(N2C(=O)c3cccc(NCCCCCCCC(=O)Nc4ccc(N5Cc...</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>InChI=1S/C35H35N5O8/c41-24-15-10-21-20-39(35(4...</td>\n",
       "      <td>HAHDZDUOFHMMEA-UHFFFAOYSA-N</td>\n",
       "      <td>653.692</td>\n",
       "      <td>48.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>653.248563</td>\n",
       "      <td>4.16</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MPMFIVNTNVPRASVPDGFLSELTQQLAQATGKPPQYIAVHVVPDQ...</td>\n",
       "      <td>Q96SW2</td>\n",
       "      <td>MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1900</th>\n",
       "      <td>136</td>\n",
       "      <td>P00533</td>\n",
       "      <td>O=C1CCC(N2Cc3c(NC(=O)CCCCCCCN4CCN(c5ccc(Nc6cc7...</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>InChI=1S/C49H57FN12O5/c50-33-10-12-34(13-11-33...</td>\n",
       "      <td>ZWLPWTDAYPOQGR-UHFFFAOYSA-N</td>\n",
       "      <td>913.072</td>\n",
       "      <td>67.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>912.455891</td>\n",
       "      <td>5.26</td>\n",
       "      <td>NaN</td>\n",
       "      <td>MRPSGTAGAALLALLAALCPASRALEEKKVCQGTSNKLTQLGTFED...</td>\n",
       "      <td>Q96SW2</td>\n",
       "      <td>MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...</td>\n",
       "      <td>HCC827</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1901 rows × 35 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Compound ID Uniprot                                             Smiles  \\\n",
       "0               1  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "1               2  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "2               3  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "3               4  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "4               6  Q07817  Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...   \n",
       "...           ...     ...                                                ...   \n",
       "1896          384  Q07820  O=C(CCCCC(=O)NCCN1C(=O)c2cccc3c(Sc4ccc(Br)cc4)...   \n",
       "1897          910  Q9UBN7  O=C(CCCCCCC(=O)N/N=C/c1ccc(OCCOCCOCCn2cc(CNc3c...   \n",
       "1898         2544  O60760  O=C1CCC(N2C(=O)c3cccc(N4CCN(C(=O)C5CCN(c6ccc(N...   \n",
       "1899         1214  P14174  O=C1CCC(N2C(=O)c3cccc(NCCCCCCCC(=O)Nc4ccc(N5Cc...   \n",
       "1900          136  P00533  O=C1CCC(N2Cc3c(NC(=O)CCCCCCCN4CCN(c5ccc(Nc6cc7...   \n",
       "\n",
       "     E3 Ligase                                              InChI  \\\n",
       "0          VHL  InChI=1S/C73H88ClF3N10O10S4/c1-47(49-13-15-51(...   \n",
       "1          VHL  InChI=1S/C74H90ClF3N10O10S4/c1-48(50-13-15-52(...   \n",
       "2          VHL  InChI=1S/C75H92ClF3N10O10S4/c1-49(51-16-18-53(...   \n",
       "3          VHL  InChI=1S/C76H94ClF3N10O10S4/c1-50(52-17-19-54(...   \n",
       "4          VHL  InChI=1S/C78H98ClF3N10O10S4/c1-52(54-19-21-56(...   \n",
       "...        ...                                                ...   \n",
       "1896      CRBN  InChI=1S/C45H45BrN6O8S/c46-27-15-17-28(18-16-2...   \n",
       "1897      CRBN  InChI=1S/C37H45N9O10/c47-31-15-14-30(35(50)40-...   \n",
       "1898      CRBN  InChI=1S/C40H38N8O7/c49-33-14-13-32(36(51)44-3...   \n",
       "1899      CRBN  InChI=1S/C35H35N5O8/c41-24-15-10-21-20-39(35(4...   \n",
       "1900      CRBN  InChI=1S/C49H57FN12O5/c50-33-10-12-34(13-11-33...   \n",
       "\n",
       "                        InChI Key  Molecular Weight  Heavy Atom Count  \\\n",
       "0     SXPDUCVNMGMWBJ-FMZBIETASA-N          1486.282             101.0   \n",
       "1     HQKUMELJMUNTTF-NMKDNUEVSA-N          1500.309             102.0   \n",
       "2     ATQCEJKUPSBDMA-QARNUTPLSA-N          1514.336             103.0   \n",
       "3     FNKQAGMHNFFSEI-DTTPTBRMSA-N          1528.363             104.0   \n",
       "4     DKBAKHBUQPFQDO-PXKQGBTKSA-N          1556.417             106.0   \n",
       "...                           ...               ...               ...   \n",
       "1896  BORXNUWYWZOREQ-UHFFFAOYSA-N           909.860              61.0   \n",
       "1897  MHILTYZXXFOWJH-WVKHYPTHSA-N           775.820              56.0   \n",
       "1898  KQNXUQJGOJWQGL-UHFFFAOYSA-N           742.793              55.0   \n",
       "1899  HAHDZDUOFHMMEA-UHFFFAOYSA-N           653.692              48.0   \n",
       "1900  ZWLPWTDAYPOQGR-UHFFFAOYSA-N           913.072              67.0   \n",
       "\n",
       "      Ring Count  Rotatable Bond Count  ...              Name  \\\n",
       "0           10.0                  24.0  ...               NaN   \n",
       "1           10.0                  25.0  ...               NaN   \n",
       "2           10.0                  26.0  ...               NaN   \n",
       "3           10.0                  27.0  ...               NaN   \n",
       "4           10.0                  29.0  ...               NaN   \n",
       "...          ...                   ...  ...               ...   \n",
       "1896         7.0                  19.0  ...               NaN   \n",
       "1897         5.0                  23.0  ...               NaN   \n",
       "1898         8.0                   8.0  ...  PROTAC(H-PGDS)-7   \n",
       "1899         6.0                  12.0  ...               NaN   \n",
       "1900         9.0                  17.0  ...               NaN   \n",
       "\n",
       "                                      Assay (DC50/Dmax)  Exact Mass XLogP3  \\\n",
       "0                                                   NaN         NaN    NaN   \n",
       "1                                                   NaN         NaN    NaN   \n",
       "2                                                   NaN         NaN    NaN   \n",
       "3                                                   NaN         NaN    NaN   \n",
       "4                                                   NaN         NaN    NaN   \n",
       "...                                                 ...         ...    ...   \n",
       "1896                                                NaN  908.220296   5.98   \n",
       "1897                                                NaN  775.328939   1.00   \n",
       "1898  Degradation of HPGDS in KU812 cells after 6/24...  742.286346   2.77   \n",
       "1899                                                NaN  653.248563   4.16   \n",
       "1900                                                NaN  912.455891   5.26   \n",
       "\n",
       "      Target (Parsed)                                       POI Sequence  \\\n",
       "0                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "1                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "2                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "3                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "4                 NaN  MSQSNRELVVDFLSYKLSQKGYSWSQFSDVEENRTEAPEGTESEME...   \n",
       "...               ...                                                ...   \n",
       "1896              NaN  MFGLKRNAVIGLNLYCGGAGLGAGSGGATRPGGRLLATEKEASARR...   \n",
       "1897              NaN  MTSTGQDSTTTRQRRSRQNPQSPPQDSSVTSKRNIKKGAVPRSIPN...   \n",
       "1898            HPGDS  MPNYKLTYFNMRGRAEIIRYIFAYLDIQYEDHRIEQADWPEIKSTL...   \n",
       "1899              NaN  MPMFIVNTNVPRASVPDGFLSELTQQLAQATGKPPQYIAVHVVPDQ...   \n",
       "1900              NaN  MRPSGTAGAALLALLAALCPASRALEEKKVCQGTSNKLTQLGTFED...   \n",
       "\n",
       "      E3 Ligase Uniprot                                 E3 Ligase Sequence  \\\n",
       "0                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "1                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "2                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "3                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "4                P40337  MPRRAENWDEAEVGAEEAGVEEYGPEEDGGEESGAEESGPEESGPE...   \n",
       "...                 ...                                                ...   \n",
       "1896             Q96SW2  MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...   \n",
       "1897             Q96SW2  MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...   \n",
       "1898             Q96SW2  MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...   \n",
       "1899             Q96SW2  MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...   \n",
       "1900             Q96SW2  MAGEGDQQDAAHNMGNHLPLLPAESEEEDEMEVEDQDSKEAKKPNI...   \n",
       "\n",
       "     Cell Line Identifier Active - OR  \n",
       "0                  MOLT-4         NaN  \n",
       "1                  MOLT-4         NaN  \n",
       "2                  MOLT-4         NaN  \n",
       "3                  MOLT-4         NaN  \n",
       "4                  MOLT-4         NaN  \n",
       "...                   ...         ...  \n",
       "1896                 HeLa         NaN  \n",
       "1897                MM1.S         NaN  \n",
       "1898                Ku812        True  \n",
       "1899            A549 Cas9       False  \n",
       "1900               HCC827        True  \n",
       "\n",
       "[1901 rows x 35 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Remove duplicates with a custom function\n",
    "def merge_numerical_cols(group):\n",
    "    key_cols = [\n",
    "        'Smiles',\n",
    "        'Uniprot',\n",
    "        'E3 Ligase Uniprot',\n",
    "        'Cell Line Identifier',\n",
    "    ]\n",
    "    class_cols = ['DC50 (nM)', 'Dmax (%)']\n",
    "    # Loop over all numerical columns\n",
    "    for col in group.select_dtypes(include=[np.number]).columns:\n",
    "        if col == 'Compound ID':\n",
    "            continue\n",
    "        # Compute the geometric mean for the column\n",
    "        values = group[col].dropna()\n",
    "        if not values.empty:\n",
    "            group[col] = np.prod(values) ** (1 / len(values))\n",
    "\n",
    "    row = group.drop_duplicates(subset=key_cols + class_cols).reset_index(drop=True)\n",
    "\n",
    "    assert len(row) == 1\n",
    "\n",
    "    return row\n",
    "\n",
    "\n",
    "def remove_duplicates(df):\n",
    "    key_cols = [\n",
    "        'Smiles',\n",
    "        'Uniprot',\n",
    "        'E3 Ligase Uniprot',\n",
    "        'Cell Line Identifier',\n",
    "    ]\n",
    "    class_cols = ['DC50 (nM)', 'Dmax (%)']\n",
    "    # Check if there are any duplicated entries having the same key columns, if\n",
    "    # so, merge them by applying a geometric mean to their DC50 and Dmax columns\n",
    "    duplicated = df[df.duplicated(subset=key_cols, keep=False)]\n",
    "\n",
    "    # NOTE: Reset index to remove the multi-index\n",
    "    merged = duplicated.groupby(key_cols).apply(lambda x: merge_numerical_cols(x))\n",
    "    merged = merged.reset_index(drop=True)\n",
    "\n",
    "    # Remove the duplicated entries from the original dataframe df\n",
    "    df = df[~df.duplicated(subset=key_cols, keep=False)]\n",
    "    # Concatenate the merged dataframe with the original dataframe\n",
    "    return pd.concat([df, merged], ignore_index=True)\n",
    "\n",
    "\n",
    "display(protac_df)\n",
    "display(remove_duplicates(protac_df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "pDC50_threshold = 6.0\n",
    "Dmax_threshold = 0.6\n",
    "protac_df['Active'] = protac_df.apply(\n",
    "    lambda x: pdp.is_active(x['DC50 (nM)'], x['Dmax (%)'], pDC50_threshold=pDC50_threshold, Dmax_threshold=Dmax_threshold), axis=1\n",
    ")\n",
    "protac_df['E3 Ligase'] = protac_df['E3 Ligase'].str.replace('Iap', 'IAP')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "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>Uniprot</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>E3 Ligase Uniprot</th>\n",
       "      <th>Active</th>\n",
       "      <th>Database</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Smiles, Uniprot, Cell Line Identifier, E3 Ligase Uniprot, Active, Database]\n",
       "Index: []"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get all entries with same ['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase Uniprot'] columns\n",
    "tmp = protac_df.dropna(subset=['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase Uniprot', 'Active'])[['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase Uniprot', 'Active', 'Database']]\n",
    "\n",
    "# Get entries with duplicates\n",
    "duplicates = tmp[tmp.duplicated(subset=['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase Uniprot', 'Active'], keep=False)]\n",
    "# Sort duplicates, so that they appear close to each other\n",
    "duplicates = duplicates.sort_values(['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase Uniprot', 'Active'])\n",
    "duplicates.to_csv('duplicates.csv', index=False)\n",
    "duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>Uniprot</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>Active</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...</td>\n",
       "      <td>Q07817</td>\n",
       "      <td>MOLT-4</td>\n",
       "      <td>VHL</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129</th>\n",
       "      <td>O=C1CCC(N2Cc3c(NC(=O)CCCCCCCN4CCN(c5ccc(Nc6cc7...</td>\n",
       "      <td>P00533</td>\n",
       "      <td>HCC827</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>137</th>\n",
       "      <td>Cc1ncsc1-c1ccc(CNC(=O)[C@@H]2C[C@@H](O)CN2C(=O...</td>\n",
       "      <td>P00533</td>\n",
       "      <td>HCC827</td>\n",
       "      <td>VHL</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>175</th>\n",
       "      <td>Cc1ncsc1-c1ccc(CNC(=O)[C@@H]2C[C@@H](O)CN2C(=O...</td>\n",
       "      <td>O43353</td>\n",
       "      <td>THP-1</td>\n",
       "      <td>VHL</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>178</th>\n",
       "      <td>Nc1ncnc2c1c(-c1ccc(Oc3ccccc3)cc1)nn2C1CCN(CCCC...</td>\n",
       "      <td>Q06187</td>\n",
       "      <td>Namalwa</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1578</th>\n",
       "      <td>C=C(F)C(=O)N1CCN(c2nc(OC[C@@H]3CCCN3CCC(=O)NCC...</td>\n",
       "      <td>P01116</td>\n",
       "      <td>NCI-H2030</td>\n",
       "      <td>VHL</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1641</th>\n",
       "      <td>CCn1c(=O)n(CC(=O)NCCOCCNC(=O)COc2cccc3c2C(=O)N...</td>\n",
       "      <td>O00418</td>\n",
       "      <td>MDA-MB-231</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2034</th>\n",
       "      <td>O=C1CCC(N2C(=O)c3cccc(NCCCCCCCC(=O)Nc4ccc(N5Cc...</td>\n",
       "      <td>P14174</td>\n",
       "      <td>A549 Cas9</td>\n",
       "      <td>CRBN</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2120</th>\n",
       "      <td>Cc1sc2c(c1C)C(c1ccc(Cl)cc1)=N[C@@H](CC(=O)NCCO...</td>\n",
       "      <td>O60885</td>\n",
       "      <td>HEK293T</td>\n",
       "      <td>FEM1B</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2121</th>\n",
       "      <td>Cc1sc2c(c1C)C(c1ccc(Cl)cc1)=N[C@@H](CC(=O)NCCO...</td>\n",
       "      <td>O60885</td>\n",
       "      <td>HEK293T</td>\n",
       "      <td>FEM1B</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>112 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                 Smiles Uniprot  \\\n",
       "4     Cc1ncsc1-c1ccc([C@H](C)NC(=O)[C@@H]2C[C@@H](O)...  Q07817   \n",
       "129   O=C1CCC(N2Cc3c(NC(=O)CCCCCCCN4CCN(c5ccc(Nc6cc7...  P00533   \n",
       "137   Cc1ncsc1-c1ccc(CNC(=O)[C@@H]2C[C@@H](O)CN2C(=O...  P00533   \n",
       "175   Cc1ncsc1-c1ccc(CNC(=O)[C@@H]2C[C@@H](O)CN2C(=O...  O43353   \n",
       "178   Nc1ncnc2c1c(-c1ccc(Oc3ccccc3)cc1)nn2C1CCN(CCCC...  Q06187   \n",
       "...                                                 ...     ...   \n",
       "1578  C=C(F)C(=O)N1CCN(c2nc(OC[C@@H]3CCCN3CCC(=O)NCC...  P01116   \n",
       "1641  CCn1c(=O)n(CC(=O)NCCOCCNC(=O)COc2cccc3c2C(=O)N...  O00418   \n",
       "2034  O=C1CCC(N2C(=O)c3cccc(NCCCCCCCC(=O)Nc4ccc(N5Cc...  P14174   \n",
       "2120  Cc1sc2c(c1C)C(c1ccc(Cl)cc1)=N[C@@H](CC(=O)NCCO...  O60885   \n",
       "2121  Cc1sc2c(c1C)C(c1ccc(Cl)cc1)=N[C@@H](CC(=O)NCCO...  O60885   \n",
       "\n",
       "     Cell Line Identifier E3 Ligase Active  \n",
       "4                  MOLT-4       VHL   True  \n",
       "129                HCC827      CRBN   True  \n",
       "137                HCC827       VHL   True  \n",
       "175                 THP-1       VHL   True  \n",
       "178               Namalwa      CRBN   True  \n",
       "...                   ...       ...    ...  \n",
       "1578            NCI-H2030       VHL  False  \n",
       "1641           MDA-MB-231      CRBN  False  \n",
       "2034            A549 Cas9      CRBN   True  \n",
       "2120              HEK293T     FEM1B   True  \n",
       "2121              HEK293T     FEM1B   True  \n",
       "\n",
       "[112 rows x 5 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "count    55.000000\n",
       "mean      2.036364\n",
       "std       0.188919\n",
       "min       2.000000\n",
       "25%       2.000000\n",
       "50%       2.000000\n",
       "75%       2.000000\n",
       "max       3.000000\n",
       "Name: Count, dtype: float64"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get all entries with same ['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase'] columns\n",
    "tmp = protac_df.dropna(subset=['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', 'Active'])\n",
    "tmp = tmp.groupby(['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', 'Active']).size()\n",
    "tmp = tmp[tmp > 1]\n",
    "tmp = protac_df[\n",
    "    protac_df.apply(lambda x: (x['Smiles'], x['Uniprot'], x['Cell Line Identifier'], x['E3 Ligase'], x['Active']) in\n",
    "        tmp.index, axis=1)\n",
    "]\n",
    "display(tmp[['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', 'Active']])\n",
    "\n",
    "# Display the tmp entries ['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase'] with an additional column with their repetition count\n",
    "tmp = tmp[['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', 'Active']]\n",
    "tmp['Count'] = tmp.groupby(['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', 'Active'])['Smiles'].transform('count')\n",
    "tmp = tmp.drop_duplicates()\n",
    "tmp['Count'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_duplicates(df, active_col = 'Active (Dmax 0.6, pDC50 6.0)'):\n",
    "    tmp = df.dropna(subset=['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', active_col])\n",
    "    tmp = tmp.groupby(['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', active_col]).size()\n",
    "    tmp = tmp[tmp > 1]\n",
    "    tmp = df[\n",
    "        df.apply(lambda x: (x['Smiles'], x['Uniprot'], x['Cell Line Identifier'], x['E3 Ligase'], x[active_col]) in\n",
    "            tmp.index, axis=1)\n",
    "    ]\n",
    "    # display(tmp[['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', active_col]])\n",
    "\n",
    "    # Get entries with duplicates\n",
    "    duplicates = tmp[tmp.duplicated(subset=['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase Uniprot', active_col], keep=False)]\n",
    "    # Sort duplicates, so that they appear close to each other\n",
    "    duplicates = duplicates.sort_values(['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase Uniprot', active_col])\n",
    "    print(f'Duplicated entries (len {len(duplicates)} ({len(duplicates) / len(df):.4%})):')\n",
    "    display(duplicates[['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', active_col]])\n",
    "\n",
    "    # Display the tmp entries ['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase'] with an additional column with their repetition count\n",
    "    tmp = tmp[['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', active_col]]\n",
    "    tmp['Count'] = tmp.groupby(['Smiles', 'Uniprot', 'Cell Line Identifier', 'E3 Ligase', active_col])['Smiles'].transform('count')\n",
    "    tmp = tmp.drop_duplicates()\n",
    "    print(tmp['Count'].describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "--------------------------------------------------------------------------------\n",
      "Study: standard\n",
      "--------------------------------------------------------------------------------\n",
      "Test:\n",
      "Duplicated entries (len 0 (0.0000%)):\n"
     ]
    },
    {
     "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>Uniprot</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>Active (Dmax 0.6, pDC50 6.0)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Smiles, Uniprot, Cell Line Identifier, E3 Ligase, Active (Dmax 0.6, pDC50 6.0)]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    0.0\n",
      "mean     NaN\n",
      "std      NaN\n",
      "min      NaN\n",
      "25%      NaN\n",
      "50%      NaN\n",
      "75%      NaN\n",
      "max      NaN\n",
      "Name: Count, dtype: float64\n",
      "--------------------------------------------------------------------------------\n",
      "Train/Val:\n",
      "Duplicated entries (len 0 (0.0000%)):\n"
     ]
    },
    {
     "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>Uniprot</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>Active (Dmax 0.6, pDC50 6.0)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Smiles, Uniprot, Cell Line Identifier, E3 Ligase, Active (Dmax 0.6, pDC50 6.0)]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    0.0\n",
      "mean     NaN\n",
      "std      NaN\n",
      "min      NaN\n",
      "25%      NaN\n",
      "50%      NaN\n",
      "75%      NaN\n",
      "max      NaN\n",
      "Name: Count, dtype: float64\n",
      "--------------------------------------------------------------------------------\n",
      "--------------------------------------------------------------------------------\n",
      "Study: similarity\n",
      "--------------------------------------------------------------------------------\n",
      "Test:\n",
      "Duplicated entries (len 0 (0.0000%)):\n"
     ]
    },
    {
     "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>Uniprot</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>Active (Dmax 0.6, pDC50 6.0)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Smiles, Uniprot, Cell Line Identifier, E3 Ligase, Active (Dmax 0.6, pDC50 6.0)]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    0.0\n",
      "mean     NaN\n",
      "std      NaN\n",
      "min      NaN\n",
      "25%      NaN\n",
      "50%      NaN\n",
      "75%      NaN\n",
      "max      NaN\n",
      "Name: Count, dtype: float64\n",
      "--------------------------------------------------------------------------------\n",
      "Train/Val:\n",
      "Duplicated entries (len 0 (0.0000%)):\n"
     ]
    },
    {
     "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>Uniprot</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>Active (Dmax 0.6, pDC50 6.0)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Smiles, Uniprot, Cell Line Identifier, E3 Ligase, Active (Dmax 0.6, pDC50 6.0)]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    0.0\n",
      "mean     NaN\n",
      "std      NaN\n",
      "min      NaN\n",
      "25%      NaN\n",
      "50%      NaN\n",
      "75%      NaN\n",
      "max      NaN\n",
      "Name: Count, dtype: float64\n",
      "--------------------------------------------------------------------------------\n",
      "--------------------------------------------------------------------------------\n",
      "Study: target\n",
      "--------------------------------------------------------------------------------\n",
      "Test:\n",
      "Duplicated entries (len 0 (0.0000%)):\n"
     ]
    },
    {
     "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>Uniprot</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>Active (Dmax 0.6, pDC50 6.0)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Smiles, Uniprot, Cell Line Identifier, E3 Ligase, Active (Dmax 0.6, pDC50 6.0)]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    0.0\n",
      "mean     NaN\n",
      "std      NaN\n",
      "min      NaN\n",
      "25%      NaN\n",
      "50%      NaN\n",
      "75%      NaN\n",
      "max      NaN\n",
      "Name: Count, dtype: float64\n",
      "--------------------------------------------------------------------------------\n",
      "Train/Val:\n",
      "Duplicated entries (len 0 (0.0000%)):\n"
     ]
    },
    {
     "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>Uniprot</th>\n",
       "      <th>Cell Line Identifier</th>\n",
       "      <th>E3 Ligase</th>\n",
       "      <th>Active (Dmax 0.6, pDC50 6.0)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Smiles, Uniprot, Cell Line Identifier, E3 Ligase, Active (Dmax 0.6, pDC50 6.0)]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    0.0\n",
      "mean     NaN\n",
      "std      NaN\n",
      "min      NaN\n",
      "25%      NaN\n",
      "50%      NaN\n",
      "75%      NaN\n",
      "max      NaN\n",
      "Name: Count, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "active_col = 'Active (Dmax 0.6, pDC50 6.0)'\n",
    "studies_dir = 'data/studies'\n",
    "train_val_perc = f'{int((1 - test_split) * 100)}'\n",
    "test_perc = f'{int(test_split * 100)}'\n",
    "active_name = active_col.replace(' ', '_').replace('(', '').replace(')', '').replace(',', '')\n",
    "\n",
    "experiments = ['standard', 'similarity', 'target']\n",
    "\n",
    "for split_type in experiments:\n",
    "\n",
    "    train_val_filename = f'{split_type}_train_val_{train_val_perc}split_{active_name}.csv'\n",
    "    test_filename = f'{split_type}_test_{test_perc}split_{active_name}.csv'\n",
    "    \n",
    "    train_val_df = pd.read_csv(os.path.join(studies_dir, train_val_filename))\n",
    "    test_df = pd.read_csv(os.path.join(studies_dir, test_filename))\n",
    "\n",
    "    print('-' * 80)\n",
    "    print('-' * 80)\n",
    "    print(f'Study: {split_type}')\n",
    "    print('-' * 80)\n",
    "    print('Test:')\n",
    "    print_duplicates(test_df)\n",
    "    print('-' * 80)\n",
    "    print('Train/Val:')\n",
    "    print_duplicates(train_val_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1138, 1138)"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "cell2embedding = pdp.load_cell2embedding('../data/cell2embedding.pkl')\n",
    "\n",
    "# Get one-hot encoded embeddings for cell lines\n",
    "onehotenc = OneHotEncoder(sparse_output=False)\n",
    "cell_embeddings = onehotenc.fit_transform(\n",
    "    np.array(list(cell2embedding.keys())).reshape(-1, 1)\n",
    ")\n",
    "cell_embeddings.shape\n",
    "# cell2embedding = {k: v for k, v in zip(cell2embedding.keys(), cell_embeddings)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}