diff --git a/04_add_cancer_types/plot_add_cancer_results.ipynb b/04_add_cancer_types/plot_add_cancer_results.ipynb
new file mode 100644
index 0000000..cbf705d
--- /dev/null
+++ b/04_add_cancer_types/plot_add_cancer_results.ipynb
@@ -0,0 +1,1121 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Add cancer analysis\n",
+    "\n",
+    "Analysis of results from `run_add_cancer_classification.py`.\n",
+    "\n",
+    "We hypothesized that adding cancers in a principled way (e.g. by similarity to the target cancer) would lead to improved performance relative to both a single-cancer model (using only the target cancer type), and a pan-cancer model using all cancer types without regard for similarity to the target cancer.\n",
+    "\n",
+    "Script parameters:\n",
+    "* RESULTS_DIR: directory to read experiment results from\n",
+    "* IDENTIFIER: {gene}\\_{cancer_type} target identifier to plot results for"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "import pancancer_evaluation.config as cfg\n",
+    "import pancancer_evaluation.utilities.analysis_utilities as au"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RESULTS_DIR = os.path.join(cfg.repo_root, 'add_cancer_results', 'add_cancer')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(10272, 12)\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>auroc</th>\n",
+       "      <th>aupr</th>\n",
+       "      <th>gene</th>\n",
+       "      <th>holdout_cancer_type</th>\n",
+       "      <th>signal</th>\n",
+       "      <th>seed</th>\n",
+       "      <th>data_type</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>num_train_cancer_types</th>\n",
+       "      <th>how_to_add</th>\n",
+       "      <th>identifier</th>\n",
+       "      <th>train_cancer_types</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.98128</td>\n",
+       "      <td>0.96627</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>train</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>similarity</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>UCEC COAD THCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.74925</td>\n",
+       "      <td>0.44968</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>similarity</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>UCEC COAD THCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.93750</td>\n",
+       "      <td>0.89993</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>cv</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>similarity</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>UCEC COAD THCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.98493</td>\n",
+       "      <td>0.97138</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>train</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>similarity</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>UCEC COAD THCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.64394</td>\n",
+       "      <td>0.45539</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>similarity</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>UCEC COAD THCA</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     auroc     aupr  gene holdout_cancer_type  signal  seed data_type  fold  \\\n",
+       "0  0.98128  0.96627  BRAF                COAD  signal    42     train     0   \n",
+       "1  0.74925  0.44968  BRAF                COAD  signal    42      test     0   \n",
+       "2  0.93750  0.89993  BRAF                COAD  signal    42        cv     0   \n",
+       "3  0.98493  0.97138  BRAF                COAD  signal    42     train     1   \n",
+       "4  0.64394  0.45539  BRAF                COAD  signal    42      test     1   \n",
+       "\n",
+       "   num_train_cancer_types  how_to_add identifier train_cancer_types  \n",
+       "0                       2  similarity  BRAF_COAD     UCEC COAD THCA  \n",
+       "1                       2  similarity  BRAF_COAD     UCEC COAD THCA  \n",
+       "2                       2  similarity  BRAF_COAD     UCEC COAD THCA  \n",
+       "3                       2  similarity  BRAF_COAD     UCEC COAD THCA  \n",
+       "4                       2  similarity  BRAF_COAD     UCEC COAD THCA  "
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "add_cancer_df = au.load_add_cancer_results(RESULTS_DIR, load_cancer_types=True)\n",
+    "print(add_cancer_df.shape)\n",
+    "add_cancer_df.sort_values(by=['gene', 'holdout_cancer_type']).head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load data from previous single-cancer and pan-cancer experiments\n",
+    "# this is to put the add cancer results in the context of our previous results\n",
+    "pancancer_dir = os.path.join(cfg.results_dir, 'pancancer')\n",
+    "pancancer_dir2 = os.path.join(cfg.results_dir, 'vogelstein_s1_results', 'pancancer')\n",
+    "single_cancer_dir = os.path.join(cfg.results_dir, 'single_cancer')\n",
+    "single_cancer_dir2 = os.path.join(cfg.results_dir, 'vogelstein_s1_results', 'single_cancer')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(20772, 10)\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>auroc</th>\n",
+       "      <th>aupr</th>\n",
+       "      <th>gene</th>\n",
+       "      <th>holdout_cancer_type</th>\n",
+       "      <th>signal</th>\n",
+       "      <th>seed</th>\n",
+       "      <th>data_type</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>train_set</th>\n",
+       "      <th>identifier</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.99987</td>\n",
+       "      <td>0.99879</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>train</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single_cancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.72689</td>\n",
+       "      <td>0.46638</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single_cancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.72844</td>\n",
+       "      <td>0.38910</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>cv</td>\n",
+       "      <td>0</td>\n",
+       "      <td>single_cancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.99860</td>\n",
+       "      <td>0.98630</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>train</td>\n",
+       "      <td>1</td>\n",
+       "      <td>single_cancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.74887</td>\n",
+       "      <td>0.48700</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>1</td>\n",
+       "      <td>single_cancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     auroc     aupr    gene holdout_cancer_type  signal  seed data_type  fold  \\\n",
+       "0  0.99987  0.99879  MAP3K1                BRCA  signal    42     train     0   \n",
+       "1  0.72689  0.46638  MAP3K1                BRCA  signal    42      test     0   \n",
+       "2  0.72844  0.38910  MAP3K1                BRCA  signal    42        cv     0   \n",
+       "3  0.99860  0.98630  MAP3K1                BRCA  signal    42     train     1   \n",
+       "4  0.74887  0.48700  MAP3K1                BRCA  signal    42      test     1   \n",
+       "\n",
+       "       train_set   identifier  \n",
+       "0  single_cancer  MAP3K1_BRCA  \n",
+       "1  single_cancer  MAP3K1_BRCA  \n",
+       "2  single_cancer  MAP3K1_BRCA  \n",
+       "3  single_cancer  MAP3K1_BRCA  \n",
+       "4  single_cancer  MAP3K1_BRCA  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "single_cancer_df1 = au.load_prediction_results(single_cancer_dir, 'single_cancer')\n",
+    "single_cancer_df2 = au.load_prediction_results(single_cancer_dir2, 'single_cancer')\n",
+    "single_cancer_df = pd.concat((single_cancer_df1, single_cancer_df2))\n",
+    "print(single_cancer_df.shape)\n",
+    "single_cancer_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(20784, 10)\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>auroc</th>\n",
+       "      <th>aupr</th>\n",
+       "      <th>gene</th>\n",
+       "      <th>holdout_cancer_type</th>\n",
+       "      <th>signal</th>\n",
+       "      <th>seed</th>\n",
+       "      <th>data_type</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>train_set</th>\n",
+       "      <th>identifier</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.95820</td>\n",
+       "      <td>0.68399</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>train</td>\n",
+       "      <td>0</td>\n",
+       "      <td>pancancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.69619</td>\n",
+       "      <td>0.40796</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>0</td>\n",
+       "      <td>pancancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.62527</td>\n",
+       "      <td>0.20878</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>cv</td>\n",
+       "      <td>0</td>\n",
+       "      <td>pancancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.98367</td>\n",
+       "      <td>0.82884</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>train</td>\n",
+       "      <td>1</td>\n",
+       "      <td>pancancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.77170</td>\n",
+       "      <td>0.44885</td>\n",
+       "      <td>MAP3K1</td>\n",
+       "      <td>BRCA</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>1</td>\n",
+       "      <td>pancancer</td>\n",
+       "      <td>MAP3K1_BRCA</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     auroc     aupr    gene holdout_cancer_type  signal  seed data_type  fold  \\\n",
+       "0  0.95820  0.68399  MAP3K1                BRCA  signal    42     train     0   \n",
+       "1  0.69619  0.40796  MAP3K1                BRCA  signal    42      test     0   \n",
+       "2  0.62527  0.20878  MAP3K1                BRCA  signal    42        cv     0   \n",
+       "3  0.98367  0.82884  MAP3K1                BRCA  signal    42     train     1   \n",
+       "4  0.77170  0.44885  MAP3K1                BRCA  signal    42      test     1   \n",
+       "\n",
+       "   train_set   identifier  \n",
+       "0  pancancer  MAP3K1_BRCA  \n",
+       "1  pancancer  MAP3K1_BRCA  \n",
+       "2  pancancer  MAP3K1_BRCA  \n",
+       "3  pancancer  MAP3K1_BRCA  \n",
+       "4  pancancer  MAP3K1_BRCA  "
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pancancer_df1 = au.load_prediction_results(pancancer_dir, 'pancancer')\n",
+    "pancancer_df2 = au.load_prediction_results(pancancer_dir2, 'pancancer')\n",
+    "pancancer_df = pd.concat((pancancer_df1, pancancer_df2))\n",
+    "print(pancancer_df.shape)\n",
+    "pancancer_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "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>identifier</th>\n",
+       "      <th>delta_mean</th>\n",
+       "      <th>p_value</th>\n",
+       "      <th>corr_pval</th>\n",
+       "      <th>reject_null</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>329</th>\n",
+       "      <td>SMAD4_HNSC</td>\n",
+       "      <td>0.319513</td>\n",
+       "      <td>0.000004</td>\n",
+       "      <td>0.001648</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>56</th>\n",
+       "      <td>ARID1A_STAD</td>\n",
+       "      <td>0.110541</td>\n",
+       "      <td>0.000184</td>\n",
+       "      <td>0.027420</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>241</th>\n",
+       "      <td>FBXW7_LUSC</td>\n",
+       "      <td>0.317024</td>\n",
+       "      <td>0.000127</td>\n",
+       "      <td>0.027420</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>242</th>\n",
+       "      <td>NF1_SARC</td>\n",
+       "      <td>0.405654</td>\n",
+       "      <td>0.000442</td>\n",
+       "      <td>0.039537</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>154</th>\n",
+       "      <td>KDM5C_KIRC</td>\n",
+       "      <td>-0.349511</td>\n",
+       "      <td>0.000394</td>\n",
+       "      <td>0.039537</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>375</th>\n",
+       "      <td>NF1_BLCA</td>\n",
+       "      <td>0.201823</td>\n",
+       "      <td>0.000560</td>\n",
+       "      <td>0.041698</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>427</th>\n",
+       "      <td>JAK2_UCEC</td>\n",
+       "      <td>0.394205</td>\n",
+       "      <td>0.000854</td>\n",
+       "      <td>0.054526</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>412</th>\n",
+       "      <td>BRAF_SKCM</td>\n",
+       "      <td>-0.186559</td>\n",
+       "      <td>0.001091</td>\n",
+       "      <td>0.059650</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>160</th>\n",
+       "      <td>PPP2R1A_UCS</td>\n",
+       "      <td>0.273885</td>\n",
+       "      <td>0.001201</td>\n",
+       "      <td>0.059650</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>309</th>\n",
+       "      <td>SMAD4_LUAD</td>\n",
+       "      <td>0.212423</td>\n",
+       "      <td>0.001585</td>\n",
+       "      <td>0.063753</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      identifier  delta_mean   p_value  corr_pval  reject_null\n",
+       "329   SMAD4_HNSC    0.319513  0.000004   0.001648         True\n",
+       "56   ARID1A_STAD    0.110541  0.000184   0.027420         True\n",
+       "241   FBXW7_LUSC    0.317024  0.000127   0.027420         True\n",
+       "242     NF1_SARC    0.405654  0.000442   0.039537         True\n",
+       "154   KDM5C_KIRC   -0.349511  0.000394   0.039537         True\n",
+       "375     NF1_BLCA    0.201823  0.000560   0.041698         True\n",
+       "427    JAK2_UCEC    0.394205  0.000854   0.054526        False\n",
+       "412    BRAF_SKCM   -0.186559  0.001091   0.059650        False\n",
+       "160  PPP2R1A_UCS    0.273885  0.001201   0.059650        False\n",
+       "309   SMAD4_LUAD    0.212423  0.001585   0.063753        False"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "single_cancer_comparison_df = au.compare_results(single_cancer_df,\n",
+    "                                                 identifier='identifier',\n",
+    "                                                 metric='aupr',\n",
+    "                                                 correction=True,\n",
+    "                                                 correction_alpha=0.001,\n",
+    "                                                 verbose=False)\n",
+    "pancancer_comparison_df = au.compare_results(pancancer_df,\n",
+    "                                             identifier='identifier',\n",
+    "                                             metric='aupr',\n",
+    "                                             correction=True,\n",
+    "                                             correction_alpha=0.001,\n",
+    "                                             verbose=False)\n",
+    "experiment_comparison_df = au.compare_results(single_cancer_df,\n",
+    "                                              pancancer_df=pancancer_df,\n",
+    "                                              identifier='identifier',\n",
+    "                                              metric='aupr',\n",
+    "                                              correction=True,\n",
+    "                                              correction_alpha=0.05,\n",
+    "                                              verbose=False)\n",
+    "experiment_comparison_df.sort_values(by='corr_pval').head(n=10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plot change in performance as cancers are added"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "IDENTIFIER = 'BRAF_COAD'\n",
+    "# IDENTIFIER = 'EGFR_ESCA'\n",
+    "# IDENTIFIER = 'EGFR_LGG'\n",
+    "# IDENTIFIER = 'KRAS_CESC'\n",
+    "# IDENTIFIER = 'PIK3CA_ESCA'\n",
+    "# IDENTIFIER = 'PIK3CA_STAD'\n",
+    "# IDENTIFIER = 'PTEN_COAD'\n",
+    "# IDENTIFIER = 'PTEN_BLCA'\n",
+    "# IDENTIFIER = 'TP53_OV'\n",
+    "# IDENTIFIER = 'NF1_GBM'\n",
+    "\n",
+    "GENE = IDENTIFIER.split('_')[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'AUPR')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gene_df = add_cancer_df[(add_cancer_df.gene == GENE) &\n",
+    "                        (add_cancer_df.data_type == 'test') &\n",
+    "                        (add_cancer_df.signal == 'signal')].copy()\n",
+    "\n",
+    "# make seaborn treat x axis as categorical\n",
+    "gene_df.num_train_cancer_types = gene_df.num_train_cancer_types.astype(str)\n",
+    "gene_df.loc[(gene_df.num_train_cancer_types == '-1'), 'num_train_cancer_types'] = 'all'\n",
+    "\n",
+    "sns.set({'figure.figsize': (14, 6)})\n",
+    "sns.pointplot(data=gene_df, x='num_train_cancer_types', y='aupr', hue='identifier',\n",
+    "              order=['0', '1', '2', '4', 'all'])\n",
+    "plt.legend(bbox_to_anchor=(1.15, 0.5), loc='center right', borderaxespad=0., title='Cancer type')\n",
+    "plt.title('Adding cancer types by confusion matrix similarity, {} mutation prediction'.format(GENE), size=13)\n",
+    "plt.xlabel('Number of added cancer types', size=13)\n",
+    "plt.ylabel('AUPR', size=13)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0YAAAGECAYAAAASmzCOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAACH9UlEQVR4nOzdd1iV9f/H8SfnsIcMBTfujQtxpYSao9zzp+WoLGdq37ZmudLSbJg7G9pOU0RxlqMyzVw50NyboYIiIJtzfn+QJ0lxBRyB1+O6uODe7/twn3Pu9/1ZNmaz2YyIiIiIiEghZrB2ACIiIiIiItamxEhERERERAo9JUYiIiIiIlLoKTESEREREZFCT4mRiIiIiIgUekqMRERERESk0FNiJCJ5Jj09naioKGuHIVZ27tw5a4dgFYX1vAuy2NhYEhIScnzdgkCf95IfKTESuY1XXnkFPz8/Lly4kO06R48epVq1atku7969O8HBwQA8++yzLF68OMfjzC9efPFFNmzYYO0wOH/+PNWqVePatWvWDuUm27dvJzAwkICAAHbv3n1f+5g/fz6vvPJKDkeWMw4dOsTjjz+e7fKVK1fSt2/fHDtehw4d+PXXX+9pm4iICOrXr09iYiJ//PEHjRs3vq9jjxs3jg8//BCAr7/+munTp9/XfgD++OMPqlWrRv369alfvz716tWjU6dObN682bLOrFmzqFmzZpZ1AgICGDZsGJcuXcqyP5PJRKtWrejYseNNx/r3fq7/PPfcc3cVa2pqKnPmzOHRRx+lfv36BAUFMWXKlJveb7///jtPPvkk/v7+NGzYkL59+2b7+TBjxgyqVavG/v37b/u61K1bl3bt2rFgwQJMJtNdxftftGvXjoiIiHte90F+j97K119/Tf/+/YG7f4/e+Hm/a9cuWrVqlasxiuQEW2sHIPKgunr1Kr/88gvt2rXj+++/5/nnn//P+/z0009zILL868qVK9YO4YG3atUqmjZtyrvvvnvf+xg6dGgORpSz4uPjSUtLy3Z5586d6dy5c44db/Xq1fe8TalSpfjzzz//87EnTZpk+Tsnrn0PDw/++OMPAMxmM2vXrmXUqFFs3LgRHx8fAFq3bs3MmTMt21y8eJHnn3+et99+25KkAWzZsoVSpUpx8eJFfv/9d5o2bZrlWP/ez91KT0/nmWeewdnZmXnz5lGhQgXCw8N58803GTZsGF9++SUAoaGhvPXWW7zyyivMmTMHBwcHfv75Z8aNG8f58+d56qmnLPvMyMggODiYHj168PXXX9/03vj363LgwAFefvllrl69muvJR2xs7H2t+yC/R+/kbt+jN17zAQEBbNq0KTfDEskRKjESyUZISAgBAQH07duXJUuWkJqaCmQ+af3ggw9o3LgxzZs3v+nGa9u2bXTo0IH69eszZsyYLDeB/fv35+uvvwagVatWLFiwgHbt2tGgQQOGDBnC1atXAUhISOCFF16gQYMGtG/fntmzZ2f7tC0uLo5XXnmFgIAAyw212WwG4Msvv6RTp040aNCAhx56iFmzZlm2q1atGl9++SUtW7akUaNGvPzyy5ZzvN0+d+7cSY8ePQgICKBXr15ZnuBWq1aNiRMn0rBhQz7++OMscU6ZMoVdu3YxdepUpk6dSv/+/Zk/f75leWxsLHXq1OHixYv079+fd999l3bt2lG/fn1GjhyZ5abi22+/pW3btjRu3JjnnnvO8jQ8NTWVMWPGWP43o0aNuu0N6cKFC2nevDmPPPKI5f+yfPly2rVrl2W9kSNH8sknn9zTa79q1Srat29PgwYN6NOnD/v27QMyS6sCAgJYsGABzZo1o2nTprz99tsAjB07luXLl7NmzRo6d+58y9KKxo0bW24CFy1aRIsWLWjcuDF9+/YlLCwMyHziP2rUKACuXbvGxIkTadasGc2aNWPs2LHEx8db1nv55ZcZMmQI9evXp3379vz222+3fK1Gjx7Nu+++S58+fahXrx79+vVj//799OnTh/r16zNw4EBLNaFz584xdOhQgoKCqFOnDn369OHEiRPExMQwaNAgYmNjqV+/PleuXKF///6MHj2ahx56iMGDBxMcHEz37t0xm83079+fl156yfK/7dix4y1v1uPi4hg+fDiNGjWiZcuWjB07lpSUFCDzfXa9VKVatWosXryYoKAg/P39mTNnDsHBwTz88MM0atSIzz77zPI/yq5E8U7vqRuv/9GjRzNt2jTWr1/Pxx9/zIYNG+jZsyezZ89m4MCBWfbbvXt31qxZc8vX/lZsbGxo37499vb2nDhxItv1fHx8aNeuHceOHcsyf8mSJbRu3Zru3bvzzTff3PVx72TVqlWcOXOGmTNnUqFCBQBKly7Ne++9R5EiRbh06RLJyclMnjyZSZMm0atXL1xdXbGzs6NNmzZ88MEHvPfee8TExFj2uXnzZjw9PRk5ciQ//vgjly9fzvb4NjY21KlTh8mTJ/PFF1/cMnEJDg5m6NChjB49mvr169O2bVt27tzJSy+9RP369enQoQOHDx8Gsr6XIGsNge7duwPQq1cvNmzYQHJyMhMmTKBNmzbUq1ePtm3bWkpM/r1ubr1Hx48fT/fu3alfvz5PPvkk4eHhlnN+4okn6NWrF40bN+bMmTNEREQwdOhQGjduTNu2bVm2bJllX7GxsYwYMQJ/f386duzI0aNHs7x+18/HZDIxe/ZsSyn38OHDuXLlyk2f9//+LPviiy945JFHaNiwIQMHDuTkyZNAZglgp06deOedd2jUqBEPP/zwLT97RXKLEiORbPzwww/06NEDf39/vLy8WLduHQDfffcd69evJzg4mNWrV7N3717LNtHR0Tz33HMMGzaMHTt24Ofnl+UL5d82bNjAt99+y7p16zh9+jTff/89kPmkOSEhgZ9//pn58+ezcuXKbPcxfvx44uPj2bhxI6tWreKXX35hyZIl7Nq1i/nz5zNr1ix2797NzJkzmTNnDmfOnLFs+/vvvxMaGsrixYv57bff+PHHH2+7z4iICIYMGcKwYcPYvn07AwcOtNzoXpeSksLWrVtvqmoxduxYAgICGD16NKNHj6Zz585ZbgTXrVtHgwYNLE++V6xYwUcffcSWLVtITU1l4sSJAKxdu5YFCxYwZ84cfv31V8qWLcsLL7xg2ebEiRNs3ryZn376icTERMsT6ls5efIkP/30EzNnzuSjjz5i69attGnThqioKA4dOgRkJqm//vrrLascZfc6bdmyhXHjxjFx4kT++OMPevbsyTPPPGNJ4OLj4zl//jybN29m3rx5fPvtt/z5559MmTKFTp060b9//9v+zwHOnj3LRx99xDfffMP27dtp0qQJ77zzzk3rjRs3jpMnTxIaGsqaNWuIjo5m3LhxWV73p556ij/++IOgoCDeeuutbI8ZHBzM5MmT2bp1K9HR0QwfPpwpU6bw888/Ex4ezooVKwB44403qFixIhs3bmT79u14enoyf/58ihYtyieffIKHhwd//vknnp6eABw8eJD169fz/vvvW45lY2PDO++8w+bNm/nll1/48MMPcXZ2Zvjw4TfF9fnnn2M0Gvntt98ICQnh4MGD2b5+W7duZd26dcyaNYtZs2axZcsWfvzxR6ZPn877779vuSG9lbt5T93q+m/Xrh1DhgyhdevWLF261JL0Xr/BP3XqFKdPn76nqkYmk4lVq1bh6OhI7dq1s13vzJkzLFu2jCZNmljmXbx4kW3bttG5c2d69OjBr7/+etfVwe5ky5YtBAUF4eDgkGW+l5cXs2fPxtvbmz///JPExEQeeeSRm7Zv0qQJPj4+/PLLL5Z5S5YsoUePHpQsWZImTZrcVXXkRo0aYTQaLQ8k/m3z5s08/PDD7N69m7p16/LUU0/Rtm1b/vjjD2rUqMHcuXPveIzrVaR/+OEHWrduzWeffcaJEycIDg5m9+7ddO/e3fJ++ve6N8rJ92hISAivvfYa27dvx9fX1/LZCLBnzx5L9bYyZcowdOhQqlSpwpYtW5g5cyYffvgh27dvt8QE8Ntvv/HRRx9lqbJ5o8WLFxMSEsIXX3zBtm3bcHJyYvLkyTd93v97m88++4w5c+awdetW/P39GTRoEMnJyUBm8unu7s62bdt48803+eCDD9RWSfKMEiORW9izZw9xcXG0aNECgD59+lieqq5Zs4a+fftSunRp3N3dszxN/PnnnylfvjwdO3bEzs6Ovn37Uq5cuWyP07t3b4oWLYq3tzeBgYGcPn2a1NRU1q1bx4svvoibmxu+vr43PV2+LjU1lZ9++on//e9/uLu7U7RoUebNm0dQUBC1atUiODiY8uXLEx0dTVpaGo6Ojly8eNGy/ZNPPomrqysVKlSgfv36luNnt89Vq1bRuHFjWrduja2tLY899hhVq1Zl/fr1ln126NABe3t7XF1db/saP/roo5w6dcrytHv16tV06tTJsrxfv35Ur14dV1dX/ve///HTTz+RmprK0qVLeeqpp6hSpQoODg68+OKL7Nu3j1OnTuHm5saZM2dYvnw5V65cYcGCBbetAjl69GicnJyoVasWXbt2ZfXq1bi6utKqVStL0vbjjz9Sp04dSpYsedev/cqVK+nWrRsNGzbE1taWnj17UqlSpSztJwYNGoS9vT316tWjYsWKWW6u74aTkxNpaWksWbKEw4cP89xzz9305D85OZn169fzyiuv4OXlhbu7O6+99hpr164lKSkJgHr16tG0aVPs7e3p1KnTbeNo2bIllStXxsXFhdq1axMUFESlSpVwd3enbt26lqfTU6dOZdSoUWRkZBAREYGHh8dt2+m1atUKNzc33NzcsswvU6YMr732GmPHjuWHH35g+vTp2NreXAPczc2NgwcPsnr1atLS0ggODqZXr163PFa/fv1wcnKiSZMmmM1m+vbti6OjI4GBgWRkZNw2zrt5T93N9e/r60utWrUs75tVq1bRtm1bHB0ds90GMqv3BgQEEBAQQJ06dXjppZf4v//7vyzH2rRpEwEBAdSrV49atWoxePBg2rVrx6uvvmpZJzg4mBYtWuDl5YW3tzctW7bku+++y3Ks6/u58ScxMfG28UFmSYOXl9dt14mOjsbDwwM7O7tbLi9WrBjR0dEAREZGsnPnTrp06QLA448/zvfff096evodYylSpEi2nR2ULl2a9u3bYzAYaNSoEaVKlaJdu3bY29vTpEmT+0oU+/bty8yZM3F2diYyMhIXF5fbXk+Q8+/RTp060bhxYxwcHHj55ZfZt2+fpdMPb29vmjZtipubGwcOHCAyMpIXXngBe3t7qlevTp8+ffjhhx9ISUlh06ZNjBgxAmdnZypVqsQTTzxxy+OtXr2a/v37U7FiRezt7Rk7duwdqwmuWLGCp556iurVq2Nvb8/w4cNJTU1lx44dABiNRgYNGoStrS1t2rTB2dlZHZdInlEbI5FbWLJkCVeuXOHhhx8GMuvNx8bGEhYWRnR0NMWLF7esW6ZMGcvf/14GmV/A2bnxBsLOzg6z2czVq1dJSUmhRIkSlmWlSpW65fZXr14lLS0tyzF9fX2BzCfXc+fOZf369RQtWhQ/Pz+ALA2Sszt+dvuMiIhgy5YtBAQEWJalp6fToEEDy3SxYsWyPd8bubm50bJlS9auXUuvXr04cOAA8+bNsyy/MaEsXrw4aWlpxMbGEhkZyYwZM5g9e7ZluY2NDRERETz66KNcvnyZ4OBgpkyZQtWqVZk0aRJ16tS56fh2dnaW0imAEiVKWJ6Wdu7cmbfeeouXX36ZVatWZUnYrrvd63T58mWqV6+eZf1SpUpleep542tva2t7zw3Fvb29+eSTT/j0009ZtGgR7u7uPP/88/To0cOyTlxcHGlpaVmun9KlS2M2my038/+O43pVwFtxd3e3/G00GilSpIhl2mAwWLY9efIk06dP58KFC1SuXBkbG5vb7vd210zHjh2ZNm0a9erVy/Yhw1NPPUVqaiqff/45r7/+Og0aNGDy5MmUL18+23MwGo0AlnMwGDKfE97u/2AwGO74nrrb6/96ienjjz/OqlWrspQQZMfd3d1SjRIyO7IYNWoURYoU4emnnwYyk8yZM2eSkZHBN998w/z582nRogX29vZAZhucpUuXcvnyZZo1awZAUlIS9vb2jBgxwlLSc30/9+rGpObfYmJiKFq0KMWKFSMmJobU1FRLXDeKiIiwvI5Lly4lNTWV9u3bW+KPiYlhw4YNPProo9nGkZGRQVxc3E0PNK7z8PCw/G00GrMk5QaD4b46boiPj2fixIns37+fsmXLUrZs2dte95Dz79Hrn0GQeb04Oztb/h/e3t6WZRERESQkJNCoUSPLvIyMDGrVqkVsbOxNn23ZfY9FR0dn+a7y8vK6Y2IcExOT5XwNBgMlS5bkwoUL+Pr64ubmliVpvp/PR5H7pcRI5F/i4+NZt24dixYtyvIlM2XKFL7++mt8fHyyPE288Ymgj4+P5an5rZbfDS8vL+zt7YmMjLRUNcpuH15eXtjZ2XHhwgXLulu2bCE2Npbw8HCOHj3Khg0bcHNzIy0t7a7aMNxun97e3rRv3z5L4+dz585Z1oPMJOVuderUiZkzZ+Lu7k5QUFCWJ983PoWPiIjA0dERDw8PvL29GThwID179rQsP3HiBGXLluX06dM0adKEJ554gitXrjBnzhxeffVVSzXIG11PtK7fIEVERFi+rJs3b05iYiK///47e/bsydJo/W5ep5IlS950HZw/fx5/f/+7fm0g84btxjZqaWlplnYvly9fxtnZmc8++4yUlBTWrVvHa6+9RvPmzS3rFytWDHt7e8LDwy03K+fPn8dgMGT5n92tu/nfpqamMmLECN555x3Ljevs2bOz3NDfy36nT59OvXr1OHr0KGvWrLHcIN/o2LFjdOnShWHDhnHhwgXefvtt3nrrLUuboXs9h+wsXLjwju+pu91/+/btmTZtGr///jvXrl3LUtXtbtWsWZM2bdqwbds2S2J0ndFoZMCAAYSHhzNs2DBCQkIoWrQoW7duJSkpiXXr1mWJtWfPnqxevdrSduR+BQYGMm3aNJKTk7OUgF2+fJmgoCA+/fRTGjRoQJEiRQgNDc2SyMM/76GHH34Yk8nEsmXLePfdd7PcwH/++ed88803t02Mdu7ciclkokqVKv/pfAwGg6XtJdy+s4Xx48dTqVIl5s+fj62tLTt37mTt2rW33X9Ov0dv/Ny8cuUKiYmJlChRglOnTmVZz8fHh+LFi/Pzzz9b5kVHR2M2m3F3d8fOzo6IiIg7fgcVL148y7Jz586xYsUKRowYkW2MpUqVyvL5aDKZiIiIoGjRovd0riK5QVXpRP5lxYoV+Pr60qBBA7y9vS0/128cAgMD+eKLLzh58iQJCQlZnqq2aNGCqKgoS1WPH3744bYNo2/FaDTSpUsXPvroIxISEggPD2fhwoXZrtu+fXtmzpxJQkICly5d4t133yU5OZmEhATs7Oyws7Pj2rVrTJs2jbS0tDtWQbndPjt06MDmzZv5/fffMZvN7N69m86dO3PgwIG7Ojd7e/ssVVuCgoK4cOECP/zww02lMl9//TXnzp0jPj6eGTNmWKoodevWjYULF3LmzBlMJhNfffUV//d//0dSUhIbN27kpZdeIjo6Gnd3d1xcXLI8Gf639957j6SkJPbu3cuKFSssN2l2dnY89thjTJ06lWbNmmUpKbmb16lr166EhISwc+dO0tPTWbp0KcePH7+pbcGd+Pr6kpSUxE8//UR6ejqffPKJ5f8XHh7O008/zcGDB3FwcMDT0xMHBwecnZ0t2xsMBjp37sx7773H5cuXuXr1Ku+++y5BQUFZSntyUlpaGikpKTg5OQGwd+9evv/+e0uCZ29vT2pqapabzexs27aNlStXMmXKFN544w0mTpx4y9KIJUuWMH78eBISEvD09LQk0Tntft9TcPO17+XlRdOmTZk6dSrt27e3lGDdi7Nnz7Jx40bq16+f7TovvfQSLi4ulnYpS5Ys4bHHHsPHxyfL51uXLl0sHZD8F4899hilS5fmf//7H2fPngUyH1yMGDGCBg0a0LhxY+zt7Rk/fjxTp07lhx9+ICEhgaSkJNavX89rr73GCy+8QLFixfjll19ISkqibdu2WWL9v//7P3bs2MGRI0duOr7ZbGbPnj2MHz+eQYMG3VQ9815VqFCBPXv2cPbsWRISEli0aFGW5XZ2dpb/a0JCAo6OjhiNRiIjI/noo48ALNf+jetel9Pv0ZUrV3Lo0CFSUlJ49913adKkyS1LzerWrYujoyOffvopaWlpREVF8fTTT/PNN99gb2/PY489xgcffEBcXBynT5/m22+/veXxOnXqxNdff83Zs2dJSUlh5syZnD59Grj5mr+ua9eufPHFFxw5coTU1FRLe677eTggktOUGIn8y5IlS27Z0P6hhx7C09MTs9nM//3f/9G3b19at26dpeGzl5cX8+fP57vvvrN0T3pjNbO79eqrr2Jvb09gYCCDBw8mICAg2/r4b775Ju7u7rRt25auXbvSpk0bevXqxdNPP42trS1NmzalXbt2pKam4u/vf1eJWnb7LF++PDNmzGD69Ok0aNCA1157jTFjxtzU1W92OnbsyMcff8ybb74JZH5xtmvXjqioKEu1xevq1avHsGHDaNmyJd7e3owdOxaALl260KtXLwYNGkRAQAArVqzg448/xt3dnQEDBlCnTh1Lr2F79uy5ZYcE149drFgxAgMDeeWVVxg/fnyWKnedOnXi8OHDt6xGd6fXKSAggIkTJzJ+/HgaNmzI999/zyeffJJttZ7s+Pj48MorrzBlyhQeeughEhISqFmzJgC1a9fmpZdeYuTIkdSrV4+pU6cyY8aMm24Ex4wZQ/ny5encuTOtW7fG09PzP3UFficuLi5MnDiRN954gwYNGjBx4kT69OnDmTNnSE9Pp1q1alSuXNnSM1Z2EhISeP3113nhhRcoWbIkjz76KP7+/pZr50YvvPACLi4uPPLIIzRp0oSrV68yZsyYHD+3//KeatGiBUePHs3S4+G/r7Fdu3bdNsm53pvf9Z++ffvyyCOPMGTIkGy3sbe3Z/Lkyaxbt441a9awadOmW36+de3alYMHD/7nbsqNRiOfffYZvr6+PPXUU9SvX59BgwZRt25d5s6daymleuyxx5gzZw7r1q2jZcuWNG/enC+//JKJEyfyzDPPAJmfxe3atbvps69ChQrUq1fP0qbuxtelYcOGjB8/nv79+2dp/3m/WrduTatWrejVqxedO3cmKCgoy/Lu3bvz9NNPs3z5csaMGcPPP/+Mv78//fr1IygoCGdnZ8v1ceO6N8rJ96i/vz/jx4+nadOmXL16NUuHJjeys7NjwYIF7Nixg+bNm9O9e3dLL5+QWfrl4eFBixYtGDRoULYdg/To0YMePXrw1FNPERgYSHp6uqVa6L8/76/r0qULAwcO5LnnnqNx48bs2LGDhQsXZnmoI2ItNuY7VYAVkTy3c+dO/Pz8LE/dv/32W1auXGnpta4gmTdvHpGRkVnGfOnfvz/t2rWjX79+VovrwoULdOjQga1bt97Uw5ZITti9ezdjx47NUtVz1KhR99W2R2T06NF4enry2muvWTsUkXxLJUYiD6D58+czd+5cMjIyuHjxIosXL87SdqQguHz5Mvv372fx4sVZ2gtZm8lk4ujRo8yYMYPOnTsrKZIcl5yczJEjR5g7d26W3vPOnTtHrVq1rBiZiEjhps4XRB5AEyZMYPz48TRu3Bg7Ozs6duzI4MGDrR1Wjtq1axevvvoqTzzxxC17jbMWGxsbBgwYQIkSJW7ZeF/yv4SEBPbs2ZNjY/fcCx8fH8qWLUufPn2oU6dOlvGOypYte9tqcQ+Cnj17Zlt1sEGDBnz66ad5HJGISM5RVToRESk0IiMjadmyJR4eHvj6+lq66c4LZrOZyMhITp06xaZNm/5zj2kiIpKzVGIkIiKFQkpKCq1ataJ///6Wzjys4bPPPqNVq1bs27fvjmO+iIhI3ikwJUYmk4mMjAJxKiIikgsOHDjAE088zoEDYdYOhbZtW/Pqq6/RunUba4ciIlKo2NllPzxCgSkxysgwExubaO0wRETkAXXq1Dm8vX2yfFfs2bOLFSuWMXHiP926z5s3i3LlytOgQUNmz57BlSuXSUlJoVq1Gjz//EvY2dnRokUT/Pyyto0bP34y3t4+7Nu3l4ULF5Cenk5ycjLt23eie/deWdYtWtSHkyfP6ntLRCSPeXtnP75ZridGJpOJCRMmcOTIEct4CuXKlbMsX7hwIUuXLrVUJ5g4cSLly5e/7TYiIiL34/o4OndiMmUwZsxLvPTSGGrV8gNgxoz3+PTT+QwbNpIiRdyZPXvBTduFh59nxox3ef/9WXh5FSUlJZmRI4dSqlRpmjR56J7jEBGRvJPridGGDRtITU1l8eLF7N27l6lTpzJv3jzL8oMHDzJt2jT8/Pws83788cfbbiMiIpKbLl68iI9PcUtSBDBs2EjuVPt8/fo1PPpoB7y8igLg4ODIBx/MtoxJJiIiD65cT4x2795NYGAgkDmSfVhY1rrdBw8eZMGCBVy6dIkWLVowZMiQO24jIiKSm0qWLEVCQnyWeTeOaRUXd5URI/7pQt/b24fx4ycTHX2JKlWqZtnO1dU1d4MVEZEckeuJUUJCQpYvBaPRSHp6Ora2mYfu0KEDTzzxBK6urowYMYLNmzffcZtbMRpt8PBwzr0TERGRfM3V1QFbW0OW74pixdwxm01Z5plMacTGRnPlSkyW+bGxsezdu5cWLVrg7u7O119/fdMxypf3JT7+SpbtDh8+DJipXr2GZZ69vS3Ozg763hIReYDkemLk6urKtWvXLNMmk8mS4JjNZp588knc3DIbQQUFBXHo0KHbbpMddb4gIiK3k5CQQnq6Kct3RdGiJTl06BDHj5+lWLFipKSksGPHDt56axo//bSBbdt2ULOmH2azmRkzZuDg4EC9eo0wm7nld05g4COMGfMyTZu2wNPTk8TERMaNG8fTTz9LiRL/tJVNTU0nMTFF31siInnMqp0v+Pv7s3nzZtq3b8/evXupWvWfKgYJCQl07NiRNWvW4OzszB9//EGPHj1ITk7OdhsREZGc4uLiysiRL/Dqq8/j4OBIenoaPXr0xte3HG+9NZUPP3yX5ORkkpKSqFXLj0GDhgM3V6UDGDp0BH5+dRg+fBRjx76CwWAgMTGRTp260rRpc2ucnoiI3INcT4zatGnD1q1b6dOnD2azmbfffpvQ0FASExPp3bs3L7zwAgMGDMDe3p6mTZsSFBSEyWS6aRsREZHcEBTUiqCgVjfNL126DO+9N/OW2/z88/Zs99eoURMaNWqSY/GJiEjeyPXEyGAwMGnSpCzzKlWqZPm7a9eudO3a9Y7biIiIiIiI5BaDtQMQERERERGxNiVGIiIiIiJS6OV6VToREZEH2cmTJ5g3b6alk4WmTZsxcOBgYmNjmTNnBlFRkZhMJnx8ijNy5AsULVrMsu17773DwYMHWLjwW8u8ESMGk5KSjIODIxkZ6ZQsWZrnn38Jd3cPK5ydiIjcLSVGIiJSaMXHxzNhwutMmTKdsmV9ycjI4M03RxMSsoyfflrH44/3IzCwBQA7d/7Bq6++wIIFizAajSQnJ3PgwD4qVKjEnj278PcPsOz3jTcmUa5ceQB+/HEt7747hSlTplvhDEVE5G6pKp2IiBQ4+45HM+2bPew7Hn3b9X777Rf8/RtStqwvkDmg+BtvTKRateq4urpakiKAhg0bU7p0Gfbt+xOATZt+okGDhrRv34ng4CXZHqNt28c4cuQwKSkp//3EREQk1ygxEhGRAidkyymOnIslZMup264XHX2JUqVKZ5nn7OxMZGQkpUqVuWn9UqVKExUVCUBoaAgdO3YlIKARR48e4dKli9kex83NjYSE+Ps4ExERyStKjEREpMBJTk3P8js7xYuX5OLFC1nmRUSE4+XlRVRUxE3rnz9/luLFS3D69ClOnTrB7NkzePnl57GxsSEkZNktj2E2m7l8OQZPT6/7PBsREckLSoxERKTQatasOX/8sY3w8PMApKenM2vWh5w8eYKYmBh+++1Xy7rbt2/j/Pnz1KvnT2hoCIMGDeeDD2bxwQez+Oij+axevZK0tLSbjrFq1QoaNGiEwaCvXBGRB5k6XxARkULLxcWVsWMnMm3aZEwmE4mJiTRrFkj37r1o1ao1H330Pl99tRAAH5/iTJ8+A5PJxMaNP7Jo0XeW/ZQoUYLKlauwefNGACZPHoejoxMA3t4+vPjia3l/ciIick+UGImISKFWvXoNZs6cf9N8T08vJkyYcsttQkLW3jTvvfdmAtC27aM5G6CIiOQJleuLiIiIiEihp8RIREREREQKPVWlExGRQmvWrA85cuQvLl+OITk5mVKlSuPh4cnFixdYsGCRZb2QkKXExMTwzDNDiIuLY86cGZw/fw6TKQMfn+K88spYXF1dgcwuwHv37srYsRNp1aq1lc5MRETulRIjEREptEaOfAGANWtCOXPmNMOGjSQyMoLx41/PdpsJE8bSpUt3goJaArB48TdMnz6FiRPfAWD16pX06vU4wcFLlBiJiOQjSoxERETuUlRUJJcvx1iSIoCePfuQlJQEZI5ZtH79GubM+ZS9e/dw8uRxKlasbK1wRUTkHigxEhER+ZfTp08xYsRgy3R0dDRt2rQjOvoSJUuWyrKu0Wi0VKPbtWsHFStWxtPTkw4dOhMc/AMvvzwmT2MXEZH7o8RIRETkX8qXr8Ds2Qss09fbGBUvXoJLly5mWTc9PZ1NmzbQtu2jhIaGEBkZwYsvjiQ9PY1jx44ydOhIS+IkIiIPLiVGIiIid8nb2wd3dw+2bPmZwMAWACxZ8h1//XWQRo2acPDgAZYsWYHRaARg2rTJrF27il69+lgtZhERuTvqrltEROQevPnmJH76aT3Dhz/LoEFPcvToYV577Q3WrVtFixatLEkRQKdOXVm+/AfMZrMVIxYRkbuhEiMRESn02rfvZPm7ZMlSWbrqBujataflbw8PDyZNeuemffTp0++meTVr+vHtt8tyLlAREck1KjESEZECI8NkYsu+CC7HpQBwOS6FLfsiMJkyS2welJKbByUOERH5h0qMRESkQMgwmZgfcpDdRy9Z5qVlmFi49jD7T8TQrJI7ly9ftmKE/4iJicbLy8vaYYiIyA1UYiQiIgXCtgNRWZKiG+0+eonolCJcuXKZ77//Jo8jy+qnn9YRFraf2rXrWTUOERHJSiVGIiJSIGzZH3nb5TuOxrJ06Up69OjEhg0/UqpUaQyGvHs+aDabuXAhil9/3cxXXy2mePHieXZsERG5MyVGIiJSIFyOT7798rhkqlRpwPr1m9m6dQtRUVF5FNk/atSoyejRb1C+fIU8P7aIiNyeEiMRESkQPF0dLJ0u3IpXEUcgs9e5nj1751VYIiKST6iNkYiIFAjF3B1vu7xe5aJ5FImIiORHSoxERCTfO3Ayhh2HL952nV2HL5GWbsqjiEREJL9RYiQiIvlaePQ15q8I4/rQQE1qFsfONvPrzc5ooOjfVehOR8Xz/cZj1gpTREQecEqMREQk34pPTGXm0n0kpWQA0NK/NIM718LLzQEAryIOvPZEfVwcM5vUbv4znN8P5n2nCyIi8uBTYiQiIvlSeoaJOcEHuBSb2RtdzfKePNG6yk3rFfNw4tmONS3TX6w7TPilhDyLU0RE8gclRiIiku+YzWa+XHeEo+evAlDCy5lhXf0wZjMuUd3KxejQtBwAqWkm5iwPIyklPc/iFRGRB58SIxERyXfW7zjHbwcyB3R1cbTl+Z51cHG0u+023QIrUqOcJwBRlxNZuPYw5usNk0REpNBTYiQiIvnK3mPR/LD5OABGgw3Du9WmuJfzHbczGGwY0rkWHq72AOw6fJENu87naqwiIpJ/KDESEZF849zFBD4OPcj1cp5+bataSoHuRhEX+7+r3NkAsGTzcY7/XR1PREQKNyVGIiKSL1y9ltkDXUpqZg90bRuWJahe6XveT5UyHvRqUQmADJOZeSvCiLuWmqOxiohI/qPESEREHnhp6RnMDt5PTFwKAHUqFeX/Wla+7/21aViWgGreAFyJT+HjlQcxmdTeSESkMFNiJCIiDzSz2czCtYc5ER4HQOliLgzpXAvD39Xh7oeNjQ1Pt69haZv015krrPjtVI7EKyIi+ZMSIxEReaCt/v0M2w9eAMDVyY5RPevg5GD7n/fr5GDLc139sLfN/CoM3Xaa/Sdi/vN+RUQkf1JiJCIiD6xdhy8S/OtJAGyNNozoXhtvD6cc238ZH1cGPFrNMv1J6EGirybl2P5FRCT/UGIkIiIPpDNR8Xy66pBl+slHq1O1rEeOH+chv5IE1SsFwLXkdOYuDyMt3ZTjxxERkQebEiMREXngXIlPYeay/aT+naA81sSXZrVL5trxnmhdhXLF3QA4HRXP9xuP5dqxRETkwfTfK2nfgclkYsKECRw5cgR7e3smT55MuXLlblrvzTffxN3dnZdffhmArl274uaW+SVVpkwZ3nnnndwOVUREHgApaRnMWrafK/GZPdDVr1KMHkGVcvWYdrZGhnfzY9KinVxLTmfzn+FULuNO01olcvW4IiLy4Mj1xGjDhg2kpqayePFi9u7dy9SpU5k3b16Wdb7//nuOHj1Kw4YNAUhJyfwy/Oqrr3I7PBEReYCYzGY+W/0Xp6PiASjr48qgTjUx2NxbD3SO9rZZft8Nbw8nnu1Yk4+W7gfgi3WH8fVxpbS36z0dW0RE8qdcr0q3e/duAgMDAahXrx5hYWFZlv/555/s27eP3r17W+YdPnyYpKQkBg4cyIABA9i7d29uhykiIg+Alb+dYtfhiwAUcbFnVI8695TcXNc1sALVfT3oGljhnrarW7kYHZpm1mpITTMxZ3kYSSnp93x8ERHJf3K9xCghIQFX13+ethmNRtLT07G1teXixYvMnj2b2bNns3btWss6jo6OPPPMM/Tq1YvTp08zaNAg1q1bh61t9uEajTZ4eDjn6rmIiEju2bI3nJVbTwNgZ2tgzJMNqeTreV/7CgrwJSjA9762faqTH2cvJnDgRAxRlxP5ZsMxXnrCH5t7LLUSEZH8JdcTI1dXV65du2aZNplMlgRn3bp1XLlyhcGDB3Pp0iWSk5OpWLEiHTt2pFy5ctjY2FChQgU8PDy4dOkSJUtm3/A2I8NMbGxibp+OiIjkghMRV5n1wz7L9NPtq1O8iIPVPtefaV+DCQt3EJuQyrYDkZTbeJQ2AWWtEouIiOQcb2+3bJflelU6f39/fv31VwD27t1L1apVLcsGDBhAcHAwX331FYMHD6Zjx450796dpUuXMnXqVAAuXLhAQkIC3t7euR2qiIhYweW4ZGYtO0B6RmYPdJ0eKk+Tmtbt9KCIiz3DuvphNGSWEi3ZdJzj4VetGpOIiOSuXE+M2rRpg729PX369OGdd95hzJgxhIaGsnjx4my36dmzJ/Hx8Tz++OO88MILvP3227etRiciIvlTcmo6Hy3dT9y1VAACqvvQ5R7bBeWWKmU86NUisze8DJOZeSFhxCWmWjkqERHJLTZms9ls7SByQlpahqrSiYjkIyazmTnBB/jzWDQA5Uq4MbqvPw52RitH9g+z2czckDB2H7kEQM3ynrz4f/UwGNTeSEQkP7JqVToREZFbCf7lpCUp8nDN7IHuQUqKAGxsbBjYvgbFPZ0AOHT6Cit+O2XlqEREJDcoMRIRkTy39UAka7afAcDe1sConnXwdHOwclS35uRgy3PdamNvm/mVGbrtNPtPxFg5KhERyWlKjEREJE8dPRfLF+sOW6af7ViT8iWKWDGiOyvj40r/dtUs05+EHiT6apIVIxIRkZymxEhERPJMdGwSs4MPkJ6R2by1W2AFAqr7WDmqu9OsdkmC6pUC4FpyOnOXh5GWbrJyVCIiklOUGImISJ5ISknno2X7SUhKA6BJzeJ0fKi8dYO6R0+0rkK54pkNd09HxfP9xmNWjkhERHKKEiMREcl1JpOZj1ceJPxS5oDflUoV4en21bGxyV+9u9nZGhnezQ8Xx8whJDb/Gc7vB6OsHJWIiOQEJUYiIpLrlmw+bumwwKuIAyN61MHO9sHqge5ueXs48WzHmpbpL9YdJvxSghUjEhGRnKDESEREctWv+yL4cec5ABzsjIzqUQd3F3srR/Xf1K1cjA5NywGQmmZizvIwklLSrRyViIj8F0qMREQk1xw+c4Wv1h8BwAYY3LkmvsWzH1wvP+kWWJEa5TwBiLqcyKK1hykgY6aLiBRKSoxERCRXXLiSyJzlB8gwZSYLPVtWon4VbytHlXMMBhsGd66Fu2tm6dfOwxfZsPu8laMSEZH7pcRIRERyXGJyGjOX7udacmb1sua1S/JoI18rR5Xz3F3sGdbFD8PfnUgs2XSc4+FXrRyViIjcDyVGIiKSozJMJuaFhBEZkwhA1TLu9G9XLd/1QHe3qpb1oFfLSgBkmMzMCwkjLjHVylGJiMi9UmIkIiI56rsNxzh4+goAxdwdGd69Nna2Bfvrpm3DsjSolllN8Ep8CgtWHsRkUnsjEZH8pGB/U4mISJ7auPs8m/aEA+DkYOT5nnUo4py/e6C7GzY2NgxsX4Pink4AHDp9hRW/nbJyVCIici+UGImISI44eOoy3204BoCNDQzp7Edpb1crR5V3nBxsea5bbez/Lh0L3XbaMnaTiIg8+JQYiYjIfxYZc425IWGY/u6uuk+rKtSpVNTKUeW9Mj6u9G9XzTL9SehBoq8mWTEiERG5W0qMRETkP0lISuOjH/ZbBjgNqleK1gFlrByV9TSrXZKgeqUAuJaczryQMNLSTVaOSkRE7kSJkYiI3Lf0DBNzlx/gYmxmqUiNcp70bVO1wPZAd7eeaF2Fcn8PZHsqMp7vNx2zckQiInInSoxEROS+mM1mvv7xKIfPxgJQ3NOJYV39sDXqq8XO1sjwbn44O9gCsHlPONsPRlk5KhERuR19e4mIyH35add5ft0XAYCzgy2jetbB1cnOylE9OLw9nHi2U03L9KJ1hwm/lGDFiERE5HaUGImIyD3bfyKaxX9XDzPY2DCsmx8li7pYOaoHT73KxejQtBwAqWkm5iwPs7TFEhGRB4sSIxERuSfnLyUwf8VB/u6Ajr5tqlCrvJd1g3qAdQ2sQHVfDwCiLieyaO1hzGYN/ioi8qBRYiQiInctLjGVmUv3k5yaAcAjDcrQ0r/w9kB3N4wGA0O6+OHumjnQ7c7DF9mw+7yVoxIRkX9TYiQiInclLd3E7OADRF9NBsCvghd9Hqls5ajyB3cXe4Z18cPwd299SzYd53j4VStHJSIiN1JiJCIid2Q2m/li3WGOn8+8mS9Z1JmhXfwwGvQ1creqlvWgV8tKAGSYzMwLCSMuMdXKUYmIyHX6RhMRkTta+8dZtoVldjft4mjL8z3r4Oxoa+Wo8p+2DcvSoJo3AFfiU/hk5UFMJrU3EhF5ECgxEhGR29pz9BLLfj4BgNFgw4jutfHxdLZyVPmTjY0NA9vXoLinEwAHT19h5dZTVo5KRERAiZGIiNzG2QvxfBJ6iOtlGv3bVaOar6dVY8rvnBxsea5bbextM7+CQ7ee5sDJGCtHJSIiSoxEROSWriakMHPZflLSMnuga9eoLA/XLWXlqAqGMj6u9G9XDQAzsGDlQaKvJlk3KBGRQk6JkYiI3CQ1LYNZwQe4HJcCQN1KRenVQj3Q5aRmtUtaEs1ryenMCwkjLd1k5ahERAovJUYiIpKF2Wxm4drDnIyIA6C0twuDO9fCYLCxcmQFT982VShX3A2AU5HxfL/pmJUjEhEpvJQYiYhIFqHbTvPHoQsAuDnb8XyPOjg5qAe63GBna2R4Nz+c/359N+8JZ/vBKCtHJSJSOCkxEhERi52HLxKyJbOXNFujDSO716GYh5OVoyrYvD2ceLZTTcv0onWHCY++ZsWIREQKJyVGIiICwKnIOD5bdcgy/dRj1alcxt2KERUe9SoXo0PTcgCkppmYu/wASSnpVo5KRKRwUWIkIiJcic/sgS7178b/HZqW4yG/klaOqnDpGliB6r4eAETGJPLFusOYzRr8VUQkrygxEhEp5FLSMpi5dD9XE1IB8K/qTbeHK1o5qsLHaDAwpIsf7q72AOz46yIbd5+3clQiIoWHEiMRkULMZDbz6apDnLkQD4CvjyuDOtbEYKMe6KzB3cWeYV38LK//4k3HORF+1cpRiYgUDkqMREQKsZAtp9h95BKQeVM+qmcdHOyNVo6qcKta1oNeLSsBkGEyMzckjLjEVCtHJSJS8CkxEhEppH4/GMWqbacBsLM1MLJHHbyKOFo3KAGgbcOyNKjqDWS2//pk5UFMJrU3EhHJTUqMREQKoePhV1m45rBl+pkONahYqogVI5Ib2djY8HT7Gvh4ZnaVfvD0FVZuPWXlqERECjYlRiIihUz01SRmL9tPekZmD3RdmlegUY3iVo5K/s3Z0ZbnutXG3jbzqzp062kOnIyxclQiIgWXEiMRkUIkKSWdmUsPEJeYBkCjGj50blbeukFJtsr6uNK/XTUAzMCClQeJuZps3aBERAooJUYiIoWEyWTmk9BDnL+UAECFkm4MbF8DG/VA90BrVrskD9ctBcC15HTmhoSR9vd4UyIiknNyPTEymUyMGzeO3r17079/f86cOXPL9d58803ee++9e9pGRETu3rJfTrD3eDQAnm4OjOxRB3s79UCXH/RtU4Vyxd0AOBUZx+JNx6wckYhIwZPridGGDRtITU1l8eLFvPTSS0ydOvWmdb7//nuOHj16T9uIiMjd+21/JGv/OAuAvZ2BUT3q4OHqYOWo5G7Z2RoZ3s0PZwdbADbtCWf7wSgrRyUiUrDkemK0e/duAgMDAahXrx5hYWFZlv/555/s27eP3r173/U2IiJy946ei+WLdf/0QDeoYy3KlXCzYkRyP7w9nHi2U03L9KJ1hwmPvmbFiEREChbb3D5AQkICrq6ulmmj0Uh6ejq2trZcvHiR2bNnM3v2bNauXXtX22THaLTBw8M5d05CRCSfioq5xpzlB8j4ewycvu2q80jjclaOSu5XiwBfzkcnEvzzcVLTTMxfcZB3RzTHySHXv85FRAq8XP8kdXV15dq1f55omUwmS4Kzbt06rly5wuDBg7l06RLJyclUrFjxtttkJyPDTGxsYu6chIhIPpSYnM7bX+8m/u8e6JrWKkGreiX1WZnPPdaoDIdORnP4bCzhlxL46Ps9DOlcS51oiIjcBW/v7GtM5HpVOn9/f3799VcA9u7dS9WqVS3LBgwYQHBwMF999RWDBw+mY8eOdO/e/bbbiIjInWWYTMxfGUbE31WtKpd256nHquvmuQAwGgwM6eKHu6s9ADv+usjG3eetHJWISP6X6yVGbdq0YevWrfTp0wez2czbb79NaGgoiYmJWdoV3WkbERG5e4s3HSfs5GUAihZxYET32tjZaoSGgsLdxZ5hXfx499s/MZnNLN50nAoli1CptLu1QxMRybdszGaz2dpB5IS0tAxVD7lH+45Hs+6Pszza2Je6lYtZOxwRySE//xnOl+uPAOBgb2RsvwaU8XG9w1aSH6374yxLNh8HMrtgn/B0Q9yc7a0clYjIg8uqVenkwRWy5RRHzsUSsuWUtUMRkRzy1+nLfPNT5vAHNsCQzrWUFBVg7RqVpUFVbwCuxKewIPQQJlOBeN4pIpLnlBgVYsmp6Vl+i0j+FnU5kbkhYZYe6Hq1rEw9lQYXaDY2NjzdvgY+nk4AHDx1mZVb9bBLROR+KDESESkAriWn8dHS/VxLznzQEVinJO0albVyVJIXnB1tea5bbez/bkMWuvU0B07GWDkqEZH8R4mRiEg+l55hYu7yMC5czmxnWbWsB/3bVVMPdIVIWR9X+rerBoAZWLDyIDFXk60blIhIPqPESEQkHzObzXy74Rh/nbkCgLeHI89188PWqI/3wqZZ7ZI8XLcUANeS05kbEkZausnKUYmI5B/65hQRycc27Qnn5z/DAXByMPJ8z7rqlawQ69umCr7FMzvbOBUZx+JNx6wckYhI/qHESEQknwo7GcO3G/7ugc4GhnXxo1QxFytHJdZkZ2tkeLfaODtkDlO4aU842w9GWTkqEZH8QYmRiEg+FBF9jXkrwrg+Et0TraviV7GodYOSB4KPhxPPdqxpmV607jDh0desGJGISP6gxEhEJJ+JT0zlo6X7SErJAKBl/dK08i9t5ajkQVKvSjHaNykHQGqaibnLD2hoBhGRO1BiJCKSj6RnmJizPIxLsZk9jtUo58njrauoBzq5SbeHK1Dd1wOAyJhEFq09jNmswV9FRLKjxEhEJJ8wm818uf4IR8/FAlDcy5nh6oFOsmE0GBjSxQ9318zOOHb8dZFNe8KtHJWIyINL36YiIvnE+h3n+G1/JAAujrb8r2cdXBztrByVPMjcXewZ1sUPw98lit9vPMaJ8KtWjkpE5MGkxEhEJB/YezyaHzYfB8BosGF4Vz+KezlbOSrJD6qW9aBni0oAZJjMzFsRRnxiqpWjEhF58CgxEhF5wJ2/mMDHKw9yvXVI3zZVqVHey6oxSf7SrlFZGlT1BuByXAoLQg9hMqm9kYjIjZQYiYg8wOKupfLR0v2kpGb2QNc6oAwt6qsHOrk3NjY2PN2+Bj6eTgAcPHWZlVtPWTkqEZEHixIjEZEHVFp6BrODDxATl9kDXe2KRendqrKVo5L8ytnRluFd/bCzzfzqD916mgMnY6wclYjIg0OJkYjIA8hsNrNo7WGO/91QvlQxF4Z0roXRoI9tuX++xd3o37YaAGZgwcqDxFxNtm5QIiIPCH3Diog8gNZsP8PvBy8A4Opkx6iedXB2tLVyVFIQNK9TkofrlgTgWnI6c0PCSM8wWTkqERHrU2IkIvKA2X3kIst+OQlk9kA3onttfDycrByVFCR921TFt7grAKci41i88biVIxIRsT4lRiIiD5AzUfF8suqQZfrJR6tTtayH9QKSAsnO1sjwbrVxdsgshdy45zx/HLpg5ahERKxLiZGIyAMiNiGFmcv2k5qWWa3p0ca+NK9T0spRSUHl4+HEsx1rWqYXrT1MePQ1K0YkImJdSoxERB4AqWkZzFq2nyvxKQDUq1yMnkGVrByVFHT1qhSjfZNyAKSkZTB3+QGSU9OtHJWIiHUoMRIRsTKz2cxnq//iVGQ8AGW8XRncuSYGg42VI5PCoNvDFaju6wFAZEwii9YexmzW4K8iUvgoMRIRsbKVW0+z8/BFAIo42/F8zzo42qsHOskbRoOBIV38cHe1B2DHXxfZtCfcylGJiOQ9JUYiIla0468LrPjtFAC2RgMjetShqLujlaOSwsbdxZ5hXfww2GSWUn6/8Rgn/h5DS0SksFBiJCJiJScj4vhs9V+W6afbV6dyaXcrRiSFWdWyHvRskdmuLcNkZt6KMOITU60clYhI3lFiJCJiBZfjkpm1bD9p6Zk90HV8qDxNa5WwclRS2LVrVBb/qt4AXI5LYUHoIUwmtTcSkcJBiZGISB5LSc1g5rL9XL2W+TQ+oJo3XQMrWDkqEbCxsWFg+xr4eGYOKHzw1GVCt522blAiInlEiZGISB4ymc18suoQZy8kAFCuhBvPdKxpadshYm3OjrYM7+qHnW3mLcLK304RdjLGylGJiOQ+JUYiInlo+a8n2XP0EgDurvaM6lEHBzujlaMSycq3uBv921YDwAwsCD1EzNVk6wYlIpLLlBiJiOSRbWGRrP79DAD2tgZG9aiDp5uDlaMSubXmdUrycN2SACQkpTFvRRjpGSYrRyUiknuUGImI5IHj56+yaO1hy/QzHWtSoWQRK0Ykcmd921TFt7grkNmL4uKNx60ckYhI7lFiJCJ5Yt/xaKZ9s4d9x6OtHUqei45NYlbwftIzMnv36hpYgYbVfawclcid2dkaGd6tNs4OmQMOb9xznj8OXbByVCIiuUOJkYjkiZAtpzhyLpaQLaesHUqeSkpJ56Nl+4lPTAOgcc3idHqovHWDErkHPh5OPNOxhmV60drDhEdfs2JEIiK5Q4mRiOSJ5NT0LL8LA5PJzMcrDxJ+KfMmsmKpIjz9WHVs1AOd5DP1q3jzWBNfAFLSMpi7/EChei+LSOGgxEhEJJf88PNx9p/I7ObYq4gDI7vXxl490Ek+1f3hilT39QAgMiaRRWsPYzZr8FcRKThumxiZzWZiY2Nvmp+cnMw777yTWzGJiOR7v+6LYP2OcwA42BkZ1aMO7q7qgU7yL6PBwJDOtXB3tQdgx18X2bQn3MpRiYjknGwTo71799KiRQuaNm1Kt27duHQpc9yNXbt20bFjR1avXp1nQYqI5CdHzl7hq/VHALABBnWqiW9xN+sGJZID3F0dGNbFzzIg8fcbj3Ei4qqVoxIRyRnZJkbvvPMObdq0Yfny5VSsWJFZs2axbNkynnrqKRo2bKjESETkFi5eSWR28AEyTJlVjHq0qIR/VW8rRyWSc6qW9aBni0oAZJjMzAsJIz4x1cpRiYj8d7bZLTh27BhffvklDg4OTJgwgTZt2rBx40Y++ugjHnnkkbyMUUQkX0hMTuejpfu5lpzZKL2ZXwkea+xr5ahEcl67RmU5Hn6VPUcvcTkuhU9CD/G/XnUxGNSxiIjkX7dtY+TgkFkf3s3NjWvXrjFjxgwlRSIit5BhMjFvRRiRMYkAVC7jzoBH1QOdFEw2NjYMbF8DH08nAMJOXSZ022nrBiUi8h/dda909vb2NGzYMDdjERHJt77feJyDpy4DUMzdkRHda2Nnq44/peBydrRleFc/y3W+8rdThJ2MsXJUIiL3766/tY3G++ti1mQyMW7cOHr37k3//v05c+ZMluXr16+nR48e9OzZkx9++MEyv2vXrvTv35/+/fszZsyY+zq2iEhe2LznPBt3nwfA0d7IqJ51KOJsb+WoRHKfb3E3+retBoAZWBB6iJirydYNSkTkPmXbxigxMZGmTZtapuPj47NMA/z+++93PMCGDRtITU1l8eLF7N27l6lTpzJv3jwAMjIyeP/991m2bBnOzs60b9+eRx55BBcXFwC++uqr+zopEZG8cvD0Zb756RgANjYwtEstyni7WjkqkbzTvE5JjofH8uu+SBKS0pi3IozRff2xNarEVETyl2wToy+//DJHDrB7924CAwMBqFevHmFhYZZlRqORNWvWYGtrS0xMZvG7i4sLhw8fJikpiYEDB5Kens6LL75IvXr1ciQeEZGcEhlzjXnLwzD9Pchl71ZVqFOpmJWjEsl7T7SuyunIeM5eTOBkRByLNx2nb5uq1g5LROSeZJsYNWrUCLPZzNWrV/Hw8LjvAyQkJODq+s/TU6PRSHp6Ora2mYe2tbXlxx9/ZNKkSQQFBWFra4ujoyPPPPMMvXr14vTp0wwaNIh169ZZtrkVo9EGDw/n+46zMDL8/TTPYDTotZNcV9Cut/jEVGYvDyMxJbMHujaNfOnVuqo6W5BCa/STDXl51hYSk9PZuPs8dat607xuaWuHJSJy127bXfegQYO4cOECVatWZebMmZQrV+6eD+Dq6sq1a9cs0yaT6aYEp23btrRu3ZrRo0cTEhJCp06dKFeuHDY2NlSoUAEPDw8uXbpEyZIlsz1ORoaZ2NjEe46vMDNlmCy/9dpJbitI11t6hokPFu8lMjrzs626rwe9gipy9WqSlSMTsR5How3PdKjBrGUHAJizdD9eLvaUKuZi5chERP7h7Z39gOvZVgCeNm0ajz32GKGhodStW5dp06bd18H9/f359ddfAdi7dy9Vq/5TtJ6QkEC/fv1ITU3FYDDg5OSEwWBg6dKlTJ06FYALFy6QkJCAt7cGSBQR6zObzXzz01EOn40FwMfTieHdaqs9hQhQv4o3jzXJHLsrJS2DOcsPkJyabuWoRETuTrYlRnv37uXjjz/GaDTy0ksv0aFDh/s6QJs2bdi6dSt9+vTBbDbz9ttvExoaSmJiIr1796ZTp0707dsXW1tbqlWrRufOncnIyGDMmDE8/vjj2NjY8Pbbb9+2Gp2ISF7ZsOs8v+yNAMDJwZbne9bB1cnOylGJPDi6P1yRUxFxHD4bS2RMIl+sO8LgTjVVzVREHnjZZhtms9nSRbe7uzupqan3dQCDwcCkSZOyzKtUqZLl7969e9O7d+8sy41GI++///59HU9EJLfsPxHD95sye6Az2NgwvKsfJYuqmpDIjYwGA0M612LCop1cTUjlj0MXqFzanUcalLF2aCIit5Vt3Q/z370siYgIhF9KYP6KMK5/ND7Rpgq1KnhZNyiRB5S7qwPDuvhh+LuU6PuNxzgRcdXKUYkUHPuORzPtmz3sOx5t7VAKlNsmRidOnOD48eMcP34ck8mUZfr48eN5GaeIiNXEJaby0dL9JKdmANDKvzSt/PX0W+R2qpb1oGeLzBoiGSYz80LCiE+8v9on+YFuVCUvhWw5xZFzsYRsOWXtUAqUbKvSJSUl0bFjxywlRze2M7KxseGvv/7K3ehERKwsLd3EnOADRF9NBqBWBS8eb13FylGJ5A/tGpXl2PlY/jwWzeW4FD4JPcT/etXFYCh47Y1CtpzizIV4klMzqFtZ45lJ7rreqYk6N8lZ2SZGhw8fzss4REQeOGazmS/XH+bY+cwqQCW8nBnWpRZGg3qgE7kbNjaZXXhPWrSLi7FJhJ26zKptp+ncvIK1Q8txulEVyf/07S4iko11O86y9UAUAC6Otjzfqw7OjuqBTuReODvaMbybH3a2mbccK347RdipGCtHJSJys2xLjJo0aXJT15r29vaUKFGCzp0707dv31wPTkTEWv48domlm08AYDTY8Fy32hT3dLZyVCL5k29xN/q1rcrCNYcxAwtWHmLC0w3xKuJo7dBERCyyTYxmzpx507yMjAzOnj3LwoULycjIYMCAAbkanIiINZy9EM+ClYe43sKyf7tqVC/nadWYRPK7wDqlOH7+Klv2R5KQlMbckDBG9/XX4Mgi8sDINjFq1KjRLec3bdqUmjVr8uqrryoxEpEC52pCCjOX7SclLbMHurYNy/Jw3VJWjkqkYOjbpipnouI5ezGBkxFxLN50nL5tqlo7LBER4D7bGPn5+REVFZXTsYiIWFVaegazgw9wOS4FgDqVivJ/LStbOSqRgsPezsjw7rVxcsh8Lrtx93n+OHTBylGJiGS6r8QoKSkJBweHnI5FRMRqzGYzC9cc5kREHAClvV0Y0rlWgexWWMSafDyceLZjDcv0orWHiYi+ZsWIREQy3VdiNG/ePBo0aJDTsYiIWM2qbafZ/veTazdnO57vUcfyVFtEclb9Kt481sQXgJS0DOYsP6BurkXE6rL91u/Ro8dNvdJlZGQQERGBq6srCxcuzPXgRETywq7DF1n+9+jhtkYbRnSvTTEPJytHJVKwdX+4Iqci4jh8NpbImES+WHeEwZ1q3nTvISKSV7JNjPr163fTPHt7e4oXL06FChVYtmwZgwcPztXgRERy2+moOD5ddcgy/eSj1alSxsN6AYkUEkaDgSGdazFh4U6uXkvlj0MXqFLGnVb+ZawdmogUUtkmRt26dbtp3qFDh/jqq69Ys2YNnp6eSowKKLPZzNatWzhy5DBJSUl5emx7ezsqVKhIy5atsbVVNSbJXVfiU5i5dD+p6SYA2jcpR7PaJa0clUjh4e7qwNAutZj+3V5MZjPfbThG+RJFqFiqiLVDE5FC6I53nunp6axbt46vv/6affv28dhjjzF37lweeuihvIhP8pjZbGby5AmsWrWChx9uiYuLS54ePyUlme+//5YffvieuXM/VXIkuSYlLYOZy/YTm5AKQP0qxegeVNHKUYkUPtV8PenRoiI/bD5BhsnMvJADjH+6Ea5OdtYOTUQKmWzvOi9dusR3333HkiVLKFq0KL179+b06dOMHTuWokWL5mWMkoc+//wTNm3awNq1G/Hyss7/OTk5mSeffJyJE9/krbfesUoMUrCZzGY+W3WIM1HxAPj6uDKoU00MatsgYhWPNvLl+Pmr/Hksmpi4FBaEHuR/verqPSkieSrbXulatmzJuXPnmD17NitWrOCJJ57Q0/tCYOvWLfzvfy9ZLSkCcHR0ZMyYN/ntt1+tFoMUbCu2nGLXkUsAFHGxZ1TPOjja6/NNxFpsbGx4pkMNfP7u9CTs5GVWbT1t3aBEpNDJ9k7gscce49dffyUpKYmePXsSFBSUl3GJlcTGXsHT0yvLvJMnTzBv3kySk5NJSkqiadNmDBw4mNjYWObMmUFUVCQmkwkfn+KMHPkCRYsWs2z73nvvcPDgARYu/NYyb8SIwaSkJOPg4EhGRjolS5bm+edfwt3dw7JO0aLFiI29kuvnK4XP9oNRhG47DYCt0cDIHrXxKuJo3aBEBGdHO4Z382PKV7tJSzex4rdTVCxdBL8KqqUiInkj2xKj6dOn89NPP9GoUSPef/99WrZsSXx8POfOncvL+MQKbuwqNT4+ngkTXmfUqJeYNetjPv54ISdOHCckZBljx75CUFBLZs9ewNy5n9KhQ2deffUFMjIygMwqcQcO7KNcuQrs2bMryzHeeGMSs2cvYN68z2nS5CHefXdKtjGI5JQT4Vf5fM1hy/QzHWpQqZS7FSMSkRv5FnejX9uqAJiBBSsPcTku2bpBiUihcdu6I0WKFGHAgAEMGDCAPXv2sGTJEp5++mnKlStHx44defbZZ/MqTrGS3377BX//hpQtmzkQn9Fo5I03JnL69El+//03AgNbWNZt2LAxoaEh7Nv3J/7+AWza9BMNGjSkSZNmBAcvwd8/4JbHaNv2MRYsmEtKSgoODg55cVpSCMVcTWZW8AHSMzJ7oOvcrDyNaxa3clQi8m+BdUpx/PxVtuyPJCEpjbkhYYzu64+t8b7GpLe6pUsXM3XqFM6fP4vJZMrTYzs6OlKtWg3mzv2EKlWq5umxxToOHNjHqFHDOX78KCkpKXl6bKPRSNmyvowfP5kOHTrl6bFzyl1Xqvf398ff35833niDkJAQfvjhByVGhUB09CVKlSqdZZ6zszORkZGUKnXzWBOlSpUmKioSgNDQEF555XXKl6/Ae++9w6VLF/H29rnlcdzc3EhIiFdiJLkiOTWdmcv2E3ctswe6htV96Ny8gpWjEpHs9G1TlTNR8Zy9mMDJiDgWbzpO3zb578b+hx++5623xrNw4dfUqVMPO7u87WkvISGB4OAf6NGjE8HBq6hcuUqeHl/yVljYAfr06cHEiVN47LGOed6zcGpqKrt27WDQoKewsbGhffuOeXr8nHDPj19cXV3p168fK1asyI145AFTvHhJLl68kGVeREQ4Xl5eREVF3LT++fNnKV68BKdPn+LUqRPMnj2Dl19+HhsbG0JClt3yGGazmcuXY25q2ySSE0xmM5+EHuLcxQQAypdwY2CHGurtSuQBZm9nZHg3P5wcMp/fbtx9nh1/XbjDVg+eKVMm8uWX39GgQcM8T4og855twICn6dfvST7+eG6eH1/y1uzZMxg58n/07Nk7z5MiAHt7ex56qDnz53/G1Klv5fnxc0L+LJeWPNOsWXP++GMb4eHngcxxrWbN+pCTJ08QExOTpee47du3cf78eerV8yc0NIRBg4bzwQez+OCDWXz00XxWr15JWlraTcdYtWoFDRo0wmDQ5Sg5b9kvJ/jzWDQAnm4OjOxRBwc7o5WjEpE78fF05tkONSzTC9ceJjLmmhUjujfp6elcuBBF7dp1rR0K9erV59y5M9YOQ3LZuXNnqVu3vrXDoF69+pw9e9baYdwX9U8rt+Xi4srYsROZNm0yJpOJxMREmjULpHv3XrRq1ZqPPnqfr75aCICPT3GmT5+ByWRi48YfWbToO8t+SpQoQeXKVdi8eSMAkyePw9Exs1tWb28fXnzxtbw/OSnwftsfydrtmR/O9rYGRvWog6ebqmuK5Bf1q3rzWGNf1v5xlpTUDOYsD+ONAQ3yRff6JpMJg8GA0fjPg5g9e3axYsUyJk78Z4y+ESMG88orr1OuXHkAUlJS6Nu3J0uXhlrWeeqpJ6hduy4vvfTPd2WLFk3w86tj2aZx46YMHDj4lg8Z7ezsLR0jScFlMmVkKZm07vWWntOnlyce/E8Wsbrq1Wswc+b8m+Z7enoxYcKUW2wBISFrb5r33nszAWjb9tGcDVDkFo6ei+WLdf/0QPdsx5qUK+FmxYhE5H50D6rIyYg4jpyLJSL6Gl+uO8KgTjULTe+l+/fvpVKlSuzZs5PExGs4O2dWkSpSxJ3ZsxcAmVXSp09/m+DgJfTs2cea4Uo+V9ivN9VdKoQyTCa27IvgclxmbyWX41LYsi8Ck8ls5chEcsal2CRmBx8g4+9rutvDFQmofuuOP0TkwWY0GBjapRbuLvYAbD90gc1/hls5qrwTGhpCixaP8PDDLVm7dtUt17GxsaFPn35s3PhTHkcnBU1hv96UGBUyGSYT80MOsnDtYdL+7rY4LcPEwrWHmRcShqub2wMxsOqVK5cpUqSItcOQfCgpJZ2ZS/eTkJTZnq1JreJ0bFrOylGJyH/h7urA0C61LJ2mfLfhGCcj4qwcVe65Xhp27VoC+/fvpWnT5nTo0Jnly2/diRGAl1dRrl6NzaMIpSDR9fYPJUaFzLYDUew+eumWy3YfvUSx0tX55JP5XLtmvQau6enpzJ49g4CARlaLQfInk8nM/BUHCY/OvH4rlS7C049VLzRVbkQKsmq+nvRoURGADJOZeSEHLA9A8jMHB0dSU1Mt00lJSZahK378cR0mk5lXX32BDz54l5iYaHbt2nHL/URFReLtrbHZ5PZ0vd2e2hgVMlv2R952uW2Z1hS7dJ4uXR6jTZt2uLi45lFkmVJSktm2bSsGgw0zZqhrUbk3SzYf58DJGACKFnFgRPc62NmqBzqRguLRRr4cP3+VP49FExOXwoLQg/yvV9183f1+1arV+OWXTZYBWLdv30r16jWBzGpN06Z9QMWKlQD48ce1BAf/cNODQ5PJxHfffUXr1m3zNnjJd3S93Z4So0LmcnzybZdHx6Vgrtgbu4yt/PxnOC72Zoq42FPE2R43ZzuMuTzyuL29PT169KJbt544OTnl6rGkYPllbzg/7jwHgIOdkVE961raJIhIwWBjY8MzHWowadEuLsYmEXbyMqu2ns5XAzbv2PEHzzzT3zI9Zsw4vvpqIQMH9sPBwR43N3dee20sR48eBsyWm1SAoKBWzJz5ARcuRBEXd5URIzJ7BUtPT6dhw8Z07NjFCmckDzJdb/dGiVEh4+XmaOl0ITs2NgZKVg3MMi8OiAdKFHWmXAk3yhXP/PEt7oqzY94PWidyo7/OXOHrH48CYAMM6VyLsj55W9opInnD2dGO4d38mPLVbtLSTaz47RSVSrtTq8KDP0i4v38Aa9duumn+xIlv3zSvaNFifP75N1nmOTg4sGpVZoP3n3/enjtBSoGh6+3eKTEqZALrlOR4+NVslz9ctyRODraciYrnzIUEklL+6YfeDETGJBIZk8j2g/+MQO7j4YRvCTfKFXfNTJZKuFHEWU/qJW9cuJzI3OX/9EDXq2Vl6lUpZuWoRCQ3+RZ3o1/bqixccxgz8PHKg0x4uiFeRRytHZqI5GNKjAqZZrVLsv9EzC07YGhQ1ZsB7apjMGTW1TabzVy6mszZqHjOXIj/O1mKJz4xa2PXi7FJXIxNYtfhi5Z5nm4OmaVK10uXSrjh4WqvRvCSo64lpzFj6X6uJWcm8M1rl6Rdo7JWjkpE8kJgnVIcO3+V3/ZHkpCUxryQMF7r649tLlf5FpGCS4lRIWMw2DC0ay22hUXx9Y9HSUs3YWdroF/bqjTzK2lJiiCzLrePhxM+Hk6WMWDMZjNX4lMsidLZCwmcuRDPlfis1fOuxKdwJT6FvcejLfOKONv9XbL0T7JUzN1RyZIQHn6eAwf231NX8SazmR93nLP0QFfCyxnHcr4sXrznrvdhMBgoXboM/v4BatMmkg/1a1OVs1HxnL2YwImIOJZsOs4TbapaO6xs7dmzixUrljFx4juWefPmzaJcufI0aNCQ2bNncOXKZVJSUqhWrQbPP/8SdnZ2tGjRBD+/Oln2NX78ZLy9fdi3by8LFy4gPT2d5ORk2rfvRPfuvfL61OQBpOvt3ikxKoSMBgOBdUqx5vczXLiShJebA4F1St3VtjY2NngVccSriCP1q3hb5sddS+XshawlS5dis3b0EJeYRtjJy4SdvGyZ5+xgaylV8i2RWRWvuJdzvu5hSO7N1q1bePbZAdSv3wBPT6+7TpRPRsQRdTkRyOxswdmlKNu2nrmnY6enp3PixHHs7OxYvDgYNzeNnSWSn9jbGRnezY+Ji3aRlJLOht3nqVzGnUY18lc3wiZTBmPGvMRLL42hVi0/AGbMeI9PP53PsGEjKVLEndmzF9y0XXj4eWbMeJf335+Fl1dRUlKSGTlyKKVKlaZJk4fy+jQkn9D1lj0lRpIjirjY41exKH4Vi1rmXUtOyyxRioq3JE1RMYmYb9guMSWdv85c4a8z/5QUONgb8fX5u73S3yVLJYs6q3pEAXT48F88++wAPvnkC5o3f/iut9u4+zzf/HSUEoCTg5HX+wdQupjLfcVgMpkYPfolnnzyCYKDbz3Kt4g8uHw8nXm2Qw1mBR8AYOHaw5T1caVk0fv7TLCGixcv4uNT3HKTCjBs2EjMZvNttoL169fw6KMd8PLK/O51cHDkgw9mqwRcbkvXW/aUGEmucXG0o0Y5T2qU87TMS05N59zFBEup0pmoBCKir2G64c2YkprBsfNXOXb+n04ibI0Gyvq4WDp3KFfcjTLeLhqjJp/bunULHTp0uaekKOxUDN9tOAaAjQ0M7eJ330kRZFane+ed96hQoSTXrl3DxSX/3EyJSKb6Vb15rLEva/84S0pqBnOWh/HGgAY42ueP25ySJUuRkBCfZd71QTcBS1fJ13l7+zB+/GSioy9ZxqO5ztVVPXLK7el6y17++MSQAsPR3pYqZTyoUsbDMi8tPYPzl67dkCzFc/5SAukZ/yRL6RkmTkXGcyrynzey0WBDqWIuWTp5KOvjioO9kqX8Ijr6Ej4+PlnmnTx5gnnzZpKcnExSUhJNmzZj4MDBxMbGMv2D99h94DgmUwa2jh4MHjqK2jeUUr733jscPHiAhQu/tcwbMWIwKSnJODg4kpGRTsmSpXn++Zdwd/ewrGM0GilatBiXL8coMRLJp7oHVeRkRBxHzsUSEX2NL9cdYVCnmg9UO1YHB0dSU7N2YJSUlEhUVCQXL17IMv/q1VjCwg7QrFlgtlWbSpQoedN2x44dBcxUqVItx+OX/EXX271TYiRWZ2drpELJIlQo+U/7jvQMExHR1zhz4Z8OHs5eiCc1zWRZJ8Nk5tzFBM5dTOC3A5FA5hg2Gmspf7nxpiU+Pp4JE15nypTplC3rS0ZGBm++OZqQkGWsW78WU9FGlG7yCACVi1xm1TfT6Ry0CKPRSHJyMgcO7KNChUrs2bMLf/8Ay37feGMS5cqVBzJH8n733SlMmTI92zhEJP8xGgwM7VKLCQt3cvVaKtsPXaByGXda+ZexdmgW5cuX59ixI0RHR1OsWDFSUlLYt+9P3nprGlu2/MKhQ2HUrOmH2Wzm888X4ODgQLNmgdnur02bRxkz5mVatWqLp6cniYmJTJ/+Nk8//WyBuVGV+6fr7d4pMZIHkq3RgO/fbYyuM5nMXLiSmKVk6W7HWvL2cMxSsqSxlh5Mv/32C/7+DSlb1hfILMl5442JnDh5gktLV+NRvgoANcp58sL/tWDSxN3s2/cn/v4BbNr0Ew0aNKRJk2YEBy/JkhjdqG3bx1iwYC4pKSlZqg6ISP7n7urA0C61mP7dXkxmM99tOEb5EkWoWOrB6FjFxcWVkSNf4NVXn8fBwZH09DR69OiNr2853nprKh9++K6ltLxWLT8GDRoO3Fy1CWDo0BH4+dVh+PBRjB37CgaDgcTERDp16krTps2tcXrygNH1du+UGEm+YTDYULKoCyWLutCkVgng1mMtnY6KJyEpa9HxpdhkLsUms+vIP+M3aaylB0909CVKlSqdZZ6TkxNL1u0m1Sbzxqa4pxPDuvphazRQqlRpoqIySwtDQ0N45ZXXKV++Au+99w6XLl3E29vnpmMAuLm5kZAQr8RIpACq5utJjxYV+WHzCTJMZuaFHGD8041wdXowag4EBbUiKKjVTfNLly7De+/NvOU2P/+8Pdv9NWrUhEaNmuRYfFKw6Hq7N0qMJF/TWEsFS/HiJTl69HCWeUvW7eLYhTTSkq7g7GDL873qWm5wzp8/S8OGjTl9+hSnTp1g9uwZQOZ1ERKyjEGDht10DLPZzOXLMXh6euX6+YiIdTzayJfj56/y57FoYuJS+CT0EM/3qqOhIETktpQYSYGT3VhLV/8ea+lsToy15OmcZTBcyRnNmjXnq68+p1u3npQuXYY9h6NY+OlsnL2rkJEST7Ny8ZTwcgZg+/ZtnD9/nnr1/Jk7dyaDBg2nR4//AyAqKoqhQ5/mqaeevekYq1atoEGDRhgM6v5dpKCysbHhmQ41mLRoFxdjkzhwMoZV207TuVkFa4cmIg+wXE+MTCYTEyZM4MiRI9jb2zN58mTKlStnWb5+/XoWLFiAjY0NvXv3plevXnfcRuR+uLvYU7ti0Sy9mN33WEt2RsoWd81SsqSxlv47FxdXxo6dyLRpk0lKSeNUeAzO3tVxL9eUp5/oxu5N3zJk/VIAfHyKM336DEwmExs3/siiRd9Z9lOiRAkqV67C5s0bAZg8eRyOjpnjLHh7+/Dii6/l/cmJSJ5ydrRjeDc/pny1m7R0Eyu2nKJSKXdqVVBpsYjcWq4nRhs2bCA1NZXFixezd+9epk6dyrx58wDIyMjg/fffZ9myZTg7O9O+fXseeeQRdu3ale02IjnpvsdaSsvg+PmrHNdYSzmuevUaTH5nJm99sQvfCpkleq0blKHTw1Xp9PCUW24TErL2pnnX6063bfto7gUrIg803+Ju9GtTlYVrD2MGPl55kAlPN8SriKPVYrrdkARz5swgKioSk8mEj09xRo58gaJFi1m2vd8hCaTw0vV2b3I9Mdq9ezeBgZld/9WrV4+wsDDLMqPRyJo1a7C1tSUmJgYAFxeX224jkts01pJ1paWbmB18gJi4zKTIr4IXvR+pbOWoRCS/CqxbimPhV/ltfyQJSWnMCwnjtb7+Vinhv92QBD/9tI7HH+9HYGALAHbu/INXX32BBQtyZkgCKXx0vd27XE+MEhISsoyKazQaSU9Px9Y289C2trb8+OOPTJo0iaCgIGxtbe+4za0YjTZ4eDjn3okUQIa/vxQMRoNeu7vgXcyN+jVKWKbTM0ycu5DAyYirnAy/ysmIq5yOiCMlLcOyzi3HWrKB0t6uVCzlTsXS7lQoVYSKpdxxeUB6TMott7reHB3tMBj+mTabzcz6YR/HwzNL4sr4uPLakw1xyYNxqAwGG4oUcdJ7QaQAeq5XPcIvXeNUZBwnIuJYsfU0z3T2y9Fj/PszLjU1857lxs+UX375kaZNm1K7dnXLvPfee5cTJ06wc+fvdOrU3jK/TZuWrFsXyokTh2jUqDEhIet56KGHaN48kKVLf6BVq4cBsLU14ubmaDnO//1fDz79dB5OTkZLz5uurg7Y2Rn1+VaA3Oo71Wg0ZLkWrHW9JSdnxpYfr7dcT4xcXV25du2aZdpkMt2U4LRt25bWrVszevRoQkJC7mqbf8vIMBMbm5izwRdwpgyT5bdeu/vj6WxLg8pFaVA5s92SyWQm6nKipb3SLcdaMsP5iwmcv5jAr3vDLfML+lhLt7rekpPTMBgMlunVv5/m5z3nAXB1smNENz/SktOITU679U5zMj6Tmbi4JL0XRAqoIZ1rMnHRLpJS0lm97TRlvV1oVKN4ju3/359xqampAFk+U86eDado0eL/+pyx4ejRU/j4lLzp88fbuwTHj5+matXaLF68xDIkwcGDEzh27DTe3j6kp2cQH5+cZVsXF1fOn79gqRaVkJBCWlqGPt8KkFt9p2ZkmLJcC9a63pKTM2t8PKjXm7e3W7bLcj0x8vf3Z/PmzbRv3569e/dStWpVy7KEhASGDh3K559/jr29PU5OThgMhttuI/IgM/xdda5UMY21dK92H7nE/HkfkRwbTkZqPK4OMOlYWTw8PLl48QILFiyyrBsSspSYmBieeWYIcXFxzJkzg/Pnz2EyZeDjU5xXXhlrKXWOjr5E795dGTt2Iq1atbbS2YmItfl4OvNshxrMCj4AwMK1hynr40rJoi55FsOthiSIiAjHy8uLqKiIm9bXkATyX+h6u3e5nhi1adOGrVu30qdPH8xmM2+//TahoaEkJibSu3dvOnXqRN++fbG1taVatWp07twZGxubm7YRya801tKdnYmK55NVB/Gu2QmAOh7hOJhjGTZsJJGREYwf/3q2206YMJYuXboTFNQSgMWLv2H69ClMnPgOAKtXr6RXr8cJDl6ixEikkKtf1ZvHGvuy9o+zpKRmMHd5GG8MCMizdp//HpIgPT2dWbM+JCCgETExMfz22680b55ZZUlDEsh/pevt3uV6YmQwGJg0aVKWeZUqVbL83bt3b3r37n3Tdv/eRqQgudNYSzd28hB9tWCPtZScmsHMZftJTcusFvBoI19ck69x5kzsHbeNiork8uUYS1IE0LNnH5KSkoDMBHT9+jXMmfMpe/fu4eTJ41SsqI4cRAqz7kEVORERx9FzsYRHX+OL9YcZ1LFmnjxcunFIApPJRGJiIs2aBdK9ey9atWrNRx+9z1dfLQQ0JIH8d7re7p0GeBV5gBS2sZYyTGb+OHQBn9qZJWV1KxWlZ4tKrFv3V5b1Tp8+xYgRgy3T0dHRtGnTjujoS5QsWSrLukaj0VKNbteuHVSsWBlPT086dOhMcPAPvPzymFw+KxF5kBkNBoZ2qcWEhTuJu5bK9oMXqFLanZb+ZfLk+NWr12DmzPk3zff09GLCBA1JIDlL19u9UWIk8oArqGMtmc1m9h6LJjYhBR+gjLcLgzvXumUpV/nyFZg9e4Fl+nobo+LFS3Dp0sUs66anp7Np0wbatn2U0NAQIiMjePHFkaSnp3Hs2FGGDh2ZpddLESl8PFwdGNalFtO/24vJbOa7jccoX7IIFUoWsXZoImJFSoxE8qGCMNZS6NbThEdfw8bGhiLOdozqWQcnh3v7SPL29sHd3YMtW362jMWwZMl3/PXXQRo1asLBgwdYsmQFRmPmuUybNpm1a1fRq1efnD0ZEcl3qvl60iOoIj/8fIL0DDNzlx9g/NONcC3gQyeISPaUGIkUEHa2Rir864lneoaJiOhrnLkQz9mozA4ezl6Mt7TngWzGWgJKFHX+p91ScTfKFXfFOYfGE9rx1wVCfjsFgMHGhhE96lDM3em+9vXmm5P44INpfPfd16SlpVG6dBlee+0NVq0KoUWLVpakCKBTp65Mnjyenj175+vOKkQkZzza2Jfj4Vf581g0MXEpfBJ6iOd71cGQi58PX321iF27dmAw2GBjY8Pgwc+xbNliHnmkLU2aPER6ejoTJ76Bu7sHL730GvHx8dn2vNmzZyfKlavA++/PtOz/+++/ZvbsGfz2265cOwfJP3S93RslRiIFmK3RgO/fiQ11MuddH2vpnx7xbjHWEhAZk0hkTCLbD16wzM+JsZbSMkx8tvqfNkT1qxSjcmn3LOu0b9/J8nfJkqWydNUN0LVrT8vfHh4eTJr0zk3H6dOn303zatb049tvl91TvCJScNnY2PBMhxpMWrSLi7FJHDgZw6ptp+ncrEKuHO/UqZNs3for8+Z9ho2NDceOHWHy5AlUrVoNyKwKPG7cGMqW9WXYsJHAnXvevHTpArGxsXh4eADw++/bcHNTlUDR9XY/lBiJFDI3jrXUNA/GWsowmdh2IIrLcZkdLFz/DZlVWUp4OeT2Kd+VtLS0LKVLIlI4ODvaMbybH1O+2k1auokVW05RqbQ7tcrn/Lgsnp5eXLgQxerVK2jc+CGqVKnGJ598wfTpb5OWlsrrr79CjRo1efrpQcCde94EaNmyNZs3b6Bbt56cOXOa0qVLc+rUiRyPXfIfXW/3TomRiOTaWEu+Pq4cPhPLyci4m47p4WpPg2Z1WB0agtlstmrVtgsXooiNvYKPT3GrxSAi1uNb3I1+baqycO1hzMDHKw4y4emGeBVxzNHjeHh4MHXqByxbtpjPP/8ER0dHBg8eDsCMGe9RunQZLl78p0OZO/W8CdC6dTvefXcK3br1ZP36NbRt+xi//fZrjsYt+ZOut3v34PTbKyIPlOtjLdWv4k3XwIqM6lmH959rxocjm/PC/9Wl+8MVaVDNm2LuN984XB9rac32s7dMigBiE1IpWq4hFy9eZNy410lIiL/lernJbDZz8uQJunfvyEsvvYatrZ4ViRRWgXVL0bxOSQASktKYtyKM9AzTHba6N+fPn8PFxYXXXx9PcPBqxo17i/fem0pc3FV69OjNBx/M5uTJ46xfvwYg2543f/xxnWXax6c4ZrOZCxeiOHBgH3Xr1s/RmCX/0vV273QXICL3JNuxlqIy2ypdL2G6cDnrWEu3sudkAkuXruDZZ5+iVq3KZGRk5GnJUUZGBh4engwdOoJRo17Is+OKyIOpX5uqnImK59zFBE6Ex7Fk83GeaF01x/Z/4sQxli9fyrRpH+Lg4EDZsr64urpiMBipWLEStra2jBv3FsOHP0u1ajUoX75Ctj1v3jieTOvWbZk9ewZ+fnXUsYxY6Hq7d0qMROQ/c3G0o0Z5L2rcUCc/OTWd1+b/TnxiWrbbXY5LxsPDk6VLV2AymUhNTc2LcC1sbGxwcHgw2jiJiPXZ2xkZ3s2PSYt2kpSSwYZd56lc2p1GNXKmmm1QUCtOnz7F4MFP4ezshMlkZvjw59my5WfLOqVLl2H48FG8+eZrfPLJl9n2vHmjli1bM2PGeyxc+G2OxCkFg663e2djNpvv9FA3X0hLyyA2NtHaYeQrYz7+nQtXkiju6cQ7Q5paOxwpgN7+ajfHw69mu7xyGXde79cgDyMSEbmzPUcvMTv4AAAO9kbGPRlAyaIut93m39+pqampVKhQkvDwmLwI+bY2b97I3Lkz+eGHFdYORXLIre7hHnusFW+9NZWAgEZWjS05OZkqVcpy7tylO69sBd7ebtkuUxsjEck1gX/X17/f5SIi1uBf1ZtHG/sCkJKawdzlYaSkZlg5KhHJbUqMRCTXNKtdkgZVvW+5rEFVb5r5KTESkQdTj6CKVC3rAUB49DW+WH+YAlLJRkSyoTZGIpJrDAYbhnatxbawKL7+8Shp6SbsbA30a1uVZn4lMRgKVqNNESk4jAYDQ7vUYsLCncRdS2X7wQtUKe1OS/8y973PWbM+5MiRv7h8OYbk5GRKlSqNh4cnFy9eyDKQdUjIUmJiYnjmmSHExcUxZ84Mzp8/h8mUgY9PcV55ZaylC+Xo6Ev07t2VsWMn0qpV6/962lKA6Hq7dyoxEpFcZTQYCKxTCi+3zE4OvNwcCKxTSkmRiDzwPFwdGNalFoa/e976buMxTmUzBMHdGDnyBWbPXkC/fk/Rps2jzJ69gOeee/6220yYMJaHHgpkzpxPmDfvc2rW9GP69CmW5atXr6RXr8cJDl5y33FJwaTr7d4pMRIRERHJRjVfT3oEVQQgPcPM3OVhJCRl39tmToqKiuTy5RiCglpa5vXs2YdXXhkLZI7Ftn79Gnr37kt6ejonTx7Pk7ikYNL1pqp0IiIiIrf1aGNfjodf5c9j0cTEJfNJ6CGe71XHUpL0X50+fYoRIwZbpqOjo2nTph3R0ZcoWbJUlnWNRqOlWtOuXTuoWLEynp6edOjQmeDgH3j55TE5EpMUXLresqfESEREROQ2bGxseKZDDSYu2sml2GQOnIxh9bbTdGpWIUf2X758BWbPXmCZvt7mo3jxEly6dDHLuunp6WzatIG2bR8lNDSEyMgIXnxxJOnpaRw7dpShQ0dabmRFbkXXW/ZUlU5ERETkDpwd7RjetTa2xsxbp5Atpzh4+nKuHtPb2wd3d48sA3IuWfIdW7b8TGxsLAcPHmDBgkV88MEsZs6cT4sWrVi7dlWuxiQFl643JUYiIiIid6VcCTf6ta0KgBn4eMVBLscl5+ox33xzEj/9tJ7hw59l0KAnOXr0MK+99gbr1q2iRYtWGI1Gy7qdOnVl+fIf1K243LfCfr2pKp2IiIjIXXq4bimOn7/KbwciSUhKY96KMF57wv+e9tG+fSfL3yVLlsrSdTJA1649LX97eHgwadI7N+2jT59+N82rWdOPb79ddk+xSMGn6+3uqcRIRERE5B70a1uVsj6Z7SpOhMcxY8k+LselAHA5LoUt+yIwmQrOU3R5cGSYTGzZF6HrLZeoxEhERETkHtjbGRnezY9JC3eSlJrBoTNXLMvSMkwsXHuYfceKYjQauXbtGi4uLlaMFq5ejcXV1c2qMch/l2EyMT/kILuPXrLMu3697T8Rg4uLK3FxV60YYaarV2Nxc8uf15sSIxEREZF7VNzTmaZ+Jdi0J/yWy/ccj6F0uWq8++FHPPXMiDyO7h/JyUks+PRTGjYJ/E+D04r17T12KUtSdKPdRy9RtFQVFi78lObNg7C3t8/j6DKZzWYWLJhH3br1rXL8/0qJkYiIiMh9OHsh4bbLyz88ii+/fJNVG3fiXrwSNgbjbdfPaempSUQd/wMnt2KcMTTkrS925enxJW+V8e/F0Y0f8vjjPWjTph3OznlbUpmamsKuXTv5669DLFsWmqfHzilKjERERETuw+X42/dI5+RWlKb/N5nzh34mPvosZnNGHkWWyWjrQJmaLSnr9wiGPE7KJO9dTczgs8++4ptvvuT48aMkJ+duj4n/ZjQaqV27LlOmvEvRokXz9Ng5RYmRiIiIyH3wcnO0NIK/5fIiDgQ2bwCPNsjDqKSg2rIvgsvxt7veHLG3t+fpp5/Nw6gKFiVGIiIiIvchsE5Jjodn39i9S/MKBNYplYcRSUHm5ebAwrWHs10eWKdkHkZTMKm7bhEREZH70Kx2SRpU9b7lsgZVvWnmpxtVyTm63nKfEiMRERGR+2Aw2DC0ay2ebl8dO9vMWyo7WwNPt6/OsK5+GAw2Vo5QChJdb7lPiZGIiIjIfTIaDATWKYWXmwOQWd0psE4p3aRKrtD1lruUGImIiIiISKGnxEhERERERAo9JUYiIiIiIlLoKTESEREREZFCT4mRiIiIiIgUekqMRERERESk0FNiJCIiIiIihZ4SIxERERERKfSUGImIiIiISKGnxEhERERERAo9JUYiIiIiIlLo2eb2AUwmExMmTODIkSPY29szefJkypUrZ1m+atUqvvjiC4xGI1WrVmXChAkYDAa6du2Km5sbAGXKlOGdd97J7VBFRERERKSQyvXEaMOGDaSmprJ48WL27t3L1KlTmTdvHgDJycnMmDGD0NBQnJycePHFF9m8eTPNmzcH4Kuvvsrt8ERERERERHK/Kt3u3bsJDAwEoF69eoSFhVmW2dvb8/333+Pk5ARAeno6Dg4OHD58mKSkJAYOHMiAAQPYu3dvbocpIiIiIiKFWK6XGCUkJODq6mqZNhqNpKenY2tri8FgoFixYkBm6VBiYiLNmjXj6NGjPPPMM/Tq1YvTp08zaNAg1q1bh61t9uEajTZ4eDjn9ukUKC7O9nAlCRdne712kusMRoPlt643ESlo9BkneUnXW+7I9cTI1dWVa9euWaZNJlOWBMdkMjF9+nROnTrFrFmzsLGxoUKFCpQrV87yt4eHB5cuXaJkyZLZHicjw0xsbGKunktB06lpOdbvOEu7Rr567STXmTJMlt+63kSkoNFnnOQlXW/3z9vbLdtluV6Vzt/fn19//RWAvXv3UrVq1SzLx40bR0pKCnPnzrVUqVu6dClTp04F4MKFCyQkJODt7Z3boRY6dSsX49Un/KlbuZi1QxERERERsapcLzFq06YNW7dupU+fPpjNZt5++21CQ0NJTEzEz8+PpUuXEhAQwJNPPgnAgAED6NmzJ2PGjOHxxx/HxsaGt99++7bV6ERERERERP6LXM82DAYDkyZNyjKvUqVKlr8PHz58y+3ef//9XI1LRERERETkOg3wKiIiIiIihZ4SIxERERERKfSUGImIiIiISKGnxEhERERERAo9JUYiIiIiIlLoKTESEREREZFCT4mRiIiIiIgUekqMRERERESk0FNiJCIiIiIihZ4SIxERERERKfSUGImIiIiISKGnxEhERERERAo9JUYiIiIiIlLoKTESEREREZFCT4mRiIiIiIgUekqMRERERESk0FNiJCIiIiIihZ4SIxERERERKfSUGImIiIiISKGnxEhERERERAo9JUYiIiIiIlLoKTESEREREZFCT4mRiIiIiIgUekqMRERERESk0FNiJCIiIiIihZ4SIxERERERKfSUGImIiIiISKGnxEhERERERAo9JUYiIiIiIlLoKTESEREREZFCT4mRiIiIiIgUekqMRERERESk0FNiJCIiIiIihZ4SIxERERERKfSUGImIiIiISKGnxEhE8oSjvW2W3yIiIiIPEiVGIpInugZWoLqvB10DK1g7FBEREZGb6NGtiOSJupWLUbdyMWuHISIiInJLKjESEREREZFCT4mRiIiIiIgUekqMRERERESk0FNiJCIiIiIihZ4SIxERERERKfRyvVc6k8nEhAkTOHLkCPb29kyePJly5cpZlq9atYovvvgCo9FI1apVmTBhAsBttxEREREREclJuV5itGHDBlJTU1m8eDEvvfQSU6dOtSxLTk5mxowZfPnll3z//fckJCSwefPm224jIiIiIiKS03I9Mdq9ezeBgYEA1KtXj7CwMMsye3t7vv/+e5ycnABIT0/HwcHhttuIiIiIiIjktFyvSpeQkICrq6tl2mg0kp6ejq2tLQaDgWLFMgd8/Oqrr0hMTKRZs2asXbs2222yYzTa4OHhnHsnIiIiIpINg9Fg+a37Ecltut5yR64nRq6urly7ds0ybTKZsiQ4JpOJ6dOnc+rUKWbNmoWNjc0dt7mVjAwzsbGJOX8CIiIiIndgyjBZfut+RHKbrrf75+3tlu2yXK9K5+/vz6+//grA3r17qVq1apbl48aNIyUlhblz51qq1N1pGxERERERkZyU6yVGbdq0YevWrfTp0wez2czbb79NaGgoiYmJ+Pn5sXTpUgICAnjyyScBGDBgwC23ERERERERyS25nhgZDAYmTZqUZV6lSpUsfx8+fPiW2/17GxEREZEHlaO9bZbfIrlJ11vu0ACvIiIiIv9R18AKVPf1oGtgBWuHIoWArrfcYWM2m83WDiInpKVlqPGZiIiIiIhky6qdL4iIiIiIiDzolBiJiIiIiEihp8RIREREREQKPSVGIiIiIiJS6CkxEhERERGRQk+JkYiIiIiIFHpKjEREREREpNBTYiQiIiIiIoWeEiMRERERESn0lBiJiIiIiEihp8RIREREREQKPRuz2Wy2dhAiIiIiIiLWpBIjEREREREp9JQYiYiIiIhIoafESERERERECj0lRiIiIiIiUugpMRIRERERkUJPiZGIiIiIiBR6SoxERERERKTQU2JUSJlMJsaNG0fv3r3p378/Z86csXZIUsDt27eP/v37WzsMKQTS0tJ45ZVXeOKJJ+jZsycbN260dkhSCMTExBAUFMSJEyesHYoUEv379+fEiRPMmjWL7777ztrhFAi21g5ArGPDhg2kpqayePFi9u7dy9SpU5k3b561w5IC6pNPPmHlypU4OTlZOxQpBFauXImHhwfTp0/nypUrdOvWjUceecTaYUkBlpaWxrhx43B0dLR2KCLyH6jEqJDavXs3gYGBANSrV4+wsDArRyQFma+vL7NmzbJ2GFJIPProozz//POWaaPRaMVopDCYNm0affr0wcfHx9qhSAGVkJDA888/z8CBA+nWrRvffvuttUMqkJQYFVIJCQm4urpapo1GI+np6VaMSAqydu3aYWurAmrJGy4uLri6upKQkMCoUaP43//+Z+2QpAALDg7Gy8vL8rBRJDecOXOGDh068PnnnzN//nwWLVpk7ZAKJN2pFFKurq5cu3bNMm0ymXTjKiIFRmRkJM899xxPPPEEnTp1snY4UoAtW7YMGxsbfv/9d/766y9ee+015s2bh7e3t7VDkwKkWLFifPHFF/z444+4urrqYXYu0Z1wIeXv78/mzZtp3749e/fupWrVqtYOSUQkR0RHRzNw4EDGjRtH06ZNrR2OFHDffPON5e/+/fszYcIEJUWS4z7//HPq1avHE088wfbt2/nll1+sHVKBpMSokGrTpg1bt26lT58+mM1m3n77bWuHJCKSI+bPn09cXBxz585l7ty5QGYHIGoYLyL5VcuWLZkwYQKhoaF4eHhgNBpJTU21dlgFjo3ZbDZbOwgRERERERFrUucLIiIiIiJS6CkxEhERERGRQk+JkYiIiIiIFHpKjEREREREpNBTYiQiIlIAnDt3ztohiIjka0qMRESspFq1aowfP/6m+a1atWLz5s05eqzRo0czbdq0HN3n3QgNDaVx48Y0bNiQiIiI+97P0aNHqVatWrbLu3fvTnBwcI7vN7/4+uuvmT59urXDEBHJ15QYiYhY0eLFiwv0QH3BwcE88cQT7Ny5k1KlSlk7nALrypUr1g5BRCTfU2IkImJFvXr1YuzYscTGxt5yef/+/fn6668t019//TX9+/cHYNasWbz++usMGTKE+vXr07VrV/bt28ezzz5L/fr16dWrF5GRkZZtw8PD6devH40aNWLQoEFZSnB+/PFHOnbsSEBAAE8++SSnTp0C4Pz58zRo0IDRo0cTEBDAihUrbopx69atdO/eHX9/f7p06WJJ9AYOHMj27dv55JNPGDp06E3bnTt3jqFDhxIUFESdOnXo06cPJ06cAMBkMvHBBx/QuHFjmjdvzurVq7Nsu23bNjp06ED9+vUZM2YMaWlplmXJyclMnjyZwMBAmjdvzrRp0ywDId5pvzcymUzMnj2bwMBAAgICGD58uCUB+f333+nTpw9NmjTB39+fUaNGkZSUZPmfffjhh3Tp0gV/f3/69evH+fPn77jPiIgIhg4dSuPGjWnbti3Lli3Lch2MHj2ahx56iMGDB2eJc/369Xz88cds2LCBnj17Mnv2bAYOHJhlne7du7NmzRpmzZrFCy+8wIABA6hXrx69evXir7/+sqy3c+dOevToQUBAAL169WL//v2WZYsWLaJFixY0btyYvn37EhYWlu1rJyKSHykxEhGxon79+lG5cuVbVqm7GytXrmTQoEHs2LEDNzc3nnzySYYPH87vv/+Oo6MjX375pWXdLVu28L///Y/ffvuNEiVK8OKLLwKwf/9+Xn/9dSZOnMjvv/9Oy5YtGTJkiCXZSEhIoHTp0mzbto22bdtmOf6xY8cYNmwYQ4cOZceOHbz44os8//zzHDlyhM8//5yAgABGjx7N/Pnzb4r9jTfeoGLFimzcuJHt27fj6elpWe+7775j/fr1BAcHs3r1avbu3WvZLjo6mueee45hw4axY8cO/Pz8OHr0qGX5tGnTOHnyJCtXrmTlypWEhYXd1X7/bfHixYSEhPDFF1+wbds2nJycmDx5MomJiYwYMYJBgwaxfft21qxZQ1hYGKtWrbJsu3r1ambPns0vv/yC2WxmwYIFt91nRkYGQ4cOpUqVKmzZsoWZM2fy4Ycfsn37dss+Dx48yPr163n//fezxNmuXTuGDBlC69atWbp0KZ07d+aPP/7g8uXLAJw6dYrTp0/TqlUrANauXUufPn3YuXMnQUFBDB8+nNTUVCIiIhgyZAjDhg1j+/btDBw4kEGDBhEbG8vZs2f56KOP+Oabb9i+fTtNmjThnXfeyfa1ExHJj5QYiYhYkY2NDe+88w5bt24lNDT0nrevX78+AQEB2NnZ0aBBA+rVq4e/vz+Ojo4EBARkKRXq1KkTAQEB2Nvb8/LLL/Pnn38SGRnJ0qVL6dq1Kw0aNMDOzo6nnnqK9PR0/vjjjyzb2tvb4+TklOX4q1ev5qGHHqJt27bY2toSFBREq1at7upcpk6dyqhRo8jIyCAiIgIPDw8uXLgAwJo1a+jbt+//t3O3IU21YQDH/zp1Zvmow2Vq6oiIwDDC3rSosDebOhQLFCmSIAo1iaQSQ9CENI3EMioNigrEQVmYaC9mCIlQUYgQBbJefElnga0122TPh+jQrLTn+dKL1+/TfXad+9q9c/bhXNz3fQgNDcXPz489e/Yo/dra2tDpdCQmJuLp6UlGRgYREREAOJ1Orly5Ql5eHgEBAWg0GnJycqivr58073g3btxg69atzJkzBy8vLwoKCti1axdqtZqrV6+ydu1a3r9/z+DgoMvYAQwGA2FhYfj6+rJ+/XpMJtOEObu6uujv72fv3r14eXkxf/580tLSMBqNSs64uDh8fX3x9fWd8LqGh4cTGRlJS0sLAI2NjWzYsAFvb28AYmJi0Ov1eHp6snv3bqxWK48ePaKxsZFly5axbt06PDw82LRpE/PmzaOlpYVp06Zht9upr6/n6dOnZGVlcfny5UnvsRBC/Ek8fvUAhBBiqgsODubQoUMUFxezZMmS/9TX399faatUKv755x/l2N3dHafTqRx/vcfHz88PHx8fhoaG6O/vp7Ozk4aGBiVut9vp7+9Hp9MBEBgY+N3vf/v27Td7h0JCQhgYGJh07D09PZSXl/PmzRvmzp2Lm5ubMl6z2UxQUJBy7uzZs5X2+BhAaGioMh6bzcbWrVtxc3MDPhdLdrud0dHRCfOOZzabmTVrlnKs0WjQaDQAtLa2cuHCBeDzSzQ+fvzocq2/nAfg4eHh8ru+l7OpqQmLxcLSpUuV2NjYGJGRkcrxj+7B9xgMBpqamkhPT6exsZHCwkIlFh4errRVKhVarRaz2UxfXx/t7e0sXrxYiTscDqKjo9FqtdTU1FBbW8v58+fx8/MjNzeX1NTUnx6TEEL87qQwEkKI30BycjJ37twhPz/f5QHb3d3dZf/M+L1IXx7+f4bZbFba7969w2q1EhISglarZceOHeTm5ipxk8lEUFAQw8PDE35PcHDwN8vRXr9+7fLw/z2fPn0iOzubI0eOEB8fD8DJkyeVWaqZM2e6zHZ9PRszc+ZMent7XfJ9ifv7++Pp6UlDQwNhYWEAWK1WzGYzarV6wrzjBQUFucRfvXrFtWvXiI2Npbq6GqPRqBSO27Ztm/D3TpZz+fLlBAUF0dbWpsTMZrPLf+G/3Gu9Xk9ZWRkdHR18+PCB5cuXK7HBwUGl7XA4GBwcZNasWWi1WvR6PUePHnUZX0BAAG/fvsXHx4dz584xOjpKc3MzBw4cYOXKld8UqUII8aeSpXRCCPGbKCoq4tmzZy4P7jqdjtu3b2OxWHj16hXXr1//3/mvX7/OkydPsNlslJWVsXr1agIDA0lJScFoNNLd3Y3T6eTWrVskJia6vLjhR/R6PZ2dndy8eZOxsTHu3btHa2srer1+wn5fZnC+LM17/PgxdXV1ShFoMBi4cOECPT09WCwWqqqqlL5r1qxhYGCAuro6HA4HRqNReWmDSqUiKSmJiooKRkZGsFqtFBYWcvDgwUnzjpeUlMSlS5d4+fIlo6OjVFVVYTKZsFgsuLu74+3tzdjYGA0NDTx48ACHwzHp9fpRzoULF+Lt7U1tbS12u52BgQEyMzN/ermal5cXFotFOdZoNMTExFBaWoper0elUimx9vZ27t+/j91up7q6moCAABYtWkRCQgJ3796lo6MDp9PJw4cPMRgMdHV10dvbS2ZmJt3d3ajVagICAlCr1fj4+PzU+IQQ4k8gM0ZCCPGb0Gg0HD58mN27dyuf7dy5k/z8fFatWkVERATJycl0dHT8r/xxcXEUFhbS29tLbGwspaWlACxZsoSDBw+yf/9++vr6CA0NpbKykjlz5ihvU/uRiIgIqqurqaio4MCBA4SGhnLs2DGioqIm7Dd9+nSKioo4dOgQVquV8PBw0tLSuHz5Mg6Hg82bNzM0NERGRgZOp5P09HTa29uV63T69GmKi4spLS0lJiaG6OhoJXdBQQEVFRUkJCRgs9mIjo7m+PHjABPmHS81NZXh4WG2b9+OxWJhxYoVFBUVMWPGDOLj40lKSsLd3Z0FCxaQkpKiFGcT+VFOT09Pzp49S0lJCTU1NahUKvR6PVlZWZPmhM/F4sWLF9m4caOytygpKYm8vDxKSkpczo2KiqKmpobs7GwiIyM5c+YMKpUKnU5HZWUl5eXlmEwmNBoN+fn5xMTEALBv3z5ycnKU5ZOVlZWT7ncSQog/iZvz63l6IYQQQvwVHj58SEFBAc3NzcpnJ06c4Pnz5xPOlAkhxFQlM0ZCCCHEX8Rms/HixQtOnTrFli1bfvVwhBDijyF7jIQQQoi/yMjICGlpaTgcDjIyMn71cIQQ4o8hS+mEEEIIIYQQU57MGAkhhBBCCCGmPCmMhBBCCCGEEFOeFEZCCCGEEEKIKU8KIyGEEEIIIcSUJ4WREEIIIYQQYsqTwkgIIYQQQggx5f0LuQgtHELRNGUAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 1008x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "id_df = add_cancer_df[(add_cancer_df.identifier == IDENTIFIER) &\n",
+    "                      (add_cancer_df.data_type == 'test') &\n",
+    "                      (add_cancer_df.signal == 'signal')].copy()\n",
+    "\n",
+    "# make seaborn treat x axis as categorical\n",
+    "id_df.num_train_cancer_types = id_df.num_train_cancer_types.astype(str)\n",
+    "id_df.loc[(id_df.num_train_cancer_types == '-1'), 'num_train_cancer_types'] = 'all'\n",
+    "\n",
+    "sns.set({'figure.figsize': (14, 6)})\n",
+    "cat_order = ['0', '1', '2', '4', 'all']\n",
+    "sns.pointplot(data=id_df, x='num_train_cancer_types', y='aupr', hue='identifier',\n",
+    "              order=cat_order)\n",
+    "plt.legend([],[], frameon=False)\n",
+    "plt.title('Adding cancer types by confusion matrix similarity, {} mutation prediction'.format(IDENTIFIER),\n",
+    "          size=13)\n",
+    "plt.xlabel('Number of added cancer types', size=13)\n",
+    "plt.ylabel('AUPR', size=13)\n",
+    "\n",
+    "# annotate points with cancer types\n",
+    "def label_points(x, y, cancer_types, gene, ax):\n",
+    "    a = pd.DataFrame({'x': x, 'y': y, 'cancer_types': cancer_types})\n",
+    "    for i, point in a.iterrows():\n",
+    "        if gene in ['TP53', 'PIK3CA'] and point['x'] == 4:\n",
+    "            ax.text(point['x']+0.05,\n",
+    "                    point['y']+0.005,\n",
+    "                    str(point['cancer_types'].replace(' ', '\\n')),\n",
+    "                    bbox=dict(facecolor='none', edgecolor='black', boxstyle='round'),\n",
+    "                    ha='left', va='center')\n",
+    "        else:\n",
+    "            ax.text(point['x']+0.05,\n",
+    "                    point['y']+0.005,\n",
+    "                    str(point['cancer_types'].replace(' ', '\\n')),\n",
+    "                    bbox=dict(facecolor='none', edgecolor='black', boxstyle='round'))\n",
+    "\n",
+    "cat_to_loc = {c: i for i, c in enumerate(cat_order)}\n",
+    "group_id_df = (\n",
+    "    id_df.groupby(['num_train_cancer_types', 'train_cancer_types'])\n",
+    "         .mean()\n",
+    "         .reset_index()\n",
+    ")\n",
+    "label_points([cat_to_loc[c] for c in group_id_df.num_train_cancer_types],\n",
+    "             group_id_df.aupr,\n",
+    "             group_id_df.train_cancer_types,\n",
+    "             GENE,\n",
+    "             plt.gca())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plot gene/cancer type \"best model\" performance vs. single/pan-cancer models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\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>auroc</th>\n",
+       "      <th>aupr</th>\n",
+       "      <th>gene</th>\n",
+       "      <th>holdout_cancer_type</th>\n",
+       "      <th>signal</th>\n",
+       "      <th>seed</th>\n",
+       "      <th>data_type</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>identifier</th>\n",
+       "      <th>train_set</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.5000</td>\n",
+       "      <td>0.43056</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>0</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>single_cancer</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.5000</td>\n",
+       "      <td>0.33333</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>single_cancer</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>0.5000</td>\n",
+       "      <td>0.41667</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>2</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>single_cancer</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>0.5000</td>\n",
+       "      <td>0.38889</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>shuffled</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>3</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>single_cancer</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.5403</td>\n",
+       "      <td>0.18644</td>\n",
+       "      <td>BRAF</td>\n",
+       "      <td>COAD</td>\n",
+       "      <td>signal</td>\n",
+       "      <td>42</td>\n",
+       "      <td>test</td>\n",
+       "      <td>0</td>\n",
+       "      <td>BRAF_COAD</td>\n",
+       "      <td>single_cancer</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     auroc     aupr  gene holdout_cancer_type    signal  seed data_type  fold  \\\n",
+       "1   0.5000  0.43056  BRAF                COAD  shuffled    42      test     0   \n",
+       "4   0.5000  0.33333  BRAF                COAD  shuffled    42      test     1   \n",
+       "7   0.5000  0.41667  BRAF                COAD  shuffled    42      test     2   \n",
+       "10  0.5000  0.38889  BRAF                COAD  shuffled    42      test     3   \n",
+       "1   0.5403  0.18644  BRAF                COAD    signal    42      test     0   \n",
+       "\n",
+       "   identifier      train_set  \n",
+       "1   BRAF_COAD  single_cancer  \n",
+       "4   BRAF_COAD  single_cancer  \n",
+       "7   BRAF_COAD  single_cancer  \n",
+       "10  BRAF_COAD  single_cancer  \n",
+       "1   BRAF_COAD  single_cancer  "
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "id_df = add_cancer_df[(add_cancer_df.identifier == IDENTIFIER) &\n",
+    "                      (add_cancer_df.data_type == 'test')].copy()\n",
+    "\n",
+    "best_num = (\n",
+    "    id_df[id_df.signal == 'signal']\n",
+    "         .groupby('num_train_cancer_types')\n",
+    "         .mean()\n",
+    "         .reset_index()\n",
+    "         .sort_values(by='aupr', ascending=False)\n",
+    "         .iloc[0, 0]\n",
+    ")\n",
+    "print(best_num)\n",
+    "best_id_df = (\n",
+    "    id_df.loc[id_df.num_train_cancer_types == best_num, :]\n",
+    "         .drop(columns=['num_train_cancer_types', 'how_to_add', 'train_cancer_types'])\n",
+    ")\n",
+    "best_id_df['train_set'] = 'best_add'\n",
+    "sc_id_df = (\n",
+    "    id_df.loc[id_df.num_train_cancer_types == 1, :]\n",
+    "         .drop(columns=['num_train_cancer_types', 'how_to_add', 'train_cancer_types'])\n",
+    ")\n",
+    "sc_id_df['train_set'] = 'single_cancer'\n",
+    "pc_id_df = (\n",
+    "    id_df.loc[id_df.num_train_cancer_types == -1, :]\n",
+    "         .drop(columns=['num_train_cancer_types', 'how_to_add', 'train_cancer_types'])\n",
+    ")\n",
+    "pc_id_df['train_set'] = 'pancancer'\n",
+    "all_id_df = pd.concat((sc_id_df, best_id_df, pc_id_df), sort=False)\n",
+    "all_id_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f3de0db5518>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.set()\n",
+    "sns.boxplot(data=all_id_df, x='train_set', y='aupr', hue='signal', hue_order=['signal', 'shuffled'])\n",
+    "plt.title('{}, single/best/pancancer predictors'.format(IDENTIFIER))\n",
+    "plt.xlabel('Training data')\n",
+    "plt.ylabel('AUPR')\n",
+    "plt.legend(title='Signal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Single cancer significance: False\n",
+      "Pan-cancer significance: False\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Single cancer significance: {}'.format(\n",
+    "    single_cancer_comparison_df.loc[single_cancer_comparison_df.identifier == IDENTIFIER, 'reject_null'].values[0]\n",
+    "))\n",
+    "print('Pan-cancer significance: {}'.format(\n",
+    "    pancancer_comparison_df.loc[pancancer_comparison_df.identifier == IDENTIFIER, 'reject_null'].values[0]\n",
+    "))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Q2: where is this example in the single vs. pan-cancer volcano plot?\n",
+    "# see pancancer only experiments for an example of this sort of thing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "experiment_comparison_df['nlog10_p'] = -np.log(experiment_comparison_df.corr_pval)\n",
+    "\n",
+    "sns.set({'figure.figsize': (8, 6)})\n",
+    "sns.scatterplot(data=experiment_comparison_df, x='delta_mean', y='nlog10_p',\n",
+    "                hue='reject_null', alpha=0.3)\n",
+    "plt.xlabel('AUPRC(pancancer) - AUPRC(single cancer)')\n",
+    "plt.ylabel(r'$-\\log_{10}($adjusted p-value$)$')\n",
+    "plt.title('Highlight {} in pancancer vs. single-cancer comparison'.format(IDENTIFIER))\n",
+    "\n",
+    "def highlight_id(x, y, val, ax, id_to_plot):\n",
+    "    a = pd.concat({'x': x, 'y': y, 'val': val}, axis=1)\n",
+    "    for i, point in a.iterrows():\n",
+    "        if point['val'] == id_to_plot:\n",
+    "            ax.scatter(point['x'], point['y'], color='red', marker='+', s=100)\n",
+    "        \n",
+    "highlight_id(experiment_comparison_df.delta_mean,\n",
+    "             experiment_comparison_df.nlog10_p,\n",
+    "             experiment_comparison_df.identifier,\n",
+    "             plt.gca(),\n",
+    "             IDENTIFIER)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Overall, these results weren't quite as convincing as we were expecting. Although there are a few gene/cancer type combinations where there is a clear improvement when one or two relevant cancer types are added, overall there isn't much change in many cases (see first line plots of multiple cancer types).\n",
+    "\n",
+    "Biologically speaking, this isn't too surprising for a few reasons:\n",
+    "\n",
+    "* Some genes aren’t drivers in certain cancer types\n",
+    "* Some genes have very cancer-specific effects\n",
+    "* Some genes (e.g. TP53) have very well-preserved effects across all cancers\n",
+    "\n",
+    "We think there could be room for improvement as far as cancer type selection (some of the cancers chosen don't make a ton of sense), but overall we're a bit skeptical that this approach will lead to models that generalize better than a single-cancer model in most cases."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:pancancer-evaluation]",
+   "language": "python",
+   "name": "conda-env-pancancer-evaluation-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/04_add_cancer_types/run_add_cancer_classification.py b/04_add_cancer_types/run_add_cancer_classification.py
new file mode 100644
index 0000000..b09c40b
--- /dev/null
+++ b/04_add_cancer_types/run_add_cancer_classification.py
@@ -0,0 +1,257 @@
+"""
+Script to run "add cancer" experiments. The general idea is to add cancers
+in a particular order (either random or determined by cancer type similarity).
+
+The prediction goal is the same as in 02_cancer_type_classification
+experiments; that is, predicting presence/absence of a given mutation in
+a particular cancer type.
+
+"""
+import sys
+import argparse
+import itertools as it
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+import pancancer_evaluation.config as cfg
+from pancancer_evaluation.data_models.tcga_data_model import TCGADataModel
+from pancancer_evaluation.exceptions import (
+    NoTrainSamplesError,
+    NoTestSamplesError,
+    OneClassError,
+    ResultsFileExistsError
+)
+from pancancer_evaluation.utilities.classify_utilities import run_cv_cancer_type
+import pancancer_evaluation.utilities.data_utilities as du
+import pancancer_evaluation.utilities.file_utilities as fu
+
+def process_args():
+    p = argparse.ArgumentParser()
+    p.add_argument('--custom_genes', nargs='*', default=None,
+                   help='currently this needs to be a subset of top_50')
+    p.add_argument('--debug', action='store_true',
+                   help='use subset of data for fast debugging')
+    p.add_argument('--gene_set', type=str,
+                   choices=['top_50', 'vogelstein', 'custom'],
+                   default='top_50',
+                   help='choose which gene set to use. top_50 and vogelstein are '
+                        'predefined gene sets (see data_utilities), and custom allows '
+                        'any gene or set of genes in TCGA, specified in --custom_genes')
+    p.add_argument('--holdout_cancer_types', nargs='*', default=None,
+                   help='provide a list of cancer types to hold out, uses all '
+                        'cancer types in TCGA if none are provided')
+    p.add_argument('--how_to_add', type=str,
+                   choices=['random', 'similarity'],
+                   default='random',
+                   help='Method for choosing cancer types to add to the '
+                        'training dataset; see data model for details')
+    p.add_argument('--log_file', default=None,
+                   help='name of file to log skipped cancer types to')
+    p.add_argument('--num_folds', type=int, default=4,
+                   help='number of folds of cross-validation to run')
+    p.add_argument('--results_dir', default=cfg.results_dir,
+                   help='where to write results to')
+    p.add_argument('--seed', type=int, default=cfg.default_seed)
+    p.add_argument('--subset_mad_genes', type=int, default=cfg.num_features_raw,
+                   help='if included, subset gene features to this number of '
+                        'features having highest mean absolute deviation')
+    p.add_argument('--verbose', action='store_true')
+    args = p.parse_args()
+
+    if args.gene_set == 'custom':
+        if args.custom_genes is None:
+            p.error('must include --custom_genes when --gene_set=\'custom\'')
+        args.gene_set = args.custom_genes
+        del args.custom_genes
+    elif (args.gene_set != 'custom' and args.custom_genes is not None):
+        p.error('must use option --gene_set=\'custom\' if custom genes are included')
+
+    sample_info_df = du.load_sample_info(args.verbose)
+    tcga_cancer_types = list(np.unique(sample_info_df.cancer_type))
+    if args.holdout_cancer_types is None:
+        args.holdout_cancer_types = tcga_cancer_types
+    else:
+        not_in_tcga = set(args.holdout_cancer_types) - set(tcga_cancer_types)
+        if len(not_in_tcga) > 0:
+            p.error('some cancer types not present in TCGA: {}'.format(
+                ' '.join(not_in_tcga)))
+
+    args.results_dir = Path(args.results_dir).resolve()
+
+    if args.log_file is None:
+        args.log_file = Path(args.results_dir, 'log_skipped.tsv').resolve()
+
+    return args, sample_info_df
+
+
+if __name__ == '__main__':
+
+    # process command line arguments
+    args, sample_info_df = process_args()
+
+    # create results dir if it doesn't exist
+    args.results_dir.mkdir(parents=True, exist_ok=True)
+
+    # create empty log file if it doesn't exist
+    log_columns = [
+        'gene',
+        'cancer_type',
+        'shuffle_labels',
+        'skip_reason'
+    ]
+    if args.log_file.exists() and args.log_file.is_file():
+        log_df = pd.read_csv(args.log_file, sep='\t')
+    else:
+        log_df = pd.DataFrame(columns=log_columns)
+        log_df.to_csv(args.log_file, sep='\t')
+
+    tcga_data = TCGADataModel(sample_info=sample_info_df,
+                              seed=args.seed,
+                              subset_mad_genes=args.subset_mad_genes,
+                              verbose=args.verbose,
+                              debug=args.debug)
+
+    genes_df = tcga_data.load_gene_set(args.gene_set)
+
+    # we want to run mutation prediction experiments:
+    # - for signal and shuffled labels
+    #   (shuffled labels acts as our lower baseline)
+    # - for all genes in the given gene set
+    # - for all cancer types in the given holdout cancer types (or all of TCGA)
+    # - for all numbers of cancers to add to training set
+    #   (cfg.num_train_cancer_types)
+    for shuffle_labels in (False, True):
+
+        print('shuffle_labels: {}'.format(shuffle_labels))
+
+        progress_1 = tqdm(genes_df.iterrows(),
+                          total=genes_df.shape[0],
+                          ncols=100,
+                          file=sys.stdout)
+
+        for gene_idx, gene_series in progress_1:
+            gene = gene_series.gene
+            classification = gene_series.classification
+            progress_1.set_description('gene: {}'.format(gene))
+
+            gene_dir = fu.make_gene_dir(args.results_dir, gene, add_cancer=True)
+
+            progress_2 = tqdm(args.holdout_cancer_types,
+                              ncols=100,
+                              file=sys.stdout)
+
+            for test_cancer_type in progress_2:
+
+                progress_2.set_description('cancer type: {}'.format(test_cancer_type))
+                cancer_type_log_df = None
+
+                progress_3 = tqdm(cfg.num_train_cancer_types,
+                                  ncols=100,
+                                  file=sys.stdout)
+
+                for num_train_cancer_types in progress_3:
+
+                    progress_3.set_description('num train cancers: {}'.format(
+                        num_train_cancer_types))
+
+                    try:
+                        tcga_data.process_data_for_gene_and_cancer(gene,
+                                                                   classification,
+                                                                   test_cancer_type,
+                                                                   gene_dir,
+                                                                   num_train_cancer_types,
+                                                                   how_to_add=args.how_to_add,
+                                                                   shuffle_labels=shuffle_labels)
+                    except NoTrainSamplesError:
+                        if args.verbose:
+                            print('Skipping due to no train samples: gene {}, '
+                                  'cancer type {}'.format(gene, test_cancer_type),
+                                  file=sys.stderr)
+                        cancer_type_log_df = fu.generate_log_df(
+                            log_columns,
+                            [gene, test_cancer_type, shuffle_labels, 'no_train_samples']
+                        )
+                        continue
+
+                    try:
+                        # check if results file already exists, if not skip it
+                        check_file = fu.check_add_cancer_file(gene_dir,
+                                                              gene,
+                                                              test_cancer_type,
+                                                              num_train_cancer_types,
+                                                              args.how_to_add,
+                                                              args.seed,
+                                                              shuffle_labels)
+                    except ResultsFileExistsError:
+                        if args.verbose:
+                            print('Skipping because results file exists already: '
+                                  'gene {}, cancer type {}'.format(gene, test_cancer_type),
+                                  file=sys.stderr)
+                        cancer_type_log_df = fu.generate_log_df(
+                            log_columns,
+                            [gene, test_cancer_type, shuffle_labels, 'file_exists']
+                        )
+                        continue
+
+                    try:
+                        # run cross-validation for the given cancer type
+                        #
+                        # since we already filtered the dataset to the cancer
+                        # types of interest, we can just use this function with
+                        # the "pancancer" option (you can think of it as a a
+                        # pancancer model where the "universe" of all cancers
+                        # is limited by our previous filtering, kinda).
+                        results = run_cv_cancer_type(tcga_data,
+                                                     gene,
+                                                     test_cancer_type,
+                                                     sample_info_df,
+                                                     args.num_folds,
+                                                     use_pancancer=True,
+                                                     use_pancancer_only=False,
+                                                     shuffle_labels=shuffle_labels)
+                    except NoTrainSamplesError:
+                        if args.verbose:
+                            print('Skipping due to no train samples: gene {}, '
+                                  'cancer type {}'.format(gene, test_cancer_type),
+                                  file=sys.stderr)
+                        cancer_type_log_df = fu.generate_log_df(
+                            log_columns,
+                            [gene, test_cancer_type, shuffle_labels, 'no_train_samples']
+                        )
+                    except NoTestSamplesError:
+                        if args.verbose:
+                            print('Skipping due to no test samples: gene {}, '
+                                  'cancer type {}'.format(gene, test_cancer_type),
+                                  file=sys.stderr)
+                        cancer_type_log_df = fu.generate_log_df(
+                            log_columns,
+                            [gene, test_cancer_type, shuffle_labels, 'no_test_samples']
+                        )
+                    except OneClassError:
+                        if args.verbose:
+                            print('Skipping due to one holdout class: gene {}, '
+                                  'cancer type {}'.format(gene, test_cancer_type),
+                                  file=sys.stderr)
+                        cancer_type_log_df = fu.generate_log_df(
+                            log_columns,
+                            [gene, test_cancer_type, shuffle_labels, 'one_class']
+                        )
+                    else:
+                        # only save results if no exceptions
+                        fu.save_results_add_cancer(gene_dir,
+                                                   check_file,
+                                                   results,
+                                                   gene,
+                                                   test_cancer_type,
+                                                   tcga_data.y_df.DISEASE.unique(),
+                                                   num_train_cancer_types,
+                                                   args.how_to_add,
+                                                   args.seed,
+                                                   shuffle_labels)
+
+                    if cancer_type_log_df is not None:
+                        fu.write_log_file(cancer_type_log_df, args.log_file)
+
diff --git a/04_coefficient_analysis.ipynb b/05_coefficient_analysis.ipynb
similarity index 100%
rename from 04_coefficient_analysis.ipynb
rename to 05_coefficient_analysis.ipynb
diff --git a/pancancer_evaluation/config.py b/pancancer_evaluation/config.py
index 0fe5698..5305bee 100644
--- a/pancancer_evaluation/config.py
+++ b/pancancer_evaluation/config.py
@@ -58,3 +58,11 @@
 cross_cancer_types = [
     'THCA', 'COAD', 'GBM', 'LGG', 'SKCM'
 ]
