scRNA_train_script.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "outside-swift",
   "metadata": {},
   "source": [
    "### Pseudo code\n",
    "\n",
    "Read in scRNA data\n",
    "\n",
    "X=scRNA.X count matrix\n",
    "\n",
    "Y=scRNA.obs dbscan (hand annotated labels)\n",
    "\n",
    "Train, validation, test split \n",
    "\n",
    "Shuffle \n",
    "\n",
    "**Train model over N epoches with batches**\n",
    "\n",
    "    For each epoch \n",
    "    \n",
    "        For each batch within an epoch\n",
    "        \n",
    "            1. Store every 1000 batch's latent space --> Silhouette score on latent space to true labels\n",
    "            \n",
    "            2. Train loss (reconstr + KL lower bound)\n",
    "            \n",
    "        At the end of each epoch evaluate on validation:\n",
    "        \n",
    "        1. Validation latent space transform_rna(train_x) --> silhouette score\n",
    "        \n",
    "        2. Reconstruct validation set --> MSE (to original validation data)\n",
    "\n",
    "\n",
    "### Grid search for best learning rate, learning rate decay, loss weights, \n",
    "\n",
    "        \n",
    "**Evaluate on test set**        \n",
    "        \n",
    "1. Validation latent space transform_rna(train_x) --> silhouette score\n",
    "        \n",
    "2. Reconstruct validation set --> MSE (to original validation data)\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "according-carpet",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import os\n",
    "import functools\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error, f1_score, roc_auc_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import silhouette_samples, silhouette_score\n",
    "from tqdm.notebook import tqdm\n",
    "import scanpy as sc\n",
    "from collections import Counter\n",
    "import matplotlib.cm as cm\n",
    "from anndata import AnnData\n",
    "import itertools as it\n",
    "\n",
    "import scTrans\n",
    "from scTrans import scTranslate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "external-chick",
   "metadata": {},
   "source": [
    "### Data preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "considered-button",
   "metadata": {},
   "outputs": [],
   "source": [
    "scrna=sc.read_h5ad(\"/Users/yaoestelle/scRNA_mit.h5ad\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "surrounded-robertson",
   "metadata": {},
   "outputs": [],
   "source": [
    "scrna_full=scrna.X\n",
    "scrna_label=scrna.obs.dbscan.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "stretch-ensemble",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1: 7018,\n",
       "         2: 826,\n",
       "         3: 22610,\n",
       "         4: 3188,\n",
       "         5: 1191,\n",
       "         6: 3570,\n",
       "         7: 5946,\n",
       "         8: 811,\n",
       "         9: 597,\n",
       "         10: 332})"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(scrna.obs['dbscan'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "professional-reward",
   "metadata": {},
   "outputs": [],
   "source": [
    "##Train test split\n",
    "validation_percent = 0.20\n",
    "x_train, test_x, y_train, test_y  = train_test_split(scrna_full, scrna_label,\n",
    "                                                     test_size=validation_percent,\n",
    "                                                     stratify = scrna_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "taken-ending",
   "metadata": {},
   "outputs": [],
   "source": [
    "##Train val split\n",
    "train_x, val_x, train_y, val_y = train_test_split(x_train, y_train,\n",
    "                                                  test_size=validation_percent,\n",
    "                                                  stratify=y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "stunning-theorem",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((29496, 3000), (29496,), (7375, 3000))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_x.shape, train_y.shape, val_x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "precious-lotus",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 10)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(Counter(train_y)), len(Counter(val_y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cathedral-equilibrium",
   "metadata": {},
   "outputs": [],
   "source": [
    "###Downsample for test run \n",
    "train_x=train_x[:4000,]\n",
    "train_y=train_y[:4000]\n",
    "val_x=val_x[:1000,]\n",
    "val_y=val_y[:1000]\n",
    "train_x.shape, train_y.shape, val_x.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "connected-gossip",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "featured-status",
   "metadata": {},
   "outputs": [],
   "source": [
    "###Hyper paramter\n",
    "\n",
    "def intialize_model(X, n_latent, \n",
    "                    learning_rate = 1e-4, learning_rate_decay = 0.99999,\n",
    "                    lambda_latent = 1e-2, lambda_reconst_rna = 1e-3):\n",
    "\n",
    "    #n_latent = 50\n",
    "    network_architecture = {\n",
    "        \"n_input_rna\": X.shape[1],\n",
    "        \"n_input_atac\": X.shape[1],\n",
    "        \"n_hidden_recog_1\": 250,\n",
    "        \"n_hidden_recog_2\": 100,\n",
    "        \"n_hidden_recog_3\": 100,\n",
    "        \"n_hidden_gener_1\": 100,\n",
    "        \"n_hidden_gener_2\": 100,\n",
    "        \"n_hidden_gener_3\": 100,\n",
    "        \"rna_n_z\": n_latent,\n",
    "        \"atac_n_z\": n_latent\n",
    "    }\n",
    "\n",
    "    tf.compat.v1.disable_eager_execution()\n",
    "    sct = scTranslate(network_architecture, \n",
    "                      transfer_fct =tf.nn.relu,  # .nn.relu,identity\n",
    "                      learning_rate = learning_rate,  \n",
    "                      learning_rate_decay = learning_rate_decay,\n",
    "                      lambda_latent = lambda_latent, \n",
    "                      lambda_reconst_rna = lambda_reconst_rna,\n",
    "\n",
    "                      batch_size=16,\n",
    "                      lambda_nonzero=0, \n",
    "                      lambda_reconst_atac=1e-3,\n",
    "                      lambda_trans=1e-3, \n",
    "                      lambda_atac_cross=1e0, lambda_rna_cross=1e-3,\n",
    "                      bound_atac_output=False)\n",
    "    return sct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "sweet-yellow",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Training loop \n",
    "\n",
    "def scRNA_train(sct , ###scTranslate class \n",
    "                x_train, y_train, x_val, y_val ,num_epochs, batch_size):\n",
    "    \n",
    "    ##Progress bar\n",
    "    pbar = functools.partial(tqdm, leave=True, ncols='70%')\n",
    "    pbars = [pbar() for _ in range(2)]\n",
    "    \n",
    "    history_train={'latent':[], 'cost':[], 'y_train':[]}\n",
    "    history_val={'latent':[], 'cost':[]}\n",
    "    \n",
    "    for epoch in range(num_epochs):\n",
    "        \n",
    "        shuffle_index=np.arange(x_train.shape[0])\n",
    "        np.random.shuffle(shuffle_index)\n",
    "        shuffle_x = x_train[shuffle_index]\n",
    "        shuffle_y = y_train[shuffle_index]\n",
    "        \n",
    "        total_batch = int(x_train.shape[0] / batch_size)\n",
    "\n",
    "        pbars[1].reset(total=total_batch)\n",
    "\n",
    "        for step in range(total_batch):\n",
    "            \n",
    "            offset = (step * batch_size) % (x_train.shape[0] - batch_size)\n",
    "            batch_x = shuffle_x[offset:(offset + batch_size), :]\n",
    "            \n",
    "            ##training step --> update weights\n",
    "            cost=sct.train_rna(batch_x)\n",
    "            \n",
    "            pbars[1].update()\n",
    "        \n",
    "        ##Record latent space per epoch\n",
    "        ##Last batch of the epoch = epoch loss\n",
    "        ##cost= resonstruct loss + latent loss \n",
    "        rna_train_latent=sct.transform_rna(shuffle_x)\n",
    "        history_train['latent'].append(rna_train_latent)\n",
    "        history_train['cost'].append(cost)\n",
    "        history_train['y_train'].append(shuffle_y)\n",
    "        \n",
    "        pbars[0].update()\n",
    "        \n",
    "        ###Validation\n",
    "        rna_val_reconstruct = sct.reconstruct_rna(x_val)\n",
    "        rna_val_latent=sct.transform_rna(x_val)\n",
    "        ##validation loss per epoch\n",
    "        val_epoch_loss=np.mean(np.sum(np.square(x_val-rna_val_reconstruct),axis=1))\n",
    "        \n",
    "        history_val['cost'].append(val_epoch_loss)\n",
    "        history_val['latent'].append(rna_val_latent)\n",
    "        \n",
    "        ##print epoch weight\n",
    "        print(f\"Epoch: {epoch}, Train loss: {cost}, Validation loss: {val_epoch_loss}\")\n",
    "    \n",
    "    return [history_train, history_val]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "ancient-broadcast",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scRNA_loss(history_train, history_val):\n",
    "    \n",
    "    ###Loss function trajectory\n",
    "    train_cost = history_train['cost']\n",
    "    val_cost = history_val['cost']\n",
    "    \n",
    "    ##Line plot visuzlie loss per epoch \n",
    "    fig, ax = plt.subplots(1,2, figsize=(11, 6.5)) \n",
    "    ax[0].scatter(np.arange(len(train_cost)),train_cost)\n",
    "    ax[0].plot(np.arange(len(train_cost)),train_cost)\n",
    "    ax[0].set_xlabel(\"Epochs\", fontsize=12)\n",
    "    ax[0].set_ylabel(\"Training loss\", fontsize=12)\n",
    "    ax[0].set_title(\"Training loss (Reconstruction + Latent Loss)\", fontsize=14)\n",
    "    \n",
    "    ax[1].scatter(np.arange(len(val_cost)),val_cost)\n",
    "    ax[1].plot(np.arange(len(val_cost)),val_cost)\n",
    "    ax[1].set_xlabel(\"Epochs\", fontsize=12)\n",
    "    ax[1].set_ylabel(\"Validation loss\", fontsize=12)\n",
    "    ax[1].set_title(\"Validation loss (Reconstruction Loss)\", fontsize=14)\n",
    "    \n",
    "    fig.suptitle(\"Visualization of loss across epochs\",fontsize=16,y=1)\n",
    "    plt.tight_layout()\n",
    "    plt.show()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "processed-representative",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scRNA_silhouette(history_train, history_val, val_y , epoch_num):\n",
    "    \n",
    "    ###Latent space \n",
    "    train_latent = history_train['latent'][epoch_num]\n",
    "    train_y = history_train['y_train'][epoch_num]\n",
    "    \n",
    "    val_latent = history_val['latent'][epoch_num]\n",
    "    \n",
    "    ###Calculate silhouette score per sample\n",
    "    train_sil=silhouette_samples(train_latent, train_y)\n",
    "    val_sil=silhouette_samples(val_latent, val_y)\n",
    "    \n",
    "    n_clusters=len(Counter(train_y).keys())\n",
    "    \n",
    "    ###Plot silhouette score for train and test \n",
    "    fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "    fig.set_size_inches(18, 7)\n",
    "        \n",
    "    ax1.set_xlim([-0.1, 1])\n",
    "    ax1.set_ylim([0, len(train_latent) + (n_clusters + 1) * 10])\n",
    "    \n",
    "    ax2.set_xlim([-0.1, 1])\n",
    "    ax2.set_ylim([0, len(val_latent) + (n_clusters + 1) * 10])\n",
    "         \n",
    "    y_lower = 10\n",
    "    val_y_lower = 10\n",
    "    for i in range(n_clusters):\n",
    "        \n",
    "        #############################################################\n",
    "        ###############Training \n",
    "        # Aggregate the silhouette scores for samples belonging to\n",
    "        # cluster i, and sort them\n",
    "        train_ith_cluster_silhouette_values = train_sil[train_y == i]\n",
    "        train_ith_cluster_silhouette_values.sort()\n",
    "        \n",
    "        size_cluster_i = train_ith_cluster_silhouette_values.shape[0]\n",
    "        y_upper = y_lower + size_cluster_i\n",
    "\n",
    "        color = cm.nipy_spectral(float(i) / n_clusters)\n",
    "        ax1.fill_betweenx(np.arange(y_lower, y_upper),\n",
    "                          0, train_ith_cluster_silhouette_values,\n",
    "                          facecolor=color, edgecolor=color, alpha=0.7)\n",
    "\n",
    "        # Label the silhouette plots with their cluster numbers at the middle\n",
    "        ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))\n",
    "\n",
    "        # Compute the new y_lower for next plot\n",
    "        y_lower = y_upper + 10  # 10 for the 0 samples\n",
    "        \n",
    "        #############################################################\n",
    "        ###############Validation \n",
    "        val_ith_cluster_silhouette_values = val_sil[val_y == i]\n",
    "        val_ith_cluster_silhouette_values.sort()\n",
    "        \n",
    "        val_size_cluster_i = val_ith_cluster_silhouette_values.shape[0]\n",
    "        val_y_upper = val_y_lower + val_size_cluster_i\n",
    "\n",
    "        color = cm.nipy_spectral(float(i) / n_clusters)\n",
    "        ax2.fill_betweenx(np.arange(val_y_lower, val_y_upper),\n",
    "                          0, val_ith_cluster_silhouette_values,\n",
    "                          facecolor=color, edgecolor=color, alpha=0.7)\n",
    "\n",
    "        # Label the silhouette plots with their cluster numbers at the middle\n",
    "        ax2.text(-0.05, val_y_lower + 0.5 * val_size_cluster_i, str(i))\n",
    "\n",
    "        # Compute the new y_lower for next plot\n",
    "        val_y_lower = val_y_upper + 10  # 10 for the 0 samples\n",
    "     \n",
    "    ax1.set_title(\"Training silhouette plot for known labels\")\n",
    "    ax1.set_xlabel(\"Silhouette coefficient values\")\n",
    "    ax1.set_ylabel(\"Cluster label\")\n",
    "    \n",
    "    ax2.set_title(\"Validation silhouette plot for known labels\")\n",
    "    ax2.set_xlabel(\"Silhouette coefficient values\")\n",
    "    ax2.set_ylabel(\"Cluster label\")\n",
    "    \n",
    "    # The vertical line for average silhouette score of all the values\n",
    "    train_avg=silhouette_score(train_latent, train_y)\n",
    "    val_avg=silhouette_score(val_latent, val_y)\n",
    "    \n",
    "    ax1.axvline(x=train_avg, color=\"red\", linestyle=\"--\")\n",
    "    ax1.set_yticks([])  # Clear the yaxis labels / ticks\n",
    "    ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])\n",
    "    \n",
    "    ax2.axvline(x=val_avg, color=\"red\", linestyle=\"--\")\n",
    "    ax2.set_yticks([])  # Clear the yaxis labels / ticks\n",
    "    ax2.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])\n",
    "    \n",
    "    plt.suptitle(\"Silhouette scores for VAE latent space\", fontsize=14, fontweight='bold')\n",
    "    plt.show()           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "imported-spencer",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scRNA_latent(history_train, history_val, val_y , epoch_num):\n",
    "    \n",
    "    ###Latent space \n",
    "    train_latent = history_train['latent'][epoch_num]\n",
    "    train_y = history_train['y_train'][epoch_num]\n",
    "    \n",
    "    val_latent = history_val['latent'][epoch_num]\n",
    "    \n",
    "    train_adata = AnnData(train_latent) \n",
    "    \n",
    "    train_adata.obs['ground_truth'] = train_y\n",
    "    train_adata.obs['ground_truth'] = pd.Categorical(train_adata.obs['ground_truth'])\n",
    "    sc.pp.neighbors(train_adata, n_neighbors=15, use_rep='X')\n",
    "    sc.tl.umap(train_adata)\n",
    "    sc.pl.umap(train_adata, color=['ground_truth'],size=50, title=\"Training embedding\")\n",
    "    \n",
    "    val_adata = AnnData(val_latent)\n",
    "    val_adata.obs['ground_truth'] = val_y\n",
    "    val_adata.obs['ground_truth'] = pd.Categorical(val_adata.obs['ground_truth'])\n",
    "    sc.pp.neighbors(val_adata, n_neighbors=15, use_rep='X')\n",
    "    sc.tl.umap(val_adata)\n",
    "    sc.pl.umap(val_adata, color=['ground_truth'],size=50, title=\"Validation embedding\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "congressional-answer",
   "metadata": {},
   "source": [
    "### Test model training  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "satellite-bennett",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs=10\n",
    "batch_size=64\n",
    "n_latent=50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "retained-aluminum",
   "metadata": {},
   "outputs": [],
   "source": [
    "model=intialize_model(train_x, n_latent, learning_rate = 0.1, \n",
    "                      learning_rate_decay = 0.99999,\n",
    "                      lambda_latent = 1e-2, lambda_reconst_rna = 1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "going-motel",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<scTrans.scTranslate at 0x7f9c758575b0>"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "otherwise-examination",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "560249d8be54434fa6cf2f0cd5e7db95",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5ad45321a8604d999f895b19e9bbded7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss: 8.78565788269043, Validation loss: 8640.952504086055\n",
      "Epoch: 1, Train loss: 10.010330200195312, Validation loss: 7840.871188755898\n",
      "Epoch: 2, Train loss: 8.482831954956055, Validation loss: 7604.570415629679\n",
      "Epoch: 3, Train loss: 7.783790111541748, Validation loss: 7650.904001517858\n",
      "Epoch: 4, Train loss: 9.853605270385742, Validation loss: 7666.267431621577\n",
      "Epoch: 5, Train loss: 6.619032382965088, Validation loss: 7079.885888806475\n",
      "Epoch: 6, Train loss: 6.440624237060547, Validation loss: 6850.695440329205\n",
      "Epoch: 7, Train loss: 6.111123561859131, Validation loss: 6731.844640018532\n",
      "Epoch: 8, Train loss: 8.928987503051758, Validation loss: 6640.272615983752\n",
      "Epoch: 9, Train loss: 5.176590442657471, Validation loss: 6498.677221359737\n"
     ]
    }
   ],
   "source": [
    "history_train, history_val = scRNA_train(model , \n",
    "                                         train_x,  train_y,val_x, val_y ,num_epochs, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "innovative-wrapping",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x468 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "scRNA_loss(history_train, history_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "competent-paraguay",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "scRNA_silhouette(history_train, history_val, val_y , epoch_num=9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "respected-travel",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAEFCAYAAACl5zMEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAB8y0lEQVR4nO2dd3hcxdWH37l3m3q3ZMm9925jbLCNwWA6wfTQAyGEFhJCS2hJSEi+JISeBAg1tFASg+nY4Ip773KXrN7L9jvfH7vqq7orrSTPy+OH3blzZ45Wq/ndmTlzjpBSolAoFApFV6OF2wCFQqFQnJgoAVIoFApFWFACpFAoFIqwoARIoVAoFGFBCZBCoVAowoISIIVCoVCEBSVAipAihPhMCHFdqOuGCyHEICGEFEKYQtTeYSHEGc1cmyeEyKr3fqcQYl4o+lUouiMh+aNS9GyEEJX13kYCTsDrf3+LlPLfbW1LSnl2Z9Q9EZFSjg23DQpFZ6IESIGUMrrmtRDiMHCTlPLrxvWEECYppacrbVMoFL0XtQSnaJaaJSEhxH1CiFzgFSFEghDiEyFEgRCixP+6X717vhVC3OR/fb0QYqUQ4s/+uoeEEGd3sO5gIcRyIUSFEOJrIcRzQog3W7D9PCHEFiFEqRBitRBiQr1rh4UQvxRCbBNCVAkhXhZCpPqXBGvaT2jU5I1CiONCiBwhxC/qtaUJIe4XQhwQQhQJId4TQiTWu36NEOKI/9qvGtkYIYR41f/z7gKmN7peu1wnhHjU3/brfht3CiGm1as7RQix2X/tP0KId4UQv2v2l6tQdAOUAClaIw1IBAYCP8b3nXnF/34AYAeebeH+k4C9QDLwJ+BlIYToQN23gHVAEvAocE1zHQohpgD/Am7x1/8HsFgIYa1XbRGwABgBnA98Bjzo71sD7mzU7GnAcOBM4P56+zh3AhcBc4F0oAR4zm/HGOAFv63pflv61WvzEWCo/99ZQGv7YRcA7wDxwGL8n7sQwgJ8BLyK73f1NvCDVtpSKMKOEiBFaxjAI1JKp5TSLqUsklJ+IKWsllJWAI/jG3yb44iU8kUppRd4DegLpLanrhBiAL7ZwcNSSpeUciW+Abg5bgb+IaVcK6X0Silfw7evNbNenWeklHlSymxgBbBWSrlZSunEN5hPbtTmY1LKKinldnwCfKW//BbgV1LKLP+9jwKX+J0WLgE+kVIu9197yP951nAZ8LiUslhKeQx4uoWfCWCllPJT/+fzBjDRXz4T33L601JKt5TyQ3xirVB0a9QekKI1CqSUjpo3QohI4ElgIVCzTBUjhND9A2NjcmteSCmr/ROa6AD1WqqbDBRLKavr1T0G9G+mnYHAdUKIO+qVWfDNQmrIq/faHuB9YxuP1Xt9BBhfr6+PhBD1hcWLT2TT698npawSQhTVq9fgur/dlsit97oasPmFLh3Ilg0jCx9DoejmqBmQojUah0v/BTASOElKGQvM8Zc3t6wWCnKARL/41dCc+IBv8H1cShlf71+klPLtIGyo398A4Hi9vs5u1JfNP7PKqX+f3/6kRj9X43Y7Qg6Q0Whps6XPR6HoFigBUrSXGHwzhFL/Zvsjnd2hlPIIsAF4VAhhEUKcjG/fpjleBH4ihDhJ+IgSQpwrhIgJwoyHhBCRQoixwA3Au/7yvwOPCyEGAgghUoQQF/qvvQ+cJ4Q4xb9P8xsa/s29Bzzgd+zoB9SfsbWHNfhmXbcLIUz+/md0sC2FostQAqRoL38DIoBC4Hvg8y7q94fAyUAR8Dt8AuAMVFFKuQHfPtCz+JwCMoHrg+z/O3873wB/llJ+6S9/Ct9+1JdCiAp8n8lJfjt2Arfhc6DI8duSVa/Nx/Atux0CvsS3r9NupJQu4GLgR0ApcDXwCc18PgpFd0GohHSKnogQ4l1gj5Sy02dgPREhxFrg71LKV8Jti0LRHGoGpOgRCCGmCyGG+s/dLAQuBP4bZrO6DUKIuUKINP8S3HXABLpudqpQdAjlBafoKaQBH+LbxM8CbpVSbg6vSd2Kkfj2lKKBA8AlUsqc8JqkULSMWoJTKBQKRVhQS3AKhUKhCAudsgSXnJwsBw0a1BlNKxQKRa9l48aNhVLKlHDb0VV0igANGjSIDRs2dEbTCoVC0WsRQrQWDaNXoZbgFAqFQhEWlAApFAqFIiwoAVIoFApFWFACpFAoFIqwoARIoVAoFGFBCZBCoVAowoIKxaNQ9ACKKp28ve4oNrNOVkk127PKGJAYyeXT+7Mrp4L4SDNxEWZOH91cslmFovuhBEih6Ob8Y/kB/vDpniblG4+W8tGW4w3KzLpgaHI0i6b2Y0RaDHNHnDBnGhU9ECVACkU3w+M1eG3NYf79/VEqHC4KKt1tvtftlezJq+DxT3cDkBJtYWK/OLwSfr5gBOP7xXeS1QpF+1ECpFCEkSqnh3WHiimucnKsxM7y/QUcK6qmoNIVkvYLKl18vacAgGV7CxCArgkm9otja1YpAsGt84Zw5+kjMOlqS1jRtXRKNOxp06ZJFYpHoQhMtcvDX7/Yy0urDofblAZkxEfw3i0zyUiIDLcpJyxCiI1SymnhtqOrUDMghaKL+P2nu3nz+yNUu7zhNiUg2aV2Zv9xGdecNJDf/mBcuM1RnAAoAVIoOpkyu5sLnlnJkeLqcJvSJt5Ye4S88mqG9Inh0qn9GdonOtwmKXopSoAUik7AMCRf784j2mbiw03ZPUZ8avhydwHsLuDv3x3kX9dPY/4o5d6tCD1KgBSKELNsTz4/eXMjTo8RblNCwo2vbiDSrPPjOYP52YKR4TZH0YtQAnQCUVBQwCeffIKmaZx//vkkJiZ2Wl+GYfDFF19w5MgRpk6dypQpU9B1vdP66w68tOIgf/t6P5VOT4fbsOiCy6f3543vj4bQsuCpdnv52zeZrDtUzE9PG84pw5PDbZKiF6C84E4g3nzzTTIzMwGw2Wycc845FBQUMGXKFBISEkLa1zfffMOKFSsalN16662kpva+pZx1h4r46RsbKKzuuPD0NEwCnvvhFM4a1zfcpvQqTjQvOCVAJxBPPvkkZWVlAa8tXLiQmTNnBt3HwYMHycvLY9myZbhcDc+yREREcN999wXdR3fh5RUHWbIth03HSsNtStj406IJXDa9f7jN6DWcaAKkluB6OV6vl5dffpnjx4+3WO/LL78MSoCKiop49913yc/Pb7aOydR7vm5XvbiG1QeKw21G2Ln3g21UuTzcMHtwuE1R9EDU0edezqefftqq+IBvz6ajFBcX88ILL7QoPgBTp07tcB/dhUMFlcx4/GslPvV48qt9ZJX0LC8/Rfeg9zySKgJSXd22gcFqtSKlRAjR5raLi4t56623KCwsbFP9oqKiNrfd3fB4Dc5/diW7cyrCbUq3o9zh4ap/fs/y++aH2xRFD0PNgHo58+bNa1M9p9OJw+Foc7ubNm3i5ZdfbrP4AIwfP77NdbsbT3y2W4lPC+SWt/27o1DUoGZAvZzU1FRSUlIoKChosV5SUlKbZz/r169nyZIl7bIjOjqaESNGtOue7sL9H2zjnfXHwm1GtybS0rtd7BWdg5oBnQBERUW1WqeoqIi//vWvVFZWtlivtLSULVu2tNuGyy+/vN33dAfeW3+0y8Vn9pDOO5/VWZTaPbi9vePgraLrUALUy8nOzubw4cNtqutyufj444+bve7xePjXv/5FdnZ2u+1IT09v9z3hxDAkV/xzDfd+sL3L+151sGc6OCzb07ITikLRGLUE18vZunVru+rv3buXpUuXMn/+fBwOB3v37iUlJYX09HTsdjvl5eXttuGGG25oNgrCjhVZfPfvfQBEJ1r44aMnYwqwnCOl5Nmlmbyy6hDF1XUJ2sb0jeHDn87GZg7NEpCUklP/tJSskhNrTyM52kJhkDmIkmOsIbJGcaKgBKiX43a3PZtmDcuXL0cIwc6dOyksLEQIwQ033MCAAQNITk5ul+PBqaeeysCBAwNe87i9teIDUFnsYskLW7nwrilN6n6xM5e/fLWvSfmunAo+2pzNlTMGtNmmlrjin2s6TXzMusDtDf3B71AQjPjER5p54OxRTBkQ2mgait6PEqBezqFDhzp033fffVf7WkpJdnY2AwYMYPDgwW0WIE3TmD59erPXC4813W/K3ldKeaGd2OSIBuUtBfYM1Qb4L97bwtpDJSFpSwcaZ/3pruLTUZKjLPxswXAumzYAi0mt5ivaj/rW9HKaC73THqKjoxk9ejTfffcd69evb/N9U6ZMITY2ttnrWXuanguSXnj3d+soL7Q3KD9tZJ9m2xmb3nwfbcXp8fLBpvbvbTVHb9+On9g/jrW/OoOrZw5S4qPoMOqb08sZMCC4pamkpCTuuOMO4uPj2bt3b7vubSkygtdjsHbx4YDXXA4vBUcbnrm59d8bm21r4+HgN+3f2xBaT7feNddpyNj0WF65fga61vZDywpFIJQA9XKuuuoqzGZzgzJNa9uvPTU1lZtvvhmr1be53NJsJhBz585t9tredbnNXotOtJIxIoE1B4p4fMkuXvg2k01HS5ut//y3B9tlVyB+s3hn0G2cCMwYFM+SO08lMcoSblMUvQC1B9TLsVqt/PSnP+XZZ5/F6/XtSrQW961///7Mnz+fwYPrAkzu27ePPXv2tLnfyMhIhg4d2uz1XSubj09XWezk03f38Iv9R0nxCPJNLc8nom3B7QHllztw9/A1M02A0cnTriun9+f3F/fcaBaK7ocSoBOAhIQEbr75Zl5//fVWY8Ppus5FF11EUlJSbZlhGHz77bcN6tlstmZD90yZMoUzzzyzxX5sUeZmr5UKgx3bc4kxg0O0PqpeMzO4ZcYPNmUFdX93oDPFJ8am886PT2ZselzndaI4IVECdIKQlpZGVFRUiwJksVhYtGhRA/EBWLZsWYOI2hEREdjt9sa3k5qayjnnnNOs23V9cjJLm71Wqkk+s/ndgtswsE7un9R6pRbIzG85+sOJzNnj0nj+h1PaFaRWoWgrag/oBKIll2jwRUJ49913m5TXjyOXlJTUbFSD66+/vk3iA6C34DllrS86bRj3LKbgBscbVS6bJpw8JJE3fjSDF66eqsRH0WkoATqBmDFjBmPHjm2xjmEY1M+Sa7fbyc2tcxgoLi7mwIEDAduOiIhoUt4c089vOug7kOToXnZZGp+gaZl/LA/OCSE1zhbU/b2JxEgL//3pLN7+8cmcOjwl3OYouglCiH8JIfKFEDtC2a5agjvBuPTSS3E4HAFFpIYXX3yRadOmUVhYiK7rlJaW1l4LlMLdbDZzxhlntMuO3AMNzyeVCoOXY50Ygnb7MAd7DmhTCNy4ezpWk8bye08jNVaJsSIgrwLPAq+HslElQCcgkydPrhWgqKgoqqqqGlw/fvw4ixcvBnzebC0xduxYLr744mZjvTXH0Z0ND6HGSoEBaBISDEGyV7DX0rpr2kmDErh6ZtuW/QLxxY4cbnlzU4fv7+mYNcEFk9K5dd4wJT69hEH3L7kK+D0wADgKPHj4iXPfCqZNKeVyIcSgEJjXACVAJyDjxo0jISGBtWvXsmNHyzPq6upqxo4dy86dgc/J/OAHP2i3+ORkluKo8jQoq3lnCCjSJeNdOnaXwdEWjpuYNHj2hx3fo8gvd5zQ4tM3zsqaB9o3c1V0b/zi8yJQ8+Q4EHhx0P1LCFaEOgO1B3SCEh8fz7Zt21o9E2Sz2Zg8eXLAa2eeeSYmU/ufYT766+Ymy2wWBPUds6uRHGveUxsAXdMoqHC2u3/wLSVe+sLKDt3bG0iMNLP0F/PafZ/hMXAdr6R8TTalXx6mfEUWjgOlyJ5+kKr38HvqxKeGSH95t0PNgE5QWhOeGiZOnEhmZmaDMpvNxv3339+hftd+fAAZ4NCKE4PTq01ssHpJ8Qp2WL3IViY2To/B+sPFjOnAHtB972/jSEnHxKunYjUJXr5uGpVOLwvH9W33/aXLjlD5xdEWOtDAWe97lWAm456TELryoutCmjsUF5pw8SFGCdAJSkxMDHPmzGH58uUBr0dGRrJo0SKGDh3Kk08+2eDa9ddf36E+D20rZMOSIwGvHTcZrLZ5KNehsJXIB33jrOSUOUmOtrQYpLQ5nv5mP+9t7PmHT9vD2PRY3v/JyURYWv+Td+VUUvLfTNyFdvRYC94SBzja8MDibFSnxE32r/yzTKuGbUg88RcNw3W4HHdBNdXbC/Dm+c6TmQbGkHbrpHb+VIoAHMW37BaovNuhBOgEprm9G5vNxrXXXktaWhpHjhxpElG7vTHhalj1/v6A5Yd0D59EunEEWBCOc1bg0C2YDIMqi8/NO8Zq4u+3T2NIchQxtlbW6fw4PV4OF1YzMCmSt9Z2y7/FkDMwKZIYq4kHzh7N7OHJLdat2JBL2Qf7myyNehvt1XUYp4FjdzG5u9cFvOw5UkHR4kySLhgWmv5OXB6k4R4QQLW/vMMIId4G5gHJQogs4BEp5cvBtAlKgE5oKioqApYPGDCAtLQ0AF555ZUm1zuS5M4wJGX5TaMnSCQDvDq3l+sstbnZZGt4BqjMGsNVu7/kkyGza8v25VdRYfe0WXwcbi+X/H01O7LL6Z8QQW55+xPOWXRwte94UpeTEWehuNrD0JQo3r+17Vliq7YVUNbMw0FXYl+dw/EdRfS9fwZCRdruEIefOPetQfcvgdB7wV0ZAvOaoAToBOaUU07hyJEjDSIdgC/wqMPhaNbBIC6u/THBNE34ohpI2GPyUKZJ+nk0kg2B1e8LM9VlaiJAAG+NbhhXLjnawqi+MW3ue29uBTuyfanEj5U0FcG2EE7xiYswcdLgJL7clQfAFdP78eGmbFxeyU2nDGZCvzhibWbmjWr/ciRA5ffNB4btaoxyF8f/sJaMX80Mtyk9Fr/YdDuPt0AoATqBiY+P57bbbuPRRx9tUB4dHY3FYgnoqGCzdfysSEJqJHvzKynRJSc7fbOXCmHUht45rgfeZ0iNtZJX7nMYGNM3lldvmE5ytLXN/Q5JiSLSolPd3acwwHNXTebLXXmMSotl45FiSqpcPHbhOMamx7Iqs4j4SDPjMuJ4YtHEkPTnKbTjPlgekrbai0iyIu1uqG74e5cVbnKe3EDfu6eFxS5F16EESNHkMOqECRPQNI2NG5smgRsyZEiH+ti/t4iS3Gq+iHYxxVn3tbNIwSHdwx6LwR5zU4G4f+FIThuVyl3vbMbu8vLweWPo084Dk5EWE25P9xeflGgLZ41N49wJNbH2GqazOKWVfZz2Ij0Ghf/eHdI2W0JLtJJ29zSMMidajBnNaiL3yQ14qpvOSr15dgrf2k3MzL5Yh8T77HV7Mao96HFtf/hQdG+UACn40Y9+xNNPP137fvXq1aSmpjZxPoiLi+P888/vUB//eW4rcfhW4ez1UixYgOURHgp0SV+v4LjWcBc8q6SatQcLkVJypLiaa/+1lj9cPIH0+AheWXWIselx3Hn6sGYPo76z7ii/W7K7W+f7mT0siYsn9+O0UX0w6Z17NM95pJySxZl48qoRJg3p6DphNoqdeIrtWFKjAHDsK8GT1/ySqGNbIY5thej9IpGVHoxSX4R0EaFjG5mAO6cKLcJE/IXDsfSN6pKfQRFalAApSExMxGw2N3Au+Oijj8jIyGhQb9GiRe0KOFrD9u+OEeuSgOC8KgvbzA09qwp0yWi3jk3CcVPDAfHNtQ1TZbu8kl/8Z2vt+y935dEvMYJFU/o16begwsn9H25vt72hQhMwd0QKZdVuNmeV0jfWxtnj0oiymvjJvKEcLa7GMOjQOaaOULEim7IldYFbZf1ZYQdi8HWE/L9tos8dkzGnRVG9vaD1GwBvVsMUItLuxb6lsK7NpzaRcNVIoiZ0bA9MET6UACkAuPbaa3n55YZeldnZ2bWv4+Li6N+/f4fazsksQ/jzKsRLjSpNssniplgzOGwyMBtw1ORltt3MIM3giP8cUGsHUWt48MPtWHSN8yf6lq6+2Z3H2+uO0iema5dqasbw+Agzj104lgsnZbRYf1Ra5wmPNCRCE+w/UMwXe/KYqZtJW57Twg2dZkqTfvKf3ux7bQndbK/krb3oURZsQ+ND1qai81ECpAB8abjPOeccPv3004DXPR5Ph2Ou2StdSCReYLfFS7QULI3wNBAYF/BFpJvLqyxcUuUbmKoFfBDlJK+Vg6lOj8Gd72zmjNGp7Mur4KbXNrR7PI30VBHvLiXfkoxHb59wXTYtg5tPHcrw1Bjyyh3ER5qxmoJLEx4MlauPU/rJQYRNx1rt5mzwhznqZq7NrtCuixa9vov0R05WLtydgBCiP75I2GmAAfxTSvlUsO0qAVLU0rdv8+FZGkfMbiubvjzKsd0lCASfRbrY48/1k+YR5DYWFgFRZh3hX6GLknCyw8x/o12t9iMl3PLGBnLL7O0WnxhXKRpwPCIDk9fla6wdYjsuI47hqT638HBFlC5ZfICq9bloESbfvo4hkdUeNAQ9dsteF+Ct99uM1n2/l4pmDscasutmciceHuAXUspNQogYYKMQ4isp5a5gGlUCpKiltSW2zMxMhg1r30n1/etyapff8uq5WdsknF5tor9HZ7/ZS4UmmeMwYwjfXlENVZqBkG1bjlu+v7D1SgEwYVBiSQTAo1vQpBeDts9gHv7fLo6XOLn/nFEd6r8tGNVuHAfKsGREY9g9uHOriBiThBZhwr6/hKrVvrM8hrt1se50LALcfiXQgI76OXglaCDMOpFTU0m4YChZv24+gGziFSNV3DmAR+OapGPg0bJgD6LmADn+1xVCiN1ABqAESBE6Lr74Yj788MOA1zSt/Wv21eV1AT9nOE18GeHGKmGe3UyK4RvkU5wamy1uDpi9jHOZKMNLFBpVQjLEpfNDr06ObrDL7CanbcEP2kWFqd6hVikxRPuXz/6+/AA3nDKQ1Nj2O2m0hvQY5D29GW9pw+CpBfFWrJrAW9r+yA6dikvWbYgJ4ROkji63GSCdXqpWHyf65L5Ez+lH5dJjAavaxiR12OReg098mqRj4NE4ghWhGvx5gSYDa4NtS6VjUDRgwoQJzJgxI+C1AQPaF1DXafdQXV63XDLBZeKuMhu3ldtqxQfAQLLR6uWzSDc7zB5KdIkOvB3tJBaNvl6NKS4TEbJzvq4ezQzSQDO87Vp6a8y1L62jvNqN29v2wbba5eHN74/wlT/KQSBK/pfZRHwATKVOvMUO34p8d6NmKcwjQ7PXYxKULM5sVnyiFwzo8B5lL6NT0zEIIaKBD4CfSSmDPsGsZkCKJkybNo1165oGjWxv7p+yfL/7rOEBzXevOcBG+KeRLkp034jlRTLIa0YiSfJqvB/p5KjZINYQVIlGC/wNV+uaJQJoNQCP0HzpwINgb34lE37zJTYdzhqfzsDESPonRLAnrwJd07hlzhCSGkVwuP2tzSzdkw/Any6ZwGXT6pZBXVkV5L+0rW2RqLszjfdy2otJgEfi2l8W+PLgGOJP73hW3F5Gp6VjEEKY8YnPv6WUgZdJ2okSIEUTYmNjEUIgZcNB49NPP+Wcc85pcztJGdGkDIym4Ehli/WGu3R2m30heQZ5fDOjYyaDGCnYbvVtINQIVAPqCYZZgrsZAbkeKy/Qdbl/HF7435am8dX25lbw2o0NZ5e7ssux4PMCtKzNJXdFPlq0mcgxSVRvKwgoPgYSrbt5tLVEMOIDvllUM0SdnEbChcODa7930SnpGIRvevkysFtK+ddg2qqPWoJTNKEmHUNj1q1bx3fffdfmdnSTxiX3TWfA2ES8LbgnjfDoJHsFSYZGjBTsNXt5N9pVKz6tMcapke5pfkCejYlzu8GzVm5Zw3mYp9TJG95IviaGr4lh2jEHnrxqXAfKKP34IM4jgaOVawhkd3L3CqMWOo9WkPfsJgrf3YO7qGOBZnsZD+JLv1CfoNMxALOBa4D5Qogt/n9tfxpthvD/VSq6JYMHDyYyMpLq6obf5VWrVpGYmMj48ePb1I6mCfqNSmD9rkJSm3FlEwhsEtK8GhqC5baGnlyxHihv4ZvqRdYeXg3EA1QzrRt81c8u8JL10CrwGr59GwEREkAQyHm7pXFddKcZUBi10JPtOx7gzqrCsbmA+IuHET2j/dleew2Plr3Fo3EQei+4lXTCo4aaASmaZdSopm7FLpeLDz74gMWLF7e5neHT0kj1OxB4kRzTfDObmqd4B5Jsk2Sf2UsFkmGuuq+l2YD5WvMb9OAL5aMBFnfgZbZjSD6i/TmM2kLTAEA+LMDMeq7cAjjT0MFt1DkNdKNJTKu0NPSYu48Yln6YieHs/oFnO5VHy97i0bJBPFqm+f/fbVMzKAFSNMu5557L2HFjsTocWBwNXX03bdrE0aNtW1bOP1K3efx5pJuDZg+bLW6W2tx8EeGiUpNcVGXCEBJDSE5zWvlJqYUryy3cUW6lwhRYWCwGpLoFxSYweV3Euzp2WDYYAiX2PhWdN4jGVm/U7odGbE/+c2tGLIVV9+3RdB8Nomp9brhNULSRHvwXoehsdF3n0ksuZdBgjbnffsugg4d8UQL8/Otf/2qSzC4QbmfdRvpkh8Y+i2SNzUOVBgW6wRqrh4EeE+dVWYjzz5Ri0H3RCazlfG+kBmxXAzK8dV/h/KjEuosy9NOLtoyxqTEWhmtmMtC4CSvD0EhE8DC+80HS/197qUByK1UsoJx/B3CoyMPLh7ha3GvrDKTT6xOnbjSb02M64bCYolMQjT2dQsG0adPkhg0bQt6uInwcPnyYV199NeC1sWPHcvHFF6PrgQ9wer0G//3rJnIPlCORfBrp4lS7mVipIZEI/6a6QNR6eOXpBrvNHuY4zHxndbPT6sUe4HFJk/jcp9sZPidUCMBqEjg8EpvJ9/N4PJI/EYEJWImbHxFBtF++KjGI9j/3eZAUI4lH4EUS4S+v+Szq8wEunsRR2+c3xGCpV8dAchVVLMDEjwLuKJ0AmAVxC4cQMzu99brdFCHERinlCZOJL/w7s4oeQXp6ekCnBICdO3eSkpLCvHnzAt6r6xqR/sjUAsEcu5kY/0ynZqCtEZ9vbC48QrDf7MUpYIvVywy7hgdI9EBxo29s7dkdIbpchEb0ieLRC8cxNj2OAwWVWHSNHz+zirlYeAUXO/wxaG6vd09kPdEwITiEh7/iwAL8jSiS0AI6GGTUW6xIRdD4GV/iE6Fj3fJUaucTMb0PSYtGhtsMRTtRAqRoExaLhRtuuIG1n/6bbYdy8GDCqDcMlpSUtHh/yoBoDm7xLdfFSK3JWRaJ5IMoF4fNBlbDf6ZHgBvYaDNwa1Cs0fLh0xCIj07bQ5c5vZLiCicRJU4mJsew9Zn1vEY0EQg8SH5CFYPQGqxONT6/cxJm3sVMFZJNeDi1mVXxmZh4nAicSGZjrhWpY/gcNz7FjQH8sOeGHm1K/QOsmvAFG20G+/p8srYWYkmPJvbsgVj7x6mo2D0AJUCKNpOSksJ5M4Yy89BfEcAz3Fh7rbS0lDVr1mC1Wpk0aVKTuHGjTu7L2sWHat9r9ZbdAMqRHDb7nt6dmm9pra4umCSc5DBRohnsshogYbxTJ9YQrIrwhGwT3IsvbskINLa0Mps4UlTNX9/ZyiCi+A9OPsfDB/jiypkQZMTbuK9Ua1NY0ygEw2gqzPWZ22jek42X/+AiEcHPsfWsw6ltIOXGsVRuzMO+tQAt3oJR1MphYpeB63A5hS/4khCm/GQC1kFxXWBp70cIYQOWA1Z8uvG+lPKRYNtVTgiK9jH6fJL6DiGBMoZy2F8oOXLkCF988QWLFy9m1apVTW6zRJgQlro9DidGg6UmGw1D6UcbYDLAZoBdwCyHiVlOM+farSysMoOA3VYvM116yL/EDqgVnzgvDeyahMbFmElH8B7RvEY08WjcTAQZaHzYR8MAtsZrjIy0YkK0+cxOX/R2icj92PkQNy/h4uNOcjMPmiBctAte3IF9UwF4aV18At3/yo4O961oghOYL6WcCEwCFgohZgbbqBIgRbsRo89FA37If7mW/9B4+lFY2DQtgsVm4tJ7puIZFs0Gq6fBPW7/XMhWb6Av18GjgUODZK8gpZ63W7Lhex1lCKqFwBJiPxr/GVH6AHdpNp4hknMxIfD9Fd6NjTuxkd5ov2Y8On+K8nDygmjeGmjmyuPedh0Yba93XFG9+sXdyQ3Nj8eQVIdzVnaCBicd/9r4q8a/Nv7w+NfGG/7/XxVsm9JHTUwts/9f0F865QWnaD+uavj8fmTZMf6dM5jMal/sOJPJREREBFdddRVSSvLy8hgxYgSRkXXBeStLnLz+4KomXtISSb4u2WzxUKgZ5Jh8EbHn2k1MdZlJ1qHCADuS/bqXLLPBZKfOtxEeDphbWCprJWBpTdaAQOU/wMzPqUuvkIdBKj5PN0c9r7X6fIaLGWYLSe2ckHjxHaZtj2Atw83zOMhA4zEiiDvRnyc1EJFmZKUbLILk68b1uBTdwXrB+cWmfjoG8IXiuXn7dduDOpAqhNCBjcAw4Dkp5X3BtAdqD0jRESyRcMHTCOBqoLi4mOjoaCwWCwDHjx/npZdewjAMoqOjcblcxMXF8cMf/pC4uDiS+kVTcKyiwWArEGheyXC7k7OOf8iTYxaB1InqE4EppxI9axPJCRk8m5rKISTpHsFnNiNgkNIGotLKeF7/bjPwIdFcSSWVwH9xcw4WRvl3cVKp89yLQOBG4kYSWW/gX4gZ0Uh8XIaBSQi0Fp7I2ys+AKdh5rQm/nCBMZAUY5DcjkR7XUZzTwF+ouZkYN+cj1HRVNVFrBlh0oiclEL8mYM7z8aeQ0vpGIINx+MFJgkh4oGPhBDjpJRBrXMqAVIETWJiIhxbB84KGDqfnJwcDMM3K6ms9M3aCwoKWLduHTMmnkLhsUqcUHtapcYZIRlBAtHooh8LSw+xN3IEh/MrWbThGdYk9WOXGzJFHwCOmetGrHgvVGjg9Q9kbcmeGoh+aFQjuQQLr+PCALIxGNmMa7QZgQlwY9Tu9dgNSYVXkmQSmPyCY27DUlBnxHYzMNDQav+f0F1nSK0swtiGJRA7O4OKtTlUrswGt4GeHEH8BUOJGJ7QNTb2HDotHUMNUspSIcS3wEJACZAizGx6HRbf4Xt98u2MnP0AK1eupKSkhKioKKqqfCFyduzYwbgx44mKt0Cpi4O6by9oiNf3VC78A3pexjyGG4Ix1RpF0sETE85lT1LTp1tdwgyHTqWQbLf5l+HaMo43syz3BJH+CAY6lUgOYzAbHTtNHylrEIjaHEdVXsm3FV48QJwOc6JN5AjJG8JJCoLrsPp3kjofFy62R+6nryuFddE7mFc+nXgjpvUbQ4DHkJhC5QJt1bENj0cIQfyZg4g/c1Bo2u29dFY6hhTA7RefCOAM4I/BtAnKCaH7YXihsgBKjkD2pnBb0zYO1kvRcPBbos2S26++kHvuuYdzzjkH4fcoKy8v55XX/oWWUQRSMsRrolQ3cDd6BC7UJdUCVlvd7LJp7EkcFLDbCAMmu8xUtPAtDnipmbGxvshMwMT5WPgONy/ixIukEMMX6aCZR/Zir6Qm/2uZF5wSfi2r+QQ3r+DiPVwB7+sMLFiYWj2WdE8fLiqdj0d4uiSFgyEJnfgAaXdNVplO20dnpWPoCywTQmwD1gNfSSk/CbJNNQMKK2XHYf1LsO1dKA8U1hKISAJHCUj/E75uhYlXwMhzoeI4VBX6IgCYI2HAdHA7fQNsxnQw3GCy+v6FAmcFVOZD4pCGHkYTLofdi8HrgmEL4G/j0e0lRJ98O5H2aCaxi82MA8DtdpN3sJwI4QtOM8yl868YJwNdgggh8AIluptDJhM7rTXOBYIBbo10r8Yes5dS/75PpQ5HTF5GujXfGaIA41Rz7gn1E9iZAA/wBxzcjJUsDP7gz6H6ClHk4+ElnKShcSEW/oeTRf4Dn6twMwyNFDSSTQKbAIeEFP/ru7GxAg9v46I8jJ5qSd74LknhEOqznyJSDVHtYft1298a/9p4aJSOIVgHBCnlNmBy8BY2RHnBdRWOMqjMA48HstbB3k9h/xed15/Q6kSrPuZI6D8T5vzSlyq7zyiI7tNyW7nbIWc7fPlrsBf529dh3CVw4bNgsviEyeOAzW/Cd3+s7UvGZuAsOsIyZrGfQRST4NukkYK40jForgT+GeOgv0fjPLsFpwCzcPJGXAUFMhqANLfgh1VWNHxpuf8R68ArIMErGOfSWRHhm3cISy6WpOW4Cs5EeuIb/Agj0MjFoFrCALfGGLfOlggPWf4TrwMRHKknEJHAk0QwNsAm/6VUEIsgEsEd2BiBTiZeXsfJXGlmumEiWqOB08GzOLgGS5s81aSU7XrqDxQ7rn55c9e7O9aRCaTcMC7cZnQpKhacInSUZUPm11C4H9Y807V9BxIfAHc1HFzq+9eYxOFQdhRSx8CgUyF7I+TvqROdBu17Yfu7kDYeTr4NKnIgth8MOLlO/AbORpgjsRXt52y+JULM4ls5wzdTEZLqqCziXYncUmHD6R8kbRKclgokErOEaENwXrW59oBmlBREGb6IBVdVWvkqot6yliuNpPxzKOqzBGfO5Q2cqxLReI4olpS5qdQkJ8eYKBOSLP+iWbZsmFKgGohpRixuwsofcXAOZkb4vcqGobMJL98JD2/p0U1SL9zud7loi7i0d8mpOXGpH2evhvaKW5ehgXlwHH1uGAe66J42KkKOEqDOomAfPDeDbhWnvjWK9/v+f3yz718b8H75a/TlfwZnKSBgyjXw429h/1ew9gWoqhOveXI1pUYcWzRfojuTJwqJRPfPJlxIXLY8nNFHsblGMK/awmBPnduwF8lGq4dy3ZcLKFIKxrhM7De7kAJ+jJVrvLEsLT6Dh6n75M34zvRkYTAuWueg7uEr4aY/Ao26g6f1GY5GWj0RqRm4JXAmFjbgIbPeAp/Tn2bB638diJrVhnCKQLcY2HVI/dlUEOAtcWJOj0KPsoTbKkUYUAIUaqqK4LP7YMd/2n6PZvIth9WgmyFtEpQdw6jMR8PAjoUcfSAD+vfDdHhZ0zas8b5ZR0QsDDwFRl/g25c5th5KDgT7UzWLLvCLD4D0ecTpVtj8hm9JrhEXaJ+DI4UDzpMZunc72QOG1l6zILA40oh2pLFQMyhxF5KRs4vqyFQctkT+nBZLtV8T3AK+tToo0gVDXDDBrHON5tuXme8czF8opwyIAi7HzNSdH+PJ24aRMZ07Rp6KHZ+DwqPYOFxlcFAYbLR5SEDwU83GVEwN0h24DCe6ZuULr4HFbrA62kuZkGTjJQMdK4K7sJGPZEgzZ206Y/D34kWv118wy22GlHgMsOidI1Iizow5MYLka8eiRfiGHnNyc/6FdTg8DpxeJ3HWwHHdXF4XZc4yUiJTQmqvovNRAhQqyrJg6e9g13/BbW+9fv+ZEJsBc+/17cNICYeWw77PYcRZMGQeAFr+bsjZij5wLkPi/bnuj6zxOSCMOt+3/9Ico8/1/d/r8e0/WaJ8tsX2hcOrYN0/4cB34KyLZC0lGJjRhYcOz97Wv9jsJbs3llSXm3RtGd4MN9kEHjQT3R4Gl5fitMYzes/r2Fzl/GbgAv48fiEVmmS8R+f7iLpAbbMcOl6rRBeCnXgoAyIkvCSi6Ft0CPv+zwEQ5f8jpe9wjsamYQBlSDxCcIG0cKvHRpbHYEaE3kQsrLqNA04vHruBBxjh1Fhv81KCJMNf50y6/im+RnxqPkMHLiI6GBFbAMfdBoOayesULGm3TUGPbfoZVburMWtmDAysupVqdzW3f3M7e0r2kBqRyoGyA0gkJmHCIz0kWBO4Z9o9PLXpKao91djddrx4GRw7mGEJw4i3xnP31LuJsXSN27mi4ygnhGDZvxQ+vh3Ks1uvG50Gw8+AEWfD6PM637a24nYAkvLPPiP7/ofAMEj68Y30ueZCcJT7RLGqEAwXuO1UV5bhzd9DtP04QtPBEuPz1AOwRIOrstmuqr1xROpltal7NlddwOqKG9Bx4jA5AYFXrya2zILL5jtkmJazhjF732T/0Is51v90AMp0L69FuXD6Z0R93YL5LhNlNvhGd2MHxkqdf4goSsqzeL5oFx5N57rdn/PKzDtZFRuHDjyg2ahwSs61WGqdBiqkQYxouv+T6zZYW+VL1iCF5IM4J7EI/kwUEd1kk9+DF1MQ0Q46a3kw7uzBxMztB8DB0oNsLdjKvP7zeHLjk3yU+ZEvEobQeGzWY/x5w58prZ1VdwyLZiHeGs/QhKH835z/a3b21N1QTgiKtpG/G55vKRisfwt8wGy49qPQuUJ3BmbfBnnFyu+hJoLBsuX0+fkvfdf7N/x7aLJo4qqCz+8HYYJJV8FHt4C9FAbPgT0fN1hejNTL2FV9OsvLbyZaL2JW9CskRX2Px1SOt+xMnzmeaCIcmbUCJKRv0M9JO7m2nTivziVVFt6KdhFvCOY6zDgESLvE7nOe4yBeDuHl3dgkPov1/a4OJI9ikbsPU8rBq0nmxpgxrA1TIMQIrTZx9nHDSz/N92eSahKMsWkcNLyk2TTeIIZyJO/i5Pp2ZCH9H05Ox1KbJTWUBCM+EJplQi3JhjQkmlVDM+tEn5yOfbTO8+v+iN1t58PMD31OJsKMW/rC60gkXunl16t+HXT/AC7DRb49n3x7Pme9fxZuw41Ft3DB0Au4cdyNpEYFTvOuaB5/LLgNQLaUMiRP0EqA2ovHDY+n+rzAmmPyNXDOn2sH9p5CzIIFlC/5FLxeYs5a2PYbLVFwQT0vvzvrHaC1l8Cyx+HAd3xU2I+JcjdrK6/Ci5UybzqrKm8kOzYHSRqx/ls0PEyM/4Tt5Wcj4yIZOHAf2Ynn4DFFNOg21vB5zf2owopDt3NUMxjjiqbSLtlh9lBkgh9TVRupAKDIFkNN5oI+QkMIgY7AhYHud0qoWQ7UEKSJugFdCMFim4uPcBMnBc8TyUB0rmnHktca3PwNJ+eFYLnOhRuL3028WCvDLE1EyghCn6CijcSaiF84hOgpDQd3l9fF7V/dwoa8hqsiNeLT2VR5fJE4XIaLt/a8xVt73mJKnylcM+Yazhh4RpfY0Eu4C9gNtX+qQaMEqD1kbYKXTmv+euIwGH0+nP4waD0vyETsggXYPv8Mo7oa28jQpDcuk9EUj/w1X35zHiXVXv4W6eAMDBL918u9fTHbdRLjv2ZC9FZy3aMYE/EVg23rGRG1Ck+ElShTNd5EjfyikZR4htWe6F9v9TDDvIdP+1aTWT2RZK9khEsyw2mmDIOxbo0CTbLb6qWPR1CiS8o0+M7mJl0KzrLWPSDo+ISohhoRMglBrtsgShMcc3nZbvKCGcqEZLHHzR0mvcF9rX4eSNzA33BwDVaSGvVb623XylKYF4MHBjxNujuFm/MuJtHo4iUmswZu32zZlB5Fnx9PQLP5hpPDZYd5Yt0TuAwXp6SfwrNbnsVtNBUbzdAwtPCkEN+Uv4lN+ZsYGDOQH0/8MWcPOhuz3rbArt2d3aNGX0Wjg6ij9+wONhJ2P+Bc4HHg50Eb6UcJUFtZ+Qx8/VDz10eeB1f+u+vs6SQs/fuHrK1le/K55c2NLCjXGeMyEYPgnHIvp6/9HbvG3UJFrC++m9kZR5UnmolRrzNVfFhnS7QXq/BFFdGFwbH4bcR4D/K851SEgEoN4uOO4ymcj0uD4ybINBkM9+ic5rTUxl1L9LrYbvX6Jj4C1tk8XGdYkECFVxKjNxQBpyExCdCFINtlsKG6brZ7rsvCU3EONAlRTtr9F3Q6ZtbiYT1ehuLhonozofqiI4TgsYy/c3Hx6YywD2JV7CaGOQYwwOVzRNHRGOboz5aoPcQa0e0zIki8GOwen0PK3KFsyd/C8IThlFTt5+dLfk61q5piV3Ft3fW565ttJ1ziU58jFUf41cpfsThzMbdPvp2JKRO7h6t6B/GLT/10DAOBF3ePGk2QIvQ34F4gpJ4dSoDawme/grXPBr427hK45OWutaeH8PbaI7g8BrqzEkQSAIOL9xPlqmDapr9QmDwBKQ0yh12CXj2d/MIPSJtSjqb7vPE+si9CtxznHH0d64xRfGtMZKb1GMPZzxY5HIFBsnThMDQq/YNZpT+yQf2gnxNdJtZEeGu35a6vttDfo7PH5CXJJIjSNIQAp1ey02lw3CUp1g1OidJJ1nSGWAQHXZJ4XTDcpjPRiGJNpYcxbfQWc+Phf4nLkEguKJnHI9I3NhiNDr82vuf7mG1k2o6ysGw2X8avIcoTwXOHH/RFN5CSs7LP4wbLhR387bSOFmfBKPMd9NUSrThsLp42XmV/5FGO2nPg87q6I+JHkFXZTDipHsDa3LWs/Wwt01Onc/246xmRMIK0qLRwm9URQp6OQQhxHpAvpdwohJgXlHWNUALUEl/9Blb9JfC1wfPhuo+61p5ujjQMKpcuxekycPUdzOSv3sHrjebmLe9zPGMeXt1G/yxfBAaBJKVwq+/GhBTWpgxkzqxbiEh/nynZkvHHrsEhYFRhLjOHPYtXmJlnPsB49nCR18vK8lG4sbAsqZRpRiHH7H2IloLRLo0S4SVOamj+MDSHzB6MmoFeQLRHwyHhqFtiN3wzoASTRpFXkuXyCVi8VyNWCuJMgnG6zg7NxelWC9H+p+O+kYKvdQ8D8dKnlY3/f6S+z5LE5QDkWoq4I/dKgCb5gYQQuAyJ3VTJzwf+GQ2NAa6+nFY2nQuK5/HTIY/zbsT3zC07iaMug2lREegdzT3RCpZBsaTcMoHjlcf59NCnjE4aTbw1nm+WrA1Yf1/pvrY3LiHSsGHzz0JLTOVti2LeBazPW8/6vPUIBH+Z+xcWDFoQbpPaS2ekY5gNXCCEOAdfFpVYIcSbUsqrg2gTUALUPH+fB7kBogHY4uCXB0FXH119yj7/nPw//R/HSj28O/xUFhx7knnFh5mDQEMyIGtps8lJ+2QuZZ57OK/OrObyFS4WrZYYvExOYiJlUcV8XXYXllSdEhnLqspz2Fh9Kvi330/JWcBRi529Hi8TXTqvxLgo0yXDXRoXVJuRCMa6zeQ44aDZi1X6IhXUuE3nGAYFldDX5uWoRWITAq+EOA0ShaDSY2DXJTaboL4LRIxJ4wdYcLThrNTC0lmsidlKsbmMw3pBg6U2wzDwILD4o3haNIHZiCZKRmAIg03Ru3mq77/549G7GV89nFFGChtdlcTKQPlY24YXgyxLHgP9y3k1mAbEkHjxMMwpUQhd4PK6uPqzqym0+1KsT0yeyIKBC/jqyFcd7NmPgFhPNFOrR7M+eme3EZ/6SCQ//+7nbB+0PdymtJeQp2OQUj4APADgnwHdEwrxASVAgXn+FMgP8MW76O8w6cqut6ebU711K8d/djceTPTFw8+2flB7Tas3QLvM0dhibQiHHcPjIXLyZKq//x6AmKOZjMpJ4KS9vvoCSKwo5u/n6Hzg6cPFm4ewJv1Mboj6gv36UOyGz0Xba7KTZMvhrxWDORzh5Rvhu3+/xaDUAYn+qc8Cu4V9ePif1c2XkW5Os5up0iRf2VxcUWXlnxYXZZokOhrudURQ5oYvKr2kRMNor05stWCPycuoCJ+PmRACl5SY6w2ezUUhGOYcwK25l7EsdgNpR+dx0GMw2KpR7pWsqfJiETA72oRNq4vdNtwxgP0RvjHDQHLEksNPci4jVkYxOK6CldFrEGVz2v27Whm9iaf7vk2FqYoLjDNYEbGRAbb+/GHW4+ywZ/Krb25BSsnloy5nV+GuWvEB2Fq4FQpbaLwd5FoLWWJdEZrGOpEbPr+Bu6fezYSUCeE2pa08SOCU3MGmY+gU1EHU+hgG/DYFpKfptZl3wsLfdr1N3ZSC556j6PXXMSUk4j52DLwN3dIbz3a8wkTUw39i0CVnIMw+byPn/v0cvvoajLIywBdeJzsZBhXU3bd0guDv5+r87jUPI46DZvNiT41nRZ/LqewbiTMyD03qXO+cQz5wvT+ddqQBN5db2WT1ssbmIdUrOElKPgzg6HRJhYX3Y3x7HVYD7iyvm+ssjXBxvsNCVb0/k0QNTooxYfHPYlaJMiYKC9FGQzdxQ8raZbaaWU+O22BdlZcIAfZ6bcZqcFpsnXFleiW/zfgHOyMPkOyOxyM8vJH5h9pzPu8kfsYVxWc39+tpQvwVI4ielMod39zBt1nfNrlekzlV0RSB4NFZj3Lx8Is7v68QHETtDC+4zkLNgGowDPhtUuAo0uc/D1N/2PU2dRO8ZWWIiAiEpuHOyeHQpZfhqPRQHjuQ5MM7A97jQcOr6QjNSlHyOPoWbCC5jwVhNmPfvoOKb77GOmw4xk2Xc/j1fzKwAEwS+hdAtW4h0usThL39BELCr68z8YNVBlcuB+uRCs448hJPnHYdmiUGh3coGhppwDNYeEQzkDaN/3ldHDb5NvqzTZLM/H1MM7zsSx6OVZgo0GGwW2O9zUWiV1CsS3SgTDOIMzQMJPm6QX1pNZDkNko9tEtamS0bnvnahpO8aoOTbTbMQmL1u+WnmQQRwp83p74A6XVpEw5Zs3gt5WMGuPoyqnowRZZSRlYPIs9cRLInjq/i1rIkeSXl5mpuLlyEMMCUFoUp0UZZQTH/Mr9HljmPIlFKohbPXXN/zk7LFkaVj+KUfqcEFCAlPs0jkTyy+hFcHhdXjL4i3Oa0il9suqXgNEbNgGo4tAJeC3C4995DEJnYtLyXYDg9VG8tQIsWWDMi0KKiKHzpJVyHDlO5YQNGduAQQ83t59S2iy9ygcOWyICspZg9dvQ+fRCahic3t7bePxdqfD1ZY/4Wg5981nAQ3Jecwv9OK2X9MN93NK3SzDP/NJBOJ2gaOx9+irgJ4/jpvzcx16szCh3zxBSuv2gMcRFmpJQMffBTDP9XfEhpNoPKc1k6YCp3YkV3wTvChQ3B2dUWXo92UKlDlAGj3Tr5umSiSWNohY7JKzALwdFBVv5dXMr9DhtTbCYyhZffYud2awkXOgdSieRr83HeGvg0FaZKrs+6kssrT6n73KQk2y2p8Ery3D5x62uGYTaNEnMpmiG4c8gfKTVXAJBhpJKt5dX7YDWo574cY47h1H6nsuzYMmy6jeEJw1mXu67B59g4J1BXZEbtjQgE14+9np9PC9kxmKZ9nGCheJQA1fCnYVBd0LDsqvd8gUF7GNLtxltejinJ5/ospcSxfTumpCTMGRm19ao3b+b4A3/CXXAcqgpqByavZqI8dghR1XlYXWUhta3SCl4d4vxJg5dME7y2QCfKLnnlb02jS6wfLvjLxRqGJjh3ncEtZZOxjRxF9KyTiTndFxduVWYhX+/O4/RRqZwyPLnB/Uu2HedXH+0AKfEYkkpXXR+ahCsqLWR4dfaaPSyOdDdR1X5ovEIUS5NN7IzTOW1qP/IqHJicBtb9lbxxKJdM3YshDH46JI0bhvbhrKPX4NZKAbBKCy9lPkKyJwEt2crWrDIOOnzLaIMtGsMGa7w57DPKTS5W5C/DRcMDmxnOPmRb84P5yBUh5rIRl/HQyS2cCQyCE02A1BIcwBsXNxWfjKk9TnwMu53i11+n8F+vIMvKwGLx7c0Yhu9gDYDJ5MvKGoCaVaGtE+/Eo9uILT/EwKNfEelouvPc2gyoubpeDUqjINIJxTHwxVTf0tSMfQEehHSNef3nkv7iMiojYGQ2ONiI5cG7iBkzvbba7GHJzB6W3PR+4KTEWH5aYsXt8DJgSjx3HMwC/z6KIeCtaBdRWiVV0kagP4ckhM9jrtDO4kIHnxws5Mu756JrgkVrV1NscmGO34hmWFjrTeLe0wcx8pN+7CgqBWBaxnSGX3E6pnwvrmMVZC3JA0cUANlaFYfmHeY3k//AI6sewZVfJz4Tq0bQx51ItrlACVA3471973Fqv1OZ139euE3p8bQqQEKIWCBFSnmgUfkEf57wnoujDJ6eBtWN/8AF3PBZWEzqKO7SMjLnzgWns67Q5WpasRnxqUPg1SxM3/gnNOnB3Sj+Wl2ttmHgy7tTI0Jxdt8/l4Al0zXSSiSXLfdy8h6fEEn/Pw3ImdiP+c8/T8z+XRz5wSIAimJgh3M3lzI9YH8ARnU1pf/9L6bkZI7KkbgdvlnPxn3bfdG6DZ8AxUUIHDGfoCWtIModQ/WRnyDdSbXWTkXnIb/z9Rb/TpAhodLpYcPhYoqrXFj7/hdLvG+2n9HHCszmzXPe5JnNz2DTbVw26jLMJjPZb2/CXALT3DGs1j14DS+LB/6bw9u2833O9+wraXiO5p7j15Psief15I/ZFdW2fE46Ol5aiFGoCBlPbXqKccnjSI4I/OCjaBstCpAQ4jJ8IRjyhRBm4HopZU1sjVeBKZ1qXWdSXQxPTQBnRdNrV7zVvaNXN8KVnc2BMxbUzXKCQjIs8wM0vyeg2WP3l3bsuMZHswRpJTB7d0PbLBJu/Mq3l+E0xyCk7/fgMcFvL9eIscOUH5zNfCB+2Ggeums4pl0H2DHMzNMDWl6hyP7FPVQu8yXtS7nrAUyWAXhcBuOHjKSf9V9kH5yPrnt57aa5XPf1gz6RNFcwbPB+Ts3oxwdZj2MvnkR5QiRPVxRS6opna/l0IvVIrpzRn0n94zFpAqtJQ7fW7WfZdZ+I6JrOz6b+jD+u+yNz352LSZqYGTmeK6oXMpT+ZGd8wJKEFRiaTyy2FGxp8jNsOy2PCQdteMuNNn/4XrzYdBsOb9NEgIrQklmaydkfnM0lIy7hnmn3oGudk0Opt9PaDOhBYKqUMkcIMQN4QwjxoJTyQ7rl8bF2sOODwOIz9lIYdU7X29MBvGVl5PzmN1Qt+zZE4uP7pSaU7cfwO+bWL28rEvhsqmBPf8H3owSDc2HWbm/ANrwIrG7/7yHWSvRvHmJo1HoSbYn8aPItvr6F4Inr3mJl9kpujx/GsIRhLfbv3Lu39rW54AhXPXoZFUV20obEMd89km0F2xibPJbkiGQm9ZnIpvxNaELjt2efy8eZH2OY8rH2+ZJyUyTrzdVU7H0UDCvVXi+JUb4Hk7HpsfziBw4+yxzOfnsWQvjinn1x6AtGJ43msTWP1ToDeISHlbGbWROzlUeP3cp3cetrxafZzzDNTMlwE+8t+6JNn3kNSny6DofXwZu73+RQ2SH+vuDv4Tan0xFCHAYqAC/gCcVeVWsCpEspcwCklOuEEKcBn/gjo/ZcV5qc7bDs9wEuaLDon11uTmt4ioooeOopDIcD27hxlC35FNfevUhH5ww2AhBBuOUKwG2C70f7ltWG5BrNCphrnIeIHf6nx3In/SefyhOpi5rUi7ZEs3Bw21JEJP/0VnIefQw9IZ6EK6/AmmijylrKw2seJsYSwx2T7yDS7Dun98IZL/DN0W8YFDuI8Snj+fuWuoFkYOxAdhfvRmh2pOFzs96TUw7AH9f/kX/v9gWfrYmo45Ve7ltxH4PjBpNZmtnELq8weKj/cw3UXEdnUso4dhfvpbqeeHx84GNeP/t1Fg1fxBeHv6DS3XySP0V4WXV8FXuK9zAqcVS4TekKTpNShug4citecEKI1cA19fd/hBAxwH+BU6SUAdepurUX3L6v4K1Lmr/+UFG3CrNTtXYtR390Uxv2bsJHcytE348UOCxwyk6JqRk9c6UaWPL8+z8pEYz+dj2igymhC44cQkpJn0FDkG43mEy1IW9u+uIm1ub64phdN+Y67pl+T5P73YabKW/UrSr/YuovKCzsz7OfNxT6l26J5e7lP+2QjY0RwDCrl0ov5Hj0Rtd87tM6OpqmBUxpoOg+vHXOW4xPGR9UG6HwgnvuJ0ubHES97e/zgz4X5J8BTQulALUWTupWGo0tUsoKYCFwY6iM6FLWNBPVGiAiMeziYzgcOI8epfSDD8m+55ccve76biE+jhY+lsbiU/NIM3OvZN725sUHICau7qkxctDYDovPtq8/5/V77+CN++5k45L/IszmBmH1q9xVda89VYGawKyZmZbq+9sXCPaV7CO/sOEmcxSCPf8pQTNCs+Yvgf1OvYn4+K753eLxKvHpATy16alwm1AjPi/iiwcn/P9/0V8eLBL4UgixUQjx4xC01/ISnJRyqxDiIiHERcB2KeUX/nI30DOT34gWNPfqD5q/1ok4du8m9w9P4Dp2DG9OTlhsaA1bPQ0MNOPxAvlxEFcFkW3Uy7grr8A2fDh5v/GFOIo9s+Nu75nr19R7/T0yNpnX1mYzfMRQbjtvKg+d/BB/WPsHoi3R/HRi87OXR2c9yvkfnY9E8vHBj7lt9ClYNmt4PQaTnDrjXSZEqY2JllPZnPBth+1V9D4Olh0MtwnQCekY6jFbSnlcCNEH+EoIsUdKuTyYBlvzgnseGAusBn4rhJghpezZAdEOLg1cfsHzkNG1Tn1GdTWewkKy7rzLF0+th2DgO0lTX4g0oG87zqwmXHstKffew+Gtm4j95wsk9UnDNqpuNpSbuY9t33xO3/wSIr5biXX4cDL+8me0yLq/rfLCfNwOB2ZbBDmZdY4HuYcP8uz7OzgW0R8K89Aj93HbGWN445w3mthRXV5GdVkpyf19AYSf2/hcg0gBMwamsfzeMZRXuVj+ly0YjmLMHjuTBo5jc/m3bfxpO+pDqOhJFNgLusNeUGekYwBASnnc//98IcRHwAyg8wQImANMlFJ6hRCRwAqgZwrQ5w/C2n8Evjb75zClc2K9GU4nZYsXo8fHE7ugLrdIxbffkX3HHb69ih5GzWJR/SG1TcOr/xCsnpRE4o038vGTT3Bgw1qEprHowd/UxpD3ety8//uHcFVWkrH9IG4J7qws9p97Hs5f/gyX4cXr8bDq3TeQhuGb1daL4eexV1ORWJe48VixbwP/cM4+vv76HSaMm8WMyWeQe2A/7/3mQdwOOxMXnMOESy7hs6N157+mHjYxnn6Y42ykxdmIOk1Sdv8jCI+Lj3QB89q6DFf36Zgw8HQ4kYKiu/PQyof4zwX/CacJIU/HACCEiAI0KWWF//WZwG+CaRNaFyCXlNILIKWsFj01V+0r58GRZkK/X/4mjD4/ZF059++n5IMPcOXkEjFqFI4d26n8xjfrOm6zIV0uLIMG4jp0OGSu052BgW/Y9GggDLBlZOBpJi5cWxEREciKCrxFReQ99hhHqnwxzqRhkLV7BwPHT8Kdl0/hq6+QdiSHI4nRuHQdm8fnsrxdc3PktUZeilL6rW3IKcWrWdpnLjG4iVv2Ma/sfIOjR/YQbTfx3ZK1eH7pwdhfgNvhO+e0e+Uy5IzhDdoYkq3j2LEdc6ov5I++eQXC4zvce9pOjcyzDfTqJL4XxUyI8GJI2OEw+U6rCurc4+rhaUGqpfTdIqWG4UxBt+U1Wzfw/TqO3AuwpnyGZlLu2OFgT8kedhbuZGzy2HCZ0FnpGFKBj/wSYALeklJ+3vItrdOaAI0SQtREOxDAUP97AUgpZfdPknFsXWDxicmAu7aCKUB8/g6S8/vfU/p63TJP1RcNz3DUuE27Dh4KWZ+dRVkk3HqHzqJVBpeulMRddCFFzz0fVJuyou7cleGwM37+mWz+7GOsUVEMnzELgKw778CxdRtjAVtMDHkXnM3AJV+B00m5zdK00UaDfKkpmipLFMvPOY/i5L7MW/IaluIsiosh2v9116Rg846VXDDtMtYv/gDD62HQxKlMGTKF6I3RVGqVWD0mzjweS8TkyZQ6Srl96e3003O4VhMIQ2IeBz9MdgDZTHVoDLf5RHBJqeSrMlNA8fEb3OJn5KkaiLv4VCx92nf+x2vPwFm4ALw2hB4gAoaiy/ho30dhE6Db/j7/red+shRC7AUnpTwITAzewoa05oYdaCpX36gjgcq7jRu2lPBYfNPyk26Fs58IWTeVq1dz7I47oSqwd1WHMJuJOu00qr78svk6vsfloLppaXeiJowOgLBafVGog8Q8YADmtDTSHn4I67BhlOQeJyImFltUNAD758zFk+8LjbQ3NYHD/dPQpcTtdmHyeHGbGz0z1Uwb6v08u4ZP5NPTL2XGpuXMXdf08yuNcmNcOZHHF/yJ4uNZVBQW0n/ceDRNJ78in9UHVjDRnUTCsFGUVXzGzaueJsfl4dJ4F3PLvWgV4BwuETp8V2HiSCVcV1LBGOHmf/3ieDm/DzZPNCWR7Xco8TrSMJypmOO2tuu+6qM34K0aiSX5S6wpzexzKrqMp057ivkD5rf7PhWMtB7NCYwQYjZwFXBbSK05sgpWPw8zb4XBp7RevzU+DhA23RITMvGpWreOozf/uGH8tRChWa1UrVrVcqUQLOGtGwbRLkgphT7l9S5E2NBl3awtJOIzehT9/vQnXAcOYEpNBSAhLb1BndQHHyTv979nfZROTmwkuF2+6GZC4DabMFmteJxOMAz6llSSkxRbe290YjKVxYX0O36Iiz57k9iK0iY25CY4+HxmHjcl+aJdJKb3IzG9Hy5XKdXVBynO/S9p7t3ce3AXe3ZpxLpjKDf73PryPQJPhu8z323XqPLCR6W+WdmeqASWHc1mUJWVqw4/hNmwsj3tO1YN/rBdn5Fuy0W35bZesRER/V9FeiJAdN9l3Z6KRbPgMto3q/zv/v92SIBONNp86EUIMQmf6FwGHALa95fVGkc3wCv+EDh7P4FZP4czHwmuzU3/alr2YFZwbfo5/uhjlL3zTkjaCoRR2TUn37OTBe+cppNULrlqmZeESjiaDAs3OTq8Ve7F56iQFxtJhdXM4MJyHGYd8+QJHL7kUqTTiXXkSAZ/9CFCa9hL7MKziF5wBouvujBw2zVOG5pGTj1HA4DkAQOwVxUSV1VOXFV5PV82/zzPpBOzYBI3DErnlgm3UF6xk9KS9Rw4+GcMw15b+7BTY4/DF/mg3Fy3bLjX4bPVI+GbCjMHnHW2O4XAI8BTncrelHUcTNpMaUSjCOudiBASYa7usv5OJNorPgAR5sBBfBUNac0NewRwBXAlUAS8i2/Z7rSQW/LdHxq+X/1XOP1B0Du4R/PquU3LBofmiWTPjBnI8gBx5Hog526QFMcZFEfDe6fo5CUJXng2OD+t4phIDqbEURTj2wfdn5aErmlcNmgopf6ZlHPvXozycvT4+Ab3bv78E1a8/WqTNqPiEzjp4stZ++G7VJWW+ArrLb2ZrGaydu/EW2+iJhq9mnvV9YyeN5XjOe+yesVkpAw8sCSZDCI1SbUhMBk6XiRSGOR6BH/LtVIlBQWeuk/IYkgWVVSx2TyQ56OsHI17v82flaJ38otpvwi3CT2C1mZAe/C5Xp8vpcwEEELc3SmWnPRjOPB1w7LfpcF9h8AWG/ie5lj5Nzi8smn5dR912LwanMeO9RrxAYjuN4ibvjoKhsGGYYLnztNwd1B99NRUbMOHkzV8AEWb1taWS01w+k/uInnMBCpffRXP8Rxizl7YRHzWfPAOq997s0HZwAmTGX3KPMbOPZ2sXTvqxMePZvaSMq6EuEFV7Pso8JZlVFIEwy7eSZl2D9+vDVilAbEmE48MH8NmewLf7sglN+agX8M0Djfymu8b2ZdqTzVva4K34wwgNDNsRc9lYvJE+kT2CbcZPYLWBGgRvhnQMiHE58A7dNaJuhFnQfpUOL6xrkx64In+cPOyth0SdVbA0sdhbYDItLNDk0bXvnFj65X8WEaOxKisDNp9udPQNNyHD9e+nZYZOCtpi5jN9H/5JSInTUKz+PZD0t1ubP95iy1ffoLb4WTGRZcy7rQzABj66ad4CoswZzTc+9n06f+aiA/AiJNPJSohkeP7diNMTc/dxPSvou+MAqpyo5tcy5hkRU84Smz/MkQr0aeFsBAfP5PRo36HzdYXITSeev8scmOPt3hfsbOYq0dfzfaC7azLq0uFbXNKHNaeeWpBERxT06aG24QeQ5tScvsPHl2EbyluPvAa8JGUMqCLVlBecI+ngdvetDxpJPzwPUgc1PSaYYDHDk9PhsoAZyciEn0zqRDgzssj87T5vj7bgBYfj1FaGpK+Q4UWG4tl0EAc27YH3Va/f/6DmDlzAl4zDC+Gx4vJEsB92o+jqhIpJS/feTPOqpb3vXSTGa+n/hREMuryA9ji3Vi8M9j2jsRRWQEI4oeUM2hBy8JvtabTp89CBvS/EZutb225y+tiRdYKfvndL3HLth0UTo9K53hVU7FKLZbkJdCCW7ait/GPM/7BrIxZHbq3O3vBCSHigZeAcfg2Vm+UUq5p8aZWaJMTgpSyCl/st38LIRKBS4H7gRZ8hDvIr3LhuZlQsLthedFeeHoinPE7OPknvr0hrxv+NgkqskCzgtGMp9ZPWvEmawfm1FSGfvUlR676IZ681g8KdjfxAYgYP57qLVuCbifqtNOaFR8ATdPRLM1HC8jcsJZPnvwDUkr0FkSqhobiAwiwxbtxV5nI3XuAhH7TydnjE7GIlAAPMQDoDB58F4MG3oSm+YK5O6vd7FuXS1JGNEkZ0dz2zW18n/N9q/bUJ5D4AOTHo8TnBOLU9FM7LD49gKeAz6WUlwghLDSNOdduWjsHlNjSzVLK4kDlITkH9OZlkNm+w3gBmXM/zH8g+HYCYHg8uI8e5dBFP0AGSn/dnQnyDJGpb18GvvYqlgFtCzFVVVrC//7yOBUF+Uy/6FJ2LP2SouxjGP5I31EJiVSVBPw61aPhqSXN7GX89fvY858hOEv9mUE0wIARpycTNXwdUjrRNBuDB/2Mfv2uwGRq6DknDcm7j6+jKLsKzSSYcVsK16+7so2fgkJRhy50Vl+5ujbXVEcIxQzoL5ef1yQdwy/e/SSog6hCiFhgKzBEtmXZrI20NgMqxLerWhPfuP6jnASGhMqQJlz9Hqz4K3zzWMfbOPn2ThMfAM1kwjpkCBlPPUX2z34WkrMyXUaQ3yFvYSH7Mn9H4aG12GzpmPQoBgy4iT59AieN2/LFJ+Ts2wPAt6+9hDQa7skk9x/UQIAcZitmjxtd1l/qbDiTMNw6218dgVHPa2LI5JOwl5fSJ+Uk+mfcT/7h/YyYOYfI2LiAdrkcHoqyfQeIy7Riblz3s7Z+BCEhyhTF4LjB7CrahRFEEkBF+BmdODoo8QkFfvGpH4pnIPDiXy4/jyBFaAhQALwihJgIbATu8q+OdZjW/J2eAUqAz4Hr8KnfYP+/zhOfGk79OdxVE/mnHUQkwgPZcNbjnWJWY2JOm0f6n/7UJX11F6TbTcmeb/B6K6mq2kdZ+WZ27LwbrzewCJfk1i1RNRAfTSciNp4j2zY1qP/e+TfyxbyL8AoNb5MUGnXiabh1ar4fsSmpHNq8npz9e1n5zuu88/C9fPPyP3j30ftp7qHNGmlm5ElpSCRrR3zU5SJQ5aliR9EOJT69gFMyQnB4PnhaSscQDCZgCvCClHIyUIVvGyYoWhQgKeVdwCTgP8A1wGYhxJ+EEIOD7bjNJAyER0vhkVJY8DhY67tkC0geBcPOgglXwCk/h1/s9TkcWJt6RXUmsWedSfpf/uyL+NxLMUySwrvc5PzVRcHP3bgaRZ3XtIZJ4Gooy89l75oAbvEAhhd7eWmDIglM2rmWY+mD+ffFt+CyNE6827QPCZSbLUij3vFT/+ypOPuYL3pCMwydksLhPlvJjGlf+BuFogaTMHHhsMCHp7uYzkrHkAVkSSlrDjK8j0+QgqLV0dK/3rdMCLEZn0v2b4H9+KZ5XYcQMPt2379uSty551L08r9w7toVblNCQs2Oi1doePtlIG6Ix5Xmc0N3D6sb6K3WdGJjx9Gv37VoWkNngpz9e1n85B9ASkxeL1MO5WI3m9g+MLXZ/gQwYe8mEssKcVpsRDibOhQUxSQQV1mKPSKaspgEto+eyvStq0j2z46ik5KpLPJlDh44cQpmm63Zn3PTF0ewywBRBDohjY9E4DWlYfJ0z8SDoeBEzH503/T76BfTL9xmQCelY5BS5gohjgkhRkop9wKnA0EPdK1FQogCLgQuB1Lwhd+ZIqXsOdnTupj+zz5D9q9/jX11UN6JXYuug7fpORkBVFptHMoYwOzRwxGnzaRgd9NzUDZbXyaMf6FJeVlBPm8/ci/S37ZH1zmSEsfw3JImdWv6qz94pecda3avyhEZzeoZZzBu72YGHD+IzVlNUmldqnpXdd3SdGLfjMA/d831jChKj+Q1HTk7YRQ1tDhA4NESEUJD85YgaOfZq25O7ccmweIWuCy9Mz7dqIRRzOg7gwUDFjApdVK4zamhs9IxANyBzxPaAhwEbgi2wdZmQPn4ZjtvA5n4/kSnCyGmA0gpQxsPrhdgTk8n+tQ5PUuAAohPDdFI5p01n6Qf/Qg9OhpNmDlw8EkcjrpnkCGDmwbHyDuYySdP/bFWfGqwur3EOlwkVVRTFBPZ4pivNRKfrD79WD95LgmlhWwZO4MBxw8yOCsTgOR64uPVdCadeR7r/vcfrJFRjD51XhP7ShwlPLzqYfKr83FFuMjMyGz2MwglulEKRimGiKA05QES8h7tkn7DggCXuXeKD8CopFH8cvovw21GA37x7idv/eXy8yDEXnAAUsotQEjPKLUmQO/5/z/S/w/qxghJqAOS9hZ60fpDyl13knzjjbXv09IuJDl5Pvszn6C6+jADB9xMYuLJDe5Z8darrPtf03homtfA4vGwMyOZomhfsEbpn/fUfGQ1gUwD8eW8iyhKTKt9XxabiFfT0BsdCrb0SWP86WchNMGxndvJP3SQvsNGNqjzyo5X+Dbr27Z8BJ2CkA4S8h5B0HsHaKBX/S00Zn/x/nCbEBC/2AQtOF1BawK0g4YLExKfK95KKWX3z6oWJsxJyV3faQhyAzWmzyMPk3Rl0zMxJlMMo0cF9jB02e1sWPLfgNcMXSMzLalBmYZk2fQFzFv/FYLmxUcCp6z9mk8WXI7XZCYt9xgVMXEsnn8pM7auJL0gu07EcrN5+c6bau89vn8PA8ZPbJD6Icoc1UxPXUOvF54TAF1va0p2RXO0JkCBXMkGAr8SQjwqpey8fAQ9mKjZs9Di4jDKyrqu00Dio2ltDhnUmMRbbw0oPi1xbOc23n/8YQyvp/XK9Zi1+dsmZYczhjIo+0DtewGMOLKHu196jI3jZjJlx1o0ZO0w3uKDdoDP5oZxN+DwOnhj5xs4m4ugoTjhsQorTtn0+zG331wV8ToEtCkWXJObfBESvpZSBnTD6zYZUcOI4XRy6MqrcPUwjzgRGUn/v79A1IwZbb4n92Am7zxyH15XcAN5/an2ljEzsLidjNm/tV1eVc3VPe9n9zHy5FOblO8o3MEDKx7gcPnhjpis6IVo/tMpg+MH88pZr1DuLOehVQ+xuWAz4Dtw+t7577XURIfpzrHgOoMOHVqRUhaLQAc+FLVoVitD3nsXx65deKuqkB4PhX//B442RNO2jB6Fa+++2tmLlhCPrK5GOl2IqEhkVdsTj8VceAEV/1vseyMEIioKGSDZnW3iRAa9/VaTBHGtserdN/n+w9BMhGsehVxmC9GVZcRUlePSTFiM1mdUHqFhkkazQtWcG3asJZasCpVCQVGHgYEudF5b+Bpx1jgSbAn8eMKPeXH7iwyKHcTDJz8cbhN7DR0SICHEfHwREhQtIEwmIiZMqH0fNW0a+06eVZvmOuA9sbEM/egjvGVlFDz1FIbLTZ+7f4awWPAWFWEZNIiqtetwZu7HsWs35tQ+xF16KQcWnAmehgO1ZfhwMn7/e6rOPx/H7j3E/+AiDIeD4/ffj2N/JlpkBDELF5J8442YU1La/fOV5ueHTHzAN3PZO3gM0fZKhh3dC4AXQZUtkiiHT3RrRGrP0HEMOpZJhMsBQjBx3unsXPYVAJaICFx2O8kDBpHQN4OMkWMYMnl6wD6PVx3HI9u3ZKjo/Xilly8Pf8mlIy+loLqAu5bdhctwsTl/M1eNvoqRiSNbb0TRKq2dA9oOTXZLE4HjwLWdZVRvRYuIYPB/3qPs00+JmDABLToa9/HjWEeNpmrFclwHDpJ4/XUA6HFxpD3c8ElLj/EF0ow6aQZRJzVcIhvwz39Q8PwLOPbvB4+H+EsWkfaALw5e9CmnEH1KXZiQQW82zbvTXgqOHub1e+8Iup36SCHYOm4mp35fF4RWRxLlqMYAKqNiiK3yJQMckH2IT864jEs/fR2AWZdcxcBxEynLy2Xc/DPRzWZsUdEBIzPUZ1rqNOb1m8eK7BVIJIZUIXEUPh5f+zgSyeQ+k2vTckskpc7S8BoWBoQQI/FlxK5hCPCwlPJvwbTb2gzovEbvJVAUbAC6Exnr8OH0ueuuJuURI0cE1W7UrFlEzeqaMPBF2cd44947gvK6M2gaB6ogMZWjGUP4ct4POGP5YjLyjtYuqWX1HURxfDJ987JILc4lPyW9NkSPpmlomsboU+a12w6TZuJI+RG8sncdBlUEj1d6+e33v2VG2gx+OumnfHLgE2alz2JGWtv3R3sL/ugHkwCEEDqQDQSdYrpFAZJSHgm2A0Xv4+Mnn2g2uGdbCTQvqYlkUJCUxtsX3oTFaUcD3CYzt7z1VwbkHEYiWDn1NPYNGcelxUcYMmU6Y+acTnRiUoAWW+fx7x/nUHnnnSjQ0FSg0R7Outx13DzhZm6deGu4TWkTWfevaJKOod8Tp4byXNDpwIFQ6EP7dpwVJzzO6mqKsoOPxBRIgDSvhxlbV/pmVpqGKyIKR0QUFo+bKHul/z6JwxbJJZ++xk/PPIMf3PcII0/uWBTivcV7eWdv554kUOLTO/jycOhzb3YGfvF5Ed9xGeH//4v+8lBxBb7oOEGjBEjRZjxuN4v/8niHzxa1hASWzL+UuHohdWqwR0SxbuJsJL7AqPNWf8a4oUPpMyi4jCDlzvKg7lecOOwq6jHHKTorHQMA/jhwF+DLkBA0vTd3gCLkrP/f+xzdEdqUBTXndraOmc7eYePYM2IiJrcLj8kMwKDDu5m+43uSSgp8kRL8TgKlx7OD7vsX36mDhIq2MS55XLhNaCudlY6hhrOBTVLKvFA0pgRI0WYclRXtqr9t5BS+nXU2c77/gkm7fQeTGzsfCGDbiEkUJqaiGQZeTcdjtjB903dM2rmO430H8vlpi0goK+KCL98mwmnHo2nE900P1GW7KHGqkwSKltGFzrWjr+XOqXeG25S20inpGOpxJSFafgO1BKdoBzMuuhTd3DDfj6Spn77El1L7qzkX4rRGsGr6GeSmpOPRTWwYP6tBfafJzIR9Wzhj5SecvcwX23bIod3MWfcV8VVlfH3q+VREx3E0Ywhbxvq8jzLHzuDcO4OLQlzuUstvitbxSi/v7nu3J7leP4gv/UJ9QpKOQQgRCSwghEGo1QxI0SK5TjeP7j/Gpgo7o8yCKY0iJXg1HZPR0IX5WN9BLJ95Vu376shoPjzranSvhx+9+1QDBwSLx137etSB7Qw+th+bq+6gbnRVBU6rL3J2TFU5Etg5dS6RsXFB/VwmYUIXunK/VrRKtaeaZzY9w2OzHwu3Ka3S74lT38q6fwV0gheclLIa6Ji7aTMoAVI0YH1ZFb/bn8XaiqZZSI86wNx/BKMztyGAkpgENCmJqyytrSOBY30HcMaKxZTGJLBs9rkIKfEKQVpBdhOxapwLqL74AFz82RtsGjeThPIixu7djFfT+f3gptlU20ukOZIEawKFjqZOD4rmsWiW2kOZJxIfZn7ITeNvon9s/3Cb0ip+sekV6RgUJwg5Dhd/OZTLm7nFAa+b3C6mbF/D/oEj0b0eNo47GbfZzLBDezhp6wp0w1ubTnvWpuUIIK0wh1GHgvMeiq8oYf6az2rfxwwcwrxRwR3araHFZTgpfSkuFA1oTXzMwoxbulus01OJMEeE24RehxKgE5wjdieL80v5w8GcFk+sjDywg7nrvqr1WhtxaFezgT9DOWzXj25dbYtk+LU/CVnbZt3c7IA6PFuSmwgVkUqE2kNvER+zMOORntqEHxbNQnJEGPJ89XKUE8IJys6Kamat2cFJ3+/m8VbEJ760kDOX/w+oE4OuGpZr+imKTmD7yMnMTY4PSbt/XPtHqt3NRxU/nCqU+ISBlIgUfjPrN+E2A5NmqpdtyueMoOIEhh41AzrBkFJyy47DLC5sOVmeCZgUE0G010Pix4ub7N10NUmVJSRtXUVs8n1Bt7U5fzNv7mk5IOuJ7prQJ6IP+fb8Lu+3wF7Aw6vDn+7A7m24B+qVXo5XHKdfbL8wWdQ7UQJ0AvFRXgm/3nuUIm/LcdwmxkTwxbSRlObm8PJdN3eRdXVIwGUyY/G4m8y0pJRBz76izYES/TbEMJ/Ys59wiE93J94WH24Teh1qCe4EYU1JBbfuOtKi+ERqgnSrmYeHplNeWMCbD97dhRbWISGg+ABouh50+8MThnP9mOuJNkUj2ihnFmFpvZKiV7Py2MpwmxBWhBB3CyF2CiF2CCHeFkIEzvLYDtQM6ASg2mtw7baDLdZJtZjYOrsu3MjbD/8GZ1XTzKldQWc/Fa0+vppXd73arntc8sRzPVY0pMR94kbOEEJkAHcCY6SUdiHEe/iCkr4aTLtKgE4A1pZWUmEEnvkkmTRsus5vh2fUlmXv2UXewcyuMq/NaKbgv65SSt7a1SOOSCi6GXP6zQm3CW3i0UcfbZKO4dFHHw3Fl94ERAgh3PgCnB4PtkG1BHcCMDzKRnMLV6lWC0unj+SclPjasi//+TRed/dzp41NCf4A6nWfXcd32d+FwBpFY2anz2bR8EWMSRzDnIw5xFmbj1ah1Rt6+kT2adO+XLhZk70m3Ca0il98mqRj8Jd3GCllNvBnfIKWA5RJKYPOUaEE6ASgn83CAFvgPYxdVQ6WFdcFGfV6PFQUds/oAI6Klj332sLmgs0hsEQRiFXHV7Hk4BL2luxlefZyypxlDIsbFnCfrX6epPzqfDyGpytN7RCySdTDbkmnpGMQQiQAFwKDgXQgSghxdTBtghKgXs8xu4vRK7ZzyBF4D8MiBKOifXuJLns1H//1D7idjoB1u5Iqa9NT5wPHTw66XZNQq86hYGTCyIDlDq+jQXy9zLLMNg3cDm/4v3OtccbAM8JtQlvorHQMZwCHpJQFUko3voCks4JsUwlQb+fevcco8TR/quVf4wczKso32H/23F85sHFtV5nWLC5NpyQmoUGZpumcc+c9QbUrpVTBR0PEtWOuZVbfoMefHkVPmKXRfNqFYNMxHAVmCiEihRACX1ru3UG2qQSoN+MyDDKrmz5ZWv0rIhf1ief0xBgADK+XzPXfd6V5zWIxvKSWNDyHMuGMhWhacC7YQoiesozS7fnVql+xOmd1UG2MThzdZjf47kBSREgDQXcWnZKOQUq5Fngf2ARsx6cd/wymTVAC1Kv59/EijjmbOhMMi7Sx79Tx/H3sIIQQ5B7M5O+3XhcGC5vH7PVQGREFgCk2jtN/dGuYLVIEQ4othfSohkkEy5xlrT4Q6M26z3QeE5MnBixvKXRTd8Hv7XYzcATfkbojwM2h8IKTUj4ipRwlpRwnpbxGSukMtk21IN5LkVLy2wM5Aa+ZNY1Yk+8Pe8OS//Hd6y92pWltZt+gsVhiYnjm1ltC0t763PUhaUfRfgocBQ3ep0SkcLyqdS9ebxiCIm0tbJp2XiB6yhJcjQj1iLMGagbUSzlod1JtNAyemG41Mychmr+OqstpsmHx+11tWpuZ5yjiH7ffSnRkY6eejuHwtH2j26YHfcj7hCXS1PLvy6SZWnzfHZFIlUW3E+j+v3lFu/muqJxrth8CQBgGMzYvpzApjZTxk3jcVUjuJ6v5JDeH4pzsbr0jMvOsc7FYQycEp/Y7lRl9ZrAuf12rdXuCV1Z3pdpTt1QlaLjvNjZpLLPTZ1PhruDtPW/X1unu/GDYDxgQG6wjmaIxSoB6GS7D4OptB6nZ+ZGaRkbeMU5d/zV8/iaLw2pd25l01rmMP+3MkLfbJ6pPyNvszQgEZw48ky+OfNGh++dkzGlw8Hdn0U52Fu1EILht0m2MSBjB6uOreXfvu9h0G4PiBrGneE+ozA8Z1469Ntwm9EqUAPUCvB43mm5CGga7Dh4gOe8YOX36gRAkluTTL/dwD3jGbMjpNyqng+5AenQ6f573ZywrLHx88ONm6w2NG4pHesiryiPBloBAMDhuMI+f+jifH/6cl7e/TE5V3Z6kRFLlrmL+gPnMHzAfgeCdve9wqPRQ2FJBtIRVt4bbhF6JEqAeisfl4vvbf4LrwEH2R1uotFlACKSUXA1sHT2NIxlDOGfpB2HP5dNuOikVtttwsz5POSK0h+zKbJYdXcbZg89md/FujpQfwW3UeVZeNuIyzht6HpvyNvF9zvfcMuEWzh96PvtL9vPe3vf4cP+HXDvmWk5KO4kHVz5IVkUWJc4SYiwxnDP4nNp2VmSvAMBpOJmVMYs9RXvYU7Kn26T47het8gB1BkqAehAel5M37/8ZJbk5JJZVMCC/lEiPh+n5BsvGDIR6uXKGH9rFltHTMXQdDG+D1NbdncFTpndKu79f+3vyqvM6pe3ezLrcdby95+0Gh3itmpWFgxeyp3gPnxz8pHbfZ23OWgSCB1c+WLv38/GBj/nggg+4bux13L/8fnShc+/0exmdNLq2vZl9Z/LB/g8AWHp0KXa3nbun3M3G/I0sz1rehT9tYEQnPRT1JIQQd+Fz8RbAi1LKvwXbphKgbojX48ZeXk5ZUQGVRYXsX7ua/evWYHjqngQLoyMojPZFMLC4mrqHlkfFMXXHGj44+xou/eQVTEbPSCccERPLRb/4Vae0vbso6IPbJyRljrImESSchpOPD37cJE21RLI6Z3UDx4P9pfspchTxwb4P8Ejfd/WTg59w0bCLaus8fPLDnDHwDP6141+17vLPbXmOYfHDOumnah8HSg8wNH5ouM0IG0KIcfjEZwbgAj4XQiyRUu4Ppl0lQN2IzPXf89VLz1Fd2r68Iy5L019jYlEuNqedvnnHEMChfsOILy8mobw4RNaGnvGnL2TBzbd12tPm9eOu54HlD9QOgoq2caj8UMDyxuIDMLXPVM4edDZLDi6pvZ4RnUGcNY5padNYk7Omtl59NKFxSsYpvLf3vdoyl+HikhGX8JvvfxOqH6XD9JAoCAB8s3Rok3QMp88/EOy5oNHA91LKagAhxHfAD4A/BdOokDL0jrjTpk2TGzZsCHm7vRmvx8PT1y7C8IZ+v+aDs6/m4MBR6B43Vyx+mfT8rJD3EQxxqWnc9PRLXdKXw+NgwX8WUOoq7ZL+egOjEkbhkR4ySzMxa2bMmpnkiGSOVvjCi9l0GzP7zmRq6lSuGHUFNpONo+VH2Vm4EwOD2emza9NZr8pehURySsYpAfs6Vn6Myz+5nAp3BYuGL+LRWY/y6cFPOVJxhCRbEr9f+/suj+dn0kw8ddpTXZIPSAixUUo5raP3+8XnRRpGxK4Gbg5GhIQQo4H/AScDduAbYIOU8o6OtglqBtRtOLh5Q4fFp+YRItC8QQKH+o8gqTif879+l+iqbnKYTgisUdFMWnAOp1xxTZd1azPZSIpIUgLUDoocRSy9bClF9iJiLbGYdTPFjmJ+v/b3VLoruXf6vQyJG9LgngGxAwKem5mdMbvFvvrH9mfpZUspc5aRGuXL/3TOkDpnhU8OfsLm/K5NqeExPNy97G6WX7GcKHNUl/bdAVpKx9BhAZJS7hZC/BH4CqgEtgJBLyUoAeomLH/j5XbVr+9U0NKClQDG7N/K0CN7SCkObgPeKzT0essuHXFsMEdGccUjfyBl4OCwbewW2rtnvqNwowu9dnYRZ42jzOnLv9QvxucBVn8ZKtGWyJ/n/rlT7LCZbNhMgQ8g/2LqL7j6s6DT0LQbj+GhM1aLOoHOSseAlPJl4GUAIcTvgaCXUpQAdRNEO9NNt2foPnvZBzjNwZ9jKI5PYvfQCczeuAxdGu0Xn4gIrnj0CfoMHBy0LcEQaY6kzBV8crvehEDwp1P/RFZVFkfLj3LV6Kv47th3FNoLuXHcjeE2r5YJKRNYNHwRiw8sbuAO3tmcnH4y0Zbun7UV357PwGbKg0II0UdKmS+EGABcjG85LiiUAHUTZl/6Qz752xOd0rYAbO6gA9eSUlJA5M61DWZBbSEiNo6FP/0ZQyZ3jnt1exkQM6DBocgTnRhLDO+e+y79Y/s3KB+RMCJMFjWPEIJHZz1K36i+PLvl2XbdaxImJB3LCdU3qm+77wkTDxJ4DyiodAx+PhBCJAFu4DYpZfu8pQKgBKibMPLkU9jx7VQOb9kYblNaJMpe2a76AydOZtEDv+lW5yh+Pu3nXLXkqhMyOZ2Gxq9m/gopfcE1TZqJef3nNRGf7s6lIy7lpe0vtStmX0vej41j1jWmu7iDt8bp8w+89c3SoRB6LziklKcG20ZjlBdcN6Mo6yhLnv4zVaXFJGb0JzohkT2rl0PPWH/GbLVx7p2/pKq0hLjUNAaOnxRukwJS6arkh0t+yMHyg+E2pUvRhc6Zg87kiVOfQBM9Oxi+0+NkT/Ee7lt+H9lV2Z3a1/brtndq+zUE6wXX01AC1MNwOexkrl/D0ldfxBoZyYTTF7J92ZdUl5VieA28bldYxErTddJHjeG0a2+mz6Ahrd8QZv6b+V8eWvVQuM0IG6+c9QrT0nrHOFfsKObdve+yImsF2wvbJxQRpgjsHnur9VZesZI4a1xHTWwzJ5oAqSW4HobFFsGYU+cz5tT5tWUnXXRp7WvD8JKTuRdN08k9sJ/i7CzK8vPI2rUdr8eNURMRoSWREqLZ6xZbJIY0MJnN9Bs7nriUVEacNJv0EaNC8vN1FQdLT6yZT2N6gDtxm0m0JXLrxFu5deKtvLnrTf64/o9tvtfusRNjjqHCXdFivZ1FO5mVPitYUxWNUALUy9A0nYwRYwDoO2xks/VK83LZtfJbyvNyGDLtJLJ27SA2KYWBEyfjdbtZ9to/yT2wH2kYSENii4pi5qIrmHLOhd1qP6ejnDnoTF7Z+Uq4zQgbe0r2NIjF1lu4eszV/N/6/8Og7Y4yrYlPrDmW0Ym977PqDigBOkGJT01j1qIrat+PmNHw6e7K3/xfV5vUpbyz551wmxBWqt3VrVfqofxxzh/55fJfhqSt2ybcxhWjr6iN5KAILT17F1Kh6AArslbwvwP/C7cZXc7QuKFkRGcwr988fjDsB+E2p9NYOHgh669aT7w1Pqh2+kX34yeTf6LEpxNRMyDFCcd/9v0nYLmOjpfe6Zp98/ibuWPyHb1i+bQt2Mw2VlyxgkJ7IcuzlvPnDX+mwlWBSTPhMVqPIJNsS+a1s1/rAkt7BkKIfwHnAflSynH+skTgXWAQcBi4rL1ng9QMSBEyDMPF5i3Xs2r1XHLzPgm3Oc1i1QJHhegt4mMSDZ8rxyaN5c4pd54w4lOf5IhkLh5+MauvXM1nF3/G0kuX1u7niACxPPrY+nD3lLtZdvky+kSq9O31eBVY2KjsfuAbKeVwfMFJ729vo2oGpAgJlZV72bjph3g8vgegnTvvpk/KWWiaOcyW1ZFblUulq5LPj3weblM6lVl9Z7H8eF0St9P6nxZGa7oPNTHt3jv/Pcpd5QgE+0r2MSx+GNFmX5gdXdPDaWJISFu2pUk6htzTJgV1EFVKuVwIMahR8YXAPP/r14Bvgfva064SIEVI2Lb9jlrx8SER3eig4zObn+Gf2/6JdgJM+tfnr+eF019g6dGlpMekc93Y68JtUrcj1hILwNTUqa3U7Fn4xad+KJ6BwItpy7YQrAgFIFVKmQMgpcwRQrR7yqgESBE0LlcpdvuBBmV9+pyLEN3nafL9fe8DtMs9NyTUDxneRXnR7R471Z5qHp71cOd3puhudEo6hs6i9z8OKjqdlasaB8XVGTsmqESJIcVtuEmJSAlP5/UER3RRgIq+kX173ZO9os10WjqGAOQJIfoC+P+f394GlAApOozTmcc3S4cjpatB+aSJr6A1s9EfDp7Z/Ax7S/aG2wxkF/y1TUyeyH8v+m+PSiGtCCnNpV0IOh1DABYDNeu71+HLmNoulAApOoTdnsXKVbOg0ZJWfPwskpJaznrZldg9dt7ZfWIcOh0cN5hXFr5CpLnxCoziBOJBfOkX6hN0OgYhxNvAGmCkECJLCPEj4AlggRBiP7DA/75dqD0gRYfYuaups4sQcUye1L7Mrp3NM5ufwe5tPdhkT8aiWfjowo/IiM7oFV5cio6Te9qkt9KWbYHQe8Fd2cyl04NpVwmQot3s3v0gZWXfNymff9qmMFjTPIfLDvPpwU/DbUanEm+J56GTH2JAbGcs8St6In6x6XYOB4FQAqRoNyWl65uUJSaeHQZLWuaaz66h1FkabjM6hSRrErdNvo1LR17aemWFopuiBEjRbmJiJmC3N0xnkJIyJ0zWNE+5qzzcJoScYXHDWDRiEYtGLCLCFBFucxSKoFBOCIp243TmNikrKPgsDJa0zIzUGeE2IaSk2FL42/y/cfWYq5X4KHoFagakaDdlZeualBUXL8fhzMVmTQuDRYE5Y+AZfJ/bdK+qJ3HPtHsYEjeEWemzlIOBotehBEjRLkpK1tPY9dqHQO8mZ3+yK7P58Zc/5mhFZxx96Drm9JvDNWOuQetGIY0UilCivtmKdnHw0NMBywcM+DFmc0IXW9MUQxrcv/z+Hi8+AsHf5v1NiY+iV6NmQIo2Ybcf49DhZyktXR3wemTk4C62KDAvbnuRLQVbwm1G0CwcvBCz3n0iiSsUnYESIEWb2LHjLsortjZz1UKflDO71J7mOFB6oPVKPYBrRl8TbhMUik5Hze8VbaKq+lCz14YNvQezOa4LrWmey0ZeFm4TOoxNt5EWlcYTpzzB+JTx4TZHoeh01AxI0SqHD/8dr7f5MzXHc94hNe3csHvAPbXpKV7e3r1CAbWVORlzeO6M58JthkLRpagZkKJVDh56psXr1dUHOZ79bhdZE5iPD3zMS9tfQtJFOQ9CzO9O+V24TVAouhwlQIoWKS3dgJSOVuuF2wnhyQ1PhrX/YIjUI4mxxITbDIWiy1ECpGiRY1mvtVpnxPBHSEu7oAusCcy6nHUUOArC1n+wvHTWS5g0tRquOPFQAqRokZiYca3WyT7+NobharVeZ9GRZHMm0T0G/N/O/q1yOFCcsCgBUrTIoIG3oGm2FutUVe0jN/fjLrKoKecOObfNdaenTufOyXc2SJUdLqamTmXhoIXhNkOhCBtKgBSt0pYIBwWFS7vAksAk2hLZ+MONbapb5anC6XXiMTy1ZZGmrs0gOjt9Npuu3sSrC1/FZmpZ3BWK3kz3WIdQdGs0zdJqncLCz8kv+Jo+KWd0gUVNsZgs3DTuJl7a8VKL9Y6VH+MfRf9oUFbtaZzBOHjmpM/BarKyOmc15w05j1/P/DXbC7YDqCU3hcKPEiBFq/RJWciRo/9otd6uXffSZ274sqIuHLywRQGy6TYq3BVdYsv9M++nf0z/BmVKeBSKhigBUrTKsGH3kpf/GQ5HywE+vd6yLrIoMCMTR3LBkAtYfHBxwOsOb+vu5B3lzsl3MiV1CofKDjG/33wSIxM7rS+ForegBEjRJiaMf5516y8gcCqGOo4ff5/09Eu6xqgA/GTiT5oVoFCgC517pt1DTlUO2wq20T+6PzdNuIkh8UMAn2OBQqFoG0qAFG0iKmoYrYkPwNFjr4RNgArthTyw/IGQt2vRLAyJG8LPp/2ck/qepFIkKBQhQgmQok1ompmY6LFUVO5ssV5V1R5WrprLpIkvEh09oous8/HY6sfYWtRcxO72MyVlCs8veJ4oc1TI2lQoFHWoRzlFm5k8+U1Gjfo9FkufFus5nVmsXXcBHk9lF1nmI6syq0P3pUWkcenwSwHQ0Lh1wq18c+k3vHbOa0p8FIpOREgZ+uCN06ZNkxs2bAh5u4ruQ27ep+zceRctLcslJ5/LxAmBM6h2BsuPLee2pbcFvGbVrIxLHkeEKYJ1OeuwmCw8cvIjzB8wH4veupu5QtEVCCE2SimnhduOrkItwSk6RFrqOWRnvU5p2fpm6xQWLqGs7Gbi4rrG/XhO/zncOelOXtj2Akg4e9DZJEYkYtJN3DrxViU0CkU3Q82AFB3Gbj/GwYN/o7BoBR5PUcA6aWmXMnbME11smULRM1EzIIWijURE9Gfs2L8AcOjQ8xw5+gpeb3GDOjFd7IigUCh6DkqAFCFh8OCfMnjwTwHIzf2YnNyPiI0dT79+14TZMoVC0V1RAqQIOWlp55OWdn64zVAoFN0c5YatUCgUirCgBEihUCgUYUEJkEKhUCjCghIghUKhUIQFJUAKhUKhCAtKgBQKhUIRFpQAKRQKhSIsdEooHiFEAXAk5A0rFApF72aglDIl3EZ0FZ0iQAqFQqFQtIZaglMoFApFWFACpFAoFIqwoARIoVAoFGFBCZCiRyGEGCSE2NGo7FEhxD1CiFeFENVCiJh6154SQkghRHK9sh/4y0Y1atcuhNgihNglhPi7EELzX/tcCFEqhPikK35GheJEQQmQoreRCVwI4BeQ04DsRnWuBFYCVzQqPyClnARMAMYAF/nL/w9QeSUUihCjBEjR23gbuNz/eh6wCvDUXBRCRAOzgR/RVIAAkFJ6gNXAMP/7b4CKTrNYoThBUQKk6G3sB1KEEAn4ZjrvNLp+EfC5lHIfUCyEmNK4ASFEJHA6sL2TbVUoTmiUACl6Gs0dXKtf/iG+2c1JwIpG9eqL0jv+9zUMFUJswTdrWiKl/CxoaxUKRbOojKiKnkYRkNCoLBE4VO/9O8Am4DUppSGEAEAIkQTMB8YJISSgA1IIca//vpo9IIVC0QWoGZCiRyGlrARyhBCnAwghEoGF+JwKauocBX4FPN/o9kuA16WUA6WUg6SU/fEJ1yldYrxCoWiAEiBFT+Ra4Nf+5bKlwGNSygP1K0gp/9G4DN9y20eNyj4ArmqpMyHECuA/wOlCiCwhxFnBGK9QKHyoWHAKhUKhCAtqBqRQKBSKsKAESKFQKBRhQQmQQqFQKMKCEiCFQqFQhAUlQAqFQqEIC0qAFAqFQhEWlAApFAqFIiz8P1nqsLaoctK5AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "scRNA_latent(history_train, history_val, val_y , epoch_num=9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "naughty-baghdad",
   "metadata": {},
   "source": [
    "### Grid search + Test time "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "personalized-theme",
   "metadata": {},
   "outputs": [],
   "source": [
    "Hyper_grid={'n_latent':range(50,100,10),\n",
    "            'learning_rate':[1e-4, 1e-3, 1e-2],\n",
    "            'lambda_latent':[1e-2, 1e-1, 1e-3],\n",
    "            'lambda_reconst_rna':[1e-4, 1e-3, 1e-2]\n",
    "           }\n",
    "\n",
    "num_epochs=100\n",
    "batch_size=64\n",
    "\n",
    "def grid_search(Hyper_grid):\n",
    "    hyperparam_combos = list(it.product(Hyper_grid['n_latent'], \n",
    "                                        Hyper_grid['learning_rate'],\n",
    "                                        Hyper_grid['lambda_latent'],\n",
    "                                        Hyper_grid['lambda_reconst_rna']))\n",
    "    pbar = functools.partial(tqdm, leave=True, ncols='70%')\n",
    "    pbars = [pbar() for _ in range(1)]\n",
    "    pbars[0].reset(len(hyperparam_combos))\n",
    "    pbars[0].set_description('Grid Search')\n",
    "    \n",
    "    losses=[]\n",
    "    for n_latent, learning_rate, lambda_latent, lambda_reconst_rna in hyperparam_combos:\n",
    "        \n",
    "        model=intialize_model(train_x, n_latent, learning_rate = learning_rate, \n",
    "                              learning_rate_decay = 0.99999,\n",
    "                              lambda_latent = lambda_latent, lambda_reconst_rna = lambda_reconst_rna)\n",
    "        \n",
    "        history_train, history_val = scRNA_train(model , train_x,  train_y,val_x, val_y ,num_epochs, batch_size)\n",
    "        \n",
    "        InteractiveSession.close()\n",
    "        \n",
    "        best_loss=min(history_val['cost'])\n",
    "        \n",
    "        losses.append([n_latent, learning_rate, lambda_latent, lambda_reconst_rna, best_loss])\n",
    "        \n",
    "        pbars[0].update()  \n",
    "    \n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "aggregate-differential",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4b29bc18298b40f2b5525f03601fd2a9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/yaoestelle/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/tensorflow/python/client/session.py:1761: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n",
      "  warnings.warn('An interactive session is already active. This can '\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "68fc8b7ff6154979baae20b5c0e2eabd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3f5bb62118f148538da612562c6f40b1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss: 0.9545318484306335, Validation loss: 8710.856136167216\n",
      "Epoch: 1, Train loss: 1.1099611520767212, Validation loss: 8708.53417153979\n",
      "Epoch: 2, Train loss: 0.9932323694229126, Validation loss: 8706.896642800384\n",
      "Epoch: 3, Train loss: 0.9611914157867432, Validation loss: 8705.678847143945\n",
      "Epoch: 4, Train loss: 1.2699213027954102, Validation loss: 8704.733039775992\n",
      "Epoch: 5, Train loss: 0.8815027475357056, Validation loss: 8703.978035371854\n",
      "Epoch: 6, Train loss: 0.8402150273323059, Validation loss: 8703.364150633663\n",
      "Epoch: 7, Train loss: 0.7568809986114502, Validation loss: 8702.858575557832\n",
      "Epoch: 8, Train loss: 0.8497778177261353, Validation loss: 8702.430800426202\n",
      "Epoch: 9, Train loss: 0.8652194738388062, Validation loss: 8702.062511411426\n",
      "Epoch: 10, Train loss: 1.1385866403579712, Validation loss: 8701.743297503579\n",
      "Epoch: 11, Train loss: 0.7330054044723511, Validation loss: 8701.464131058348\n",
      "Epoch: 12, Train loss: 0.7896168231964111, Validation loss: 8701.217043813413\n",
      "Epoch: 13, Train loss: 0.8374592661857605, Validation loss: 8700.99531105374\n",
      "Epoch: 14, Train loss: 0.7520614862442017, Validation loss: 8700.793605877861\n",
      "Epoch: 15, Train loss: 0.960896909236908, Validation loss: 8700.609354040074\n",
      "Epoch: 16, Train loss: 1.0860464572906494, Validation loss: 8700.440899837056\n",
      "Epoch: 17, Train loss: 0.9677175283432007, Validation loss: 8700.286896902535\n",
      "Epoch: 18, Train loss: 0.8507024049758911, Validation loss: 8700.14500567666\n",
      "Epoch: 19, Train loss: 0.8790463209152222, Validation loss: 8700.013371624453\n",
      "Epoch: 20, Train loss: 0.8254129886627197, Validation loss: 8699.890946646832\n",
      "Epoch: 21, Train loss: 0.7472051382064819, Validation loss: 8699.77674645487\n",
      "Epoch: 22, Train loss: 1.0871124267578125, Validation loss: 8699.66981330293\n",
      "Epoch: 23, Train loss: 0.9108022451400757, Validation loss: 8699.569084824972\n",
      "Epoch: 24, Train loss: 1.5064915418624878, Validation loss: 8699.474288612539\n",
      "Epoch: 25, Train loss: 0.9813441634178162, Validation loss: 8699.384110739898\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-102-2fc8412880f0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m#             'lambda_reconst_rna':[1e-4]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m#            }\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mlosses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrid_search\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mHyper_grid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-101-29587041ca74>\u001b[0m in \u001b[0;36mgrid_search\u001b[0;34m(Hyper_grid)\u001b[0m\n\u001b[1;32m     25\u001b[0m                               lambda_latent = lambda_latent, lambda_reconst_rna = lambda_reconst_rna)\n\u001b[1;32m     26\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 27\u001b[0;31m         \u001b[0mhistory_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhistory_val\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscRNA_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m \u001b[0;34m,\u001b[0m \u001b[0mtrain_x\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0mtrain_y\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mval_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_y\u001b[0m \u001b[0;34m,\u001b[0m\u001b[0mnum_epochs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m         \u001b[0mbest_loss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhistory_val\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'cost'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-88-cc2f03b7ad84>\u001b[0m in \u001b[0;36mscRNA_train\u001b[0;34m(sct, x_train, y_train, x_val, y_val, num_epochs, batch_size)\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m             \u001b[0;31m##training step --> update weights\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m             \u001b[0mcost\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msct\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_rna\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_x\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     32\u001b[0m             \u001b[0mpbars\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Downloads/mit684/project/scTrans.py\u001b[0m in \u001b[0;36mtrain_rna\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m    377\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mtrain_rna\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    378\u001b[0m         \u001b[0mempty_atac\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnetwork_architecture\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"n_input_atac\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 379\u001b[0;31m         opt, cost = self.sess.run((self.rna_optimizer, self.rna_loss),\n\u001b[0m\u001b[1;32m    380\u001b[0m                   feed_dict={self.x_rna: data,\n\u001b[1;32m    381\u001b[0m                              self.x_atac: empty_atac})\n",
      "\u001b[0;32m~/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m    965\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    966\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 967\u001b[0;31m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0m\u001b[1;32m    968\u001b[0m                          run_metadata_ptr)\n\u001b[1;32m    969\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1188\u001b[0m     \u001b[0;31m# or if the call is a partial run that specifies feeds.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1189\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mfinal_fetches\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mfinal_targets\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mhandle\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mfeed_dict_tensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1190\u001b[0;31m       results = self._do_run(handle, final_targets, final_fetches,\n\u001b[0m\u001b[1;32m   1191\u001b[0m                              feed_dict_tensor, options, run_metadata)\n\u001b[1;32m   1192\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_run\u001b[0;34m(self, handle, target_list, fetch_list, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1366\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1367\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mhandle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1368\u001b[0;31m       return self._do_call(_run_fn, feeds, fetches, targets, options,\n\u001b[0m\u001b[1;32m   1369\u001b[0m                            run_metadata)\n\u001b[1;32m   1370\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_call\u001b[0;34m(self, fn, *args)\u001b[0m\n\u001b[1;32m   1373\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_do_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1374\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1375\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1376\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOpError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1377\u001b[0m       \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_text\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run_fn\u001b[0;34m(feed_dict, fetch_list, target_list, options, run_metadata)\u001b[0m\n\u001b[1;32m   1357\u001b[0m       \u001b[0;31m# Ensure any changes to the graph are reflected in the runtime.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1358\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_extend_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1359\u001b[0;31m       return self._call_tf_sessionrun(options, feed_dict, fetch_list,\n\u001b[0m\u001b[1;32m   1360\u001b[0m                                       target_list, run_metadata)\n\u001b[1;32m   1361\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_call_tf_sessionrun\u001b[0;34m(self, options, feed_dict, fetch_list, target_list, run_metadata)\u001b[0m\n\u001b[1;32m   1449\u001b[0m   def _call_tf_sessionrun(self, options, feed_dict, fetch_list, target_list,\n\u001b[1;32m   1450\u001b[0m                           run_metadata):\n\u001b[0;32m-> 1451\u001b[0;31m     return tf_session.TF_SessionRun_wrapper(self._session, options, feed_dict,\n\u001b[0m\u001b[1;32m   1452\u001b[0m                                             \u001b[0mfetch_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_list\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1453\u001b[0m                                             run_metadata)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Hyper_grid={'n_latent':[50,100],\n",
    "#             'learning_rate':[1e-4],\n",
    "#             'lambda_latent':[1e-2],\n",
    "#             'lambda_reconst_rna':[1e-4]\n",
    "#            }\n",
    "losses=grid_search(Hyper_grid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "organized-produce",
   "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>n_latent</th>\n",
       "      <th>learning_rate</th>\n",
       "      <th>lambda_latent</th>\n",
       "      <th>lambda_reoncst</th>\n",
       "      <th>Reconstruction loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>50</td>\n",
       "      <td>0.0001</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0001</td>\n",
       "      <td>9000.966659</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>100</td>\n",
       "      <td>0.0001</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0001</td>\n",
       "      <td>9006.908579</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_latent  learning_rate  lambda_latent  lambda_reoncst  Reconstruction loss\n",
       "0        50         0.0001           0.01          0.0001          9000.966659\n",
       "1       100         0.0001           0.01          0.0001          9006.908579"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(losses, columns=['n_latent','learning_rate','lambda_latent','lambda_reoncst','Reconstruction loss'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "qualified-reservoir",
   "metadata": {},
   "source": [
    "#### To do \n",
    "\n",
    "After finding the best combination of hyper paramters, retrain the model for the best model\n",
    "\n",
    "Then test on test set"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}