+
+# parameters for "add cancer" experiments
+
+# how many cancer types to add to target cancer
+# 0 = just use target cancer, -1 = use all cancers (pan-cancer model)
+num_train_cancer_types = [0, 1, 2, 4, -1]
+# similarity matrix to use for 'similarity' addition option
+similarity_matrix_file = data_dir / 'expression_confusion_matrix.tsv'
diff --git a/pancancer_evaluation/data_models/tcga_data_model.py b/pancancer_evaluation/data_models/tcga_data_model.py
index 70a5215..65cd83e 100644
--- a/pancancer_evaluation/data_models/tcga_data_model.py
+++ b/pancancer_evaluation/data_models/tcga_data_model.py
@@ -6,6 +6,7 @@
 import pandas as pd
 
 import pancancer_evaluation.config as cfg
+from pancancer_evaluation.exceptions import NoTrainSamplesError
 import pancancer_evaluation.utilities.data_utilities as du
 from pancancer_evaluation.utilities.tcga_utilities import (
     process_y_matrix,
@@ -22,6 +23,7 @@ class TCGADataModel():
     """
 
     def __init__(self,
+                 sample_info=None,
                  seed=cfg.default_seed,
                  subset_mad_genes=-1,
                  verbose=False,
@@ -47,7 +49,7 @@ def __init__(self,
         self.test = test
 
         # load and store data in memory
-        self._load_data(debug=debug, test=self.test)
+        self._load_data(sample_info=sample_info, debug=debug, test=self.test)
 
     def load_gene_set(self, gene_set='top_50'):
         """
@@ -73,13 +75,22 @@ def load_gene_set(self, gene_set='top_50'):
         elif gene_set == 'vogelstein':
             genes_df = du.load_vogelstein()
         else:
+            from pancancer_evaluation.exceptions import GenesNotFoundError
             assert isinstance(gene_set, typing.List)
             genes_df = du.load_vogelstein()
-            if gene in genes_df.gene:
+            # if all genes in gene_set are in vogelstein dataset, use it
+            if set(gene_set).issubset(set(genes_df.gene.values)):
                 genes_df = genes_df[genes_df.gene.isin(gene_set)]
+            # else if all genes in gene_set are in top50 dataset, use it
             else:
-                genes_df = load_top_50()
-                genes_df = genes_df[genes_df.gene.isin(gene_set)]
+                genes_df = du.load_top_50()
+                if set(gene_set).issubset(set(genes_df.gene.values)):
+                    genes_df = genes_df[genes_df.gene.isin(gene_set)]
+                else:
+                # else throw an error
+                    raise GenesNotFoundError(
+                        'Gene list was not a subset of Vogelstein or top50'
+                    )
 
         return genes_df
 
@@ -330,7 +341,96 @@ def process_train_data_for_gene(self,
             self.y_train_df.status = np.random.permutation(
                 self.y_train_df.status.values)
 
-    def _load_data(self, debug=False, test=False):
+
+    def process_data_for_gene_and_cancer(self,
+                                         gene,
+                                         classification,
+                                         test_cancer_type,
+                                         output_dir,
+                                         num_train_cancer_types=0,
+                                         how_to_add='random',
+                                         shuffle_labels=False):
+        """
+        Prepare to train model on a given gene, to predict on a given cancer
+        type.
+
+        Arguments
+        ---------
+        gene (str): gene to train/evaluate model on
+        classification (str): 'oncogene', 'TSG' (tumor suppressor gene), or
+                              'neither' for the provided gene
+        test_cancer_type (str): cancer type to hold out
+        output_dir (str): directory to write output to, if None don't write output
+        num_train_cancer_types (int): number of cancer types besides the test
+                                      cancer to add to the training set. If 0,
+                                      only use the test cancer. If -1, use all
+                                      valid cancer types (resulting in a
+                                      "pan-cancer" model).
+        how_to_add (str): how to choose cancer types to add to the training
+                          set. 'random' adds them in a random order, 'similarity'
+                          ranks valid cancers by some precomputed similarity
+                          metric (specified in cfg.similarity_matrix) to the
+                          target cancer type.
+        shuffle_labels (bool): whether or not to shuffle labels (negative control)
+        """
+        y_df_raw = self._generate_labels(gene, classification, output_dir)
+
+        if how_to_add == 'similarity':
+            similarity_matrix = pd.read_csv(cfg.similarity_matrix_file,
+                                            sep='\t', index_col=0, header=0)
+        else:
+            similarity_matrix = None
+
+        cancer_types_to_add = self._get_cancers_to_add(
+            y_df_raw,
+            test_cancer_type,
+            num_train_cancer_types,
+            how_to_add,
+            similarity_matrix=similarity_matrix,
+            seed=self.seed
+        )
+
+        assert test_cancer_type in cancer_types_to_add
+        if num_train_cancer_types >= 0:
+            assert len(cancer_types_to_add) == num_train_cancer_types + 1
+
+        filtered_data = self._filter_data_for_gene_and_train_cancers(
+            self.rnaseq_df,
+            y_df_raw,
+            cancer_types_to_add,
+            # add cancer type covariate if more than one cancer type to add
+            (len(cancer_types_to_add) > 1)
+        )
+
+        rnaseq_filtered_df, y_filtered_df, gene_features = filtered_data
+
+        # catch the case where there are no samples for the test cancer
+        # after filtering, and raise an error
+        try:
+            num_test_cancer_samples = (
+                y_filtered_df.groupby('DISEASE')
+                             .count()
+                             .loc[test_cancer_type, 'status']
+            )
+        except KeyError:
+            # no samples for the test cancer, test_cancer_type not in df
+            raise NoTrainSamplesError(
+                'No train samples found for train identifier: {}_{}'.format(
+                    gene, test_cancer_type)
+            )
+
+        assert set(y_filtered_df.DISEASE.unique()) == set(cancer_types_to_add)
+
+        if shuffle_labels:
+            y_filtered_df.status = np.random.permutation(
+                y_filtered_df.status.values)
+
+        self.X_df = rnaseq_filtered_df
+        self.y_df = y_filtered_df
+        self.gene_features = gene_features
+
+
+    def _load_data(self, sample_info=None, debug=False, test=False):
         """Load and store relevant data.
 
         This data does not vary based on the gene/cancer type being considered
@@ -344,7 +444,10 @@ def _load_data(self, debug=False, test=False):
         # load expression data
         self.rnaseq_df = du.load_expression_data(verbose=self.verbose,
                                                  debug=debug)
-        self.sample_info_df = du.load_sample_info(verbose=self.verbose)
+        if sample_info is None:
+            self.sample_info_df = du.load_sample_info(verbose=self.verbose)
+        else:
+            self.sample_info_df = sample_info
 
         # load and unpack pancancer data
         # this data is described in more detail in the load_pancancer_data docstring
@@ -429,6 +532,30 @@ def _filter_data_for_gene_and_cancer(self, rnaseq_df, y_df, cancer_type,
         y_df = y_df.reindex(rnaseq_df_filtered.index)
         return rnaseq_df_filtered, y_df, gene_features
 
+    def _filter_data_for_gene_and_train_cancers(self,
+                                                rnaseq_df,
+                                                y_df,
+                                                cancer_types_to_add,
+                                                add_cancertype_covariate):
+        use_samples, rnaseq_df, y_df, gene_features = align_matrices(
+            x_file_or_df=rnaseq_df,
+            y=y_df,
+            # assume we're training on a single cancer, so no cancer type covariate
+            add_cancertype_covariate=add_cancertype_covariate,
+            add_mutation_covariate=True
+        )
+        cancer_type_sample_ids = (
+            self.sample_info_df.loc[
+                self.sample_info_df.cancer_type.isin(cancer_types_to_add)
+            ].index
+        )
+        rnaseq_df_filtered = rnaseq_df.loc[
+            rnaseq_df.index.intersection(cancer_type_sample_ids), :
+        ]
+        y_df = y_df.reindex(rnaseq_df_filtered.index)
+        return rnaseq_df_filtered, y_df, gene_features
+
+
     @staticmethod
     def holdout_percent_labels(y,
                                percent_holdout,
@@ -449,6 +576,7 @@ def holdout_percent_labels(y,
         test_ixs (np.array): indexes of test labels in original dataset
         """
         assert len(y.shape) == 1, 'labels must be flattened'
+        # TODO: could set a temp seed instead of reseeding?
         np.random.seed(seed)
         train_ixs = np.zeros((y.shape[0],)).astype('bool')
         test_ixs = np.copy(train_ixs)
@@ -509,3 +637,77 @@ def holdout_percent_labels(y,
             test_ixs |= nz_ixs
         return (train_ixs, test_ixs)
 
+    @staticmethod
+    def _get_cancers_to_add(y_df,
+                            test_cancer_type,
+                            num_cancer_types,
+                            how_to_add,
+                            similarity_matrix=None,
+                            seed=cfg.default_seed):
+
+        # start with test cancer type and add if necessary
+        train_cancer_types = [test_cancer_type]
+        # y_df should already be filtered to valid cancer types
+        valid_cancer_types = [ct for ct in y_df.DISEASE.unique()
+                                 if ct != test_cancer_type]
+
+        if num_cancer_types == -1:
+            # pan-cancer model, train on all valid cancer types
+            train_cancer_types += valid_cancer_types
+        elif num_cancer_types >= 1:
+            # add desired number of cancer types to train set
+            if how_to_add == 'random':
+                import contextlib
+                # We want this random addition of cancer types to be the same
+                # each time we add them. We can accomplish this by reseeding
+                # np.random each time we call this function.
+                #
+                # However, we don't want to mess with the global np.random seed
+                # when we do this, so we create a context in which the seed is
+                # temporarily reset, then put it back when we're done. In
+                # effect, this creates a "local", repeatable random seed in the
+                # relevant Python context.
+                #
+                # See https://stackoverflow.com/a/49557127 for more detail.
+                #
+                # TODO: write a test for this
+                @contextlib.contextmanager
+                def temp_seed(cntxt_seed):
+                    state = np.random.get_state()
+                    np.random.seed(cntxt_seed)
+                    try:
+                        yield
+                    finally:
+                        np.random.set_state(state)
+
+                # choose cancer types to add at random, with the same random
+                # order across experiments (i.e. across varying values of
+                # num_cancer_types)
+                with temp_seed(seed):
+                    shuffled_cancers = np.random.choice(
+                        valid_cancer_types,
+                        size=(len(valid_cancer_types),),
+                        replace=False
+                    )
+                    train_cancer_types += list(shuffled_cancers[:num_cancer_types])
+
+            elif how_to_add == 'similarity':
+                sim_df = similarity_matrix
+                # drop labels that aren't in valid cancer types
+                # this includes test cancer type, we've already added it
+                labels_to_drop = list(
+                    set(sim_df.columns) - set(valid_cancer_types)
+                )
+                # sort descending since we want high similarity
+                cancer_type_rank = (
+                    sim_df.loc[test_cancer_type, :]
+                          .drop(labels=labels_to_drop)
+                          .sort_values(ascending=False)
+                          .index
+                )
+                train_cancer_types += list(cancer_type_rank[:num_cancer_types])
+        # if num_cancer_types==0, use single-cancer model
+        # (don't need to add to train_cancer_types)
+
+        return train_cancer_types
+
diff --git a/pancancer_evaluation/exceptions.py b/pancancer_evaluation/exceptions.py
index 2a7569a..f1c072c 100644
--- a/pancancer_evaluation/exceptions.py
+++ b/pancancer_evaluation/exceptions.py
@@ -10,8 +10,7 @@ class NoTrainSamplesError(Exception):
     This allows calling scripts to choose how to handle this case (e.g. to
     print an error message and continue, or to abort execution).
     """
-    def __init__(self, *args):
-        super().__init__(*args)
+    pass
 
 
 class NoTestSamplesError(Exception):
@@ -22,8 +21,7 @@ class NoTestSamplesError(Exception):
     This allows calling scripts to choose how to handle this case (e.g. to
     print an error message and continue, or to abort execution).
     """
-    def __init__(self, *args):
-        super().__init__(*args)
+    pass
 
 
 class OneClassError(Exception):
@@ -34,8 +32,7 @@ class OneClassError(Exception):
     This allows calling scripts to choose how to handle this case (e.g. to
     print an error message and continue, or to abort execution).
     """
-    def __init__(self, *args):
-        super().__init__(*args)
+    pass
 
 
 class ResultsFileExistsError(Exception):
@@ -46,6 +43,16 @@ class ResultsFileExistsError(Exception):
     This allows calling scripts to choose how to handle this case (e.g. to
     print an error message and continue, or to abort execution).
     """
-    def __init__(self, *args):
-        super().__init__(*args)
+    pass
+
+
+class GenesNotFoundError(Exception):
+    """
+    Custom exception to raise when genes provided for classification are not
+    part of existing datasets with oncogene/TSG info.
+
+    This allows calling scripts to choose how to handle this case (e.g. to
+    print an error message and continue, or to abort execution).
+    """
+    pass
 
diff --git a/pancancer_evaluation/utilities/analysis_utilities.py b/pancancer_evaluation/utilities/analysis_utilities.py
index 9cdabf6..58d5ec9 100644
--- a/pancancer_evaluation/utilities/analysis_utilities.py
+++ b/pancancer_evaluation/utilities/analysis_utilities.py
@@ -98,6 +98,51 @@ def load_flip_labels_results(results_dir, experiment_descriptor):
     return results_df
 
 
+def load_add_cancer_results(results_dir, load_cancer_types=False):
+    """Load results of 'add cancer' experiments.
+
+    Argument
+    --------
+    results_dir (str): directory to look in for results, subdirectories should
+                       be experiments for individual genes
+
+    Returns
+    -------
+    results_df (pd.DataFrame): results of classification experiments
+    """
+    results_df = pd.DataFrame()
+    for gene_name in os.listdir(results_dir):
+        gene_dir = os.path.join(results_dir, gene_name)
+        if not os.path.isdir(gene_dir): continue
+        for results_file in os.listdir(gene_dir):
+            if 'classify' not in results_file: continue
+            if results_file[0] == '.': continue
+            full_results_file = os.path.join(gene_dir, results_file)
+            gene_results_df = pd.read_csv(full_results_file, sep='\t')
+            gene_results_df['num_train_cancer_types'] = (
+                int(results_file.split('_')[3])
+            )
+            gene_results_df['how_to_add'] = (
+                results_file.split('_')[4]
+            )
+            gene_results_df['identifier'] = (
+                gene_results_df['gene'] + '_' +
+                gene_results_df['holdout_cancer_type']
+            )
+            if load_cancer_types:
+                train_cancer_types = get_cancer_types(gene_dir, results_file)
+                gene_results_df['train_cancer_types'] = ' '.join(train_cancer_types)
+            results_df = pd.concat((results_df, gene_results_df))
+    return results_df
+
+
+def get_cancer_types(gene_dir, results_file):
+    prefix = '_'.join(results_file.split('_')[:6])
+    cancer_types_file = '{}_train_cancer_types.txt'.format(prefix)
+    return np.loadtxt(os.path.join(gene_dir, cancer_types_file),
+                      dtype=str, ndmin=1)
+
+
 def generate_nonzero_coefficients(results_dir):
     """Generate coefficients from mutation prediction model fits.
 
diff --git a/pancancer_evaluation/utilities/classify_utilities.py b/pancancer_evaluation/utilities/classify_utilities.py
index a6586d0..1ed7879 100644
--- a/pancancer_evaluation/utilities/classify_utilities.py
+++ b/pancancer_evaluation/utilities/classify_utilities.py
@@ -165,8 +165,14 @@ def evaluate_cross_cancer(data_model,
     return results
 
 
-def run_cv_cancer_type(data_model, gene, cancer_type, sample_info, num_folds,
-                       use_pancancer, use_pancancer_only, shuffle_labels):
+def run_cv_cancer_type(data_model,
+                       gene,
+                       cancer_type,
+                       sample_info,
+                       num_folds,
+                       use_pancancer,
+                       use_pancancer_only,
+                       shuffle_labels):
     """
     Run cross-validation experiments for a given gene/cancer type combination,
     then write them to files in the results directory. If the relevant files
diff --git a/pancancer_evaluation/utilities/file_utilities.py b/pancancer_evaluation/utilities/file_utilities.py
index 488991c..6814b79 100644
--- a/pancancer_evaluation/utilities/file_utilities.py
+++ b/pancancer_evaluation/utilities/file_utilities.py
@@ -4,6 +4,7 @@
 """
 from pathlib import Path
 
+import numpy as np
 import pandas as pd
 
 from pancancer_evaluation.exceptions import ResultsFileExistsError
@@ -128,6 +129,65 @@ def save_results_cross_cancer(output_dir,
     )
 
 
+def save_results_add_cancer(gene_dir,
+                            check_file,
+                            results,
+                            gene,
+                            test_cancer_type,
+                            train_cancer_types,
+                            num_train_cancer_types,
+                            how_to_add,
+                            seed,
+                            shuffle_labels):
+
+    signal = 'shuffled' if shuffle_labels else 'signal'
+    gene_auc_df = pd.concat(results['gene_auc'])
+    gene_aupr_df = pd.concat(results['gene_aupr'])
+    gene_coef_df = pd.concat(results['gene_coef'])
+    gene_metrics_df = pd.concat(results['gene_metrics'])
+
+    gene_coef_df.to_csv(
+        check_file, sep="\t", index=False, compression="gzip",
+        float_format="%.5g"
+    )
+
+    prefix = '_'.join([gene,
+                       's{}'.format(str(seed)),
+                       test_cancer_type,
+                       str(num_train_cancer_types),
+                       how_to_add,
+                       signal])
+
+    output_file = Path(
+        gene_dir, "{}_auc_threshold_metrics.tsv.gz".format(prefix)
+    ).resolve()
+    gene_auc_df.to_csv(
+        output_file, sep="\t", index=False, compression="gzip", float_format="%.5g"
+    )
+
+    output_file = Path(
+        gene_dir, "{}_aupr_threshold_metrics.tsv.gz".format(prefix)
+    ).resolve()
+    gene_aupr_df.to_csv(
+        output_file, sep="\t", index=False, compression="gzip", float_format="%.5g"
+    )
+
+    output_file = Path(
+        gene_dir, "{}_classify_metrics.tsv.gz".format(prefix)
+    ).resolve()
+    gene_metrics_df.to_csv(
+        output_file, sep="\t", index=False, compression="gzip", float_format="%.5g"
+    )
+
+    # save cancer types we trained the model on
+    # these may be useful for downstream analyses
+    output_file = Path(
+        gene_dir, "{}_train_cancer_types.txt".format(prefix)
+    ).resolve()
+    # train_cancer_types should be a 1D numpy array
+    np.savetxt(output_file, train_cancer_types, fmt='%s')
+
+
 def generate_log_df(log_columns, log_values):
     """Generate and format log output."""
     return pd.DataFrame(dict(zip(log_columns, log_values)), index=[0])
@@ -167,13 +227,19 @@ def write_counts_file(counts_df, counts_file):
         counts_df.to_csv(counts_file, mode='a', sep='\t')
 
 
-def make_gene_dir(results_dir, gene, use_pancancer_cv, use_pancancer_only):
+def make_gene_dir(results_dir,
+                  gene,
+                  use_pancancer_cv=False,
+                  use_pancancer_only=False,
+                  add_cancer=False):
     """Create a directory for the given gene."""
     dirname = 'single_cancer'
     if use_pancancer_cv:
         dirname = 'pancancer'
     elif use_pancancer_only:
         dirname = 'pancancer_only'
+    elif add_cancer:
+        dirname = 'add_cancer'
     gene_dir = Path(results_dir, dirname, gene).resolve()
     gene_dir.mkdir(parents=True, exist_ok=True)
     return gene_dir
@@ -232,6 +298,33 @@ def check_cross_cancer_file(output_dir,
     return check_file
 
 
+def check_add_cancer_file(gene_dir,
+                          gene,
+                          test_cancer_type,
+                          num_train_cancer_types,
+                          how_to_add,
+                          seed,
+                          shuffle_labels):
+    # note that the specific train cancer types used for this experiment have
+    # to be stored in the results dataframe (rather than in the filename)
+    # the filename just stores the number of them
+    signal = 'shuffled' if shuffle_labels else 'signal'
+    prefix = '_'.join([gene,
+                       's{}'.format(str(seed)),
+                       test_cancer_type,
+                       str(num_train_cancer_types),
+                       how_to_add,
+                       signal])
+    check_file = Path(
+        gene_dir, "{}_coefficients.tsv.gz".format(prefix)
+    ).resolve()
+    if check_status(check_file):
+        raise ResultsFileExistsError(
+            'Results file already exists for gene: {}\n'.format(gene)
+        )
+    return check_file
+
+
 def check_status(file):
     """
     Check the status of a gene or cancer-type application
diff --git a/tests/test_add_cancers.py b/tests/test_add_cancers.py
new file mode 100644
index 0000000..f653d3e
--- /dev/null
+++ b/tests/test_add_cancers.py
@@ -0,0 +1,100 @@
+"""
+Test cases for add cancer types in tcga_data_model.py
+"""
+import pytest
+import numpy as np
+import pandas as pd
+
+from pancancer_evaluation.data_models.tcga_data_model import TCGADataModel
+import pancancer_evaluation.config as cfg
+
+@pytest.fixture(scope='module')
+def sim_data():
+    # simulate some labels
+    y_df = pd.DataFrame({
+        'status': [1, 0, 1, 0, 1, 0, 1, 0],
+        'DISEASE': ['LUSC', 'LUSC', 'LUAD', 'BRCA',
+                    'BRCA', 'BRCA', 'THCA', 'THCA']
+    })
+    valid_cancer_types = list(y_df.DISEASE.unique())
+    # generate a random similarity matrix
+    similarity_matrix = pd.DataFrame(
+        np.random.uniform(size=len(valid_cancer_types)**2).reshape(
+            (-1, len(valid_cancer_types))),
+        index=valid_cancer_types,
+        columns=valid_cancer_types
+    )
+    return y_df, similarity_matrix
+
+
+@pytest.mark.parametrize('test_cancer_type', ['LUSC', 'BRCA', 'LUAD'])
+@pytest.mark.parametrize('num_cancer_types', [0, 1, 2, -1])
+def test_random_cancer_types(sim_data, test_cancer_type, num_cancer_types):
+    y_df, similarity_matrix = sim_data
+    cancer_list = TCGADataModel._get_cancers_to_add(
+        y_df,
+        test_cancer_type,
+        num_cancer_types,
+        how_to_add='random',
+        similarity_matrix=None
+    )
+
+    assert test_cancer_type in cancer_list
+
+    if num_cancer_types == -1:
+        assert set(cancer_list) == set(y_df.DISEASE.unique())
+    else:
+        assert num_cancer_types + 1 == len(cancer_list)
+
+
+@pytest.mark.parametrize('test_cancer_type', ['LUSC', 'BRCA', 'LUAD'])
+@pytest.mark.parametrize('num_cancer_types', [0, 1, 2, 3, -1])
+def test_sim_cancer_types(sim_data, test_cancer_type, num_cancer_types):
+    y_df, similarity_matrix = sim_data
+    cancer_list = TCGADataModel._get_cancers_to_add(
+        y_df,
+        test_cancer_type,
+        num_cancer_types,
+        how_to_add='similarity',
+        similarity_matrix=similarity_matrix
+    )
+
+    assert test_cancer_type in cancer_list
+
+    if num_cancer_types == -1:
+        assert set(cancer_list) == set(y_df.DISEASE.unique())
+    else:
+        assert num_cancer_types + 1 == len(cancer_list)
+
+    if (len(cancer_list) > 1) and (num_cancer_types != -1):
+        # check that cancer types are in sorted order in sim matrix
+        # https://stackoverflow.com/a/41309844
+        sim_values = (
+            similarity_matrix.loc[test_cancer_type, cancer_list[1:]].values
+        )
+        print(sim_values)
+        assert (np.diff(sim_values) <= 0).all()
+
+
+@pytest.mark.parametrize('test_cancer_type', ['LUSC', 'BRCA', 'LUAD'])
+def test_cancer_type_order(sim_data, test_cancer_type):
+    y_df, similarity_matrix = sim_data
+    last_list = []
+    last_num = None
+    for num_cancer_types in [0, 1, 2, -1]:
+        cur_list = TCGADataModel._get_cancers_to_add(
+            y_df,
+            test_cancer_type,
+            num_cancer_types,
+            how_to_add='random',
+            similarity_matrix=None
+        )
+        # check that when we add cancer types, the first few are the
+        # same as the first few with fewer cancer types (i.e. previously
+        # added cancer types shouldn't change)
+        if last_num is not None:
+            assert last_list[:last_num+1] == cur_list[:last_num+1]
+        last_list = cur_list
+        last_num = num_cancer_types
+
+