diff --git a/output/bay_area/data_distribution.ipynb b/output/bay_area/data_distribution.ipynb
index 5eb9b31..151a912 100644
--- a/output/bay_area/data_distribution.ipynb
+++ b/output/bay_area/data_distribution.ipynb
@@ -1,1316 +1,1449 @@
 {
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 104,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
     "import pandas as pd\n",
     "import numpy as np\n",
     "import seaborn as sns\n",
     "import matplotlib.pyplot as plt\n",
     "from scipy.stats import gmean"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 105,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Numbers of compound in soil:  889\n",
       "Numbers of compound in sludge:  160\n",
       "Find overlap cpds: 27\n",
       "Numbers of compound in combined:  1022\n"
      ]
     }
    ],
    "source": [
     "# input_file_path = \"C:\\\\Users\\\\leetseng\\\\TWtest\\\\input\\\\\"\n",
     "output_path = \"C:\\\\Users\\\\leetseng\\\\TWtest\\\\output\\\\bay_area\\\\\"\n",
     "\n",
     "#This files already contain the bay mean and bay std.\n",
     "#The reduced SMILES of previous files were generated from other toolkit. This file lead to inconsistant of SMILES.\n",
     "file_name_soil = \"soil_model_input_full.txt\"      #soil_model_input_bayes_curated_full.txt\n",
     "file_name_sludge = \"sludge_bay_PriorMuStd_3.tsv\"   #sludge_bayesian_PriorMuStd_09.tsv\n",
     "df_soil_original = pd.read_csv(output_path + file_name_soil, sep='\\t')\n",
     "df_sludge_original = pd.read_csv(output_path + file_name_sludge, sep='\\t')\n",
     "\n",
     "#Use the copy of dataframe for the later test and manipulation\n",
     "df_soil_ = df_soil_original.copy()\n",
     "df_sludge_ = df_sludge_original.copy()\n",
     "df_sludge_.loc[:, 'package'] = 0  # O: sludge, 1: soil\n",
     "df_soil_.loc[:, 'package'] = 1\n",
     "\n",
     "list_of_reduced_smiles_soil = df_soil_['reduced_smiles'].values.tolist()   #'canonicalize_smiles'\n",
     "set_of_reduced_smiles_soil = set(list_of_reduced_smiles_soil)\n",
     "print(\"Numbers of compound in soil: \", len(set_of_reduced_smiles_soil))\n",
     "\n",
     "list_of_reduced_smiles_sludge = df_sludge_['reduced_smiles'].values.tolist()   #'canonicalize_smiles'\n",
     "set_of_reduced_smiles_sludge = set(list_of_reduced_smiles_sludge)\n",
     "print(\"Numbers of compound in sludge: \", len(set_of_reduced_smiles_sludge))\n",
     "\n",
     "print(\"Find overlap cpds:\", len(set_of_reduced_smiles_sludge & set_of_reduced_smiles_soil))\n",
     "\n",
     "df_combined_ = pd.concat([df_sludge_, df_soil_], join=\"inner\")\n",
     "list_of_reduced_smiles = df_combined_['reduced_smiles'].values.tolist()   #'canonicalize_smiles'\n",
     "set_of_reduced_smiles_combined = set(list_of_reduced_smiles)\n",
     "print(\"Numbers of compound in combined: \", len(set_of_reduced_smiles_combined))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 3,
    "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>hl_log_std</th>\n",
        "      <th>hl_log_median</th>\n",
        "      <th>hl_log_gmean</th>\n",
        "      <th>hl_log_bayesian_mean</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>count</th>\n",
        "      <td>107.000000</td>\n",
        "      <td>160.000000</td>\n",
        "      <td>160.000000</td>\n",
        "      <td>160.000000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>mean</th>\n",
        "      <td>0.318333</td>\n",
        "      <td>0.444410</td>\n",
        "      <td>0.420706</td>\n",
        "      <td>0.456062</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>std</th>\n",
        "      <td>0.923251</td>\n",
        "      <td>1.077589</td>\n",
        "      <td>1.075346</td>\n",
        "      <td>1.278536</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>min</th>\n",
        "      <td>-1.951180</td>\n",
        "      <td>-1.636296</td>\n",
        "      <td>-1.636296</td>\n",
        "      <td>-2.290000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>25%</th>\n",
        "      <td>-0.094386</td>\n",
        "      <td>-0.325918</td>\n",
        "      <td>-0.366208</td>\n",
        "      <td>-0.395000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>50%</th>\n",
        "      <td>0.490693</td>\n",
        "      <td>0.567197</td>\n",
        "      <td>0.534077</td>\n",
        "      <td>0.540000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>75%</th>\n",
        "      <td>0.853649</td>\n",
        "      <td>1.165567</td>\n",
        "      <td>1.125150</td>\n",
        "      <td>1.212500</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>max</th>\n",
        "      <td>2.646196</td>\n",
        "      <td>3.016917</td>\n",
        "      <td>3.016917</td>\n",
        "      <td>3.610000</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
        "       hl_log_std  hl_log_median  hl_log_gmean  hl_log_bayesian_mean\n",
        "count  107.000000     160.000000    160.000000            160.000000\n",
        "mean     0.318333       0.444410      0.420706              0.456062\n",
        "std      0.923251       1.077589      1.075346              1.278536\n",
        "min     -1.951180      -1.636296     -1.636296             -2.290000\n",
        "25%     -0.094386      -0.325918     -0.366208             -0.395000\n",
        "50%      0.490693       0.567197      0.534077              0.540000\n",
        "75%      0.853649       1.165567      1.125150              1.212500\n",
        "max      2.646196       3.016917      3.016917              3.610000"
       ]
      },
-     "execution_count": 49,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "def non_nan_mean(x):\n",
     "    if x.empty:   \n",
     "        return None\n",
     "    else:\n",
     "        x = x.dropna()\n",
     "        return np.mean(x)\n",
     "\n",
     "\n",
     "def get_subset_target_variable(Y):  # des_X: df of descriptor,  Y: df_soil or df_sludge\n",
     "    Y_ = Y.copy()\n",
     "    Y_.loc[:, 'package'] = 1\n",
     "    aggs = [non_nan_mean]\n",
     "    df_subset_Y = Y_[[\"reduced_smiles\", \"hl_log_std\", \"hl_log_median\", \"hl_log_gmean\", \"hl_log_bayesian_mean\"]]  # \"temperature\", \"log_hl_combined\", \"log_hl_biomass_corrected\"\n",
     "    Y_group = df_subset_Y.groupby([\"reduced_smiles\"]).agg(aggs).reset_index()\n",
     "    Y_group.columns = Y_group.columns.droplevel(1)\n",
     "    return Y_group\n",
     "\n",
     "sludge_dist = get_subset_target_variable(df_sludge_)\n",
     "sludge_dist.describe()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 4,
    "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>hl_log_std</th>\n",
        "      <th>hl_log_median</th>\n",
        "      <th>hl_log_gmean</th>\n",
        "      <th>hl_log_bayesian_mean</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>count</th>\n",
        "      <td>889.000000</td>\n",
        "      <td>889.000000</td>\n",
        "      <td>889.000000</td>\n",
        "      <td>889.000000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>mean</th>\n",
        "      <td>0.279484</td>\n",
        "      <td>1.225268</td>\n",
        "      <td>1.231087</td>\n",
        "      <td>1.225040</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>std</th>\n",
        "      <td>0.192607</td>\n",
        "      <td>0.917759</td>\n",
        "      <td>0.910409</td>\n",
        "      <td>0.961831</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>min</th>\n",
        "      <td>0.000000</td>\n",
        "      <td>-2.721103</td>\n",
        "      <td>-2.674359</td>\n",
        "      <td>-2.250000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>25%</th>\n",
        "      <td>0.151745</td>\n",
        "      <td>0.681241</td>\n",
        "      <td>0.715376</td>\n",
        "      <td>0.720000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>50%</th>\n",
        "      <td>0.256414</td>\n",
        "      <td>1.340444</td>\n",
        "      <td>1.353351</td>\n",
        "      <td>1.350000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>75%</th>\n",
        "      <td>0.379963</td>\n",
        "      <td>1.894992</td>\n",
        "      <td>1.883289</td>\n",
        "      <td>1.880000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>max</th>\n",
        "      <td>1.979271</td>\n",
        "      <td>3.999957</td>\n",
        "      <td>3.999957</td>\n",
        "      <td>4.380000</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
        "       hl_log_std  hl_log_median  hl_log_gmean  hl_log_bayesian_mean\n",
        "count  889.000000     889.000000    889.000000            889.000000\n",
        "mean     0.279484       1.225268      1.231087              1.225040\n",
        "std      0.192607       0.917759      0.910409              0.961831\n",
        "min      0.000000      -2.721103     -2.674359             -2.250000\n",
        "25%      0.151745       0.681241      0.715376              0.720000\n",
        "50%      0.256414       1.340444      1.353351              1.350000\n",
        "75%      0.379963       1.894992      1.883289              1.880000\n",
        "max      1.979271       3.999957      3.999957              4.380000"
       ]
      },
-     "execution_count": 42,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "soil_dist = get_subset_target_variable(df_soil_)\n",
     "soil_dist.describe()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 103,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\2105885712.py:8: UserWarning: \n",
+      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_4072\\2105885712.py:8: UserWarning: \n",
       "\n",
       "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
       "\n",
       "Please adapt your code to use either `displot` (a figure-level function with\n",
       "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
       "\n",
       "For a guide to updating your code to use the new functions, please see\n",
       "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
       "\n",
       "  ax1 = sns.distplot(soil_dist['hl_log_std'], color=\"#a6a871\", ax=ax[1,0])\n",
-      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\2105885712.py:16: UserWarning: \n",
+      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_4072\\2105885712.py:16: UserWarning: \n",
       "\n",
       "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
       "\n",
       "Please adapt your code to use either `displot` (a figure-level function with\n",
       "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
       "\n",
       "For a guide to updating your code to use the new functions, please see\n",
       "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
       "\n",
       "  ax2 = sns.distplot(soil_dist['hl_log_median'], color=\"#a6a871\", ax=ax[1,1])\n",
-      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\2105885712.py:23: UserWarning: \n",
+      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_4072\\2105885712.py:23: UserWarning: \n",
       "\n",
       "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
       "\n",
       "Please adapt your code to use either `displot` (a figure-level function with\n",
       "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
       "\n",
       "For a guide to updating your code to use the new functions, please see\n",
       "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
       "\n",
       "  ax3 = sns.distplot(soil_dist['hl_log_gmean'], color=\"#a6a871\", ax=ax[1,2])\n",
-      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\2105885712.py:30: UserWarning: \n",
+      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_4072\\2105885712.py:30: UserWarning: \n",
       "\n",
       "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
       "\n",
       "Please adapt your code to use either `displot` (a figure-level function with\n",
       "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
       "\n",
       "For a guide to updating your code to use the new functions, please see\n",
       "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
       "\n",
       "  ax4 = sns.distplot(soil_dist['hl_log_bayesian_mean'], color=\"#a6a871\", ax=ax[1,3])  # biomass_hl_log_gmean\n",
-      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\2105885712.py:38: UserWarning: \n",
+      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_4072\\2105885712.py:38: UserWarning: \n",
       "\n",
       "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
       "\n",
       "Please adapt your code to use either `displot` (a figure-level function with\n",
       "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
       "\n",
       "For a guide to updating your code to use the new functions, please see\n",
       "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
       "\n",
       "  ax5 = sns.distplot(sludge_dist['hl_log_std'], color=\"#5f8c63\", ax=ax[0,0])  # hl_log_gmean   , fit=norm\n",
-      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\2105885712.py:46: UserWarning: \n",
+      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_4072\\2105885712.py:46: UserWarning: \n",
       "\n",
       "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
       "\n",
       "Please adapt your code to use either `displot` (a figure-level function with\n",
       "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
       "\n",
       "For a guide to updating your code to use the new functions, please see\n",
       "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
       "\n",
       "  ax6 = sns.distplot(sludge_dist['hl_log_median'], color=\"#5f8c63\",ax=ax[0,1])\n",
-      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\2105885712.py:52: UserWarning: \n",
+      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_4072\\2105885712.py:52: UserWarning: \n",
       "\n",
       "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
       "\n",
       "Please adapt your code to use either `displot` (a figure-level function with\n",
       "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
       "\n",
       "For a guide to updating your code to use the new functions, please see\n",
       "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
       "\n",
       "  ax7 = sns.distplot(sludge_dist['hl_log_gmean'], color=\"#5f8c63\",ax=ax[0,2])\n",
-      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\2105885712.py:58: UserWarning: \n",
+      "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_4072\\2105885712.py:58: UserWarning: \n",
       "\n",
       "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
       "\n",
       "Please adapt your code to use either `displot` (a figure-level function with\n",
       "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
       "\n",
       "For a guide to updating your code to use the new functions, please see\n",
       "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
       "\n",
       "  ax8 = sns.distplot(sludge_dist['hl_log_bayesian_mean'], color=\"#5f8c63\",ax=ax[0,3])  # biomass_hl_log_gmean\n"
      ]
     },
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 1920x720 with 8 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "#Sludge target variable data distribution\n",
     "#Candidates: halflife_log, hl_biomass_corrected, log_hl_biomass_corrected, hl_log_gmean, hl_log_median, biomass_hl_log_gmean,  biomass_hl_log_median,  hl_log_bayesian_mean \n",
     "fig, ax = plt.subplots(2,4, sharex=True)\n",
     "width, height = fig.get_size_inches()\n",
     "fig.set_size_inches(width*3, height*1.5)\n",
     "\n",
     "\n",
     "ax1 = sns.distplot(soil_dist['hl_log_std'], color=\"#a6a871\", ax=ax[1,0])\n",
     "ax1.set(xlabel='std log(DT$_{50}$)')  \n",
     "ax1.axvline(soil_dist['hl_log_std'].mean(), label='mean', linestyle='-.', color='r')\n",
     "ax1.axvline(soil_dist['hl_log_std'].median(), label='median', linestyle='-.', color='b')\n",
     "ax1.grid(False)\n",
     "ax1.legend()\n",
     "plt.text(x=-22, y=1.27, s='Eawag-Sludge Package', fontsize=16, weight='bold')\n",
     "\n",
     "ax2 = sns.distplot(soil_dist['hl_log_median'], color=\"#a6a871\", ax=ax[1,1])\n",
     "ax2.set(xlabel='median log(DT$_{50}$)')  \n",
     "ax2.axvline(soil_dist['hl_log_median'].mean(), label='mean', linestyle='-.', color='r')\n",
     "ax2.axvline(soil_dist['hl_log_median'].median(), label='median', linestyle='-.', color='b')\n",
     "ax2.grid(False)\n",
     "# ax2.legend()\n",
     "\n",
     "ax3 = sns.distplot(soil_dist['hl_log_gmean'], color=\"#a6a871\", ax=ax[1,2])\n",
     "ax3.set(xlabel='gmean log(DT$_{50}$)')  \n",
     "ax3.axvline(soil_dist['hl_log_gmean'].mean(), label='mean', linestyle='-.', color='r')\n",
     "ax3.axvline(soil_dist['hl_log_gmean'].median(), label='median', linestyle='-.', color='b')\n",
     "ax3.grid(False)\n",
     "# ax3.legend()\n",
     "\n",
     "ax4 = sns.distplot(soil_dist['hl_log_bayesian_mean'], color=\"#a6a871\", ax=ax[1,3])  # biomass_hl_log_gmean\n",
     "ax4.set(xlabel='bayesian mean log(DT$_{50}$)')  \n",
     "ax4.axvline(soil_dist['hl_log_bayesian_mean'].mean(), label='mean', linestyle='-.', color='r')\n",
     "ax4.axvline(soil_dist['hl_log_bayesian_mean'].median(), label='median', linestyle='-.', color='b')\n",
     "ax4.grid(False)\n",
     "# ax4.legend()\n",
     "\n",
     "\n",
     "ax5 = sns.distplot(sludge_dist['hl_log_std'], color=\"#5f8c63\", ax=ax[0,0])  # hl_log_gmean   , fit=norm\n",
     "ax5.set(xlabel='std log(DT$_{50}$)')  \n",
     "ax5.axvline(sludge_dist['hl_log_std'].mean(), label='mean', linestyle='-.', color='r')\n",
     "ax5.axvline(sludge_dist['hl_log_std'].median(), label='median', linestyle='-.', color='b')\n",
     "ax5.grid(False)\n",
     "ax5.legend()\n",
     "plt.text(x=-21.4, y=0.6, s='Eawag-Soil Package', fontsize=16, weight='bold')\n",
     "\n",
     "ax6 = sns.distplot(sludge_dist['hl_log_median'], color=\"#5f8c63\",ax=ax[0,1])\n",
     "ax6.axvline(sludge_dist['hl_log_median'].mean(), label='mean', linestyle='-.', color='r')\n",
     "ax6.axvline(sludge_dist['hl_log_median'].median(), label='median', linestyle='-.', color='b')\n",
     "ax6.grid(False)\n",
     "# ax6.legend()\n",
     "\n",
     "ax7 = sns.distplot(sludge_dist['hl_log_gmean'], color=\"#5f8c63\",ax=ax[0,2])\n",
     "ax7.axvline(sludge_dist['hl_log_gmean'].mean(), label='mean', linestyle='-.', color='r')\n",
     "ax7.axvline(sludge_dist['hl_log_gmean'].median(), label='median', linestyle='-.', color='b')\n",
     "ax7.grid(False)\n",
     "# ax7.legend()\n",
     "\n",
     "ax8 = sns.distplot(sludge_dist['hl_log_bayesian_mean'], color=\"#5f8c63\",ax=ax[0,3])  # biomass_hl_log_gmean\n",
     "ax8.axvline(sludge_dist['hl_log_bayesian_mean'].mean(), label='mean', linestyle='-.', color='r')\n",
     "ax8.axvline(sludge_dist['hl_log_bayesian_mean'].median(), label='median', linestyle='-.', color='b')\n",
     "ax8.grid(False)\n",
     "# ax8.legend()\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 165,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:13: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:14: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
       "C:\\Users\\leetseng\\AppData\\Local\\Temp\\ipykernel_20656\\274356051.py:15: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n"
      ]
     },
     {
      "data": {
       "text/html": [
        "<div>\n",
        "<style scoped>\n",
        "    .dataframe tbody tr th:only-of-type {\n",
        "        vertical-align: middle;\n",
        "    }\n",
        "\n",
        "    .dataframe tbody tr th {\n",
        "        vertical-align: top;\n",
        "    }\n",
        "\n",
        "    .dataframe thead th {\n",
        "        text-align: right;\n",
        "    }\n",
        "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
        "      <th>reduced_smiles</th>\n",
        "      <th>hl_log_std_x</th>\n",
        "      <th>hl_log_median_x</th>\n",
        "      <th>hl_log_gmean_x</th>\n",
        "      <th>hl_log_bayesian_mean_x</th>\n",
        "      <th>hl_log_std_y</th>\n",
        "      <th>hl_log_median_y</th>\n",
        "      <th>hl_log_gmean_y</th>\n",
        "      <th>hl_log_bayesian_mean_y</th>\n",
        "      <th>logKoc</th>\n",
        "      <th>hl_log_gmean_y_calculated</th>\n",
        "      <th>hl_log_bayesian_mean_y_calculated</th>\n",
        "      <th>rmse</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>C#CCOc1ccc(CCNC(=O)C(OCC#C)c2ccc(Cl)cc2)cc1OC</td>\n",
        "      <td>0.387665</td>\n",
        "      <td>-0.255707</td>\n",
        "      <td>-0.344881</td>\n",
        "      <td>-0.39</td>\n",
        "      <td>0.300281</td>\n",
        "      <td>1.773786</td>\n",
        "      <td>1.721193</td>\n",
        "      <td>1.72</td>\n",
        "      <td>4.45</td>\n",
        "      <td>2.763209</td>\n",
        "      <td>2.7217</td>\n",
        "      <td>3.111700</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>CC(C)c1ccc(NC(=O)N(C)C)cc1</td>\n",
        "      <td>1.086880</td>\n",
        "      <td>0.882442</td>\n",
        "      <td>0.799521</td>\n",
        "      <td>0.96</td>\n",
        "      <td>0.155247</td>\n",
        "      <td>1.043322</td>\n",
        "      <td>1.062348</td>\n",
        "      <td>1.06</td>\n",
        "      <td>2.00</td>\n",
        "      <td>1.145560</td>\n",
        "      <td>1.2932</td>\n",
        "      <td>2.212883</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>CC(NC(=O)c1cc(Cl)cc(Br)c1NC(=O)c1cc(Br)nn1-c1n...</td>\n",
        "      <td>NaN</td>\n",
        "      <td>1.295347</td>\n",
        "      <td>1.295347</td>\n",
        "      <td>2.64</td>\n",
        "      <td>0.228078</td>\n",
        "      <td>2.804821</td>\n",
        "      <td>2.924474</td>\n",
        "      <td>2.96</td>\n",
        "      <td>4.98</td>\n",
        "      <td>4.849919</td>\n",
        "      <td>6.0870</td>\n",
        "      <td>2.687968</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>CC1(C(=O)Nc2ccc(O)c(Cl)c2Cl)CCCCC1</td>\n",
        "      <td>0.740447</td>\n",
        "      <td>0.753775</td>\n",
        "      <td>0.537149</td>\n",
        "      <td>0.54</td>\n",
        "      <td>0.295061</td>\n",
        "      <td>-0.503062</td>\n",
        "      <td>-0.536353</td>\n",
        "      <td>-0.54</td>\n",
        "      <td>3.67</td>\n",
        "      <td>2.724477</td>\n",
        "      <td>2.7271</td>\n",
        "      <td>2.571911</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
        "      <td>CCN(CC)C(=O)C(C)Oc1cccc2ccccc12</td>\n",
        "      <td>NaN</td>\n",
        "      <td>1.840825</td>\n",
        "      <td>1.840825</td>\n",
        "      <td>1.78</td>\n",
        "      <td>0.211960</td>\n",
        "      <td>2.590922</td>\n",
        "      <td>2.535282</td>\n",
        "      <td>2.53</td>\n",
        "      <td>3.24</td>\n",
        "      <td>3.455159</td>\n",
        "      <td>3.3992</td>\n",
        "      <td>2.411668</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
        "      <td>CCNC(=O)C(C)OC(=O)Nc1ccccc1</td>\n",
        "      <td>NaN</td>\n",
        "      <td>1.840825</td>\n",
        "      <td>1.840825</td>\n",
        "      <td>1.77</td>\n",
        "      <td>0.414013</td>\n",
        "      <td>0.734174</td>\n",
        "      <td>0.954674</td>\n",
        "      <td>0.97</td>\n",
        "      <td>2.36</td>\n",
        "      <td>2.495959</td>\n",
        "      <td>2.4308</td>\n",
        "      <td>2.218009</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>6</th>\n",
        "      <td>CCNc1nc(Cl)nc(NC(C)(C)C)n1</td>\n",
        "      <td>0.472508</td>\n",
        "      <td>1.295347</td>\n",
        "      <td>1.249031</td>\n",
        "      <td>1.57</td>\n",
        "      <td>0.206256</td>\n",
        "      <td>2.045305</td>\n",
        "      <td>2.039896</td>\n",
        "      <td>2.04</td>\n",
        "      <td>2.32</td>\n",
        "      <td>1.907909</td>\n",
        "      <td>2.2032</td>\n",
        "      <td>2.067377</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
        "                                      reduced_smiles  hl_log_std_x  \\\n",
        "0      C#CCOc1ccc(CCNC(=O)C(OCC#C)c2ccc(Cl)cc2)cc1OC      0.387665   \n",
        "1                         CC(C)c1ccc(NC(=O)N(C)C)cc1      1.086880   \n",
        "2  CC(NC(=O)c1cc(Cl)cc(Br)c1NC(=O)c1cc(Br)nn1-c1n...           NaN   \n",
        "3                 CC1(C(=O)Nc2ccc(O)c(Cl)c2Cl)CCCCC1      0.740447   \n",
        "4                    CCN(CC)C(=O)C(C)Oc1cccc2ccccc12           NaN   \n",
        "5                        CCNC(=O)C(C)OC(=O)Nc1ccccc1           NaN   \n",
        "6                         CCNc1nc(Cl)nc(NC(C)(C)C)n1      0.472508   \n",
        "\n",
        "   hl_log_median_x  hl_log_gmean_x  hl_log_bayesian_mean_x  hl_log_std_y  \\\n",
        "0        -0.255707       -0.344881                   -0.39      0.300281   \n",
        "1         0.882442        0.799521                    0.96      0.155247   \n",
        "2         1.295347        1.295347                    2.64      0.228078   \n",
        "3         0.753775        0.537149                    0.54      0.295061   \n",
        "4         1.840825        1.840825                    1.78      0.211960   \n",
        "5         1.840825        1.840825                    1.77      0.414013   \n",
        "6         1.295347        1.249031                    1.57      0.206256   \n",
        "\n",
        "   hl_log_median_y  hl_log_gmean_y  hl_log_bayesian_mean_y  logKoc  \\\n",
        "0         1.773786        1.721193                    1.72    4.45   \n",
        "1         1.043322        1.062348                    1.06    2.00   \n",
        "2         2.804821        2.924474                    2.96    4.98   \n",
        "3        -0.503062       -0.536353                   -0.54    3.67   \n",
        "4         2.590922        2.535282                    2.53    3.24   \n",
        "5         0.734174        0.954674                    0.97    2.36   \n",
        "6         2.045305        2.039896                    2.04    2.32   \n",
        "\n",
        "   hl_log_gmean_y_calculated  hl_log_bayesian_mean_y_calculated      rmse  \n",
        "0                   2.763209                             2.7217  3.111700  \n",
        "1                   1.145560                             1.2932  2.212883  \n",
        "2                   4.849919                             6.0870  2.687968  \n",
        "3                   2.724477                             2.7271  2.571911  \n",
        "4                   3.455159                             3.3992  2.411668  \n",
        "5                   2.495959                             2.4308  2.218009  \n",
        "6                   1.907909                             2.2032  2.067377  "
       ]
      },
      "execution_count": 165,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "import math\n",
     "from sklearn.metrics import mean_squared_error\n",
     "\n",
     "df_read_across = pd.merge(sludge_dist, soil_dist, on='reduced_smiles', how='inner')\n",
     "df_read_across['logKoc'] = [4.45, 2, 4.98, 3.67, 3.24, 2.36, 2.32, 2.08, 3, 2.53, 2.75, 2.4, 2.46, 1.64, 3.74, 3.1, 1.5, 2.11, 1.76, 5.22, 3.93, 2.67, 2.61, 2.43, 2.58, 1.66, 2.51]\n",
     "df_read_across['hl_log_gmean_y_calculated'] = np.nan\n",
     "df_read_across['hl_log_bayesian_mean_y_calculated'] = np.nan\n",
     "df_read_across['rmse'] = np.nan\n",
     "# MSE = mean_squared_error(df_read_across['hl_log_gmean_x'], df_read_across['hl_log_gmean_y_calculated'])  \n",
     "# rmse = math.sqrt(MSE) \n",
     "\n",
     "for i in range(df_read_across.shape[0]):\n",
     "    df_read_across['hl_log_gmean_y_calculated'][i] = 0.92 * df_read_across['hl_log_gmean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
     "    df_read_across['hl_log_bayesian_mean_y_calculated'][i] = 0.92 * df_read_across['hl_log_bayesian_mean_x'][i] + 1.09 * df_read_across['logKoc'][i] -1.77\n",
     "    df_read_across['rmse'][i] = mean_squared_error(df_read_across['hl_log_bayesian_mean_x'][:i+1], df_read_across['hl_log_bayesian_mean_y_calculated'][:i+1], squared=False)\n",
     "\n",
     "\n",
     "df_read_across.loc[df_read_across['rmse'] > 2]\n",
     "\n"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 65,
    "metadata": {},
-   "source": []
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original SMILES:CCNc1nc(Cl)nc(NC(C)(C)C)n1\n",
+      "Number of tautomers generated: 9\n",
+      "Tautomers:\n",
+      "1. CCN=c1[nH]c(Cl)nc(=NC(C)(C)C)[nH]1\n",
+      "2. CCN=c1nc(Cl)[nH]c(=NC(C)(C)C)[nH]1\n",
+      "3. CCN=c1nc(Cl)[nH]c(NC(C)(C)C)n1\n",
+      "4. CCN=c1nc(Cl)nc(NC(C)(C)C)[nH]1\n",
+      "5. CCN=c1nc(NC(C)(C)C)nc(Cl)[nH]1\n",
+      "6. CCNc1nc(=NC(C)(C)C)nc(Cl)[nH]1\n",
+      "7. CCNc1nc(Cl)[nH]c(=NC(C)(C)C)n1\n",
+      "8. CCNc1nc(Cl)nc(=NC(C)(C)C)[nH]1\n",
+      "9. CCNc1nc(Cl)nc(NC(C)(C)C)n1\n"
+     ]
+    }
+   ],
+   "source": [
+    "from rdkit import Chem\n",
+    "from rdkit.Chem.Draw import IPythonConsole\n",
+    "from rdkit.Chem.MolStandardize import rdMolStandardize\n",
+    "\n",
+    "smiles = \"CCNc1nc(Cl)nc(NC(C)(C)C)n1\"\n",
+    "mol = Chem.MolFromSmiles(smiles)\n",
+    "\n",
+    "canonicalizer = rdMolStandardize.TautomerEnumerator()\n",
+    "tautomers = canonicalizer.Enumerate(mol)\n",
+    "Chem.Draw.MolsToGridImage(tautomers)\n",
+    "\n",
+    "\n",
+    "tautomers_list = []\n",
+    "for tautomer in tautomers:\n",
+    "    tautomer_smiles = Chem.MolToSmiles(tautomer)\n",
+    "    if tautomer_smiles not in tautomers:\n",
+    "        tautomers_list.append(tautomer_smiles)\n",
+    "tautomers_list\n",
+    "\n",
+    "\n",
+    "print(f\"Original SMILES:{smiles}\")\n",
+    "print(f\"Number of tautomers generated: {len(tautomers_list)}\")\n",
+    "print(f\"Tautomers:\")\n",
+    "for i, tautomer in enumerate(tautomers_list):\n",
+    "    print(f\"{i+1}. {tautomer}\")\n",
+    "# canonicalizer.Canonicalize(mol)\n",
+    "# canonical_tautomer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 72,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "smiles = \"CCNc1nc(Cl)nc(NC(C)(C)C)n1\"\n",
+    "mol = Chem.MolFromSmiles(smiles)\n",
+    "\n",
+    "canonicalizer = rdMolStandardize.TautomerEnumerator()\n",
+    "tautomers = canonicalizer.Enumerate(mol)\n",
+    "Chem.Draw.MolsToGridImage(tautomers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tautomer 1: Energy = 5.94 kcal/mol\n",
+      "Tautomer 2: Energy = 6.60 kcal/mol\n",
+      "Tautomer 3: Energy = 6.37 kcal/mol\n",
+      "Tautomer 4: Energy = 5.67 kcal/mol\n",
+      "Tautomer 5: Energy = 5.13 kcal/mol\n",
+      "Tautomer 6: Energy = 4.91 kcal/mol\n",
+      "Tautomer 7: Energy = 6.30 kcal/mol\n",
+      "Tautomer 8: Energy = 4.99 kcal/mol\n",
+      "Tautomer 9: Energy = 4.69 kcal/mol\n",
+      "Dominant tautomer: CCNc1nc(Cl)nc(NC(C)(C)C)n1\n"
+     ]
+    }
+   ],
+   "source": [
+    "from rdkit import Chem\n",
+    "from rdkit.Chem import AllChem\n",
+    "\n",
+    "def calculate_energy(smiles):\n",
+    "    # Convert SMILES string to RDKit molecule\n",
+    "    mol = Chem.MolFromSmiles(smiles)\n",
+    "    # Add explicit hydrogens to the molecule\n",
+    "    mol = Chem.AddHs(mol)\n",
+    "    # Generate 3D coordinates for the molecule\n",
+    "    AllChem.EmbedMolecule(mol)\n",
+    "    # Calculate the total energy of the molecule using MMFF94 force field\n",
+    "    energy = AllChem.UFFGetMoleculeForceField(mol)\n",
+    "    energy.Minimize()\n",
+    "    # Calculate the energy of the optimized molecule using the UFF force field\n",
+    "    energy_ = energy.CalcEnergy()\n",
+    "    # Return the total energy in kcal/mol\n",
+    "    return energy_ * 0.239\n",
+    "\n",
+    "energies = []\n",
+    "for tautomer in tautomers_list:\n",
+    "    # Generate 3D coordinates for the tautomer\n",
+    "    energy = calculate_energy(tautomer)\n",
+    "    energies.append(energy)\n",
+    "\n",
+    "# Print the relative energies of the tautomers\n",
+    "for i, energy_ in enumerate(energies):\n",
+    "    print(f\"Tautomer {i+1}: Energy = {energy_:.2f} kcal/mol\")\n",
+    "\n",
+    "\n",
+    "# Find the index of the tautomer with the lowest energy\n",
+    "dominant_index = energies.index(min(energies))\n",
+    "# Print the dominant tautomer\n",
+    "print(f\"Dominant tautomer: {tautomers_list[dominant_index]}\")"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": []
   },
   {
    "cell_type": "code",
    "execution_count": 141,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "<matplotlib.legend.Legend at 0x1e90105c0d0>"
       ]
      },
      "execution_count": 141,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 500x500 with 1 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "# from scipy import statsfrom\n",
     "import math \n",
     "from scipy import stats\n",
     "from statsmodels.formula.api import ols\n",
     "model1 = ols('hl_log_gmean_x ~ hl_log_gmean_y', data=df_read_across).fit(cov_type = 'HC3')\n",
     "\n",
     "slope, intercept, r_value, p_value, std_err = stats.linregress(df_read_across['hl_log_gmean_x'],df_read_across['hl_log_gmean_y'])\n",
     "sns.lmplot(data=df_read_across, x=\"hl_log_gmean_x\", y=\"hl_log_gmean_y\", ci=95, line_kws={'label':\"y={0:.2f}x+{1:.2f}\".format(slope, intercept)}).set(xlabel='log(DT$_{50, gmean, sludge}$)', ylabel='log(DT$_{50, gmean, soil}$)')\n",
     "plt.annotate('R$^2$: {}'.format(round(model1.rsquared_adj,2)), (-1.2, 2.4))\n",
     "plt.legend()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 145,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "<matplotlib.legend.Legend at 0x1e9267a35b0>"
       ]
      },
      "execution_count": 145,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe8AAAHvCAYAAAB9iVfNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB0DklEQVR4nO3dd3hUZdo/8O+ZnkkyqaSQBAiJJBASSujigqAgihTB18IiIJZlXVdF14K6lndXdEVc/O0rKyqgrm2lrQVRXGmKikCQBAKYAEIaIXUymWTaOb8/hoyE9MlMpn0/15ULcubMmfswIfc8z/0UQZIkCUREROQzZJ4OgIiIiLqGyZuIiMjHMHkTERH5GCZvIiIiH8PkTURE5GOYvImIiHwMkzcREZGPYfImIiLyMX6XvCVJgl6vB9eeISIif+V3ybuurg5hYWGoq6vzdChERERu4XfJm4iIyN8xeRMREfkYJm8iIiIf43XJ++mnn4YgCM2+4uLiPB0WERGR11B4OoDWZGRk4KuvvnJ8L5fLPRgNERGRd/HK5K1QKNze2rbZbLBYLG59DQosKpUKMpnXdWYRkR/yyuT9888/o3fv3lCr1Rg9ejSee+459O/fv9VzTSYTTCaT43u9Xt/utSVJQllZGWpqalwZMhFkMhmSk5OhUqk8HQoR+TlB8rLVTD7//HMYjUYMGDAA586dw1/+8hccO3YMR44cQVRUVIvzn376aTzzzDMtjtfW1kKn07U4XlpaipqaGsTExECr1UIQBLfcBwUWURRRUlICpVKJPn368OeKiNzK65L3perr65GSkoKHH34YS5cubfF4ay3vpKSkVpO3zWbDiRMnEBMT0+oHAaLuqK2tRUlJCVJTU6FUKj0dDhH5Ma/sNr9YcHAwMjMz8fPPP7f6uFqthlqt7tS1mmrcWq3WZfERNWnqLrfZbEzeRORWXj+6xmQyIT8/H/Hx8S67Jrs0yR34c0VEPcXrkvdDDz2EXbt24dSpU/jhhx8wd+5c6PV6LFiwwNOhEREReQWvS95FRUW45ZZbkJaWhhtuuAEqlQrff/89+vbt6+nQ/Mqrr76K5ORkaDQaZGdnY8+ePe2ev3DhwhaL5wiCgIyMDMc569evb/WcxsZGt93H7t27cf3116N3794QBAFbtmzp8DnffPMNLr/8ckRFRSEoKAjp6el4+eWXW5z397//HWlpaQgKCkJSUhIeeOABt94LEVFneV3N+4MPPvB0CH7vww8/xP33349XX30Vl19+OV577TVMmzYNR48eRZ8+fVp9zqpVq/D88887vrdarRgyZAhuvPHGZufpdDocP3682TGNRuN0rE8//TROnz6N9evXt/p4fX09hgwZgkWLFmHOnDmdumZwcDD+8Ic/ICsrC8HBwfjmm29w9913Izg4GHfddRcA4N1338Wjjz6KtWvXYty4cThx4gQWLlwIAK0meiJ/J4oSjpToUWU0I1KrQkZvHWQyloo8xeuSN7X09ttv44EHHkBJSUmzwXlz5sxBcHAw3n777S5db+XKlVi8eDHuuOMOAPYW5hdffIHVq1dj+fLlrT4nLCwMYWFhju+3bNmC6upqLFq0qNl57S1ne/78eWRmZuKPf/wjli1bBgD44YcfcMUVV+DTTz/FlClTunQfADBt2jRMmzatS88ZNmwYhg0b5vi+X79+2LRpE/bs2eNI3t999x0uv/xy3HrrrY5zbrnlFuzbt6/LMRL5ur0FFVi9qxCF5QZYbBKUcgEpMSFYMiEF41KjPR1eQPK6bvOeJkkSahssHvvqzEy9G2+8ETabDR9//LHjWEVFBT799FMsWrQIe/bsQUhISLtfzz33HADAbDbjwIEDLRLllClTsHfv3k7/u7355pu46qqrWpQzDAYD+vbti8TEREyfPh05OTmOx3r16oW1a9fi6aefxv79+2EwGPDb3/4Wv//9751K3K6Sk5ODvXv3YsKECY5j48ePx4EDBxzJ+uTJk9i6dSuuu+46T4VJ5BF7CyqwbHMu8kv1CFYrEBOqRrBagfzSOizbnIu9BRWeDjEgBXzLW99oxZBnvvTY6//01BSEBbU/rSgoKAi33nor1q1b5+imfvfdd5GYmIiJEyeisbERhw4davcakZGRAOxJ32azITY2ttnjsbGxKCsr61TMpaWl+Pzzz/Hee+81O56eno7169cjMzMTer0eq1atwuWXX46ffvoJl112GQDg2muvxZ133ol58+Zh5MiR0Gg0zbrje1JiYiLOnz8Pq9WKp59+2tETAQA333wzzp8/j/Hjx0OSJFitVixZsgSPPvqoR2Il8gRRlLB6VyEMJividBrHjAqNTI44nQxlehNW7yrEmP5R7ELvYQGfvH3FnXfeiZEjR6K4uBgJCQlYt26dYxBZUFAQUlNTu3S9S6c1SZLU6alO69evR3h4OGbNmtXs+JgxYzBmzBjH95dffjmGDx+O//f//h9eeeUVx/EVK1Zg8ODB+Pe//439+/c3q4nv2bOnWTe42WyGJEnYsGGD49iyZcsc3e7dsWfPHhgMBnz//fd49NFHkZqailtuuQUAsHPnTvz1r3/Fq6++itGjR6OgoAD33Xcf4uPj8eSTT3b7tYl8wZESPQrLDYjQqlr8fhAEAeFaJQrLDThSokdmYlgbVyF3YPL2EcOGDcOQIUPw9ttvY+rUqcjNzcUnn3wCoGXCa01TwouOjoZcLm/Ryi4vL2/RGm+NJElYu3Yt5s+f3+Ea3jKZDCNHjmyxwM7JkydRUlICURTxyy+/ICsry/HYiBEjmvUivPLKKyguLsYLL7zgONbUi9BdycnJAIDMzEycO3cOTz/9tCN5P/nkk5g/f76jNZ6ZmYn6+nrcddddePzxx7kBCQWEKqMZFpsElbz1n3e1XIZaUUKV0dzDkVHAJ2+dRoGfnvJcvVWn6fxbcMcdd+Dll19GcXExrrrqKiQlJQFomfBa05TwVCoVsrOzsX37dsyePdvx+Pbt2zFz5swOY9i1axcKCgqwePHiDs+VJAmHDh1CZmam45jZbMa8efNw0003IT09HYsXL0Zubq7jg8OlvQiRkZHQ6/Vd7lnoKkmSmi2zazQaWyRouVwOSZI6NU6ByB9EalVQygWYbSI0spZbM5tsIpQyAZFabsbT0wI+eQuC0GHN2VvMmzcPDz30EF5//fVmI8y72m2+dOlSzJ8/HyNGjMDYsWOxZs0anDlzBr/73e8c5zz22GMoLi5uMZL9zTffxOjRozF48OAW133mmWcwZswYXHbZZdDr9XjllVdw6NAh/N///Z/jnMcffxy1tbV45ZVXEBISgs8//xyLFy/Gp59+2pV/CgeDwYCCggLH96dOncKhQ4cQGRnpmPZ26b383//9H/r06YP09HQA9nnfK1aswL333uu4zvXXX4+VK1di2LBhjm7zJ598EjNmzOD+8hQwMnrrkBITgvzSOsTpZM26ziVJQo3RgoHxocjo3XITKHKvgE/evkSn02HOnDn47LPPWtSbu+Kmm25CZWUlnn32WZSWlmLw4MHYunVrs5HjpaWlOHPmTLPn1dbWYuPGjVi1alWr162pqcFdd92FsrIyhIWFYdiwYdi9ezdGjRoFwF5H/vvf/44dO3Y4No155513kJWVhdWrV2PJkiVdvpf9+/fjyiuvdHzftHnNggULHHPDL70XURTx2GOP4dSpU1AoFEhJScHzzz+Pu+++23HOE088AUEQ8MQTT6C4uBi9evXC9ddfj7/+9a9djpHIV8lkApZMSMGyzbko05sQrlVCLZfBZBNRY7QgRC3HkgkpHKzmAV6/q1hX6fV6hIWFtbqrWGNjI06dOuVYWcwXXX311Rg4cGCzAWDkHfzh54uoNc3meYsSlDLO8/Y0trx9RFVVFb788kt8/fXX+Mc//uHpcIgogIxLjcaY/lFcYc2LMHn7iOHDh6O6uhovvPAC0tLSPB0OEQUYmUzgdDAvwuTtI06fPu3pEIiIyEtwsioREZGPYfImIiLyMQGZvP1sgD15Cf5cEVFPCajkrVTaF2MxGo0ejoT8kdlsXyKSi7gQkbsF1IA1uVyO8PBwlJeXAwC0Wm2nN+Mgao8oijh//jy0Wi0UioD6b0VEHhBwv2Xi4uIAwJHAiVxFJpOhT58+/EBIRG4XcMlbEATEx8cjJiYGFovF0+GQH1GpVNxtjIh6RMAl7yZyuZy1SSIi8klsJhAREfkYJm8iIiIfw+RNRETkY5i8iYiIfAyTNxERkY9h8iYiIvIxTN5EREQ+hsmbiIjIxzB5ExER+RgmbyIiIh/D5E1ERORjmLyJiIh8DJM3ERGRj2HyJiIi8jFM3kRERD6GyZuIiMjHMHkTERH5GCZvIiIiH8PkTURE5GOYvImIiHwMkzcREZGPYfImIiLyMUzeREREPobJm4iIyMcweRMREfkYJm8iIiIfw+RNRETkY5i8iYiIfAyTNxERkY9h8iYiIvIxTN5EREQ+hsmbiIjIxzB5ExER+Rgm7wBw9uxZTJw4EYMGDUJWVhY++ugjT4dERETdIEiSJHk6CFfS6/UICwtDbW0tdDqdp8PxCqWlpTh37hyGDh2K8vJyDB8+HMePH0dwcLCnQyMiIicoPB0AuV98fDzi4+MBADExMYiMjERVVRWTNxGRj2K3uR9YuHAhBEGAIAhQKBTo06cPlixZgurq6hbn7t+/H6IoIikpqcuv8+qrryI5ORkajQbZ2dnYs2dPm+cuX74cI0eORGhoKGJiYjBr1iwcP3682TmrV69GVlYWdDoddDodxo4di88//7zLcRERBRombz9xzTXXoLS0FKdPn8Ybb7yBTz75BL///e+bnVNZWYnbbrsNa9as6fL1P/zwQ9x///14/PHHkZOTgyuuuALTpk3DmTNnWj1/165duOeee/D9999j+/btsFqtmDJlCurr6x3nJCYm4vnnn8f+/fuxf/9+TJo0CTNnzsSRI0e6HB8RUSBhzdsPLFy4EDU1NdiyZYvj2IMPPoj169ejsrISAGAymXD11VfjzjvvxPz587v8GqNHj8bw4cOxevVqx7GBAwdi1qxZWL58eYfPP3/+PGJiYrBr1y785je/afO8yMhIvPjii1i8eHGXYyQiChRsefuhkydPYtu2bVAqlQAASZKwcOFCTJo0qdXEvX79egiC0Ob1zGYzDhw4gClTpjQ7PmXKFOzdu7dTMdXW1gKwJ+fW2Gw2fPDBB6ivr8fYsWM7dU0iokDFAWt+4tNPP0VISAhsNhsaGxsBACtXrgQAfPvtt/jwww+RlZXlaJ2/8847yMzMBACEhYUhLS2tzWtXVFTAZrMhNja22fHY2FiUlZV1GJskSVi6dCnGjx+PwYMHN3ssNzcXY8eORWNjI0JCQrB582YMGjSo0/dNRBSImLz9xJVXXonVq1fDaDTijTfewIkTJ3DvvfcCAMaPHw9RFNt87uzZszF79uwOX+PS1rkkSe222Jv84Q9/wOHDh/HNN9+0eCwtLQ2HDh1CTU0NNm7ciAULFmDXrl1M4ERE7fD6bvPly5dDEATcf//9ng7FqwUHByM1NRVZWVl45ZVXYDKZ8Mwzz7jk2tHR0ZDL5S1a2eXl5S1a45e699578fHHH2PHjh1ITExs8bhKpUJqaipGjBiB5cuXY8iQIVi1apVL4iYi8ldenbx//PFHrFmzBllZWZ4Oxec89dRTWLFiBUpKSrp9LZVKhezsbGzfvr3Z8e3bt2PcuHGtPkeSJPzhD3/Apk2b8PXXXyM5OblTryVJEkwmU7djJiLyZ16bvA0GA+bNm4fXX38dERERng7H50ycOBEZGRl47rnnOjx38+bNSE9Pb/ecpUuX4o033sDatWuRn5+PBx54AGfOnMHvfvc7xzn/+Mc/MHnyZADAPffcg3/961947733EBoairKyMpSVlaGhocFx/rJly7Bnzx6cPn0aubm5ePzxx7Fz507MmzfPybsmIgoMXpu877nnHlx33XW46qqrPB2Kz1q6dClef/11nD17tt3zamtrWyygcqmbbroJf//73/Hss89i6NCh2L17N7Zu3Yq+ffs6zqmoqEBhYSEA+wIstbW1mDhxomOFt/j4eHz44YeO88+dO4f58+cjLS0NkydPxg8//IBt27bh6quv7sZdExH5P6+c5/3BBx/gr3/9K3788UdoNBpMnDgRQ4cOxd///vcW55pMpmbdrHq9HklJSQE1z5uIiAKL17W8z549i/vuuw//+te/oNFoOjx/+fLlCAsLc3w5s+wnERGRL/G6lveWLVswe/ZsyOVyxzGbzQZBECCTyWAymZo9xpY3EREFGq+b5z158mTk5uY2O7Zo0SKkp6fjkUceaZa4AUCtVkOtVvdkiERERB7ldck7NDS0xSpcwcHBiIqKanGciIgoEHldzZuIiIja53U17+4KxF3FiIgosHhdtzlRIBFFCUdK9KgymhGpVSGjtw4yWcfrxRNRYGPyJvKQvQUVWL2rEIXlBlhsEpRyASkxIVgyIQXjUqM9HR4ReTHWvIk8YG9BBZZtzkV+qR7BagViQtUIViuQX1qHZZtzsbegwtMhEpEXY/Im6mGiKGH1rkIYTFbE6TTQKOWQyQRolHLE6dQwmGxYvasQouhXw1GIyIWYvIl62JESPQrLDYjQqlrshy4IAsK1ShSWG3CkRO+hCInI2zF5E/WwKqMZFpsElbz1/35quQwWUUKV0dzDkRGRr2Dy9nELFy6EIAgQBAEKhQJ9+vTBkiVLUF1d3ey8fv36QRAEfPDBBy2ukZGRAUEQsH79esexnJwcTJ8+HTExMdBoNOjXrx9uuukmVFTYa7GnT592vO6lX99//32n4y8tLcWtt96KtLQ0yGQy3H///Z1+7vr165GVlQWNRoO4uDj84Q9/cDx2/PhxXHnllYiNjYVGo0H//v3xxBNPwGKxdPr67hKpVUEpF2C2ia0+brKJUMoERGpVPRwZEfkKjjb3A9dccw3WrVsHq9WKo0eP4vbbb0dNTQ3ef//9ZuclJSVh3bp1uPnmmx3Hvv/+e5SVlSE4ONhxrLy8HFdddRWuv/56fPHFFwgPD8epU6fw8ccfw2g0NrvmV199hYyMjGbHoqKiOh27yWRCr1698Pjjj+Pll1/u9PNWrlyJl156CS+++CJGjx6NxsZGnDx50vG4UqnEbbfdhuHDhyM8PBw//fQT7rzzToii2Kk9zt0po7cOKTEhyC+tQ5xO1qzrXJIk1BgtGBgfiozeXKeAiFrH5O0H1Go14uLiAACJiYm46aabmrWim8ybNw8vv/wyzp4969h9be3atZg3bx7efvttx3l79+6FXq/HG2+8AYXC/iOSnJyMSZMmtbhmVFSU47Wd0a9fP6xatcoRS2dUV1fjiSeewCeffILJkyc7jl/8IaJ///7o37+/4/u+ffti586d2LNnj9OxuopMJmDJhBQs25yLMr0J4Vol1HIZTDYRNUYLQtRyLJmQwvneRNQmdpv7mZMnT2Lbtm1QKpUtHouNjcXUqVPx1ltvAQCMRiM+/PBD3H777c3Oi4uLg9VqxebNm9GdBfiautZ37tzp9DVas337doiiiOLiYgwcOBCJiYn4n//5H5w9e7bN5xQUFGDbtm2YMGGCS2Nx1rjUaDw3OxMD40NhNFlRbjDBaLJiYHwonpudyXneRNQutrz9wKeffoqQkBDYbDY0NjYCsHcrt+b222/Hgw8+iMcffxwbNmxASkoKhg4d2uycMWPGYNmyZbj11lvxu9/9DqNGjcKkSZNw2223ITY2ttm548aNg0zW/DNgbW0t5HI5lEol0tLSoNVqXXezsH9Aaer+XrVqFcLCwvDEE0/g6quvxuHDh6FS/VorHjduHA4ePAiTyYS77roLzz77rEtj6Y5xqdEY0z+KK6wRUZex5e0HrrzyShw6dAg//PAD7r33XkydOhX33ntvq+ded911MBgM2L17N9auXdui1d3kr3/9K8rKyvDPf/4TgwYNwj//+U+kp6e32K71ww8/xKFDh5p9NW3bmpCQgGPHjmHUqFEuvV9RFGGxWPDKK69g6tSpGDNmDN5//338/PPP2LFjR4v4Dh48iPfeew+fffYZVqxY4dJYuksmE5CZGIYJA3ohMzGMiZuIOoXJ2w8EBwcjNTUVWVlZeOWVV2AymfDMM8+0eq5CocD8+fPx1FNP4YcffsC8efPavG5UVBRuvPFGvPTSS8jPz0fv3r1bJL+kpCSkpqY2+3K3+Ph4AMCgQYMcx3r16oXo6GicOXOmRXyDBg3CLbfcgueffx5PP/00bDab22MkInInJm8/9NRTT2HFihUoKSlp9fHbb78du3btwsyZMxEREdGpa6pUKqSkpKC+vt6VoTrl8ssvB2CfDtakqqoKFRUV6Nu3b5vPkyQJFoulW3V8IiJvwOTthyZOnIiMjIw2p0QNHDgQFRUVWLduXauPf/rpp/jtb3+LTz/9FCdOnMDx48exYsUKbN26FTNnzmx2bmVlJcrKypp9NdXdi4uLkZ6ejn379rUbb1N3u8FgwPnz53Ho0CEcPXrU8fjmzZuRnp7u+H7AgAGYOXMm7rvvPuzduxd5eXlYsGAB0tPTceWVVwIA3n33Xfz73/9Gfn4+Tp48iY8++giPPfYYbrrpJscIeiIiX8XfYn5q6dKlWLRoER555BHHtLCLtTcXe9CgQdBqtXjwwQdx9uxZqNVqXHbZZXjjjTcwf/78ZudeddVVLZ7//vvv4+abb4bFYsHx48dbzA2/1LBhwxx/P3DgAN577z307dsXp0+fBmAfAHdxKxsA3n77bTzwwAO47rrrIJPJMGHChGaj7BUKBV544QWcOHECkiShb9++uOeee/DAAw+0GwsRkS8QJD/rQ9Tr9QgLC0NtbS10Oi5yQURE/octbyKiACSKEqcp+jAmbyKiALO3oAKrdxWisNwAi02CUi4gJSYESyakcIEgH8EBa0REAWRvQQWWbc5FfqkewWoFYkLVCFYrkF9ah2Wbc7G3oMLTIVInMHkTEQUIUZSwelchDCYr4nQaaJRyyGQCNEo54nRqGEw2rN5VCFH0q6FQfonJm4goQBwp0aOw3IAIrarZbnYAIAgCwrVKFJYbcKRE76EIqbOYvImIAkSV0QyLTYJK3vqvfrVcBosoocpo7uHIqKuYvImIAkSkVgWlXIDZJrb6uMkmQikTEKlVtfo4eQ8mbyKiAJHRW4eUmBBUG1suEyxJEmqMFqTEhCCjN9fI8HZM3kREAUImE7BkQgpC1HKU6U1osNggihIaLDaU6U0IUcuxZEIK53v7ACZvIqIAMi41Gs/NzsTA+FAYTVaUG0wwmqwYGB+K52Zncp63j3B6eVSLxYKysjIYjUb06tULkZGRro7NKVwelYioY1xhzbd1aYU1g8GAd999F++//z727dsHk8nkeCwxMRFTpkzBXXfdhZEjR7o8UCIich2ZTEBmYpinwyAndbrb/OWXX0a/fv3w+uuvY9KkSdi0aRMOHTqE48eP47vvvsNTTz0Fq9WKq6++Gtdccw1+/vlnd8ZNRETkUaIoIbeoFrtOnEduUW2PLm7T6W7zG2+8EX/+85+RmZnZ7nkmkwlvvvkmVCoV7rjjDpcE2RXsNiciInfz9Prw3BKUiIioC5rWhzeYrIjQqqCSy2C2iag2WhCilvfIwL9ujTZ/4IEHsH79ehw8eLBZ/ZuIiMgfXbo+vFoh88j68N3aEnTixIk4fPgwPvvsMxw5cgRyuRwZGRnIyspCVlYWpk+f7qo4iYiIPK5pffjwICUsNgkyAVDI7aP0L10f3p0DAruVvE+fPo0nn3wSx44dw4ABA2AymZCXl4fDhw/jv//9L5M3ERH5lcp6E0xWEVqV3L5K3SUbvKjlMtT2wPrw3UregwcPBgAsXboUBQUFCAkJQUZGBgYPHoyrrrrKJQESERF5A7NVhM0mQS4AFpsEtaLlvPieWh++W8l78uTJAICtW7cCsA8Wy8vLQ15eHrZv347rrruu+xESERF5WF2jBZUGM/pGa5EUFYyT5w2IDlEB+DWBN60PPzA+1O3rw3creTexWq344IMPcP78eQwaNAh33nlni71iiYiIfI0oSqgwmGAwWQEAMkHAraOSsHL7CVQYzAjXqqAVBJhsImoujDbvifXhXbK2+S233IJvvvkGgiBgw4YNGDZsGBdpISIin2Y0W1FU3eBI3E2G9YnA0qsHoH+vEI+tD++Slvfx48dx+PBhx/cHDx7EnXfeiZ07d7ri8kRERD3GJkqovKi13ZphfSIwJCkcZbUm2CSpx9eHd0nyDgkJQWFhIVJSUgAAw4cPR1VVlSsuTURE1GPqGi2oqjfD1ol52jJBwKDeOkQGu3dwWmtckrxfe+01zJo1C9OmTcPAgQORn5+PPn36uOLSREREbmexiagwmNBgtnk6lE5xSc07MzMT+/fvR3Z2Nn755Rekpqbi3//+tysuTURE5Fa1RguKqxt8JnEDLkrev/3tb2EymXDTTTdh5MiR6NWrF7RarSsuTURE5BYmqw3FNQ2orDdB9LFtPlySvA8fPgydToejR4/iT3/6E7Zt24b777/fFZcmIiJyKfHCgLTi6gaYLL7T2r6YS2reSqUSkiRh/fr1WLZsGX77298iOzvbFZcmIiJymXqTFZUGM6yi6OlQusUlyfvuu+/GyJEjUVVVhaeeegoAUF9f74pLExERdZvVJqKy3oz6dqZ/+RKXJO+77roL//M//wOFQoHg4GAUFBRg9OjRrrg0ERFRt9QaLag2mn2urt0eQZL86G5gX189LCwMtbW10Oncu7YsERF5r0aLDRUGE8xW93WRh2tVvjvPm4iIyFuIF7bk1DdYPB2K27hktPmlSktLYTKZ3HFpIiKiNhlM9vXI/TlxA25K3vPnz0d6ejoeeughd1yeiIioGatNRFltI8r1jT4/krwz3NJt/tVXXwEAjh075o7LExEROfjjgLSOuLXmnZ6e7s7LExFRAOuJAWneyiXJ+9ixY/jkk08QHh6OjIwMDB48mCO9iYjILWyihKp6M+oa/buu3R6X1LynTZsGs9mMmpoavPbaa5g4cSLS0tJccWkiIiKHukYLiqqNAZ24ARe1vOPi4vD44483O2az+eZ6sURE5H3MVvuWnY0+uha5q7mk5T116lS88847zY7J5XJXXJqIiAKYJNm7yItrGpi4L+KSFdauvfZa5OXlQaVSYdSoUcjMzERmZiamT5/uihi7hCusERH5B6PZvomIxea9A9J8eoW1rVu3ArAnzry8POTl5WH79u0eSd5ERO4mihKOlOhRZTQjUqtCRm8dZDLB02H5DatNRFW9GQY/2UTEHVySvK1WK/bs2QONRoOMjAyMGzfOFZclIvI6ewsqsHpXIQrLDbDYJCjlAlJiQrBkQgrGpUZ7OjyfV9tgQXV9YM3ZdoZLus1nzZqFqKgobNmyBTqdDqIoIjMzE59++qkrYuwSdpsTkbvsLajAss25MJisiNCqoJLLYLaJqDZaEKKW47nZmUzgTmq02FBZb4bJx+ranuo2d8mAtVOnTuHNN99EUlISTp06haVLl2LEiBGuuDQRkVcQRQmrdxXCYLIiTqeBRimHTCZAo5QjTqeGwWTD6l2FEEW2GLtCFCVUGEwoqWnwucTtSS5J3kFBQQAAlUoFs9mM++67D7t27XLqWqtXr0ZWVhZ0Oh10Oh3Gjh2Lzz//3BVhEhE57UiJHoXlBkRoVRCE5vVtQRAQrlWisNyAIyV6D0XoewJlExF3cEnN+w9/+AOqqqpwww034J577sG4ceNw+vRpp66VmJiI559/HqmpqQCAt956CzNnzkROTg4yMjJcES4RUZdVGc2w2CSo5K23edRyGWovbEVJ7bPYRFQazDCaOSDNWS6peV9s/fr1OHLkCObPn4+srCyXXDMyMhIvvvgiFi9e3OG5rHkTkTvkFtXi7nf2I1itgEbZch2LBosNRpMVr80fgczEMA9E6P0kSUKN0YKaBgtcnHo8xqenilVVVeGNN96AUqnEAw884IpLArCv0vbRRx+hvr4eY8eObfUck8nUbO9wvZ5dVkTkehm9dUiJCUF+aR3idLJmXedNSWlgfCgyerPR0BqDyYoqgzkgtuvsCS6pec+dOxfBwcF44403AAB5eXktlkvtitzcXISEhECtVuN3v/sdNm/ejEGDBrV67vLlyxEWFub4SkpKcvp1iYjaIpMJWDIhBSFqOcr0JjRYbBBFCQ0WG8r0JoSo5VgyIYXzvS9hstpQUtMQMPts9xSXdJuPHDkSP/74I4YNG4acnBwAaPb3rjKbzThz5gxqamqwceNGvPHGG9i1a1erCby1lndSUhK7zYnILZrN8xYlKGWc590a8UL9398Ho/l0t3lMTAxKSkqadSM1NjY6fT2VSuUYsDZixAj8+OOPWLVqFV577bUW56rVaqjVaqdfi4ioK8alRmNM/yiusNaOukYLqurNsHHanNu4JHm//PLLWLBgAcrLy/Hhhx9i27ZtSE9Pd8WlAdjrSRe3romIPEkmEzgorRUWm33nrwYz52u7m0uS94ABA/DZZ59hy5YtyMvLw8iRI7Fw4UKnrrVs2TJMmzYNSUlJqKurwwcffICdO3di27ZtrgiViIhcTJIk+7KmRv8ZRe7tXJK833jjDaxbtw5hYWEYPHgwQkNDceLECQwdOrTL1zp37hzmz5+P0tJShIWFISsrC9u2bcPVV1/tilCJiMiFTFYbzteZYLZyMFpPcsmAteTkZGzZsgVqtRq5ubnIy8vDkSNHsGHDBlfE2CWc501E5H6SJKHaaEGtH83ZdoZPD1jLysrCgAEDEBQUhPT0dNx4442uuCwREXmhBrMNFQaTV++z7e9cMs/7ySefxPXXX49PPvkE5eXlrrgkERF5GatNRHldI0prG5i4Pcwl3eaDBg3CyJEjodFokJubi3PnziE5ORlfffWVK2LsEnabExG5liRJ0DdYUW3kPtuX8ulu87CwMLz11lvNjjm7MQkREXmPRot9QBpb2t7FJd3m48aNwzvvvNPsWL9+/VxxaSIi8gBJklB5YZ9tJm7v45Ju82uvvRZ5eXlQq9UYOXIkMjMzkZmZienTp7sixi5htzkRUfewtd15Pt1tvnXrVgD2xJmXl4e8vDxs377dI8mbqLNEUeISl0QXEUUJ1UYzav18PXJ/4JLkPWPGDGRmZiIrKwtZWVm44447IJO5pEeeyC2abS5hk6CUc3MJCmyc/uVbXJJhx44di0OHDuHHH3/E0qVLodPpMHnyZKxbt84Vlydyqb0FFVi2ORf5pXoEqxWICVUjWK1Afmkdlm3Oxd6CCk+HSNRjRFHC+ToTp385qarejMLzhh5/XZfUvIcOHYpDhw45vv/666/x2WefQSaTQaPR4H//93+7+xKdxpo3tUcUJSxYtw/5pXrE6TTNdsKTJAllehMGxofirUWj2IXupVjucB2DyYoqg5n7bDvhVEU9Nh4owlf55RiZHIF37xjTo6/vkm5zrVaLn3/+GZdddhkAYNKkSXjiiSfw7bffIjs7u0eTN1F7jpToUVhuQIRW1SxxA4AgCAjXKlFYbsCREj13jfJCLHe4hsUmotJghtFs9XQoPkWSJOz/pRobDhThx9PVjuPfFlTiaIkeg3r3XIPRJcn7n//8J2666SaMHz8eWVlZOHHiBKxWKwRBgMXCgQ/kPaqMZlhsElTy1itGarkMtaKEKqO5hyOjjjSVOwwmKyK0KqjkMphtoqPc8dzsTCbwDkiShJoL65FzsZXOM1tFbD96DhsPFuF0pbHF471C1SipafC95J2VlYV9+/Zhw4YNyMvLQ3x8PD777DMYjUbMmTPHFS9B5BKRWhWUcgFmmwiNTN7icZNNhFImIFLb81M/qG2iKGH1rkIYTNZm5Q6NTI44nQxlehNW7yrEmP5R7EJvg8FkRXW9mXXtLqiqN+PjQyX4+KcS1LQyAj+lVzAWjO2Hm0YlQa1o+fvEnVySvAFAoVDg5ptvbnH86aefdtVLEHVbRm8dUmJCkF9ahzidrEXNu8ZowcD4UGT04Cdo6hjLHc4zW0VUGExotNg8HYrPOFVRjw0HivBV/jlYbC17KMb0j8SN2YkYmhSOiGB1jyduwIXJm8gXyGQClkxIwbLNuSjTmxCuVUItl8FkE1FjtCBELceSCSlsvXkZljucU2u0oMpoDugtOztLkiT8eLoaHx0owoFfqls8rlbIMCUjFnOGJ6JPpNYDETbnluRdWlqKyMhIqNVqd1yeqFvGpUbjudmZjoFPtaIEpUzAwPhQDnzyUix3dI3ZKuK8wQQTW9sdMlls+Cq/HBsOFuGXVurZUcEqzBzaG9cP6Y2wIKUHImydW5L3/PnzUVhYiDlz5mDFihXueAmibhmXGo0x/aM45chHsNzReWxtd05H9ezUXiGYOyIRV6b1grKNHh9PckvybtoK9NixY+64PJFLyGQC66M+guWOjllsIs7XsbbdkY7q2WP7R2FudgKGJoW3GF/hTbq9SEtNTQ2++OILFBcXQxAExMfHY+rUqYiIiHBVjF3CRVqI/Fezed4Xyh2c5w3oGy2oMnCv7bY01bM3HCjC/jbq2ddkxOGG4QlI6mI921Mbk3Qreb/55pt44YUXcN111yEhIQEAUFRUhM8//xwPP/wwFi9e7LJAO4vJm8i/cYW1X3Ekefs6U8+ePSwB12XFO13P9snknZaWhgMHDiAkJKTZ8bq6OmRnZ+PEiRPdDrCrmLyJyN811flrGiysbbeiqZ79n59KWt0hzZX1bJ/cElQQBBgMhhbJ22AweHWtgIjIV9U1WlBjtHCxlVacPG/AhgPF+O+xtuvZN45IxJDEMJ/PUd1K3itWrMCECRMwePDgZt3mR44cwUsvveSSAImIiEm7LaIk4cfTVdiwvwgHztS0eFytkGFqRhzmOFHP9mbdHrBms9mwb98+lJSUQJIkJCQkYNSoUZDLe37FGYDd5kTkX+pNVlRxWdMWTBYbtueXY+OBIvxS1Uo9O0SF2UO7V8/uDJ/sNgcAuVyOsWPHuiIWIiK6oNFiQ1W9mYPRLlFVb8Z/DhXj459KW69nx4TgxuxETPTS+dmu4tJ53gaDASdOnED//v0RHh7uyksTEQUEs1VEtdGMehO367xY4XkDNhwowtfHylvUswUAY1OicGN2IrL8oJ7dGd1K3nfddRfWrFkDANi9ezduu+02DBo0CPn5+XjllVdw/fXXuyRIIiJ/Z7WJqDZaUNfIbZSbdFTP1ihkmDrYXs9OjOj5erYoSThaoodNknp82mK3kvf+/fsdf3/iiSfw2WefISMjA0VFRZgxYwaTNxFRByRJQvWFPbY57cvOXs8+hw0HinGmnXr29Kx46Dy03njOmWq8t+8siqqMECVAKe/ZBYNc1m3e0NCAjIwMAEBiYiJ/CImIOmA0W1Fp4GC0JlX1Zmw5VIyPD5VA39iybHBZTAhuHJGICQM8W8/OOVONldtPwGi2IUKrQpBSDrNNRH5pHZZtzsVzszPdnsC7lbwPHz6MmJgYSJKEuro6lJWVIS4uDmazGTYbB1kQEbXGJkqoNJhgYF0bgG/Vs0VJwnv7zsJotiE6RAWFTAaZTIBGJkecToYyvQmrdxViTP8ot3ahdyl533777Vi1ahVCQ0MBAFZr6z94RqMRr732WvejIyLyI6IooabBAn2DJeDXIRclCftOVWHDgSIc9MJ6dlsKztXjbGU9dBolBDRPzoIgIFyrRGG5AUdK9G7d+KhLyfutt97C888/70jebQkPD+f0MSKiC0RRgv7CIiuBnrQbLTZsP3oOGw4U4Wx1Q4vHo0NUmDU0AdcPiUeoxnv2z25S22iGRZSgk7feqlbLZagVJVQZzW6No0vJm3VsIqLOkyQJ+gYrahrMsImB/fuzM/Xs/7lQz1Z48fzsMI0KSpkAi02CWtEygZtsIpQyAZFa9y7c0uWat6frDURE3k6SJOgbrag1WmAVA3swWmG5ARsOtl3PHpcShbleUs/ujNTYYCRFBePkeQOiQ1TARV3nTRvGDIwPRUZv967w2eXkPWDAgA7/gauqqpwOiIjIV0mShDqTFTX1gZ20m+rZHx0oQk4b9exrBsdhzvBEJEQE9XyA3SATBNw6Kgkrt59AhcGMcK0KWkGAySaixmhBiFqOJRNS3D7fu8vJ+5lnnkFYmPuK8EREvqYpadcG+MYhjRYbvjx6DhvbqWfPHmafn+2N9ezOGtYnAkuvHuCY520wWaGUCRgYH9pj87y7tDGJTCZDWVkZYmJi3BlTt3BjEiLqSdw4BKgwmPCfQyX45Cffrmd3lShJKKs1ef8Ka75QjyAi6gncOAQoKP91frZVbKWenWqfn52Z4Bv17K6SCQIG9dZ5/65iHG1ORIHOZLWhxmgJ2I1DOqxnK2W4JsM369m+pEvJWwzgARhEFNgaLfakbTQHZtLuqJ7dK0SN2cMTcF1mnE/Xs31FlwesiaKI9evXY9OmTTh9+jQEQUBycjLmzp2L+fPn+2XXCBEFrkBP2pUGE7a0U89Oiw3F3OwEv6tne7sud5vPmDEDW7duxZAhQ5CZmQlJkpCfn4+FCxdi06ZN2LJli5tCJSLqOYHePd5RPfvy1GjMzU7w23q2t+tS8l6/fj12796N//73v7jyyiubPfb1119j1qxZePvtt3Hbbbe5NEgiop7SYLZB3xiYSVuUJHx/shIbDhTj0NmaFo9rlDJMGxyPG4YnICGc9WxP6tJUsSlTpmDSpEl49NFHW338ueeew65du/DFF1+4LMCu4lQxIuoqUbTP09Y3BOY87QaLDV8eOYeNB4tQxHp2l4RrVd4/2vzw4cP429/+1ubj06ZNwyuvvNLtoIiIekLThiG1DZaAXHu8o/nZ9np2IiYMiGY928t0KXlXVVUhNja2zcdjY2NRXV3d7aCIiNwp0JP2z+fqsOFgMXYE6Pxsf9Cl5G2z2aBQtP0UuVze5h7fRESe1rRhSI0x8Hb5Yj3bv3R5tPnChQuhVqtbfdxkMrkkKCIiVzOarag0BN4ypp2tZ0/PjEeI5teUIEoSCs7Vo7bRjDCNCqmxwZCxFe41upS8FyxY0OE5HGlORN5CkiQYTFboG60wBdgypufrTPjPoWJ8crgUdW3Us28ckYjfXNaynp1zphrv7TuLs5X1sIgSlDIBSVHBuHVUEob1ieipW6B2dGm0uS/gaHMistpE1DVaUddoDbitOU+cq8OGA0XYcfx8i9KAAGD8ZdGYOzwRgxN0rdazc85UY+X2EzCabdBplFDKBVhs9jECWpUcS68ewAR+Ea8fbX7mzBn06dOn0xcuLi5GQkKCU0EREXWV2SrCaLai3mwLuFa2KEn4rrASGw4U4aei2haPa5QyXDs4HrM7qGeLkoT39p2F0WxDdIgKAuzJXa0QEB2iQoXBjPf2ncWQpHB2oXtYp5P3yJEjMWPGDNx5550YNWpUq+fU1tbi3//+N1atWoW7774b9957r8sCJSK6VCB3iwNN9ewybDxY3Go9OyZUjdnDEnDdJfXsthScq8fZynroNEpH4m4iQECoRomzlfUoOFePAXEhLrsP6rpOJ+/8/Hw899xzuOaaa6BUKjFixAj07t0bGo0G1dXVOHr0KI4cOYIRI0bgxRdfxLRp09wZNxEFsKZucX1jYE716rCeHReKG7Nbr2e3p7bRDIsoQSdvvVWtkguokyTUNpqdjp1co8s178bGRmzduhV79uzB6dOn0dDQgOjoaAwbNgxTp07F4MGD3RVrp7DmTeSfRFFCvdkKg8mKBnPgtbKB9uvZMgEYnxqNudmJyOjdej27w+uXGfDn/+QiSKWAWtEy6TdaRTSarXh2ZiZb3hd4fc27iUajwQ033IAbbrjBHfEQETVjvJCwjSYbRP8aX9spHdWzg5RyTMuMww3DEtC7m/OzU2ODkRQVjJPnDc1q3gAgQUJdowX9e4UgNTa4W69D3dfl5E1E5G6NFhvqTVbUm2wBN1q8SYPFhi/yyrApp+169g3DE3BtZjxC1N3/Vd40r3t4n3CcqazH+TozdEFKqOQCzDZ74taq5Lh1VBIHq3kBp97xpUuXtnpcEARoNBqkpqZi5syZiIyM7FZwRBQ4Gsw21JvtLexATdiAvZ69OacYn+W2Xs9Ob6pnD+gFucw1SfTSed2SBNgkCfoGMwSZAKUgoH+vEM7z9iJOzfO+8sorcfDgQdhsNqSlpUGSJPz888+Qy+VIT0/H8ePHIQgCvvnmGwwaNMgdcbeJNW8i32G5MPDMEIDzsS/VUT378tRo3HhJPdsVq6C1N69bIRMwa1gisvtEcIW1NvhMzRuAo1W9bt06R4LU6/VYvHgxxo8fjzvvvBO33norHnjgAY9uD0pE3qneZB8pHqgDz5rYRPt64x8dKMLhLtazXbEKWmfmdR88U42bRiYycXsZp1reCQkJ2L59e4tW9ZEjRzBlyhQUFxfj4MGDmDJlCioqKlwWbGew5U3knSTJvmd2rTEw98y+WIPZhm1HyrDpYDGKa9qZn53Vej3bVaugcXR59/lUy7u2thbl5eUtkvf58+eh1+sBAOHh4TCbOReQKNBx8NmvmurZnx4uhcHUsp49MN5ez77isrbr2a5cBY3zun2X093mt99+O1566SWMHDkSgiBg3759eOihhzBr1iwAwL59+zBgwABXxkpEPsJsFWEwWVFvsgZ8KxvoxPxsx3rjYR1ey5WroIVpVFDK7K12taJlAjfbJCgFAWGanm9ZUvucSt6vvfYaHnjgAdx8882O/bsVCgUWLFiAl19+GQCQnp6ON954w3WREpFXs9pE1JtsqDNZYLYyYTfVs9uan61VyXFtZhxmD0tAfFjn52e7srXMed2+y6nkHRISgtdffx0vv/wyTp48CUmSkJKSgpCQXz/lDR061KmAli9fjk2bNuHYsWMICgrCuHHj8MILLyAtLc2p6xGRe9hECY0WGxotNjRYbEzYFzSYbfjiwnrjbdWz5wxPwDQn52e7srUsEwTcOioJK7efQIXBjFAN53X7im7N7A8JCUFWVparYgEA7Nq1C/fccw9GjhwJq9WKxx9/HFOmTMHRo0cRHMxPf0Se1LREab3JBqO5Zc02kHWunp2EKy6L7tb8bFe3lof1icDSqwc4Rq7XSRLndfsAp/fzrqmpwZtvvon8/HwIgoCBAwdi8eLFCAvruGbTFefPn0dMTAx27dqF3/zmNx2ez9HmRK4lihIaLL8uoBKIS5S253iZvZ6980Tb9Wz7/GzX/W68eLR5a61lZ/bcdsWc8UAgEwTHv4sgADqNEmFaZY/H4VTy3r9/P6ZOnYqgoCCMGjUKkiRh//79aGhowJdffonhw4e7LMCCggJcdtllyM3NbXXTE5PJBJPJ5Pher9cjKSmJyZvISaIowWwTYbqwP3ajRYSTn/H9lk20rzf+0YEi5Ba3Xs+eNjgONwzvWj27K5rN877QWu7qPG9qmyDY+zRkggC1UgaNQg6NSga1Qu7p0AA4mbyvuOIKpKam4vXXX4dCYe95t1qtuOOOO3Dy5Ens3r3bJcFJkoSZM2eiuroae/bsafWcp59+Gs8880yL40zeRM1ZbSJskgRRtC99aRMlSBf+bDputooBP52rPQ1mGz7PK8OmnCKU1DS2eDxWp8YNwxNx7eA4BLtgvfGOsLXcfUq5DGqFPSmrFDKoFDKXLTvrTk4l76CgIOTk5CA9Pb3Z8aNHj2LEiBEwGo0uCe6ee+7BZ599hm+++QaJiYmtnsOWN9GvJMneajZb7V8WmwSLTYT1QqIm53RUzx4Ur8Pc7MRu17PJvWSCgCCVHJoLiVqtkEHmo++XUx8NdTodzpw50yJ5nz17FqGhoS4J7N5778XHH3+M3bt3t5m4AUCtVkOtVrvkNYl8iSRJMFlFexe3RXQkbSZp1+monn3FZb0wNzvBpfVsb+AvLXpBEKBWyBCklNuTttI7urxdwankfdNNN2Hx4sVYsWIFxo0b59iE5E9/+hNuueWWbgUkSRLuvfdebN68GTt37kRycnK3rkfkD6w2EY2O1rR4oXubrWl36Ew9+7rMeMweloC4MI0HInQvV6yZ7ilKuczRDa5RyqFRyhybuPgbp7rNzWYz/vSnP+Gf//wnrFYrJEmCSqXCkiVL8Pzzz3erJfz73/8e7733Hv7zn/80m9sdFhaGoKCOB35wtDn5OseAMYsIk9WGRgvr0D2hqZ698WARSms9X8/2BFetme5ugiBApZBBo5BBrZRDKRegkvtvom6N01PFAMBoNKKwsBCSJCE1NRVarbb7AbXxj79u3TosXLiww+czeZMvEcULXd9We6I2XWhZU88p1zfa69m5pag3tdzlbFC8DjeOSMT4VP+uZ4uShEc25rY5f7zCYEb/XiF4YU6mR7rQ5TIBwWoFglUKv25Rd1anPz4uXbq00xdduXKlU8EAYDcg+S0mau9yrEyPj/YXYdeJ87iknO3X9ey2uHLNdFdRXahXa1UKBKn8p17tCp1O3jk5OZ06L9A/DRFdymS1Qd9g36SDC5x4lk2UsLewEhsOnEVusb7F48EqOa7143p2ezy5w5hcJkAuE6CUy6CQCY6krZC33KaU7DqdvHfs2OHOOIj8SlOt2mCywmRp2RVLPaujenacToMbhidgmh/Xszvi7h3G5DIBaoV9EJlSLnMkbIVMYKPPCYH5U0rkYk3JummjjkunFZFndFTPzuitw43Zibjcz+vZneHqNdPlMgFBSjk0F82rJtdh8iZygslqQ6NZRKOVydobdVTPnjCgF+ZmJ2JgvO8ManX33Ovu7jB28QIo3rSMqL/q1mhzb8TR5uQOjRYbTBYRDRda1qxdex+bKOHbwgpsPFDUfj17eALidL5Vz+7JudedXTNdEARolPbatEbpXwug+AImb6JLNK1c1rRPtckiMll7MaPZal9v/GBxm/XsOdn2erZW5XudjZ6Ye91WK5/TtbyH7/0kE7mYJEm/1qsv1K797DOtXzp3oZ792eFS1Jtbn5/9PyN8u54tShLe23cWRrOtWR1arRAQHaJChcGM9/adxZCkcJd3oQ+IC4EgCFDK7QPNQtScruVNmLwp4DTNt27qAjdxPXCfkl+qx4YD/lXPbktPz71umqKlVsqhksuglHMkuLfyukVaiFxNFCVHi7rBYuPmHT7IJkr4tqACHx0owpGStuvZNwxPQKyP1bPb46651wqZDEqFYP9T3rTUqNxnd9gKRE4v0nLgwAHYbDbH+uMnTpyAXC5Hdna2ayMk6iKbKDmmbDVaRc6z9mEd1bPjwzSYMzwB1/hoPbsjrpp7rZDJoFFd2F2Li5/4BacWaVm5ciVCQ0Px1ltvISLCPlCiuroaixYtwhVXXOH6KIna4NjE46JlR81WLjnq687pG7HpYDG25rZezx7c275/ti/XszujO3OvlXIZtCo5gtUKjgT3Q06NNk9ISMCXX36JjIyMZsfz8vIwZcoUlJSUuCzAruJoc/9jEyVYbOKFLwlWUYTVJtm/uNuWXwmkenZnXTzavLW51xePNm8aDR7ChO33nOpn0uv1OHfuXIvkXV5ejrq6OpcERoFBkqRfE7JoT8g20f5lFUXH38l/2UQJ3xRUYEM79ezrsuzrjftTPbuzhvWJwNKrBzjmXtddmHvdv1cIbh2VhJH9oqBRyRCiVvhl6YBa59Q7PXv2bCxatAgvvfQSxowZAwD4/vvv8ac//Qk33HCDSwMk/2C5qGvbahNhESVYbSITcwCrN/1azy7TB149uyuG9YnAkKRwnDpvRJ3JgugQNYYkhkGrVkDJ+nVAcqrb3Gg04qGHHsLatWthsVgAAAqFAosXL8aLL76I4ODOrX3rDuw296ymLm6zzd61bbGJMFlEdm+TQ5m+EZs7qmePSMTlKf5dz+4MjVKO4AvbYXLaFl2sWyus1dfXo7CwEJIkITU11aNJuwmTt3td3M1tsV7480KStokSVyKjNuWX2tcb3/0z69ltaVofXKuy72Ed6B9eqG1O90Xt2bMHr732Gk6ePImPPvoIwcHBeOedd5CcnIzx48e7MkbqYRcPELPaJFg4QIyc1GE9Wy3H9Mx4zArQejbw68IoWi45Sl3gVPLeuHEj5s+fj3nz5uHgwYMwmUwAgLq6Ojz33HPYunWrS4Mk1xLF5gnZcmFgWFOyZuuZuov17LYJgoBglRxBKs65Juc51W0+bNgwPPDAA7jtttsQGhqKn376Cf3798ehQ4dwzTXXoKyszB2xdgq7zZtrWgrUZLUvA8r6M7lTWa19vfG26tmZCTrMzU7CuJSogOsSVshkCNUooAtSBty9k+s59ZH3+PHj+M1vftPiuE6nQ01NTXdjom5oWgq0wczVxajnHC3R46MDRdjTRj17YloM5mYnID0usD5QywTBXr9WKxCskrNLnFzGqeQdHx+PgoIC9OvXr9nxb775Bv3793dFXNRJFy8F2rRuN1FPsIkS9vxcgQ0HzuJoacv1HZrq2bOHJSAmgOrZKoUMGqV90FmQ0jMJWxQlHCnRo8poRqRWhYzeOq5b7mecSt5333037rvvPqxduxaCIKCkpATfffcdHnroIfz5z392dYx0EYvtwtaVF7awtNiYrKln1Zus2JpXhk0Hi3BOb2rxuL2enYhpg+MCYgtJuUyAVqWAViWHRin3eJf43oIKrN5ViMJyAyw2CUq5gJSYECyZkIJxqdEejY1cx+mpYo8//jhefvllNDbaB6Oo1Wo89NBD+N///V+XBthV/lbzNlvFCzti2dBoZr2aPKesthGbcoqwNbcMxgCvZ3vrMqR7CyqwbHMuDCYrIrQqqOQymG0iqo0WhKjleG52JhO4n+jWPG+j0YijR49CFEUMGjQIISHd30+2u3w9eZsubF1putC6ZrImT2uvni2XCZh4YX52WlyoZwLsIcKF+nWoxjuXIRVFCQvW7UN+qR5xOk2z7npJklCmN2FgfCjeWjSKXeh+wKmfwDNnziApKQlarRYjRoxo8VifPn1cElwgMFntLeqm1jWXCyVv8Gs9uwhHS1vOzw5RKzA9Kx6zhvb2+3q2SiFDqEaJELV3L5pypESPwnIDIrSqFnV2QRAQrlWisNyAIyV6ZCaGeShKchWnkndycjJKS0sRExPT7HhlZSWSk5Nhs3GEc2skyT5t6+KaNedUkzcxmKz4PLcUm3KKW61n9w6317OvyfDverZcJiBErUCIRgG1wjfus8pohsUmQdXGvHG1XIZaUUKV0dzDkZE7OJW8JUlqdQSlwWCARuPfn8K7oilZ26dt2WCyiEzW5JXKahux8WARPs9rvZ6dlRiGucMTMdbP69lBKjlCNUqfnNYVqVVBKRdgtonQyFp+4DDZRChlAiK1Kg9ER67WpeS9dOlSAPYumCeffBJardbxmM1mww8//IChQ4e6NEBfIkmSo0XdYLEvitKNIQVEbnekpBYfHSjCNz9XBGw9WyGTIUSjQKjGt3foyuitQ0pMCPJL6xCnk7WoedcYLRgYH4qM3r43Foha6lLyzsnJAWD/QcjNzYVK9esnOJVKhSFDhuChhx5ybYRerGlBlEaL6JhjzWRN3s5ezz6Pjw4UIb+V+dlN9ezZwxLQK1TtgQh7hlaluDD4zPda2a2RyQQsmZCCZZtzUaY3IVyrhFoug8kmoubCaPMlE1I4WM1PODXafNGiRVi1apVXjuZ252hzLohCvqypnr3xYDHK61qvZ98wzL/nZwuCgGC1HOFBKqgUvtvKbk+zed6iBKWM87z9Ubemih09ehRnzpyB2dx8AMSMGTO6HZiz3JG8Kw0mJmvyWaW1Ddh0sLjdevaN2YkY099/69mCICBUo0B4kDIgNgLhCmv+z6kBa6dOncKsWbOQm5sLQRAcXcVNXU/+NtrcYLJyChf5FEmy//LecKAI3xS0Xs++Ms1ezx4Q67/1bAAI1SgRoQ2MpN1EJhM4HczPOZW8//jHPyI5ORlfffUV+vfvj3379qGyshIPPvggVqxY4eoYiaiTOlPPvn5IPGYN9e96NgAEqxX2Vcb8tHucAptTyfu7777D119/jV69ekEmk0Emk2H8+PFYvnw5/vjHPzoGthFRzzCYrNiaW4pNbdSzE8KDMGd4Aqb6+fxswD4QLVyr9KplS4lczankbbPZHEuhRkdHo6SkBGlpaejbty+OHz/u0gCJqG2ltQ3YeLAYn+eWoaGV7V+HJIZhbrZ9frbMD0ZUt0ejlCMyWMWkTQHBqeQ9ePBgHD58GP3798fo0aPxt7/9DSqVCmvWrOGWoERuxnp2c2qlHJFald/3KBBdzKnk/cQTT6C+vh4A8Je//AXTp0/HFVdcgaioKHz44YcuDZCI7GyihN0n7PXsY2WBOz+7iUohQ4RWhWC1920SQuRu3ZoqdrGqqipERER4fLEDd0wV+6WynqPNyWMMjVZ8lluKzTmsZwP2lnZ4kJJJmwKay376IyMjXXUpIgJQUtOATTmsZzcJVisQFsSBaERAF5J307rmnbFy5UqngiEKdKxnt6RVKRARrPSZ3b2IekKnk3dnp395utucyBdZbSJ2X9g/u7V6dqhGgeuz4jHTi+dni5KEgnP1qG00I0yjQmpscLd6BNRKOaI4epyoVZ1O3jt27HBnHEQBydBoxae5pdjSRj07McJez56SEYcgL05iOWeq8d6+szhbWe9YTzspKhi3jkrCsD4RXbqWRilHuFYJrYo1baK2uGzAmrfggDXyBSU19vXGt+aVotHScs38oUn2evaY/t5fz845U42V20/AaLZBp1FCKRdgsUnQN1qgVcmx9OoBnUrgXFyFqPOc+mj77LPPtvv4n//8Z6eCIfJnkiQhr1iPDQeL8G0b9exJ6TGYMzzBZ+rZoiThvX1nYTTbEB2iggD7Bw21QkB0iAoVBjPe23cWQ5LC2/wQEqSSI0LL7nGirnAqeW/evLnZ9xaLBadOnYJCoUBKSgqTN9FFmurZHx0owvE26tkzhvTGzKG9ER3infXsthScq8fZynroNEpH4m4iQECoRomzlfUoOFePAXEhzR5XKWSIDFaxe5zICU79r2lt8Jper8fChQsxe/bsbgdF5A+a6tmbDxbjvKGtenYipmTEenU9uz21jWZYRAk6eeutapVcQJ0kobbRvm2wWimHVimHVi3n6HGibnDZR16dTodnn30W06dPx/z58111WSKfU1zTgM1+Us/uSJhGBaXMXuNWK1rei9kmQSkISAjXok+kNqC25SRyJ5f2V9XU1KC2ttaVlyTyCZIkIbe4FhsOFOPbggpcOrxRIRNwZXoM5g5PwGU+Us/ujNTYYCRFBePkeUOzmjcASJBgaLRiUO9QjEuJgkzm2x9UiLyJU8n7lVdeafa9JEkoLS3FO++8g2uuucYlgRH5AqtNxK4T9vnZx8+1rGfrNApc76P17M6QCQJuHZWEldtPoMJgRqhGCZVcgFWSUNdghS5Igd9PTGXiJnIxp6aKJScnN/teJpOhV69emDRpEh577DGEhnquZcGpYtQT6hot+OxwKTbnlLRZz56bnYgpg2IDYhR1zplqvL/vLM5WGWGTJKjkMqTEhGDJhBSMS432dHhEfofzvDuByZuaFFc3YOPBImw7UtZGPTscc7MT/KKe3VkyQYAuSAmdWoH8sjpUGc2I1KqQ0VvHFjeRmzjVbb58+XLExsbi9ttvb3Z87dq1OH/+PB555BGXBEfkDZrq2R8dKMLegspW69mT0mMwNzsRqTEhrV7DHwmCgFCNAhFaFeQXknRmYpiHo3I/UbSvP88PKeRJTrW8+/Xrh/feew/jxo1rdvyHH37AzTffjFOnTrkswK5iy5tcxV7Ptu+ffeKcocXjTfXsWUN7I8oP69ltUcplCFErEKpRBNzo8b0FFVi9qxCF5QZYbBKUcoHlAfIIp1reZWVliI+Pb3G8V69eKC0t7XZQRJ5U12jBp4ft+2dXGMwtHk+KCMKcAKpnA4Ak2UsGJpuIOJ0GCeFBAdfa3FtQgWWbc2EwWRGhVUEll8FsE5FfWodlm3Px3OxMJnDqMU4l76SkJHz77bctBq59++236N27t0sCI+ppjnp2XhkarS3r2cP6hOPG7ESMSo4MmHq2IAg4VqrHuz/8gpPn6wO2tSmKElbvKoTBZEWcTuPYPVEjkyNOJ0OZ3oTVuwrtYx0C7EMNeYZTyfuOO+7A/fffD4vFgkmTJgEA/vvf/+Lhhx/Ggw8+6NIAidxJkiQcLq7Fhv1F2FvIenYTQRCg0yhwtESPF7YdC/jW5pESPQrLDYjQqlpseywIAsK1ShSWG3CkRB8QdX/yPKeS98MPP4yqqir8/ve/h9ls71bUaDR45JFH8Nhjj7k0QCJ3sNpE7DxxHh/tL8LP5axnXyxUo0SEVgmZIGDNnpNsbQKoMpphsdmnwLVGLZehVpRQZWxZZiFyB6eStyAIeOGFF/Dkk08iPz8fQUFBuOyyy6BWB9YvOfI9rGe3LUStQLhWBZXCnqByi2rZ2rwgUquCUi7AbBOhkbX8uTDZRChlAiK1Kg9ER4GoW8ujhoSEYOTIka6KhchtOqpnD+8TjrkBVs8G7Ek4WC1HeNCvSbsJW5u/yuitQ0pMCPJL6xCnkzX7MCNJEmqMFgyMD0VGb9fMcCHqSKeT99KlSzt90ZUrVzoVDJErSZKEw0W12HCg7Xr25IExmDs8ESkBVM8Gfp2jHRakhLKN5MzW5q9kMgFLJqRg2eZclOlNCNcqoZbLYLKJqDFaEKKWY8mEFL8vH5D36HTybm0b0NZc2r1G1NMsTfOz26lnzxjaGzOHBF49WyGTISxIiRCNwrGwSlvY2mxuXGo0npud6ZjnXStKUMoEDIwP9YqR91w8JrBwedRO4CItvqGjenafSC3mZifgqoGBV89WKWQI16oQou5apezXuc22VlubgTLa/GLemCS5eEzg8brkvXv3brz44os4cOAASktLsXnzZsyaNavTz2fyDjxF1UZsPFiMLzg/uwVnk/bFmiWGC61NJgbv0dbiMdUB/AErEHRrwNrRo0dx5swZx3SxJjNmzHD6mvX19RgyZAgWLVqEOXPmdCc88mNN9eyPDhThO9azW1DIZIgM6V7SbjIuNRpj+kd5XWuTuHhMIHPqf/bJkycxe/Zs5ObmQhAENDXem35wbDab0wFNmzYN06ZNc/r55DmiJKHgXD1qG80I06iQGhvs8pauxSZi5/Hz2HCA9ezWCIKA8CAlwrVKl44/kckEv58O5ou4eEzgcip533fffUhOTsZXX32F/v37Y9++faisrMSDDz6IFStWuDpG8gE5Z6rx3r6zOFtZ7+haTYoKxq2jkjCsT0S3r69vuFDPPlSMSjfWs3viA4i7BKsViAxWtTl6nPwPp/MFLqeS93fffYevv/4avXr1gkwmg0wmw/jx47F8+XL88Y9/7PTIdFcwmUwwmUyO7/V6fY+9NtnlnKnGyu0nYDTboNMooZMLsNgknDxvwMrtJ7D06gFOJ/CzVUZsOliML460Xs/O7hOOOS6qZ7v7A4i7aFUKRAQroVYE1iA84nS+QOZU8rbZbAgJsdcRo6OjUVJSgrS0NPTt2xfHjx93aYAdWb58OZ555pkefU36lShJeG/fWRjNNkSHqCDAnkDVCgHRISpUGMx4b99ZDEkK73RylSQJP12Yn91aPVspFzA5PRZzshOQ0ss19Wx3fgBxlyCVHBFaVcCNnKdfcTpf4HIqeQ8ePBiHDx9G//79MXr0aPztb3+DSqXCmjVr0L9/f1fH2K7HHnus2QIyer0eSUlJPRpDICs4V4+zlfXQaZSOxN1EgIBQjRJnK+tRcK4eA+LaT7QWm4gdF+rZBW3Us2cO7Y2ZQxMQGey6loQ7PoC4E5M2NeHiMYHLqeT9xBNPoL6+HgDwl7/8BdOnT8cVV1yBqKgofPjhhy4NsCNqtZprqntQbaMZFlGCTt76LweVXECdJKG2se2am6OenVOMyvqW5/WN1GJOdgKuHhgLtRsSlis/gLiTWilHpFaFIBWTNv2qrcVj0uNCcM3geFhECblFtZwh4GecSt5Tp051/L1///44evQoqqqqEBER0e0RrgaDAQUFBY7vT506hUOHDiEyMhJ9+vTp1rXJ9cI0Kihl9i5mtaLle2+2SVAKAsI0LVvKZ6vs87O/bKue3TcCc7MTMLKfe+dnu+IDiDspZDJEBCsRqlF65PXJ+106ne9slRHb8srw6o4CLtrip5xK3suXL0dsbCxuv/12x7HIyEisXbsW58+fxyOPPOJ0QPv378eVV17p+L6pS3zBggVYv36909cl90iNDUZSVDBOnjc063IGAAkS6hot6N8rBKmxwfZjF+rZH+0vwncnK1tczx317I505wOIOzXtqR2hVbHFRB1qms63t6ACb1zYyjWQ92D3d04l79deew3vvfdei+MZGRm4+eabu5W8J06cCC9b9I3aIRME3DoqCSu3n0CFwYxQjRIquQCzzZ64tSo5bh2VBJso4b/Hy/FRG/XssCAlZg7pjRlDe7u0nt0ZXf0A0hNUChl6hao5gpy6hIu2BA6nkndZWRni4+NbHO/VqxdKS0u7HRT5lmF9IrD06gGOaVZ1kr2l2r9XCGYNjUd+aR2e23qsnXp2Iq4eGOOWenZndPYDSE8NVgvXqhDh4kVWKDBw0ZbA4VTyTkpKwrfffovk5ORmx7/99lv07t3bJYGRbxnWJwJDksIdC5w0mkXsP1OFv3x2DKY26tk3ZidiRL8IrxjB3d4HkJ6a562U21vbHEVOzuKiLYHDqeR9xx134P7774fFYsGkSZMAAP/973/x8MMP48EHH3RpgOQ7BAD1Zgs25xTj+5NVLR5XygVcNTAWc4YnoH8P1bO74tIPIO5aYe3SVdzS4kIQGaKGTqNga5u6hYu2BA6nkvfDDz+Mqqoq/P73v3dsSqLRaPDII4/gsccec2mA5P0sNhE7jtnr2YXn61s87sl6dlfJBMGt08EuXsXNKtpHsqfGhuD3E1M5iIi6jYu2BI5ubQlqMBiQn5+PoKAgXHbZZV4x35pbgvac2gYLPj1cgi05Ja3Xs6O0mDs8EVd5sJ7tTS5exS0sSAmtUg6LKHHrRnIp7sEeGLxuP+/uYvJ2vzNVRmw8WIQvj5xrtZ49om8E5mYnYmS/7s/79xeiJOGRjbk4ed6AOJ0GiotqkpIkoUxvwsD4ULy1aBRHAVO3cQ92/9f9zX4pIEiShJyzNdhwoKjNevbVA2MxJzsRydE9N6XKVxScq0dRlRFRwapmiRvgKOCeJoqS3+9Nzj3Y/R+TN7XLbBWx43g5NrRRzw4PUmLG0N6YMcR76tnetq2nWimHXC5AlNDmvG2OAu4ZzVqkfr7yGPdg929M3tSq2gYLPvmpBFsOlaCqjXr2jdmJuGpgLFQK79k/2pu29bx4WdMqg5mjgD3s11owVx4j38fkTc10VM8e2c9ezx7R1/vq2d6yradMEBAWpET4RQutcBSwZ3HlMfI3TN7UqXr2VQNjMdeL69nesq1niEaBSG3Luja3bvQsrjxG/obJO4B1pp49c6h9fnaEl3fnenpbT7VSjqjg9vfYbmvrxoHxoX5Zc/UmnV15rKLehNyiWg7yIq/H5B2Aao0WfHK47Xp2vwv17MleVs9uj6e29ezqdp0cBewZnVl5TBRFrPrqZ5TrG/1+MBv5PibvAHKm8kI9+2jr9exR/SIwx0vr2R3xxLaeYUFKp7br5CjgntfRmINyvQlmmw1F1UYOZiOfwOTt5yRJQs6ZGmw46N/zs3tyW0+FzL6BSJCKq8b5ivbGHFTXm2G22aBWyDiYjXwGk7efMltFfH2sHBsOFuFkK/XsCK0SM4b4Rj27M3pqW88QjQLRwWr+EvdBbY05SIrU4myVEZHBHMxGvoPJ28/UGi34+HAJtuQUo9poafG4L9azO8ud23qqlXJEalVsbfu41sYcVBpM+NOGw9xGk3wKk7ef+KWyHhsPFuPLo+dgbqOePTc7Edk+WM/uCldv66mUyxAZrEKwmv9V/MWlYw5yi2q5gA75HP5G8mGSJOHgmRp8dKAI+061Uc8eFIs5w327nt1VrtjWUyGTITxYCV0nR5GT7+ICOuSLmLx9kNkq4r/HyrHxQBFOVvh/PbsnyWUCwoNU0AUp/LqHgn7FBXTIF3FL0E7wli1Ba4xmfPJTKbYcar2enRwdjLnZiZicHuN39Wx3a1rSNCxIyV/SAYrbaJIvYcvbB3RYz06OxNzhCX5fz3YHQRAQqlEgQquCnEk7oHEBHfIlTN5eqqN6tkohw5RBsZgzPAF9owKnnu1KwWoFIoNVULYxypgCDxfQIV/B5O1lOlPPnnlh/+xw1rOdopDJEBXCEeRE5Lv428tLsJ7dM0I1SkQFd31JUyIib8Lk7WGnK+ux8UAxtue3Xc++MTsRw/uEs57dDSEaBcKDVPzgQ0R+gcnbAyRJwoFfqrHhQBH2na5u8bhSLmDKoDjMyU5AP9azuyVUo0S4Vsm6NhH5FSbvHtRUz95woAin2qhnzxqagOuHxLOe3U3cPISI/BmTdw+oMZrx8U8l+M+hklbr2f0v1LMnsZ7tElqVAr1C1Zz6RUR+i8nbjX6prMeGA8X48mgZLLaWi7yMvlDPHsZ6tksIgoAIrZK9FkTk95i8XayjerZKIcPUQbG4gfOzXSpIJUdUsJo9F0QUEJi8XcRsFfHf/HPYcLC47Xr2sATMyOqNMC03u3AVhUyGyBAVQjhnm4gCCH/jdVO10YyPD5Xg45/aqGf3CsaN2Ym4Mo31bFcSBAG6C8uacs42EQUaJm8nnaqox8aDRdh+9Fyr9exRyZH4H9az3SJErUAElzUlogDG5N0FkiRh/4V69o+sZ/c4jVKOyGAVNEpO/yKiwMbk3Qkmqw1fHjmHDQeKcLrS2OLxyGCVfb1x1rPdQimXITKYa5ETETXhb8N2VBhM+Nf3v2D93tOoYT27xylkMoQHK6HT8AMREdHFmLzbsWDtPhwp0bc4Pjo5EjeOSMSwJNaz3UEmCAjXKhEWpOS/LxFRK5i82zFvdF8s25wL4Nd69pzhiegTpfVwZP6paQR5uFbF1dGIiNrB5N2OG4Yn4O3vTmN8ajSuy4xnPduNOIKciKjzmLzboZLL8Lc5WTh2rg7n9CaEBikgYzeuSwWp5IjQcgQ5EVFXMHm3YW9BBVbvKkRhuQGNFhEKGZAUFYxbRyVhWJ8IT4fn8+QyAZHBKoRyMBoRUZexj7IVewsqsGxzLvJL9QhWKxAVrEKQSoGT5w1Yuf0Ecs60nONNnReqUSIxQsvETUTkJCbvS4iihNW7CmEwWRGn00CjlEOQAWqFDNEhKhjNNry37yxEqeWqatQ+pVyG3uFB3K6TiKibmLwvcaREj8JyAyK0qhbTlAQICNUocbayHgXnWm4+Qm0LC1IiMSKItW0iIhdgzfsSVUYzLDYJqjZGPavkAuokCbWN5h6OzDcp5TL0ClUzaRMRuRCT9yUitSoo5QLMNhEaWcuEY7ZJUAoCwjQqD0TnW3RBSkQFt+zBICKi7mG3+SUyeuuQEhOCaqMF0iV1bQkS6hotSIoKRmosNx5pi1wmIC5Mg+gQNRM3EZEbMHlfQiYTsGRCCkLUcpTpTWiw2CCJQKNVRIXBDK1KjltHJXG+dxuC1QokRmihVbFTh4jIXQTp0ualj9Pr9QgLC0NtbS10Op3T12k2z9sqQiFwnnd7lHIZokJUTNpERD2AybsdoijhSIke+WV66NRKpMYGs8V9CblMQLhWBZ1GwS5yIqIewmZSO2QyAZmJYdAFKWAT/eozTrc1bSISoVVBxjnbREQ9ismbukyrUiAyWMU9zImIPITJmzqNdW0iIu/A38LUoaYu8kjO2SYi8gpM3tQutVKO6BAV1AqukEZE5C2YvKlVMkFARLAKYUHc+YuIyNsweVMLTdugKtpY352IiDyLyZscFDL7gLRgNX8siIi8GX9LEwD7lp2cs01E5BuYvAOcSiFDdAi37CQi8iVM3gFKJgiI0KoQpuWANCIiX8PkHYA4II2IyLd57W/vV199FcnJydBoNMjOzsaePXs8HZLPU8hkiNVpEKvTMHETEfkwr/wN/uGHH+L+++/H448/jpycHFxxxRWYNm0azpw54+nQfJYuSInEiCCOJCci8gNeuSXo6NGjMXz4cKxevdpxbODAgZg1axaWL1/e7nNduSVok18q6312VzGlXIZeoRyQRkTkT7yu5W02m3HgwAFMmTKl2fEpU6Zg7969Lc43mUzQ6/XNvsi+HnlksAqJEUFM3EREfsbrkndFRQVsNhtiY2ObHY+NjUVZWVmL85cvX46wsDDHV1JSUk+F6rWCVHIkRgQhXMuNRIiI/JHXJe8mlyYdSZJaTUSPPfYYamtrHV9nz57tqRC9jlwmoFeoGvFhQVByQBoRkd/yutFL0dHRkMvlLVrZ5eXlLVrjAKBWq6FWq3sqPK8VolEgKlgNOVdIIyLye17XPFOpVMjOzsb27dubHd++fTvGjRvnoai8l1IuQ3xYEGJCNUzcREQBwuta3gCwdOlSzJ8/HyNGjMDYsWOxZs0anDlzBr/73e88HZrXEAQB4UFKhGuVrGsTEQUYr0zeN910EyorK/Hss8+itLQUgwcPxtatW9G3b19Ph+YVNEo5okPUUCm8ruOEiIh6gFfO8+4Of57nLZcJiAhWQafheuRERIHMK1ve1BIHpBERURMmby+nlNu37AxScaEVIiKyY/L2UjJBQLhWibAgDkgjIqLmmLy9UIhagUhu2UlERG1g8vYi7CInIqLOYPL2ApyzTUREXcHk7WGcs01ERF3F5O0hgiAgUqtCmJZztomIqGuYvD2ArW0iIuoOJu8eJJcJCNeqEBbE1jYRETmPybsHCIKAsCAlwoOUkHGFNCIi6iYmbzcLvjBnW8k520RE5CJM3m4ilwmIClEjRM1/YiIici1mFjcIUSsQFcJNRIiIyD2YvF1ILhMQHaJGMFvbRETkRswyLsItO4mIqKcweXeTQiZDdKgKWhX/KYmIqGcw43RDqEaJqGAVp38REVGPYvJ2Anf/IiIiT2Ly7iJdkBKRWs+3tkVRwpESPaqMZkRqVcjorfN4TERE1DOYvDtJKZehV6gaGqXnW9t7CyqwelchCssNsNgkKOUCUmJCsGRCCsalRns6PCIicjMu+9UJOo0SiRFBXpO4l23ORX6pHsFqBWJC7VPT8kvrsGxzLvYWVHg6RCIicjMm706ICFZBEDzfJS2KElbvKoTBZEWcTgONUg6ZTIBGKUecTg2DyYbVuwohipKnQyUiIjdi8vYhR0r0KCw3IELb8sOEIAgI1ypRWG7AkRK9hyIkIqKewOTtQ6qMZlhsElRtbHKilstgESVUGc09HBkREfUkJm8fEqlVQSkXYLaJrT5usolQygREalU9HBkREfUkJm8fktFbh5SYEFQbLZCk5nVtSZJQY7QgJSYEGb11HoqQiIh6ApO3D5HJBCyZkIIQtRxlehMaLDaIooQGiw1lehNC1HIsmZDC+d5ERH6OydvHjEuNxnOzMzEwPhRGkxXlBhOMJisGxofiudmZnOdNRBQABOnS/lcfp9frERYWhtraWuh0/tt9zBXWiIgCF1dY81EymYDMxDBPh0FERB7AbnMiIiIfw+RNRETkY5i8iYiIfAyTNxERkY9h8iYiIvIxTN5EREQ+hsmbiIjIxzB5ExER+RgmbyIiIh/D5E1ERORjmLyJiIh8jN+tbd60z4per/dwJERERF0XGhoKQWh/oym/S951dXUAgKSkJA9HQkRE1HWd2RXT77YEFUURJSUlnfrk4sv0ej2SkpJw9uxZv9769FKBet9A4N57oN43ELj3Hqj33SQgW94ymQyJiYmeDqPH6HS6gPzhDtT7BgL33gP1voHAvfdAve/O4IA1IiIiH8PkTURE5GOYvH2UWq3GU089BbVa7elQelSg3jcQuPceqPcNBO69B+p9d4XfDVgjIiLyd2x5ExER+RgmbyIiIh/D5E1ERORjmLyJiIh8DJO3j/jrX/+KcePGQavVIjw8vFPPkSQJTz/9NHr37o2goCBMnDgRR44ccW+gblBdXY358+cjLCwMYWFhmD9/Pmpqatp9zsKFCyEIQrOvMWPG9EzATnr11VeRnJwMjUaD7Oxs7Nmzp93zd+3ahezsbGg0GvTv3x///Oc/eyhS1+vKve/cubPFeysIAo4dO9aDEXff7t27cf3116N3794QBAFbtmzp8Dn+8J539b795f12NSZvH2E2m3HjjTdiyZIlnX7O3/72N6xcuRL/+Mc/8OOPPyIuLg5XX321Y/13X3Hrrbfi0KFD2LZtG7Zt24ZDhw5h/vz5HT7vmmuuQWlpqeNr69atPRCtcz788EPcf//9ePzxx5GTk4MrrrgC06ZNw5kzZ1o9/9SpU7j22mtxxRVXICcnB8uWLcMf//hHbNy4sYcj776u3nuT48ePN3t/L7vssh6K2DXq6+sxZMgQ/OMf/+jU+f7ynnf1vpv4+vvtchL5lHXr1klhYWEdnieKohQXFyc9//zzjmONjY1SWFiY9M9//tONEbrW0aNHJQDS999/7zj23XffSQCkY8eOtfm8BQsWSDNnzuyBCF1j1KhR0u9+97tmx9LT06VHH3201fMffvhhKT09vdmxu+++WxozZozbYnSXrt77jh07JABSdXV1D0TXMwBImzdvbvccf3rPm3Tmvv3x/XYFtrz91KlTp1BWVoYpU6Y4jqnVakyYMAF79+71YGRd89133yEsLAyjR492HBszZgzCwsI6vI+dO3ciJiYGAwYMwJ133ony8nJ3h+sUs9mMAwcONHuvAGDKlClt3uN3333X4vypU6di//79sFgsbovV1Zy59ybDhg1DfHw8Jk+ejB07drgzTK/gL++5swLt/e4Ik7efKisrAwDExsY2Ox4bG+t4zBeUlZUhJiamxfGYmJh272PatGl499138fXXX+Oll17Cjz/+iEmTJsFkMrkzXKdUVFTAZrN16b0qKytr9Xyr1YqKigq3xepqztx7fHw81qxZg40bN2LTpk1IS0vD5MmTsXv37p4I2WP85T3vqkB9vzvid7uK+ZKnn34azzzzTLvn/PjjjxgxYoTTr3HptnKSJHnFVqmdvXeg5T0AHd/HTTfd5Pj74MGDMWLECPTt2xefffYZbrjhBiejdq+uvletnd/acV/QlXtPS0tDWlqa4/uxY8fi7NmzWLFiBX7zm9+4NU5P86f3vLMC+f1uD5O3B/3hD3/AzTff3O45/fr1c+racXFxAOyf1uPj4x3Hy8vLW3x694TO3vvhw4dx7ty5Fo+dP3++S/cRHx+Pvn374ueff+5yrO4WHR0NuVzeoqXZ3nsVFxfX6vkKhQJRUVFui9XVnLn31owZMwb/+te/XB2eV/GX99wVAuH97giTtwdFR0cjOjraLddOTk5GXFwctm/fjmHDhgGw1xd37dqFF154wS2v2RWdvfexY8eitrYW+/btw6hRowAAP/zwA2prazFu3LhOv15lZSXOnj3b7IOMt1CpVMjOzsb27dsxe/Zsx/Ht27dj5syZrT5n7Nix+OSTT5od+/LLLzFixAgolUq3xutKztx7a3JycrzyvXUlf3nPXSEQ3u8OeXK0HHXeL7/8IuXk5EjPPPOMFBISIuXk5Eg5OTlSXV2d45y0tDRp06ZNju+ff/55KSwsTNq0aZOUm5sr3XLLLVJ8fLyk1+s9cQtOu+aaa6SsrCzpu+++k7777jspMzNTmj59erNzLr73uro66cEHH5T27t0rnTp1StqxY4c0duxYKSEhwWvv/YMPPpCUSqX05ptvSkePHpXuv/9+KTg4WDp9+rQkSZL06KOPSvPnz3ecf/LkSUmr1UoPPPCAdPToUenNN9+UlEqltGHDBk/dgtO6eu8vv/yytHnzZunEiRNSXl6e9Oijj0oApI0bN3rqFpxSV1fn+H8MQFq5cqWUk5Mj/fLLL5Ik+e973tX79pf329WYvH3EggULJAAtvnbs2OE4B4C0bt06x/eiKEpPPfWUFBcXJ6nVauk3v/mNlJub2/PBd1NlZaU0b948KTQ0VAoNDZXmzZvXYtrIxfduNBqlKVOmSL169ZKUSqXUp08facGCBdKZM2d6Pvgu+L//+z+pb9++kkqlkoYPHy7t2rXL8diCBQukCRMmNDt/586d0rBhwySVSiX169dPWr16dQ9H7DpdufcXXnhBSklJkTQajRQRESGNHz9e+uyzzzwQdfc0TYG69GvBggWSJPnve97V+/aX99vVuCUoERGRj+FUMSIiIh/D5E1ERORjmLyJiIh8DJM3ERGRj2HyJiIi8jFM3kRERD6GyZuIiMjHMHkTERH5GCZvIiIiH8PkTdSBiRMn4v7773f5dSsrKxETE4PTp0+7/NrkfnPnzsXKlSs9HQYFKCZvIg9Zvnw5rr/+ese2rwsXLoQgCBAEAUqlErGxsbj66quxdu1aiKLoeF7TOW19LVy40DM3FGD+/Oc/469//Sv0er2nQ6EAxORN5AENDQ148803cccddzQ7fs0116C0tBSnT5/G559/jiuvvBL33Xcfpk+fDqvVCgAoLS11fP3973+HTqdrdmzVqlWeuKWAk5WVhX79+uHdd9/1dCgUgJi8ibrAZDLhj3/8I2JiYqDRaDB+/Hj8+OOPzc6pq6vDvHnzEBwcjPj4eLz88sstut4///xzKBQKjB07ttlz1Wo14uLikJCQgOHDh2PZsmX4z3/+g88//xzr168HAMTFxTm+wsLCIAhCi2PUM2bMmIH333/f02FQAGLyJuqChx9+GBs3bsRbb72FgwcPIjU1FVOnTkVVVZXjnKVLl+Lbb7/Fxx9/jO3bt2PPnj04ePBgs+vs3r0bI0aM6NRrTpo0CUOGDMGmTZtcei/UfaNGjcK+fftgMpk8HQoFGCZvok6qr6/H6tWr8eKLL2LatGkYNGgQXn/9dQQFBeHNN98EYG91v/XWW1ixYgUmT56MwYMHY926dbDZbM2udfr0afTu3bvTr52ent6lgW0KhQJDhw7F0KFDW3TNf/rpp0hLS8Nll12GN954o9PX9AVbtmzp0uDCCRMmdGvAYEJCAkwmE8rKypy+BpEzFJ4OgMhXFBYWwmKx4PLLL3ccUyqVGDVqFPLz8wEAJ0+ehMViwahRoxznhIWFIS0trdm1GhoaoNFoOv3akiRBEIROnx8eHo5Dhw61OG61WrF06VLs2LEDOp0Ow4cPxw033IDIyMhOX9ubHT58GFlZWZ0+//Tp044Bg84ICgoCABiNRqevQeQMtryJOkmSJABokUQvTqztnXOx6OhoVFdXd/q18/PzkZyc3OWYL7Vv3z5kZGQgISEBoaGhuPbaa/HFF1+0ef7hw4cxduxYZGVl4bnnnsP06dMBANOmTcPSpUsxZswYpKen48cff8SMGTPQt29frFmzBgBw/PhxXHvttcjOzsbEiRNRUVEBAHjnnXcwevRoZGZmYsaMGTCbzY5rPvXUUxgzZgz69u2Lo0ePthnXa6+9huHDh2Pw4MG49dZbm8WblZWFrKwsx7/vt99+iwULFgAAjhw5gjFjxmDIkCFYuXIlkpKSOrzXtu4DgKNc0qtXr06+A0SuweRN1EmpqalQqVT45ptvHMcsFgv279+PgQMHAgBSUlKgVCqxb98+xzl6vR4///xzs2sNGzas3eR0sa+//hq5ubmYM2dOp2PV6/XIzs7G+PHjsWvXLsfxkpISJCQkOL5PTExEcXFxq9ewWCxYsGAB1q1bh8OHD+Obb75BZmYmACAvLw9ZWVn4/vvvMWrUKDzyyCN4//338Z///Afr1q2DyWTCPffcgzVr1uDAgQOYO3euo4v+2muvxQ8//IDc3FxER0djz549jmsmJyfj+++/x5133olPPvmk1biqq6uxZs0a/Pjjj8jLy8Orr77qeOzIkSNIS0uDwWBAREQEAHtSzsjIQENDA26++WasXbsWP/30E3bu3Olopbd1r+3dR1PMiYmJiI6O7vR7Q+QK7DYn6qTg4GAsWbIEf/rTnxAZGYk+ffrgb3/7G4xGIxYvXgwACA0NxYIFCxznxMTE4KmnnoJMJmvWGp86dSoee+wxVFdXO5IMAEf91Gaz4dy5c9i2bRuWL1+O6dOn47bbbut0rE019by8PFx33XXIzc2FTqdr0QMAtOwlaLJhwwZcfvnlSE9PBwAMHDgQWVlZqK2thUqlcswn12g0uO+++xAcHAy1Wo2wsDBs2bIFR48edbReTSYT7rjjDkiShDVr1mDTpk0wm804c+YMFi9ejNraWiiVSsc1VSpVm6PmFQoFKisr8cgjj2DRokXIyMgAYO+6lslkOHPmDAYMGOA4//Dhw5g+fTo2b96MiRMnYtCgQQCAtLQ0pKSktHuvbd1Hkz179mDKlCkdvyFELsaWN1EXPP/885gzZw7mz5+P4cOHo6CgAF988UWzBLxy5UqMHTsW06dPx1VXXYXLL78cAwcObFbjzszMxIgRI/Dvf/+72fW3bduG+Ph49OvXD9dccw127NiBV155Bf/5z38gl8s7HWfTYLjBgwdj0KBBOHHiBAD7AKuLW9pFRUWIj49v9RpNresmR44cQVZWFvLy8jBy5EjH8dzcXIwePdrx98GDByM3NxcvvfQSDh06hEOHDiE/Px8PPvgg1q9fj4KCAuzevRs//fQTdDodBg0ahLy8vGbjBPLy8hxJ+VKhoaHIzc3FkCFDMHfuXHz66afNnpOXl4fBgwc7zt+/fz8GDx7siL/JwYMHHd+3da9t3QcANDY2YvPmzbjzzjvbfB+I3IXJm6gDO3fuxN///ncA9lbmK6+8gvPnz6OxsRHffPNNs0QG2JPLu+++i/r6epSWluKuu+7C8ePHkZqa2uy8J598EqtWrXKsnrZ+/XpIkgRJkmCxWFBeXo7t27dj0aJFkMla/6+6cOFC1NTUNDtWXV3tmLpUVFSEo0ePon///gDsU5vy8vJQXFyMuro6bN26FVOnTgUATJ48uVlij4qKcnT3f/3119i9ezfS0tKQl5fn6D6XJAnnzp1DXFwcADgei4uLa1ZLz83NBWBPiuPGjUNQUJDj3iMiIppds+n8ixPwxbH9/PPPCA0Nxfz583HFFVc47rWp3l1VVeUYSLZ7924cP34cffr0QVRUlKNU8eWXX2Lnzp2O12zrXtu6DwB48803MXr0aIwZM6bV94bIndhtTuRiOTk5OHbsGEaNGoXa2lo8++yzAICZM2c2O+/aa6/Fzz//jOLi4mYDp7orPz8fd999t6OrftWqVY7R5AqFAi+99BKuvPJKiKKIhx9+GFFRUZAkCQUFBc1Gnf/2t7/FtddeizFjxmDcuHEYPXo0FAoFjhw5gquuugpAy9HaeXl5mDVrFtLS0vDVV18hPT0darUa1157LZYvX4758+dj5syZePvttzFhwgRH8rz4mlarFQaDAeHh4QDQIrb//d//xQ8//ACtVosrrrgCs2fPBmBPrJMnT0ZmZiauv/56FBYWIjU1FQMHDoQgCPjtb3+LadOmOQa6JScnIzQ0tN17XbRoUav3AdhnGvy///f/XPa+EXWFILVWBCMip+Xk5OCOO+7A8ePHoVKpkJ2djZUrVzZrWXqb/Px8vP7668022qivr0dwcLAjyQ8cONBR2/d0bK7mLfdK1FlM3kTUqqeeegobN26EQqHAddddh7/85S9dmmvuSwLpXsk/MHkTERH5GA5YIyIi8jFM3kRERD6GyZuIiMjHMHkTERH5GCZvIiIiH8PkTURE5GOYvImIiHwMkzcREZGPYfImIiLyMUzeREREPobJm4iIyMcweRMREfmY/w8oZ6B0vvDtgQAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 500x500 with 1 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "from scipy import stats\n",
     "\n",
     "model1 = ols('hl_log_gmean_x ~ hl_log_gmean_y_calculated', data=df_read_across).fit(cov_type = 'HC3')\n",
     "\n",
     "MSE = np.square(np.subtract(df_read_across['hl_log_gmean_x'], df_read_across['hl_log_gmean_y_calculated'])).mean()   \n",
     "rmse = math.sqrt(MSE) \n",
     "\n",
     "slope, intercept, r_value, p_value, std_err = stats.linregress(df_read_across['hl_log_gmean_x'],df_read_across['hl_log_gmean_y_calculated'])\n",
     "sns.lmplot(data=df_read_across, x=\"hl_log_gmean_x\", y=\"hl_log_gmean_y_calculated\", ci=95, line_kws={'label':\"y={0:.2f}x+{1:.2f}\".format(slope, intercept)}).set(xlabel='log(DT$_{50, gmean, sludge}$)', ylabel='calculated log(DT$_{50, gmean, soil}$)')\n",
     "plt.annotate('R$^2$: {}'.format(round(model1.rsquared_adj,2)), (-1, 4))\n",
     "plt.annotate('RMSE: {}'.format(round(rmse, 2)), (-1,3.7))\n",
     "plt.legend()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 116,
+   "execution_count": 166,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x1e922674bb0>"
+       "<matplotlib.legend.Legend at 0x1e92288d4c0>"
       ]
      },
-     "execution_count": 116,
+     "execution_count": 166,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe8AAAHvCAYAAAB9iVfNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB7qUlEQVR4nO3deXhU1f0G8PfOnsnMZCULJGwJYQkJsooosghBrApUbd0QrFpFXBD1V4ut2kVtK4KgkqogWOtWbcG6FImySymySRIiIYGYQBJC1slkMtud+/sjZMiQBLJMMtv7eR6eh5yZuXNmCPPOPfec7xEkSZJAREREfkPm7Q4QERFR5zC8iYiI/AzDm4iIyM8wvImIiPwMw5uIiMjPMLyJiIj8DMObiIjIzzC8iYiI/EzQh7ckSTAajWCtGiIi8hdBH9719fUICwtDfX29t7tCRETUIUEf3kRERP6G4U1ERORnGN5ERER+huFNRETkZxjeREREfkbh7Q74C1EUYbfbvd0NChBKpRJyudzb3SAiP8XwvgRJklBeXo7a2lpvd4UCTHh4OOLi4iAIgre7QkR+huF9Cc3BHRMTA61Wyw9a6jZJkmA2m1FRUQEAiI+P93KPiMjfMLwvQhRFV3BHRUV5uzsUQEJCQgAAFRUViImJ4RA6EXUKJ6xdRPM1bq1W6+WeUCBq/r3iXAoi6iyGdwdwqJx6An+viKirGN5ERER+huFNRETkZxje1CFr1qzBoEGDoNFoMHbsWOzateuSj7FarXj66acxYMAAqNVqJCUl4e2333bd/tZbb2Hy5MmIiIhAREQEZsyYgX379vXkywDQtdfy3nvvYdSoUdBqtYiPj8fdd9+NqqqqNu/74YcfQhAEzJ0718M9JyJqwvCmS/roo4+wZMkSPP300zh06BAmT56M2bNno7i4+KKP+9nPfoZvvvkG69atw7Fjx/DBBx9g2LBhrtu3b9+O2267Ddu2bcN///tf9O/fHxkZGTh9+nSX+/rcc89h4cKFHn0tu3fvxl133YV77rkHubm5+Pjjj/Hdd9/h3nvvbXXfH3/8EU888QQmT57c5ddARHRJUpCrq6uTAEh1dXWtbmtsbJSOHj0qNTY2utqcTqdUa7Z55Y/T6ezQa3rnnXekyMhIyWKxuLX/9Kc/lebPn9/p92jChAnSAw884NY2bNgw6amnnmr3Mf/5z3+ksLAwqaqqqsPP43A4JL1eL73zzjuSJElSRUWFFBsbKz3//POu++zdu1dSKpXSV1991eYxnn32WWnBggUefS0vvfSSNHjwYLe21atXSwkJCa36f+WVV0pr166VFixYIM2ZM6fdY0pS279fREQdwXXenWS0ODDqd1u88tzfP5uBsBDlJe93yy234JFHHsG///1v3HLLLQCAyspKfP7559i8eTN27dqF2bNnX/QYy5Ytw7Jly2Cz2XDgwAE89dRTbrdnZGRgz5497T7+3//+N8aNG4e//OUvePfddxEaGoobb7wRf/jDH1xrnC9kNptht9sRGRkJAOjTpw/efvttzJ07FxkZGRg2bBjuvPNOPPjgg8jIyLjk+3Chrr6WSZMm4emnn8aXX36J2bNno6KiAp988gl+8pOfuN3v97//Pfr06YN77rmnQ0PxRERdxfAOQCEhIbj99tuxfv16V3i/9957SEhIwNSpU2GxWHD48OGLHqM5QCsrKyGKImJjY91uj42NRXl5ebuPP3HiBHbv3g2NRoONGzeisrISDz74IKqrq92ue7f01FNPoV+/fpgxY4ar7brrrsN9992HO+64A+PHj4dGo8Gf/vSnjrwNrXT1tUyaNAnvvfcefv7zn8NiscDhcODGG2/Eq6++6rrPt99+i3Xr1l3yfSUi8gSGd4C67777MH78eJw+fRr9+vXD+vXrsXDhQgiCgJCQECQnJ3fqeBeuSZYk6aLrlJ1OJwRBwHvvvYewsDAAwIoVK3DzzTfj9ddfb3X2/Ze//AUffPABtm/fDo1G43bb8uXLMXLkSPzjH//A/v373W6/cBTBZrNBkiR88sknrrbmUYSuvpajR4/ikUcewTPPPINZs2ahrKwMTz75JB544AGsW7cO9fX1uPPOO/HWW28hOjq63eMQUeCx2EWo5DLIZL1bt4Hh3UkGjQLfP9v5IVtPPXdHjR49GqNGjcLf/vY3zJo1C9nZ2fjss88AtA68tjQHXnR0NORyeasz04qKilZnsC3Fx8ejX79+ruAGgOHDh0OSJJw6dQpDhgxxtS9fvhwvvPACvv76a6Snp7c61okTJ1BaWgqn04kff/zR7T7jxo1zO9tdvXo1Tp8+jT//+c+utuZRhK6+lhdffBFXXnklnnzySQBAeno6QkNDMXnyZPzxj3/EmTNnUFRUhBtuuMH1GKfTCQBQKBQ4duwYkpKS2j0+EfmnRpuIcqMF/SN7vwonw7uTBEHo0HVnX3Dvvfdi5cqVOH36NGbMmIHExEQArQOvLc2Bp1KpMHbsWGRlZWHevHmu27OysjBnzpx2H3/llVfi448/hslkgk6nAwDk5+dDJpMhISHBdb+XXnoJf/zjH/HVV19h3LhxrY5js9lwxx134Oc//zmGDRuGe+65B9nZ2a6wvXAUITIyEkajsc2Rha6+FrPZDIXC/b9Kcy1ySZIwbNgwZGdnu93+m9/8BvX19Vi1apXrfSeiwNEc3JIkeacD3pwt5ws6O9vcn9TV1UlarVZSqVTShx9+2OXjfPjhh5JSqZTWrVsnHT16VFqyZIkUGhoqFRUVue7z1FNPuc1kr6+vlxISEqSbb75Zys3NlXbs2CENGTJEuvfee133+fOf/yypVCrpk08+kcrKylx/6uvrXfd54oknpIEDB0p1dXWSKIrS1VdfLf3kJz9pt6+Xmm3eldeyfv16SaFQSGvWrJEKCwul3bt3S+PGjZMmTJjQ7vNwtjlR4DJbHdKJsyapsKJeKqyolxxix1YCeRLDO4DDW5Ikaf78+W0uG+us119/XRowYICkUqmkMWPGSDt27HC7fcGCBdKUKVPc2vLy8qQZM2ZIISEhUkJCgrR06VLJbDa7bh8wYIAEoNWfZ599VpIkSdq2bZukUCikXbt2uR7z448/SmFhYdKaNWva7Oelwrurr2X16tXSiBEjpJCQECk+Pl664447pFOnTrX7HAxvosB0YXB7K7wFSfLWOb9nZGZmIjMzE0VFRQCA1NRUPPPMM5e8ptvMaDQiLCwMdXV1MBgMbrdZLBacPHnSVY3LH82cORPDhw/H6tWrvd0VukAg/H4RBROzzYEzRmurofIBUaGQc8Ja5yQkJOBPf/qT6xrnO++8gzlz5uDQoUNITU31cu+8p7q6Glu2bMHWrVvx2muvebs7RER+zWR14Gx96+D2Fr8P75YzfAHg+eefR2ZmJvbu3RvU4T1mzBjU1NTgz3/+M4YOHert7hAR+a16ix1n662t2p2ShIIzDfixyoxonRqpfQ29tmTM78O7JVEU8fHHH6OhoQFXXHFFm/exWq2wWs//IxiNxt7qXq9qvoxARERd13zGfaFDxTV4f18JSqoa4JQAlUKGpBgdFk1JwqTknq/3EBAbk2RnZ0On00GtVuOBBx7Axo0bMWLEiDbv++KLLyIsLMz1h8t4iIioLQ0XCe4VWfk4cdaEEJUCMXo1QtUK5JXVY9nGbOwpqOzxvgVEeA8dOhSHDx/G3r17sWjRIixYsABHjx5t876//vWvUVdX5/pTUlJyyeP7yjUOCiz8vSLyXWabAxVtXON2ShLe31cCs01EtE4FtaKpuppGKUecQQ2TVUTmjkI4nT37/zsghs1VKpVrwtq4cePw3XffYdWqVXjjjTda3VetVkOtVnfouEplUzEWs9nc7mYaRF1lNpsBnP89IyLf0N6scgAoONOAkqoGGDRKCHC/vi0IAsK1ShRWmJBbakRaQlirx3tKQIT3hSRJcruu3VVyuRzh4eGoqKgAAGi12ovWwCbqCEmSYDabUVFRgfDwcFe1NiLyvkvNKq+z2GB3SjDI284CtVyGOqeEarOtJ7vp/+G9bNkyzJ49G4mJiaivr8eHH36I7du3Y/PmzR45flxcHAC4ApzIU8LDw12/X0TkfUaLHZVtXONuKUyjglImwC5KUCtaB7hVdEIpExCpVfVUNwEEQHifOXMG8+fPR1lZGcLCwpCeno7Nmzdj5syZHjm+IAiIj49HTEwM7Ha7R45JpFQqecZN5ENqzTZUN1z6bDk5NhSJUaE4cdaEaJ3KbehckiTUmu0YHq9Hal/DRY7SfX5fYa27LlZhjYiIAl+VyYq6xo6fnDXPNjfbROg1SuhUcticTcGtU8vxwry0Hl8uxvBmeBMRBSVJknC23gqT1dHpx7qt8wagkvfuOm+GN8ObiCjoOJ0SztRb0GgTu36McxXW1EoZK6wREVH3OZ0SckuNqDbbEKlV9Wqw+DrRKaGsrhE2h7Nbx5EJAlLidNyYhIiIum9PQSUydxSisMIEuyhBKRd6dUjXlzlEJ8rqLLCL3QtubwuICmtERNRkT0Ellm3MRl6ZEaFq75Tu9FWBEtwAw5uIKGA4nRIydxTCZHUgzqCBRin3SulOX2QPoOAGGN5ERAEjt9SIwgoTIrSqVtUgLyzdGUzsohPlARTcAMObiChgVJttsIsSVPK2P9rVchnsvVC605fYRSfKagMruAGGNxFRwIjUqqCUC7C1E1S9VbrTV9gcTcHtcAZWcAMMbyKigJHa14CkGB1qzPZWG2s0l+5MitH1eOlOX2BzNA2VB2JwAwxvIqKAIZMJWDQlCTq1HOVGKxrtIpxOCY12EeVGK3RqORZNSQr49d5Wh4iyusaADW6A4U1EFFAmJUfjhXlpGB6vh9nqQIXJCrPVgeHx+l6pue1tFruI8joLxACfUc8iLUREAWZScjQmDo4KugprjTYRZ4wWOIOg6jfDm4goAMlkAtISwrzdjV5jtjlwxmhtda0/UDG8iYjIr5msDpytD57gBhjeRETkx4wWOyrrrd7uRq9jeBMRkV+qM9tR1RB8wQ0wvImIyA9VN9hQG0SV4i7E8CYiIr8hSRLOmqwwWRze7opXcZ13ACopKcHUqVMxYsQIpKen4+OPP/Z2l4iIus3plHDGyOAGAEEKpul5bTAajQgLC0NdXR0MhsAoGVhWVoYzZ87gsssuQ0VFBcaMGYNjx44hNDTU210jIuoS0Smh3GiB1S56uyutDIgKhbyX19Bz2DwAxcfHIz4+HgAQExODyMhIVFdXM7yJyC/ZHE6cMQbezmDdwWFzP7Rw4UIIggBBEKBQKNC/f38sWrQINTU1re67f/9+OJ1OJCYmdvp51qxZg0GDBkGj0WDs2LHYtWvXRe+fmZmJ9PR0GAwGGAwGXHHFFfjPf/7jdh+Hw4Hf/OY3GDRoEEJCQjB48GD8/ve/hzOAaxATUddZ7E11yhnc7hjefuraa69FWVkZioqKsHbtWnz22Wd48MEH3e5TVVWFu+66C2+++Wanj//RRx9hyZIlePrpp3Ho0CFMnjwZs2fPRnFxcbuPSUhIwJ/+9Cfs378f+/fvx/Tp0zFnzhzk5ua67vPnP/8Zf/3rX/Haa68hLy8Pf/nLX/DSSy/h1Vdf7XQfiSiwmawOlAVBnfKu4DVvP7zmvXDhQtTW1mLTpk2utscffxwbNmxAVVUVAMBqtWLmzJm47777MH/+/E4/x+WXX44xY8YgMzPT1TZ8+HDMnTsXL774YoePExkZiZdeegn33HMPAOD6669HbGws1q1b57rPTTfdBK1Wi3fffbfT/SSiwFRrtqG6wT+WgnnjmjfPvAPAiRMnsHnzZiiVSgBNSykWLlyI6dOntxncGzZsgCC0/4tms9lw4MABZGRkuLVnZGRgz549HeqTKIr48MMP0dDQgCuuuMLVftVVV+Gbb75Bfn4+AOD777/H7t27cd1113XouEQU+CpNVr8Jbm/hhDU/9fnnn0On00EURVgsFgDAihUrAADffvstPvroI6Snp7vOzt99912kpaUBAMLCwjB06NB2j11ZWQlRFBEbG+vWHhsbi/Ly8ov2Kzs7G1dccQUsFgt0Oh02btyIESNGuG7/1a9+hbq6OgwbNgxyuRyiKOL555/Hbbfd1un3gIi6zumUurTrWFcf1xGSJOFsvRUmK5eCXQrD209NmzYNmZmZMJvNWLt2LfLz8/Hwww8DaDq7vdgEsHnz5mHevHmXfI4Lz84lSbroGTsADB06FIcPH0ZtbS3++c9/YsGCBdixY4crwD/66CP8/e9/x/vvv4/U1FQcPnwYS5YsQd++fbFgwYJL9omIum9PQSUydxSisMIEuyhBKReQFKPDoilJF93vu6uP6wjnuaVgFh9cCuaLOGzup0JDQ5GcnIz09HSsXr0aVqsVv/vd7zxy7OjoaMjl8lZn2RUVFa3Oxi+kUqmQnJyMcePG4cUXX8SoUaOwatUq1+1PPvkknnrqKdx6661IS0vD/Pnz8dhjj3XqOjoRdd2egkos25iNvDIjQtUKxOjVCFUrkFdWj2Ubs7GnoNKjj+sIp1NCGYO7UxjeAeLZZ5/F8uXLUVpa2u1jqVQqjB07FllZWW7tWVlZmDRpUqeOJUkSrNbzGweYzWbIZO6/dnK5nEvFiHqB0ykhc0chTFYH4gwaaJRyyGQCNEo54gxqmKwiMncUwnnB7O6uPq4jxHPB7YvFV3wZwztATJ06FampqXjhhRcued+NGzdi2LBhF73P0qVLsXbtWrz99tvIy8vDY489huLiYjzwwAOu+7z22mu45pprXD8vW7YMu3btQlFREbKzs/H0009j+/btuOOOO1z3ueGGG/D888/jiy++QFFRETZu3IgVK1Z0aBifiLont9SIwgoTIrSqVpfABEFAuFaJwgoTckuNHnncpYhOCWV1jQzuLuA17wCydOlS3H333fjVr3510aIsdXV1OHbs2EWP9fOf/xxVVVX4/e9/j7KyMowcORJffvklBgwY4LpPZWUlCgsLXT+fOXMG8+fPR1lZGcLCwpCeno7Nmzdj5syZrvu8+uqr+O1vf4sHH3wQFRUV6Nu3L+6//34888wz3XjlRNQR1WYb7KIElbzt8za1XIY6p4TqC3br6urjLqY5uG0Ojrp1Bdd5++E6byKirsg+VYf7392PULUCGqW81e2NdhFmqwNvzB+HtISwbj+uPYEU3JIkwSZKGB7fu/nBYXMioiCR2teApBgdasx2XHjeJkkSas12JMXokNrX4JHHtSWQgrusrhH/989szH39W5ysbOjV52Z4ExEFCZlMwKIpSdCp5Sg3WtFoF+F0Smi0iyg3WqFTy7FoSlKrddtdfdyFAiW4RaeETw6cwj0b9uPAjzWwOpz49b+OtPpi05MY3kREQWRScjRemJeG4fF6mK0OVJisMFsdGB6vxwvz0tpdr93VxzULlOA+WdmARz48hDXbC2Fp8VpClPJeLS7Da9685k1EQag3K6zZRSfK6/x7S0+bw4n39xXj/f8Vw9FiSVxYiBLP3TACc0f3u2QRK09ieDO8iYh6jM3RFNwOP67lcLTUiJe2HMOPVWa39hnDY7B4ajLSE8N7fWMSLhUjIqIeYXWIKPfjLT0bbSLWfXsSGw+eRstXEKNX47GZQ3D5oCiv9Y3hTUTUw3pyMw9fZbY5UGG0wumng7vfFVVjRVY+zhjPV4gUANx4WV/cN3kQtCrvxifDm4ioB/XkZh6+yp/24r5QXaMdmdsLseXoGbf2/pFaPJGRgpH9Lr2OvTfwmjeveRNRD2nezMNkdSBCq4JKLoNNdKLGbIdOLe/QLG1/4s9bekqShO3HzuLVrQWobbS72uUyAbeOT8T8iQOgUrS9QGtAVCiveRMRBYILN/NonomskckRZ5Ch3GhF5o5CTBwcFRBD6OK5LT39sU752XorVn1zHHsKq9zah8bq8cSsFCT10XmpZ+1jeBMR9YDObObRkZKivsxfl4I5JQlfZpfhjR0n0GA7/6VDrZBh4aSBuHlsQq+fUXcUw5uIqAf0xGYevshiF3HG6H8zykuqzViRlY/vT9W5tY/uH46lM1PQLzzESz3rGIY3EVEPiNSqoJQLsIlOaGStN/Owik4oZQIitSov9M4zGm1Nwe1PM8pFp4R/7C/Bhj1FsIvn+x16rsTr7JFxvVpspasY3kREPaB5M4+8snrEGWRugdC8mcfweH2HNvPwRXVmO6oarJe+ow85fqYeL23JR0GFya198pBoPDI9GVE6tZd61nkMbyKiHtC8mceyjdkoN1oRrlVCLZfBKjpRe262eUc28/A1kiThrMkKk8V/ZpRb7SL+tvdHfPRdCVqO7keGqvDINcm4ekgf73Wui7hUjEvFiKgHua3zdkpQyvx3nbdddOKM0eJXm4t8f6oWL2/Jx6maRrf22SPj8MCUwdBrlN1+Di4VIyIKMJOSozFxcJTfV1hrsDpQabL6zcQ0k9WBt3aewGdHytza48M0eHxmCsYMiPBSzzyD4U1E1MNkMsFvl4NJkoSqBhuMLQqX+LpvCyqx6pvjqDSdn8kvE4CbxiTg7isHQqNsPYHQ3zC8iYioTf42TF5jtuG1rQXYduysW/vg6FA8MSsFw+IC59Iow5uIiFrxp/XbkiQh6+gZrNleCGOLiXRKuYA7Lx+AWyckQtnOent/xfAmIiI3/rR+u9xowcqsfHxXVOPWntrXgCcyUjAgKtRLPetZDG8iInIxWR04W2+Fry9EEp0SPj18Gmt3n4TFfn5YP0Qpx72TB2HOZX0h84NiK13F8CYiIgD+s5VnUVUDln91DEfL6t3aJwyKxGMzhiDWoPFSz3oPw5uIKMg5nU2FVxp8fCtPu+jEB/uK8fe9xXC0uBZv0Cjw0PRkXDMsxi9Km3oCw5uIKIjZHE0zyn19R7C8MiOWb8nHycoGt/ZrhsVg8bQkhPtxjfiuYHgTEQUpf5iY1mgX8fbuk/jXwdNo2cs+OjUemzkEEwdHea1v3sTwJiIKQvUWOypNNp+emLa/qBorso6j3Ghxa58zqi/unTwIoergjbDgfeVEREHK1yemGRvtyNxRiK9yz7i1J0aE4ImMoX5brc6TGN5EREGk0mT12VKnkiRhR34lXt16HDXm832UCcBtE/pj/sQBUCkCq9hKVzG8iYiCgOiUUFFvQaNN9HZX2lRpsmLV18fxbWGVW/uQGB2enDUUyTE6L/XMNzG8iYgCnMUuosJohcPpezPKJUnCF9nleGNnIRqs579YqBQyLJw0ELeMTej17Tb9AcObiCiAGS12VPnoxLTTNY14OesYDpfUubVflhiOx2emoF9EiJd65vsY3kREAaq6wYZas/vENKckoeBMA+osNoRpVEiODe31MqKiU8LHB05hw54itx3LQtVyPHB1Eq5LiwuaYitdxfAmIgpAZ+utqLe4T0w7VFyD9/eVoKSqAXanBKVMQGJUKG6fkIjR/SN6pV8FFSYs33IM+WdMbu1XJkfh0WuGIFqn7pV++DtB8sWxlF5kNBoRFhaGuro6GAyBs9crEQUnSZJwxmiF2eZe6vRQcQ1WZOXDbBNh0CihlAuwixKMFju0KjmWzkzp0QC3OZz423+L8OF3JWi5y2iEVolHrhmCq4dE++3Z9oCo0F6/Ls8zbyKiAOEQnThTb4XV7j6j3ClJeH9fCcw2EdE6FQQ0BY1aISBap0KlyYb395VgVGJ4jwyhHzlVi+Vb8nGqptGtfVZqLBZNSYIhROnx5wx0fr1g7sUXX8T48eOh1+sRExODuXPn4tixY97uFhFRr7M6RJTWWloFNwAUnGlASVUDDBqlK7ibCRCg1yhRUtWAgjMNrR7bHQ1WB175+jiWfPS9W3DHGTT4y01p+NW1wxjcXeTX4b1jxw4sXrwYe/fuRVZWFhwOBzIyMtDQ4NlfQCIiX9ZgdaC01tLuUrA6i63pGre87bNqlVyAXZJQZ/Fc1bX/FlbhFxv249/fl7raBAA3jemHdQvHYdzASI89VzDy62HzzZs3u/28fv16xMTE4MCBA7j66qu91CsiChROp4TcUiOqzTZEalVI7WuAzMfWHHek1GmYRgWlrOkat1rRuv82UYJSEBCm6f7OXLVmG17bVoitP1S4tQ+M0uLJWUMxPJ5zizzBr8P7QnV1TWsFIyPb/0ZntVphtVpdPxuNxh7vFxH5nz0FlcjcUYjCChPsYtNZa1KMDoumJGFScrS3uwdJklBpsrWaUd6W5NhQJEaF4sRZk9s1bwCQIKHeYsfgPjokx4Z2qz9f51Xg9W0FMFrOT5ZTyATcObE/bpvQH0q5Xw/2+pSAmW0uSRLmzJmDmpoa7Nq1q937Pffcc/jd737Xqp2zzYmo2Z6CSizbmA2T1YEIrQoquQw20Ykasx06tRwvzEvzaoA7nRLOdLLUacvZ5nqNEiq5AJvYFNzdnW1+xmjByq+PY9/Jarf2EfF6PJ4xFIOiu/6lwB94Y7Z5wIT34sWL8cUXX2D37t1ISEho935tnXknJiYyvIkIQFMwLli/D3llRsQZNG7LlyRJQrnRiuHxerxz9wSvDKE7RCfKjRa34iYd5bbOW2oaKu/OOm+nJOHTw6VYu+skGltMlNMoZbj3qkGYc1m/oChtyqViXfTwww/j3//+N3bu3HnR4AYAtVoNtZpFAIiobbmlRhRWmBChVbVadywIAsK1ShRWmJBbauz1rSlNVgcq661wdvGca3T/CIxKDPdIhbUfqxqwfEs+ckvdLz2OHxiBx2akIC5M06U+Usf4dXhLkoSHH34YGzduxPbt2zFo0CBvd4mI/Fy12Qa7KEHVzvVZtVyGOqeEanPv7YftdEqoNFlhsjoufedLkAkCUuK6vkOXXXTiw+9K8Pe9P8Iunv8SYdAo8OC0ZMwcHuO3xVb8iV+H9+LFi/H+++/j008/hV6vR3l5OQAgLCwMISEsaE9EnRepVUEpF2ATndDI5K1ut4pOKGUCIrUdn5ndnVnrvrQj2A/lRiz/Kh8nKt2X404b2gcPTU9GRCfeE+oevw7vzMxMAMDUqVPd2tevX4+FCxf2foeI/Iw/LIXqbal9DUiK0SGvrB5xBlmra961ZjuGx+uR2rdjc2S6M2vdV3YEa7SL2PBtEf558JRbadNonQpLZgzBpCTvz74PNn4d3t7+hSbyZ76+FMpbZDIBi6YkYdnGbJQbrQjXKqGWy2AVnag9N9t80ZSkDn3JaW/Wel5ZPZZtzG531npnloH1tIM/1uDlrHyU1Vnc2m8YFY/7Jg+GTu3XMeK3Ama2eVdxYxIKRr6+FMoXuH25ObcDV2e+3HR11rpDdKKi3gpLG2VOe1O9xY7M7SewObfcrT0hIgSPz0zBqMRw73TMB3G2ORH1OKdTQuaOQpisDrdQ0cjkiDPIUG60InNHISYOjgrqIfRJydGYODiqy5cVujJr3Veub+/MP4vVWwvcKrfJBODn4xNx18QBUCtbzwWg3sXwJgoyvrwUytfIZEKX34POzlqvM9tRbfbu9e0qkxWrtxZg1/FKt/bkGB2ezEjBkFi9l3pGF2J4EwUZX1wKFYg6Oms9TKPEGaMFDR5YBtZVkiRhc045MneccFuOplLIsOCKAfjZuMSgKLbSFSqFDN54axjeREGmJ5ZCUWsdmbWeEqtDuFbZ68HtlCRXoRabXcK/Dp/CoeJat/uMSgjD4xkpSIjQ9mrf/IVWpUBYiBIhKu9cQmB4EwUZTy+ForZdbNZ6TYMNWpUcN43p1+VqaV3VXCK1uNIEk01Eo939+nqoSo5fXj0YP0mP71LltUAmCAL0GgUMGiVUCu9ussLZ5pxtTkHo/Gxzsc2lUJxt7jkXzlpXCEBCpBa3ju9aPfHuaN6cxGhxwGp3wia6B3dqXwOeuX4E+uhZQrolhUwGQ4gCeo3SZy4f8MybKAhNSo7GC/PSXKFSd24p1PB4fdCv8/a0lrPWT9c1QpCApJiu1RPvDqck4e//K0aVyQbLBZuayAVAo5RDrZAhSsfLJc1UChnCQpTQqRU+V/KV4U0UpLq7FIo6TiYT0Ddcg1C195ZYbc4+gyMltRAvGGs1aBToo1PD7pRwqtqMgjMN3ap9HghC1U3XszU+vCSO4U0UxLqzFIo6xi46cdaLRVfMNgfW7jqJTw+XomVuK2QCYvVqhJ6rkCYIQL0koc4SnKsMZIIAnaYptJXtrMTwJQxvIqIeUn+uNnlvT0pr9r+TVViZdRwV9Va39vAQJaJDVW6jLDaxaX/vME1wDZsrZE1D43qNwq9GnRjeRD6Gm4X4P/HcFp7eWrtdZ7bj9e0F+Dqvwq1do5RBKRPQR6+CgBarDCCh3mLH4D46JMeG9nZ3vUKtlCMsRIlQldznrmd3BMObyIdwsxD/V2+xo7rBBtHZ+2fbkiRh6w8VeG1bIeoaz29qopAJuP3y/kiN12P11gJUmmzQa5RQyQXYxKbg1qrkuH1CYkAvD1PIZAhVyxGqVvj09eyO4FIxLhUjH8HNQvybXXSi0mRFo80717YrjBa88s1x7D1R7dY+PF6PJzKGYlB00xl18zrvkqoG2KWmofLEqFDcPqH3l671BrlMgFalgE6t8FpBlZ7AM28iH8DNQvyXJEmoa7Sjxmz3Sl1ypyThs+9L8daukzC3+OKgUcjwi6sGYd7ofm5rk0f3j8CoxHBXhbUwjQrJsb2/dK0nCYKAULW8KbCV/jksfikMbyIfwM1C/JPZ5kCVyQa76J1dwIqrzXh5yzFknza6tY8dEIGlM4cgPiykzcfJBCEgl4MJggCdWoEIrRIKP5gx3h0MbyIfwM1C/ItDdKKqwea1CWkO0YmP9pfgb//9EfYWC7f1GgUenJqEjBGxAXm2eTE6jQIRWpVfLPPyhC6Ht91uR3l5OcxmM/r06YPIyEhP9osoqHCzEP/RaBNRUW/xyoQ0ADhWXo/lW46h8GyDW/uUlD54eHoyIkOD63ck2EK7WafC22Qy4b333sMHH3yAffv2wWo9v3YwISEBGRkZ+OUvf4nx48d7vKNEgYybhfiHWrMN1Q3eGf2w2EW8s6cIHx84hZbfG6J0Kjw6fQiuGhI8kxmbr2mHh6i8vkGIt3Q4vFeuXInnn38eAwcOxI033oinnnoK/fr1Q0hICKqrq5GTk4Ndu3Zh5syZmDhxIl599VUMGTKkJ/tOFDAutgNV82Yhi6YkcbKal4hOCWfrrTDbvDNMfqi4Bi9n5aO01uLWfn16PH45eTB0muC4Atq8q5e/VEHrSR1eKnbLLbfgmWeeQVpa2kXvZ7VasW7dOqhUKtx7770e6WRP4lIx8iUX7kCllHGdt7eZrA5UmaxeGSY3WRz4685CfJld7tbeN1yDJzKG4rLE8F7vkzfIZQL0GiXCQnxnVy9v4zpvhjf5GFZY8w3enpS263glVn9zHFUthullAvCzcYlYcMUAqP28yEhH+PKuXt4WHGMtRH6Em4V4n9FiR42XqqRVN9iw+pvj2Hm80q09uY8OT8xKQUqsvsvHdkqSX6zvDlHJEaFV+X0VtJ7UrfB+7LHHMGrUKKSnpyM1NRVqNTdwJyL/ZXWIqDTZYPXCDmCSJGFz7hlkbm8q1tNMKRew4IqB+Nm4hG6tXXarrHbukoyvVVZjaHdct4bNP/30Uxw5cgRHjhxBbm4u5HI5UlNTkZ6ejvT0dFx//fWe7GuP4LA5EUmShOoGG4wWh1eqpJXWNmJlVj4OFNe6taf1C8PjGSnoH6nt1vEPFddgRVY+zDYRBo0SSrkAuyjBeK6m+dKZKV4L8OZ64zqNAmoFQ7ujunXmXVRUhN/+9rf44YcfkJKSAqvVipycHBw5cgTffPONX4Q3EQU3i13E2XqrV6qkiU4JGw+dxtu7T8LiOP/8WpUc900ejBtGxXd7WNspSXh/XwnMNhHRuvO7iakVAqJ1KlSabHh/XwlGJYb32hC6IAgIVTUFtlbFq7dd0a13beTIkQCApUuXoqCgADqdDqmpqRg5ciRmzJjhkQ4SEfUESZJQY7aj1ktV605WNmD5lmPIK6t3a584OBJLrhmCGIPGI89TcKYBJVUNMGiUbtuAAoCAplncJVUNKDjT0OMlU5tnjRs0ioAvX9rTuhXe11xzDQDgyy+/BNA0BJ2Tk4OcnBxkZWXhJz/5Sfd7SETkYSarAzUN3qlJbnM48f7/ivH+vmI4WkyICw9R4qHpyZg2tI9HZ1bXWWywOyUY5G0fUyUXUC9JqLP03JcYlUIGQ4gSes4a9xiPjFc4HA58+OGHOHv2LEaMGIH77ruP/0BEPixYl6OZrA7Umm2wObyzkUhuaR2Wf5WPH6vNbu0zhsdg8dRkhGmVHn/OMI0KSlnTNW61ovW/sU1s2hY0TOP5sqqh6qaCKpyA5nkeCe/bbrsNUVFRGDZsGD755BP86le/wscff8wKa0Q+yK0QjChBKQ/8QjBmmwPVDd4L7UabiHW7T2LjodNoOR0uRq/G0pkpmDCo5/aGSI4NRWJUKE6cNbld8wYACRLqLXYM7qNDcmyoR56PQ+O9wyPhfezYMRw5csT188GDB3Hfffdh+/btnjg8EXnInoJKLNuYDZPVgQitCiq5DDbRibyyeizbmI0X5qUFVIBb7CJqzDY02np/6Vez74qqsSIrH2eM5/eCEADMHd0P91w1sMcnbMkEAbdPSMSKrHxUmmzQa5RQyQXYxKbg1qrkuH1CYrcnq2mUcug1ChZU6SUe+a3R6XQoLCxEUlISAGDMmDGorq72xKGJyEOcTgmZO5rWEMcZNK4PWI1MjjiDDOVGKzJ3FGLi4Ci/H0J3iE5UN9jc1kv3trpGO9ZsL0TW0TNu7QMitXg8IwUj+/VeIZ7R/SOwdGaKa513vdQ0VD64j65b67wVMhl05wI7WDcI8RaPhPcbb7yBuXPnYvbs2Rg+fDjy8vLQv39/TxyaiDwkt9SIwgoTIrSqVmdGgiAgXKtEYYUJuaVGv63wJkkSjI0O1JhtcHqp8rMkSdh+7Cxe3VqA2ka7q10uazoDvuPyAV4JutH9IzAqMdwjFdaUchnCtSxb6k0eCe+0tDTs378fmzZtQl5eHpKTk/Hcc8954tBE5CHVZhvsogRVO9ch1XIZ6pwSqr20dKq7vH1dGwDO1lvxytfH8d8TVW7tQ+P0eDIjBYP79OxSrEuRCUK3loOplXJXrXHyLo/8C9x5551Ys2YNfv7zn+OLL76AzWaDVtu9ikBE5FmRWhWUcgE20QmNrPXsX6vohFImIFLr+VnHPUWSJBgtDhgb7V5Z9tXMKUn4/EgZ3tx5AuYW19fVChl+cdUg/HR0P7/dDUsplyFUzaFxX+OR8D5y5AgMBgOOHj2KJ598EpMnT8aOHTvwyiuveOLwROQBqX0NSIrRIa+sHnEGmdtwpyRJqDXbMTxej9S+/lEm2Jubh7RUUm3G8i35yD5d59Y+pn84ls5MQd/wEC/1rOvkMgFalQJ6jYLLvHyUR8JbqVRCkiRs2LABy5Ytw5133omxY8d64tBE5CEymYBFU5KwbGM2yo1WhGuVUMtlsIpO1Jrt0KnlWDQlyecnqzlEJypNNpht3puM1tyPf+w/hXf+WwS7eP4LhE6twKKpSbg2NdavrgcLggCtSg6dWgGtSu5XfQ9GHgnv+++/H+PHj0d1dTWeffZZAEBDQ4MnDk1EHjQpORovzEtzrfOuO7e71PB4vV+s8zZZHagyWb1+tp1/ph7Lv8pHwVmTW/vVKdF4ZPoQRIb6z6UHtbIpsHVqhd8O7Qejbu0q1lJtbS0UCgV0Oh0KCgrwhz/8Ae+8844nDt2juKsYBSN/q7BmdYiobvDuem0AsNpFvPPfH/GP/SVo+f0hKlSFR64ZgslDfPvLT0sapRyRodx+0195LLz9FcObyHc5RCeqzTaYLN4dIgeA70tq8XJWPk7VNLq1X5cWhweuToJO4x8zsFUKGSK0KoRyxrhf478eEfkc0Smh1uy9/bVbMlkdeGvnCXx2pMytPT5Mg8czUjDGS/tgd1bz2my9xvP106n39Uh4l5WVITIyEmq1uicOT0QBqrnISm2j92eRA8C3BZV45ZvjqDKdX/suE4CbxyZg4aSBfjHkrJDJEKZtqjXOSWiBo0fCe/78+SgsLMRNN92E5cuX98RTEFGAqbfYUdNgh8PpvfXazaobbHhtawG25591ax/cJxRPZgzF0Di9l3rWcSqFzFVQhaEdeHokvL/++msAwA8//NAThyeiAGKxi6hqsMFq9+5kNKDpzH/L0TPI3F4IY4vr7Eq5gPkTB+DW8Yk+v1MWt+EMDh4J7x9++AGfffYZwsPDkZqaipEjR8JgMGDYsGGeODwRBSCrQ0RNg93r67WblddZsCIrH/t/rHFrH9nXgCcyhqJ/lG9XjdSpFQjXqlgFLUh4ZLb5oEGDcO+990KlUiEnJwfZ2dloaGjAsWPHPNHHHsXZ5kS9yy46UeMjM8iBpslxmw6fxrrdJ2Gxnx+yD1HKcd/kQbjxsr7d3i6zpzRXQgsLUTK0g4xHzrzj4uLw9NNPu7WJoveHwIjIdzidEmrMNtSa7Th+xtTtna084WRlA5ZvOYa8snq39ssHRWLJjCGINWi80q+LaQ5snVqBEBWHxoOVR8J71qxZePfddzF//nxXm1zOXyoiatJgdaDKZMN3RVWuPaXt56q7JUaFdmtP6a6wi068/79ivPe/YjhazGoPC1HioWlJmD4sxucmecllAsJDVNBrFD5dUId6h0eGza+77jrk5ORApVJhwoQJSEtLQ1paGq6//npP9LFHcdicqOfYRSeqG2xosDpwqLgGK7LyYbaJMGiUUMoF2EUJRosdWpUcS2em9EqAHy01YvmWYyiqMru1zxgegwenJiHcx3ZVaw5tQwhnjdN5Hjnz/vLLLwE0BWFOTg5ycnKQlZXlF+FNRJ53YZEVpyTh/X0lMNtEROtUENAUQmqFgGidCpUmG97fV4JRieE9NoTeaBOx7tuT2HjwNFqescTo1VgyYwgmDo7qkeftDp1agSidmjXHqRWPhLfD4cCuXbug0WiQmpqKSZMmeeKwRNQOX61N3l6RlYIzDSipaoBBo3QFdzMBAvQaJUqqGlBwpgEpcTqP9+u7omqsyMrHGaPVrX3OqL647+pB0Kp8q9ikQiZDlI4lTKl9HvnNuPnmmxEVFYVNmzbBYDDA6XQiLS0Nn3/+uScOT0Qt7CmodO0KZhclKOUCkmJ0Xt8VrN5iR63ZDrvYushKncUGu1OCQd72FwyVXEC9JKHOYmvz9q4yNtqRuaMQX+WecWtPjAjBExlDkZYQ5tHn6y6ZIMAQokRYiJJn23RRHgnvkydPYtOmTThw4AAOHz6MVatWoaam5tIPJKJO2VNQiWUbs2GyOhChVUEll8EmOpFXVo9lG7Pxwry0Xg/wRpuIqgYrbI72K6OFaVRQypqucasVrUPJJkpQCgLCNJ653ixJEnbkV+LVrcdRY7a72uUyAbeOT8T8iQN8amkVQ5s6yyPhHRISAgBQqVSw2Wx49NFHMW3aNE8cmojOcTolZO4ohMnqQJxB45q8pJHJEWeQodxoReaOQkwcHNXjQ+h20QmTxQGT1dHmmfaFkmNDkRgVihNnTW7XvAFAgoR6ix2D++iQHBva7b6drbdi9TfH8W1hlVt7SqwOT2YMRVKM54flu0ohk8EQooBew9CmzvFIeD/00EOorq7GT3/6UyxevBiTJk1CUVGRJw5NROfklhpRWGFChFbVataxIAgI1ypRWGFCbqmxx4aDzTYHas12WDpZylQmCLh9QiJWZOWj0mSDXqOESi7AJjYFt1Ylx+0TErs1Wc0pSfgyuwxv7DiBhhb7fqsVMiycNBA3j03wmYBk3XHqLo+E95133gkAeOqpp7Bhwwbk5ubi008/9cShieicarMNdlGCqp3a2mq5DHVOCdVmz143Bprqj1c32Dod2i2N7h+BpTNTXOu866WmofLBfXTdXud9qsaMFVn5OFxS59Z+WWI4Hs9IQb/wkC4f25Oaq6GxuAp1l0fCu7q6GmvXroVSqcRjjz3miUMS0QUitSoo5QJsohMaWesPf6vohFImINKD65Q9XX98dP8IjEoMR8GZBo9UWBOdEj7eX4IN//3R7Zp7qFqORVOSMHtknE+c2eo1SpYwJY/yyG/SzTffjNDQUKxduxYAkJOT06pcKhF1T2pfA5JidKgx23FhbSVJklBrtiMpRofUvt0vNuQQnaiot+B0TaPHNw6RCQJS4nQYPzASKXG6Lgd3QYUJD753EG/uOukW3JOHRGPDwvG4Li3e68GtVsrRLyIEffRqBjd5lEd+m+rr67F48WKoVE3f+EeOHOkq3EJEniGTCVg0JQk6tRzlRisa7SKcTgmNdhHlRit05842uzNZTXRKqDJZUVLT6DMbh1zI5nBi7a4TeODvB3C8wuRqj9Aq8dwNI/C7G1MRpVN7sYdNs9qj9Wr0Cw+BWsEhcvI8jwybx8TEoLS01O1brsVi8cShiaiFScnReGFemmudd925+uDD4/XdWud9YUU0X/X9qVq8vCUfp2oa3dpnj4zDA1MGQ69ReqlnTQRBQBiXfFEv8Eh4r1y5EgsWLEBFRQU++ugjbN68mXt5E/WQScnRmDg4yiMV1kSnhLpGO4yNdjh9OLQbrA68uesEPvu+zK09PkyDpTNTMHZA721q0hZBEKDXKBAeooSinQmFRJ7kkY1JAMBms2HTpk3Izs5GXFwc7r77bmi1vr15PcCNSSg4+UtoA8Cewkq88vVxVJrOz6KXCcBNYxKw8MqBCFF6d1haKZchxqDm8Dj1Ko+Ft79ieFMwcTol1PpJaNeYbXhtawG2HTvr1j44OhSPZ6RgeLz3/78aQpSICm297p6op3lk2Hzt2rV4++23ER4ejpEjR7q2BL3ssss8cXgi6qb2NgzxRZIkISuvAmu2FcDYYtKcUi7gzssH4NYJiVB6YGjaKUldXrImlwnoo1f73IYmFDw8cuY9aNAgbNq0CWq1GtnZ2cjJyUFubi4++eQTT/SxR/HMmwKZ6JRgsjhQ12iHw3npMqbeVm604JWsfOwrct8bIbWvAY9npGBgVPfLpwLAoeIaV7EY+7lJf4lRoR0qFqPTKBARosIP5fU+t6sbBQ+PhPecOXPw4Ycfumqc+xOGNwUii12E0WJHg1X06dnjzZyShE2HSrF29wlY7Oe/ZGiUMtx71WDMHd3XY/t8HyquwYqsfJhtIgwaJZTypg1TjOfKtC6dmdJmgCvlMkTr1DhUXOOTu7pRcPHItMjf/va3uOGGG/DZZ5+hoqLCE4ckok6SJAkmqwOnaxtRWtu0TtsfgruoqgGPfHAYr20rcAvuCQMj8PbC8fjpmH4eC26nJOH9fSUw20RE61RQK2SQCQLUChmidSqYbSLe31fSaj6AXqNEv/AQHCquwbKN2cgrMyJUrUCMXo1QtcK1q9uegkqP9JPoUjxy5j1ixAiMHz8eGo0G2dnZOHPmDAYNGoSvv/7aE33sUTzzJn/ndEqo96Oh8WZ20YkP95Xg7//7EXbx/MeQQaPA4mnJmDE8xuMTwfLLTXjm02yEqBRQt1HxzOJwwmJz4Pdz0pASp2sqtqJrCminU8KC9fuQV2Z029UNaPriVG60Yni8Hu/cPYFD6NTjPDLbIiwsDO+8845bG3cVI+pZ/rTc60J5ZUYs35KPk5UNbu3ThvbBQ9OTEeHB+uwt1VlssDslGORth6tKLqBeklBnsSFEJUcfndq1btsXdnUjauaRYfNJkybh3XffdWsbOHCgJw59STt37sQNN9yAvn37QhAEbNq0qVeel8hbHKITlSYriqvNqDXb/Cq4G+0i1mwvwMMfHHIL7midCs/PHYnfXj+ix4IbAMI0KihlgtuZfks2sWmns/4RoYgPC3EruNKRXd3sPbSrG9GFPHLmnZeXh48//hi///3vMX78eNdSseuvv94Th7+ohoYGjBo1CnfffTduuummHn8+Im+xi07Umu0wWf3jWvaFDvzYNFGsrM69dPINo+Lxy8mDEaru+WVXybGhSIwKxYmzJkTrVBDQYugbTZcfRvTV4/LBka0e641d3Yja45H/Lc2bkBiNRuTk5CAnJwdff/11r4T37NmzMXv27B5/HiJvsTpE1DX6z8zxC9Vb7MjcfgKbc8vd2hMiQvBERgrSE8J7rS8yQcDtExKxIisflSYb9BolVHIBNrFpsp9BI8fiqcltXrNu3tUtr6wecQZZq2vetWY7hsfrPbKrmy9zOiWPlOal7vHoV12DwYBJkyZh0qRJnjwsUVAy25omoTXaRG93pct25p/F6q0FqG5wL21624T+mD9xgFe2yRzdPwJLZ6a41nmbpKZr3al9DRdd7tW8q9uyjdkoN1oRrlVCLZfBem5ExBO7uvm6PQWVXCbnIwKqPKogCNi4cSPmzp3b7n2sViusVqvrZ6PRiMTERM42J59hsjpQa7a57VHtbypNVqz+pgC7L1g6NSRGhydnDUVyjM5LPTvPKUk4Vd0ICUC0Tt3hM0i3ADtX4CUYAmxPQSWWbcyGyepAhFYFlVwGm+hEzbkvLi/MSwvo1+9rgq6234svvojf/e533u4GUSv1FjtqzXbYRf8NbUmS8GV2Of66sxAN1vMjBiqFDAsnDcQtYxN8YqtMQRDQR6dGcoy+04/15K5u/sLplJC5oxAmq8NtmZxGJkecQYZyoxWZOwoxcXBUQL8PvsQj4f3DDz/gs88+Q3h4OFJTUzFy5EifPYv99a9/jaVLl7p+bj7zJvIGSZJQb3Wgzs9DGwBO1zTi5ax8HC6pdWsflRCGxzNSkBDhG7sMKmRNu4BpurEbmUwmBNVyMC6T8z0eCe/Zs2fj3nvvRW1tLd544w1kZ2ejoaEBx44d88ThPUqtVkOtVnu7GxTk/LWwSltEp4RPDpzChj1FsLYY6g9VyXH/lMG4Li3eYxXSuitEJUeMXuMTZ//+pCPL5Oq4TK5XeSS84+Li8PTTT7u1iWLvTLIxmUwoKChw/Xzy5EkcPnwYkZGR6N+/f6/0gaijmgur1FvsPr+7V0cUVpjw0pZjyD9jcmu/MikKj1wzBH30vvNFOSxEiSid7/THn3CZnO/xSHjPmjUL7777LubPn+9qk8t7Z2P6/fv3Y9q0aa6fm4fEFyxYgA0bNvRKH4guxS46z4W2f67RvpDN4cS7e3/Eh9+VuH0JidAq8fD0IZiSEu1Te1xH6dQIC1F6uxt+i8vkfI9HZptfd911yMnJgUqlwoQJE3q1SEt3sbY59SSLXYSxsamwSqDIPlWH5VuOoaSm0a19VmosFk1JgsGHQlIQBNfmIdQ952ebi20uk+Ns897l0aViLYu05ObmYtWqVZ46dI9heFNPMNscqDXbYbH77xrtCzVYHVi76yQ+/b7UrT3WoMbSmSkYP7B1VTJvkssExBo03ZqYRu6CdZmcL/JIeDscDuzatQsajQYjRoxAWJj/zDZkeJMnBcIa7bbsPVGFlVnHcdZ0vkaCAGDemH6458pBCFH5VkBeuKkIeQ4rrPkGj4wl3XzzzYiKisKmTZtgMBjgdDqRlpaGzz//3BOHJ/JpgbTc60K1Zhte31aIb36ocGsfGKXFExlDMcLHrnEKQtOkqTCt7wzdB5pgWybnqzwS3idPnsSmTZtw4MABHD58GKtWrUJNTY0nDk3kswJpudeFJEnCNz9U4LWtBTBazl+vV8gE3HF5f9x+eX8ofeysVilvWr+tVvjWKABRT/BIeIeEhAAAVCoVbDYbHn30UbcZ4ESBRHRKMDbaYQyQ5V4XOmO0YOXXx7HvZLVb+4h4PR7PGIpB0aFe6ln7DCFKRIW2LiBCFKg8Et4PPfQQqqurMW/ePCxevBiTJk1CUVGRJw5N5DMcLZZ7+dMe2h3llCT8+3Ap3tp1Eo0tJtpplDLce9UgzLmsn88VN5HLBPTRq6FVcTY5BZdujXs1zyYfP348wsPD8etf/xpXXnkl8vLy8Omnn3qkg0TeZnM4cbbeipKaRtQ12gMyuIurzFjy4WGs3lrgFtzjBkTg7QXj8dMxvlGTvCWtSoGECC2Dm4JSt37rR44cCQB47LHHUFBQAJ1O56ptXlJSgvT0dI90ksgbrA4RdebAWqN9IYfoxIffleDdvT/CLp7/UqLXKLB4ahJmjoj1uaFoQRAQGapi0RUKaj22zvvo0aN45ZVXPHXoHsOlYnQhi11ErdkOsy1wQxsAjpXX46Utx3DibINb+9SUPnhoejIiQ32v1KVKIUOMXuOVfcCJfIlHxpvuvPNOrFmzBgaDAbW1tejTp49fBDdRSw3WppnjgVRYpS0Wu4j13xbhnwdPoeV8uyidCkuuGYIrfbTYBielEZ3nkfA+cuQIDAYDjh49iieeeAKTJ0/Gjh07GODk8yRJgulcaAdaYZW2HCyuwctb8lFWZ3FrvyE9HvddPRg6HywjKhMEROvVPtk3Im/xyP8GpVIJSZKwYcMGLFu2DHfeeSfGjh3riUMT9QhJkmC0OGBsDLzCKm0xWRz4645CfJlT7taeEBGCx2emYFRiuHc6dgkcJidqm0fC+/7778f48eNRXV2NZ599FgDQ0NBwiUcR9T6nU4LRYkddY2Cu0W7LruOVWP3NcVQ1nN9rWSYAPxuXiAVXDIDaR2t/c5icqH0eCe9f/vKX+NnPfgaFQoHQ0FAUFBTg8ssv98ShiTwi0Ndot6W6wYbV3xzHzuOVbu3JMTo8kZGClFi9l3p2cVy7TXRpHpltXl1djbVr10KpVOKxxx7zRL96DWebBzaboym0TdbA2Ee7IyRJwuaccmTuOOG2zE0pF7Bw0kDcMjbBZzfs4IYibeNmIHQhj4T39OnTcdNNN2HNmjXIzc1FTk4OPvjgAzz//POe6GOPYngHpkabCKPFjoYAXqPdltLaRqzMyseB4lq39vSEMDw+MwWJkVrvdKwD9BolonUcJr+Q2zacogSlnNtwkofCe/z48fjuu+8wevRoHDp0CADc/u7LGN6BI9hmjrckOiX86+ApvP1tEawtXrtWJcf9Vw/GT9LjIfPhUIwKVXMnsDbsKajEso3ZMFkdiNCqoJLLYBOdqDHboVPL8cK8NAZ4kPLIRaWYmBiUlpa6fWO2WCwXeQSR5wTbzPELnThrwktb8nGsvN6t/YrBUVgyYwj66NVe6tmlyYSm69uhXAbWitMpIXNHIUxWB+IMGtfnq0YmR5xBhnKjFZk7CjFxcBSH0IOQR/7HrFy5EgsWLEBFRQU++ugjbN68GcOGDfPEoYnaJTol1AfZzPGWbA4n/v6/H/HBvhK31x8eosTD05MxdWgfnx6C5jKwi8stNaKwwoQIbetLCYIgIFyrRGGFCbmlRu6vHYQ8Et4pKSn44osvsGnTJmRnZ2PcuHG4++67PXFoolaCceb4hXJO1+HlLfn4sdrs1p4xIhaLpib5fN3vcK0KEVplr3+58KeJX9VmG+yiBFU7k/fUchnqnBKqzbY2b6fA5pHwfvjhh/Hss8/iZz/7GX72s5954pBErQTjzPELmW0OrNtdhE2HTqPlOxBrUGPpzBSMHxjptb51hFIuQx+9GhovrC33t4lfkVoVlHIBNtEJjaz1+2UVnVDKBERqfa8GPfU8j4xXTZ06FbNmzcIf//hHNDY2euKQRC4Wu4gzRgtO1ZhRb7EHbXD/72QVfrFhPza2CG4BwE9H98PbC8b7fHDrNAr0Cw/xWnAv25iNvDIjQtUKxJy7zp5XVo9lG7Oxp6Dy0gfpZal9DUiK0aHG3Pp3XpIk1JrtSIrRIbUvJ9oGI4+E90033YT//e9/CAsLw8SJE7F27dqg/YAlz2mwOlBa24jS2sagW/LVUp3Zjhe+zMOv/5WDinqrq31ApBarb7sMD01PRojKN6ukAU2T0mIMGsToNV4Zor5w4pdGKYdMJkCjlCPOoIbJKiJzRyGcPjZvQiYTsGhKEnRqOcqNVjTaRTidEhrtIsqNVujUciyakuSzw/7Uszy6Jejp06fxzTffYOnSpYiNjcVLL72E6667zlOH7xFcKuZb7KITDVYHjI0OOJzBN3O8JUmSsPWHs3htWwHqGu2udoVMwO0T+uP2y/v7/GQvtVKOWL13i65kn6rD/e/uR6ha0eZZf6NdhNnqwBvzx/nkxC+34X6nBKXMt4f7qXd45Jr37NmzkZeXh4SEBEyYMAGvvvoqUlJS8PrrryMrKwsrV670xNNQgLLYRZhtIsw2R9Ctz25PhdGCV745jr0nqt3ah8Xp8eSsoRgUHeqlnnVciEqOWC+dbbfk7xO/JiVHY+LgKL+ZaEe9wyNn3ocOHUJ6ejrk8tbfaocNG4Yffvihu0/RY3jm3fskqWnor8EqotEmBv0ZdktOScJn35fhrV0nYLad31dco5Dh7qsG4aej+0HuBx/aOrUCffRqn1iq5u9n3kRt8ciZd1paGnbu3AmNRoMRI0YgLOz8f4Avv/zSE09BAcDmcMJoscMUxEu8Lqa42oyXt+Qj+3SdW/vY/uFYmpGC+LAQL/Wsc8JClIjS+U5hmOaJX3ll9YgzyNy+UDRP/Boer/eJiV/+tJSNvMsj4X3zzTcjKioKmzZtgsFggNPpRFpaGj7//HMMHjzYE09Bfsxkbap+ZrGLl75zEHKITny0vwR/+++PsIvnv9To1AosmpqEa1NjfeIMtiMitCpEhPrW0qXmiV/LNmaj3GhFuFYJtVwGq+hE7bkyo74w8cvflrKRd3lk2HzUqFH4/vvvcdlll+Hw4cNYtWoVampq8Nxzz3mgiz2Lw+Y9o7nOeK05OEuWdlT+mXq89NUxFJ5tcGu/OiUaj0wfgkgfC8KLaas+uS+dSfryxC/WMKfO8siZd0hI03CeSqWCzWbDo48+imnTpnni0ORnRKcEk8UBo4WhfTEWu4h39hTh4wOn0HKFUlSoCo9eMwRXDfGvD+oonbpVVTdfO5P01YlfrGFOXeGR8H7ooYdQXV2Nn/70p1i8eDEmTZqEoqIiTxya/ITZ5kC9xQGzTeQa/0s4VFyDl7PyUVrrvnnPT9Licf/Vg6HT+NcmHX30aug1rYO7rTPJ5qIo3jqTlMkEn5uUxhrm1BUe+ZS48847AQBPPfUUNmzYgNzcXHz66aeeODT5MJvDCZPVAZOFa7I7wmRx4I2dJ/BFdplbe99wDR6fmYLR/SO81LOuEQTBVamsJZ5Jdo6/L2Uj7/BIeBcUFGDFihWorKxEeno6fv3rXyMy0rdLNVLXOJ0STOfOsq2cgNZhu49XYtU3x1HVcP4DWCYAt4xNwIJJA71SMrQ75DIBseeqlV2IZ5Kdwxrm1BUeKXs0b948jBo1Co899hgiIyMxe/ZsbN++3ROHJh9hsYuoqLfgx2ozKuutDO4Oqm6w4XefHcUz/851C+7BfULx+u1jcP+UJL8LboVMhviw9muUd+RM0s4zSRfWMKeu8MiZt1qtxv333w8AuOKKK3DzzTcjIyMDhw8f9sThyUskSUK91YE6zhjvNEmS8FXuGWTuKES95XxddqVcwF1XDMDPxyV6tWRoVynlMsSHaS7ad55Jdo6/LGUj39Kt8H700UcxevRoTJ8+HWvWrMGDDz4IAIiMjPSbdanUmuiUzu2XbYfoY5s1+IOyukasyDqOAz/WuLWn9TPg8Yyh6B+p9VLPukelaDrjvlSFN38qiuIrJiVH44V5aa7Z+XXnlrINj9f7xFI28j3dCu+MjAwcOXIEJSUl+OKLL/DKK69gxIgRKCwsxE033eSpPlIvkSQJxkYHahttDO0uEJ0S/nXoNNbvPglLixrtWpUc900ejBtGxUPmp19q1Uo54gyaDpVm5Zlk1/jqUjbyTR7dVcxmsyE3NxdHjhxBTk4OXnrpJU8dusewSEuTBqsD1Q02Do930cnKBizfcgx5ZfVu7RMHR2LJNUMQY9B4qWfd19UNRny5KAqRv/NoePujYA9vq0NEdYMNjTZOQOsKm8OJ9/9XjPf3FcPRYrQiLESJh6cnY9rQPn59CSlUrUBMNzYY8aUKa0SBxL+qQZDHOM6VXqy32C99Z2rT0VIjXtpyDD9Wmd3aZwyPweKpya1KhfobT+wM5otFUYgCQY+Ed1lZGSIjI6FW+87OQtSk0Sai3mJHAyuhdVmjTcS6b09i48HTaPkOxujVeGzmEFw+KMprffMUvUaJPnr+/yXyVT0S3vPnz3dNWlu+fHlPPAV1gkNsqoRWb3HwmnY3fVdUjRVZ+ThjtLraBABzLuuLeycPglbl/4NZvralJxG11iOfNF9//TUA4IcffuiJw1MHSJIEs008V2/ccekH0EXVNdqRub0QW46ecWvvH6nFExkpGNkvMIaGI0NVCOf6ayKf1+3wrq2txVdffYXTp09DEATEx8dj1qxZiIiIwLBhwzzRR+oEu+hEvYX1xj1FkiRsP3YWr24tQG3j+fkBcpmAW8cnYv7EAVAp/K/YSlva2hmMiHxTtz511q1bhwkTJmDv3r1wOp0QRRF79+7FxIkTsW7dOk/1kS5BkiTUW+woq2tESbUZtWYbg9sDztZb8ZtNufjDF3luwT00Vo+/3jkG91w1KGCCu4+ewU3kT7q1VGzo0KE4cOAAdDqdW3t9fT3Gjh2L/Pz8bnewp/nzUjGrQ3SdZTs5+cxjnJKEL46U4c2dJ9DQYgmdWiHD3VcOxE1jEjpUrMQftLczGBH5tm79jxUEASaTqVV4m0wmv17b6su4q1fPKqk2Y0VWPr4/VefWPrp/OJbOTEG/8BAv9czzBEFArEEdEJPsiIJNt/7XLl++HFOmTMHIkSPRr18/AMCpU6eQm5uLl19+2SMdpCYWuwijxY4GK5d49QTRKeEf+0vwzn9/hK1FaVOdWoFFUwbj2pFxAfWFVCYIiAtre0tPIvJ93a6wJooi9u3bh9LSUkiShH79+mHChAmQy/3jQ8GXh82dzqZdveotdrdAIc86fqYeL23JR0GFya396iHReHh6csAtm5LLmoJbrfCP/6NE1BrLo/pgeDfaRNRb7TBbRV7L7kFWu4h3/vsj/rG/BC33YYkMVeGRa5Jx9ZA+3utcD1HIZIgL0wTMRDuiYOXRi10mkwn5+fkYPHgwwsPDPXnogMclXr3r+5JavJyVj1M1jW7ts0fG4YEpg6HXBN7Ma6W8KbiVfriPOBG569b/4l/+8peuv+/cuRMjR47Eb37zG4wePRqfffZZtzsX6LjEq/eZrA6szMrHY//43i2448M0WH5zOp6cNTRggzuewU0UMLp15r1//37X33/zm9/giy++QGpqKk6dOoUbb7wRN9xwQ7c7GIgsdhEmK5d49bY9hZV45evjqDTZXG0yAbhpTAIWXjkQIQE6eUulkCE+LCRglrcRkQeHzRsbG5GamgoASEhI4IzoC4hO6Vx9cU4+6201Zhte21qAbcfOurUPjg7FE7NSMCzON+Y69ASNUo44Q+f34iYi39at8D5y5AhiYmKahn/r61FeXo64uDjYbDaIItcgA9zFy5skSULW0TNYs70QRsv5+u5KuYA7Jw7AreMTA3oYWatSINbQvS09icg3dSq8f/GLX2DVqlXQ6/UAAIej7Q0vzGYz3njjje73zk85miefWbmLl7eU11mw8ut8fFdU49Y+sq8Bj2ekYEBUqJd61js8sRc3EfmuTi0Vk8vlKCsrQ0xMTE/2qVd5eqlYRb0FJgt38fIW0Slh0+HTWLf7JCz281+cQpRy3Dt5EOZc1heyAA80bulJFPg6debNYd9Ls9p5pu0tRVUNWP7VMRwtq3drnzAoEo/NGIJYg8ZLPesdgiAgSqeCIQBnyxORu05f8+YwHPkau+jEB/uK8fe9xXC0qLZi0Cjw0PRkXDMsJuB/b+UyAbEGljslChadDu+UlJRLfhBWV1d3uUNEnZFXZsTyLfk4Wdng1j5taB88PD0Z4VqVl3rWe1g1jSj4dDq8f/e73yEsLKwn+kLUYY12EW/vPol/HTyNlhdz+ujUWDJjCK5IivJa33oTq6YRBadOh/ett94aUBPWyP/sL6rGiqzjKDda3NpvHNUX900eFDR7UzdXTVMwuImCTqc+5QL9umF3OJ0SckuNOHamHjqVAsmxoQE/q7m3GRvtyNxRiK9yz7i1J0SE4PGMFIxKCPdOx7yAwU0U3Djb3AP2FFQic0chCitMsNidUMiAxKhQ3D4hEaP7R3i7e35PkiTsyK/Eq1uPo8Zsd7XLBOC2Cf0xf+KAoLreqz5XNY3lTomCF7cE7eY67z0FlVi2MRsmqwMRWhUgATbRCaPFDq1KjqUzUxjg3VBpsmLVN8fxbUGVW/uQGB2enDUUyTE6L/Ws5zglCQVnGlBnsSFMo3IbxQlVKxDD4itEQa/TFwedTic2bNiAf/3rXygqKoIgCBg0aBBuvvlmzJ8/P6g+VJxOCZk7CmGyOhBn0EAQBNgcTqgFGaJ1KlSabHh/XwlGJYZzCL2TJEnCF9nleGNnIRqs50vtqhQyLJw0ELeMTQjIM89DxTV4f18JSqoaYHdKUMoE1yjO1Skx6KNn8RUi6sKw+Y033ogvv/wSo0aNQlpaGiRJQl5eHhYuXIh//etf2LRpUw911ffklhpRWGFChFbV6kuLAAF6jRIlVQ0oONOAlLjAO0PsKadrGvFy1jEcLqlza78sMQyPzxyKfhEhXupZzzpUXIMVWfkw20QYNEoY5ALsooQTZ0145evjiA8LYXgTEYBOhveGDRuwc+dOfPPNN5g2bZrbbVu3bsXcuXPxt7/9DXfddZdHO+mrqs022EUJqnYmDankAuolCXUWW5u3kzvRKeHjA6ewYU+R285roWo57r86CT9JiwvYkR2nJOH9fSUw20RE61QQ0PQ61UoBcSoNzppsyNxRiImDo7hDGBGhU7N8PvjgAyxbtqxVcAPA9OnT8dRTT+G9997zWOd8XaRWBaVcgK2dzUdsogSlICBME/iFQrqroMKExe8fxJs7T7gF95XJUVi/cDyuT48P2OAGgIIzDSipaoBBo3QFNwRAKZNBIZchXKtEYYUJuaVG73aUiHxCp8L7yJEjuPbaa9u9ffbs2fj++++73Sl/kdrXgKQYHWrM9lYz8SVIqLfYkRgViuTYwN7BqjtsDifW7jqBB/5+APlnTK72CK0Sz1w/Ar+/MRXRQbDJRp3F1nSNW94iuOUy11m2Wi6D3Smh2sxRHCLqZHhXV1cjNja23dtjY2NRU1PT7u09Zc2aNRg0aBA0Gg3Gjh2LXbt29crzymQCFk1Jgk4tR7nRika7CKdTgsXhRKXJBq1KjtsnJHKyWjuOnKrFvX/bj/f3laBFSXLMSo3F+oXjMXVon4A+224pTKOCUtZ0jVsQhKbgbvHaraITSpmAyCAo90pEl9ap8BZFEQpF+5fJ5XJ5u3t895SPPvoIS5YswdNPP41Dhw5h8uTJmD17NoqLi3vl+SclR+OFeWkYHq+H2epAldkGi82BwX10XCbWjgarA698fRxLPvoep2oaXe1xBg3+clMafnXtMBhCgmtnrOTYUCRGhcJocUAhg1twS5KEWrMdSTE6pPbt/ra1ROT/OrXOWyaTYfbs2VCr2x7GtFqt2Lx5M0RRbPP2nnD55ZdjzJgxyMzMdLUNHz4cc+fOxYsvvnjJx3tqP29WWOuYvSeqsDLrOM6arK42mQD8dEw/3H3lIIQE8a5YuaV1WP7VMTTYnAjXKqGWy2AVnag126FTy/HCvDRMSo72djeJyAd0arb5ggULLnmf3pxpbrPZcODAATz11FNu7RkZGdizZ0+bj7FarbBazweH0eiZCUAymYC0hDCEa5WwtzOBLZjVmm14bVshtv5Q4dY+KDoUT2SkYHh8cJ9R6tQKXJ/eF1Ghale1vrpz67yHx+uxaEoSg5uIXDoV3uvXr++pfnRJZWUlRFFsdR0+NjYW5eXlbT7mxRdfxO9+97ve6B6hacj367wKvL6tAEbL+UsqCpmAOyf2x20T+gf9jlhhIUpEnZuUNyk5GhMHRyG31Ihqsw2RWhVS+xq4PIyI3HQ4vIuLi9G/f/8OH/j06dPo169flzrVWRdOapIkqd2JTr/+9a+xdOlS189GoxGJiYk92r9gdcZowcqvj2PfSff93UfEG/DErBQMjOIs/KhQNcK07tf3m0dxiIja0+FTnvHjx+O+++7Dvn372r1PXV0d3nrrLYwcORL/+te/PNLBi4mOjoZcLm91ll1RUdHurHi1Wg2DweD2hzzLKUnYeOg07t7wnVtwa5QyPDQtGatuvSzog1sQBMQYNK2Cm4ioIzp85p2Xl4cXXngB1157LZRKJcaNG4e+fftCo9GgpqYGR48eRW5uLsaNG4eXXnoJs2fP7sl+AwBUKhXGjh2LrKwszJs3z9WelZWFOXPm9PjzU2s/VjVg+Zb8VsVExg+MwGMzUxBn0HipZ75DJgiIC9NAE8ST84ioezq9q5jFYsGXX36JXbt2oaioCI2NjYiOjsbo0aMxa9YsjBw5sqf62qaPPvoI8+fPx1//+ldcccUVePPNN/HWW28hNzcXAwYMuOTjPTXbvFlJtTkoJ6zZRSc+/K4Ef9/7I+zi+V8pg0aBB6clY+bwmKBZs30xCpkMsWFqqBUMbiLquoDYEnTNmjX4y1/+grKyMowcORIrV67E1Vdf3aHHMry774dyI5Z/lY8TlQ1u7dOG9sFD05ObtkolKOUyxIdpoAjyCXpE1H0BEd7dwfDuOotdxPpvi/DPg6fcKqRF61RYMmMIJiVxaVMzjVKOWIMmILcxJaLe1+n9vAG4zdZuSRAEaDQaJCcnY86cOYiMjOxW58h3HfyxBi9n5aOszuLWfkN6PO67ejB06i79agUkrUqBWIOalw2IyGO6dOY9bdo0HDx4EKIoYujQoZAkCcePH4dcLsewYcNw7NgxCIKA3bt3Y8SIET3Rb4/hmXfn1FvsyNx+Aptz3Wf4J0SE4PGZKRiVGO6djvkonUaBPjoGNxF5VpdOj5rPqtevX+8KPKPRiHvuuQdXXXUV7rvvPtx+++147LHH8NVXX3m0w+Q9O/PPYvXWAlQ3nN/ZSiYAPx+fiLsmDoCas6fdtCy+QkTkSV068+7Xrx+ysrJanVXn5uYiIyMDp0+fxsGDB5GRkYHKykqPdbYn8Mz70qpMVqzeWoBdx93/LYfE6PBERgqGxOq91DPfFa5VITKUE/WIqGd06cy7rq4OFRUVrcL77Nmzrlrh4eHhsNm497A/kyQJm3PKkbnjBEzW86VNVQoZFl4xALeMS+QErDYwuImop3V52PwXv/gFXn75ZYwfPx6CIGDfvn144oknMHfuXADAvn37kJKS4sm+Ui86XduIFVn5OFRc69aenhCGJzJSkBCh9U7HfByDm4h6Q5eGzU0mEx577DH87W9/c+3frVAosGDBAqxcuRKhoaE4fPgwAOCyyy7zZH89jsPm7kSnhE8OnMKGPUWwOs6/jlCVHPdPGYzr0uK51Wk7GNxE1Fu6tc7bZDLhxIkTkCQJSUlJ0Ol0nuxbr2B4n1d41oTlX+Xj2Jl6t/ZJSVF49Joh6KPn5Kv2RIaqEM5iNETUS7q1GFen0yE9Pd1TfSEvsTmceHfvj/jwuxKILaqtRGiVeHh6Mqak9OFSp4uI0qkRFsINRoio93Q5vGtra7Fu3Trk5eVBEAQMHz4c99xzD8LCuJWhP8k5XYflW/JRXG12a5+VGosHpiQxlC5CEARE61TQa/geEVHv6tKw+f79+zFr1iyEhIRgwoQJkCQJ+/fvR2NjI7Zs2YIxY8b0RF97RLAOm5ttDry16yQ+PVzq1h5rUGPpzBSMH8jqeBcjCAJi9GqEspIcEXlBl8J78uTJSE5OxltvvQWFounDy+Fw4N5778WJEyewc+dOj3e0pwRjeO89UYVXvj6Oinqrq00AMG9MP9xz5SCEqFhs5VJiDBqWgCUir+lSeIeEhODQoUMYNmyYW/vRo0cxbtw4mM3mdh7pe4IpvGvNNry+rRDf/FDh1j4gSosnM4ZiRN/uv/5g0Eev5lA5EXlVl04dDAYDiouLW4V3SUkJ9HpW2/I1kiRh6w8VeG1bIeoa7a52hUzA7Zf3x+0T+kOl4DaVHRGlcw9up1NCbqkR1WYbIrUqpPY1QMbCNUTUw7oU3j//+c9xzz33YPny5Zg0aZJrE5Inn3wSt912m6f7SN1QYbTglW+OY++Jarf24fF6PJExFIOiQ73UM/8TFeo+q3xPQSUydxSisMIEuyhBKReQFKPDoilJmJTM7VCJqOd0KbyXL18OQRBw1113weFwQJIkqFQqLFq0CH/605883UfqAqck4bPvS/HmzpNotIuudo1Chl9cNQjzRvdjadNOiApVI0zrHtzLNmbDZHUgQquCSi6DTXQir6weyzZm44V5aQxwIuox3SrSYjabUVhYCEmSkJycDK3W/0pmBuI17+JqM17ecgzZp41u7WMHRGDpzCGIDwvxUs/804XB7XRKWLB+H/LKjIgzaNzWwEuShHKjFcPj9Xjn7gkcQieiHtHhM++lS5d2+KArVqzoUmeoexyiEx/tL8Hf/vsj7OL572R6jQIPTk1CxohYFlvppAuDGwByS40orDAhQqtq9X4KgoBwrRKFFSbklhqRlsC6B0TkeR0O70OHDnXofgwH7zhWXo/lW46h8GyDW/uUlD54eHoya253QWSoqlVwA0C12Qa7KEElb3uSn1ouQ51TQrWZu+oRUc/ocHhv27atJ/tBXWSxi9iwpwifHDiFFpVNEaVTYck1Q3Alr7t2Sbi2/VrlkVoVlHIBNtEJjaz1mnir6IRSJiCStc6JqIewyoQfO1Rcg5ez8lFaa3Frvz49Hr+cPBg6Df95u8IQorzoSEVqXwOSYnTIK6tHnEHW6pp3rdmO4fF6pHLdPBH1EH66+yGTxYG/7izEl9nlbu39wkPweEYKLksM907HAoBOo0C07uK7p8lkAhZNScKyjdkoN1oRrlVCLZfBKjpRa7ZDp5Zj0ZQkTlYjoh7TrdnmgcDfZpvvOl6J1d8cR1XD+eupMgH42bhELLhiANRKljbtKp1agRiDpsP3d1vn7ZSglHGdNxH1Dp55+4nqBhtWbz2OnfmVbu1JfULx5KyhSIllZbvu0GkUiNF3PLgBYFJyNCYOjmKFNSLqdQxvHydJEjbnnsFfdxSi3uJwtSvlAhZcMRA/G5cARTuznqlj9Bol+ugvPlTeHplM4HIwIup1DG8fVlrbiJVZ+ThQXOvWntYvDI9npKB/pP8VxfE1hhDlJa9xExH5Goa3DxKdEv516DTW7z4Ji+P89XOtSo77Jg/GDaPiIeN6+m4L16q4/p2I/BLD28ecrGzAS18dww/l9W7tEwdH4rEZKV0e3iV3kaHtr+MmIvJ1DG8fYXM48f7/ivHevmKILaqthIco8dD0ZEwb2ofV6zwkSue+OxgRkb9hePuA3NI6LP8qHz9Wm93aZwyPweKpyW2W6KSu6aN334+biMgfMby9qNEmYu3uk9h06DRaLraP0avx2MwhuHxQlNf6FmgEQUCMXo1QNX/licj/8ZPMS74rqsaKrHycMVpdbQKAOZf1xb2TB0Gr4j+NpwiCgFiDmu8pEQUMfpr1srpGO9ZsL0TW0TNu7QMitXg8IwUj+3HNsCfJBAFxYRpoWHkuYDidEgvjUNBjePcSSZKw7dhZvLa1ALWNdle7XCbg9gmJuOPyAVApWGzFk+QyAbEGBncgcStJK0pQylmSloITa5v3Qm3zs/VWrPw6H3tPVLu1D43T48mMFAzuo+v285I7hUyGuDANvxAFkD0FlVi2MRsmqwMRWhVUchlsohM15zaDeWFeGgOcggbPvHuQU5Lw2fdleGvXCZhtoqtdrZDhF1cOxE/HJEDO4T6PU8qbglvJsrEBw+mUkLmjECarA3EGjWvZpEYmR5xBhnKjFZk7CjFxcBSH0CkoMLx7SEm1Gcu35CP7dJ1b+9j+4XhsZgr6hod4qWeBTSmXIT5Mw3rvASa31IjCChMitKpW9Q4EQUC4VonCChNyS42sNU9BgeHtYQ6xqdjKO/8tgl08f0VCp1Zg0dQkXJsay2IrPUStlCPOoOFoRgCqNttgFyWo2vlSppbLUOeUUG22tXk7UaBheHtQzuk6PPbRYRyvMLm1X50SjUemD2Ed7R6kORfcHDINTJFaFZRyATbRCY2s9QREq+iEUiYgkiVvKUgwvD1k+VfHkLmj0K20aVSoCo9cMwSTh3ASTU/SqhSINag5ohHAUvsakBSjQ15ZPeIMMrd/a0mSUGu2Y3i8Hql9uz/plMgf8MKghzickltwX5cWh/ULxzO4e5hOzeAOBjKZgEVTkqBTy1FutKLRLsLplNBoF1FutEKnlmPRlCSOvFDQ4FIxDy0Vs9hFzF61C1aHiKUzUzCmf4QHe0lt0WuU3GUtyLit83ZKUMq4zpuCE8Pbg+u8T5w1QXRKnDDVC8JClIjSMbiDESusEfGat0cN7qNrs0gLeVaEVoUITv4LWjKZwOVgFPQY3uRXokLV3CKViIIew5v8RrReDQP34iYiYniT7xMEAX30aui4FzcREQCGN/k47sVNRNQaPxHJZ3FLTyKitjG8ySdxS08iovYxvMnncGcwIqKLY3iTT1EpZIgPC2GhGyKii2B4k8/glp5ERB3D8CafoFbKEc8tPYmIOoThTV7HvbiJiDqH4U1epVHKER+m4ZaeRESdwOm85DXNZ9wMbiKizmF4k1dwqJyIqOsY3tTrGNxERN3D8KZepVLIGNxERN3E8KZe01Q5LYTBTUTUTQxv6hUKWVPJUxZgISLqPi4Vox4nlwmI87Fa5U6nhNxSI6rNNkRqVUjta+CIABH5DYY39SiZIPjc7mB7CiqRuaMQhRUm2EUJSrmApBgdFk1JwqTkaG93j4joknznE5UCjnAuuNUK39mPe09BJZZtzEZemRGhagVi9GqEqhXIK6vHso3Z2FNQ6e0uEhFdEsObeoQgCIg1qKFR+k5wO50SMncUwmR1IM6ggUYph0wmnFu6pobJKiJzRyGcTsnbXSUiuiiGN/WIPno1tCrfuiqTW2pEYYUJEVpVq6pugiAgXKtEYYUJuaVGL/WQiKhjGN7kcdF6NXRq3wpuAKg222AXJajamTinlstgd0qoNtt6uWdERJ3D8CaPitKpYdAovd2NNkVqVVDKBdhEZ5u3W0UnlDIBkVpVL/eMiKhz/Dq8n3/+eUyaNAlarRbh4eHe7k7QiwxVISzEN4MbAFL7GpAUo0ON2Q5Jcr+uLUkSas12JMXokNrX4KUeEhF1jF+Ht81mwy233IJFixZ5uytBL1yrQriPn7HKZAIWTUmCTi1HudGKRrsIp1NCo11EudEKnVqORVOSuN6biHyeIF14CuKHNmzYgCVLlqC2trbTjzUajQgLC0NdXR0Mhu6fcZVUm2FvZ1g2UBlClIjWqb3djQ5zW+ftlKCUcZ03EfkX35tVRH5Fr/Gv4AaAScnRmDg4ihXWiMhvBV14W61WWK1W189GI5cFdZVOo0AfvX8FdzOZTEBaQpi3u0FE1CU+d837ueeegyAIF/2zf//+Lh//xRdfRFhYmOtPYmKiB3sfPJqqk2m83Q0ioqDkc9e8KysrUVl58RKVAwcOhEZzPjg6c827rTPvxMREXvPuBK1KgViDulWhEyIi6h0+N2weHR2N6OiemzSkVquhVvvnUK8vCFHJGdxERF7mc+HdGcXFxaiurkZxcTFEUcThw4cBAMnJydDpdN7tXADSKOWI1WsY3EREXubX4f3MM8/gnXfecf08evRoAMC2bdswdepUL/UqMKmVcsQZNJyRTUTkA3zumndv4zrvS1MpZIgPC4GcwU1E5BN8brY5+RalXIY4g4bBTUTkQxje1C6lXIb4MA0U7ezCRURE3sFPZWqTQiZDHIObiMgn8ZOZWpHLBMSFaaBkcBMR+SR+OpOb5uBWKfirQUTkq/gJTS4yQUCsQQO1Qu7trhAR0UUwvAlAU3DHhWmgUTK4iYh8HcObGNxERH7GryusUffJZU1D5QxuIiL/wfAOYs3LwTg5jYjIvzC8g5RSLuNyMCIiP8XwDkIqRVPJUxZgISLyTwzvIKPh7mBERH6P4R1EtCoFYg1q7sdNROTnGN5BQqdWoI+ewU1EFAgY3kFAr1Gij17t7W4QEZGHMLwDXFiIElE6BjcRUSBheAewyFAVwrUqb3eDiIg8jOEdoKL1ahg0Sm93g4iIegDDO8AIgoA+ejV0av7TEhEFKn7CBxBBEBBrUEOr4j8rEVEg46d8gODOYEREwYPhHQDksqbgVisY3EREwYDh7ee4MxgRUfBhePsxpVyG+DBuMEJEFGwY3n5KpZAhPiwEcm4wQkQUdBjefog7gxERBTeGt5/hzmBERMTw9iM6jQJ9dAxuIqJgx/D2E4YQJaK5wQgREYHh7RfCtSpEhnKDESIiasLw9nFRoWqEabnBCBERncfw9mHcGYyIiNrC8PZBgiAgRq9GKHcGIyKiNjAdfIxMEBBr0CBExTrlRETUNoa3D5HLmoKbO4MREdHFMLx9hEImQ2yYmjuDERHRJTG8fYBS3rQzmJIbjBARUQcwvL2MO4MREVFnMby9SH1ugxHuDEZERJ3B8PaSEJUcsXruDEZERJ3H8PaCULUCMXpuMEJERF3D8O5lOo0CMXqNt7tBRER+jOHdi7gzGBEReQLDu5eEhSgRxeAmIiIPYHj3Am7pSUREnsTw7mERWhUiGNxERORBrAzSg8IZ3ERE1AMY3j3EEKLkUDkREfUIhncP0GkUnFVOREQ9hte8PUynVnConIiIehTPvD2MwU1ERD2N4U1ERORnGN5ERER+huFNRETkZxjeREREfobhTURE5GcY3kRERH6G4U1ERORnGN5ERER+huFNRETkZxjeREREfobhTURE5GcY3kRERH6G4U1ERORnGN5ERER+huFNRETkZxjeREREfobhTURE5GcU3u6At0mSBAAwGo1e7gkRERGg1+shCMJF7xP04V1fXw8ASExM9HJPiIiIgLq6OhgMhoveR5CaTz2DlNPpRGlpaYe+6XiT0WhEYmIiSkpKLvmPSk34nnUN37fO43vWeXzP2scz7w6QyWRISEjwdjc6zGAw8Be9k/iedQ3ft87je9Z5fM+6hhPWiIiI/AzDm4iIyM8wvP2EWq3Gs88+C7Va7e2u+A2+Z13D963z+J51Ht+z7gn6CWtERET+hmfeREREfobhTURE5GcY3kRERH6G4U1ERORnGN5+pqioCPfccw8GDRqEkJAQJCUl4dlnn4XNZvN213za888/j0mTJkGr1SI8PNzb3fFZa9aswaBBg6DRaDB27Fjs2rXL213yaTt37sQNN9yAvn37QhAEbNq0ydtd8nkvvvgixo8fD71ej5iYGMydOxfHjh3zdrf8DsPbz/zwww9wOp144403kJubi5UrV+Kvf/0rli1b5u2u+TSbzYZbbrkFixYt8nZXfNZHH32EJUuW4Omnn8ahQ4cwefJkzJ49G8XFxd7ums9qaGjAqFGj8Nprr3m7K35jx44dWLx4Mfbu3YusrCw4HA5kZGSgoaHB213zK1wqFgBeeuklZGZm4sSJE97uis/bsGEDlixZgtraWm93xedcfvnlGDNmDDIzM11tw4cPx9y5c/Hiiy96sWf+QRAEbNy4EXPnzvV2V/zK2bNnERMTgx07duDqq6/2dnf8Bs+8A0BdXR0iIyO93Q3yYzabDQcOHEBGRoZbe0ZGBvbs2eOlXlEwqKurAwB+hnUSw9vPFRYW4tVXX8UDDzzg7a6QH6usrIQoioiNjXVrj42NRXl5uZd6RYFOkiQsXboUV111FUaOHOnt7vgVhrePeO655yAIwkX/7N+/3+0xpaWluPbaa3HLLbfg3nvv9VLPvacr7xld3IXbEEqS5NNb5ZJ/e+ihh3DkyBF88MEH3u6K3wn6LUF9xUMPPYRbb731ovcZOHCg6++lpaWYNm0arrjiCrz55ps93Dvf1Nn3jNoXHR0NuVze6iy7oqKi1dk4kSc8/PDD+Pe//42dO3f61bbMvoLh7SOio6MRHR3dofuePn0a06ZNw9ixY7F+/XrIZME5gNKZ94wuTqVSYezYscjKysK8efNc7VlZWZgzZ44Xe0aBRpIkPPzww9i4cSO2b9+OQYMGebtLfonh7WdKS0sxdepU9O/fH8uXL8fZs2ddt8XFxXmxZ76tuLgY1dXVKC4uhiiKOHz4MAAgOTkZOp3Ou53zEUuXLsX8+fMxbtw414hOcXEx51NchMlkQkFBgevnkydP4vDhw4iMjET//v292DPftXjxYrz//vv49NNPodfrXaM9YWFhCAkJ8XLv/IhEfmX9+vUSgDb/UPsWLFjQ5nu2bds2b3fNp7z++uvSgAEDJJVKJY0ZM0basWOHt7vk07Zt29bm79WCBQu83TWf1d7n1/r1673dNb/Cdd5ERER+JjgvlhIREfkxhjcREZGfYXgTERH5GYY3ERGRn2F4ExER+RmGNxERkZ9heBMREfkZhjcREZGfYXgTERH5GYY3BY2pU6diyZIlHj9uVVUVYmJiUFRU5PFjE918881YsWKFt7tBPobhTdRNL774Im644QbX9qMLFy507SeuVCoRGxuLmTNn4u2334bT6XQ97lJ7kS9cuNA7L4h8yjPPPIPnn38eRqPR210hH8LwJuqGxsZGrFu3Dvfee69b+7XXXouysjIUFRXhP//5D6ZNm4ZHH30U119/PRwOBwCgrKzM9eeVV16BwWBwa1u1apU3XhL5mPT0dAwcOBDvvfeet7tCPoThTUHJarXikUceQUxMDDQaDa666ip89913bvepr6/HHXfcgdDQUMTHx2PlypWtht7/85//QKFQ4IorrnB7rFqtRlxcHPr164cxY8Zg2bJl+PTTT/Gf//wHGzZsANC0hWvzn7CwMAiC0KqNCABuvPFGfPDBB97uBvkQhjcFpf/7v//DP//5T7zzzjs4ePAgkpOTMWvWLFRXV7vus3TpUnz77bf497//jaysLOzatQsHDx50O87OnTsxbty4Dj3n9OnTMWrUKPzrX//y6GuhwDdhwgTs27cPVqvV210hH8HwpqDT0NCAzMxMvPTSS5g9ezZGjBiBt956CyEhIVi3bh2AprPud955B8uXL8c111yDkSNHYv369RBF0e1YRUVF6Nu3b4efe9iwYZ2a2KZQKHDZZZfhsssuazU0//nnn2Po0KEYMmQI1q5de9HjfP7553j44Yc7/Lye8PXXX2PlypW9+py9ZdOmTZ2e/DhlypQuT2rs168frFYrysvLu/R4CjwKb3eAqLcVFhbCbrfjyiuvdLUplUpMmDABeXl5AIATJ07AbrdjwoQJrvuEhYVh6NChbsdqbGyERqPp8HNLkgRBEDp8//DwcBw+fLhVu8PhwNKlS7Ft2zYYDAaMGTMGP/3pTxEZGdnmcY4cOYLRo0d3+Hk9YcaMGZgxY0avPmdvOXLkCNLT0zv1mKKiItekxs4KCQkBAJjN5i49ngIPz7wp6EiSBACtQrRlsF7sPi1FR0ejpqamw8+dl5eHQYMGdbrPF9q3bx9SU1PRr18/6PV6XHfddfjqq6/avf+RI0eQl5eHsWPHIjU1Ffn5+QCAd999F5dffjnS0tJw4403wmaz4eDBg7j22mtdj/3nP/+JxYsXAwCOHTuG6667DmPHjsXUqVNRWVkJAHjjjTcwZswYjBw5ErfffjsAYPbs2cjLy2vzOZpvf/bZZzFx4kQMGDAAR48ebdXv2bNnY+nSpZg4cSKGDRuG7777DjfeeCMGDBiAN99803W/9vrVnedu1tZraw7v9PR017//t99+iwULFrgel5ubi4kTJ2LUqFFYsWIFEhMTXY+94oorkJ6ejhdeeAHXX3/9RV8DANflnD59+rTbTwouDG8KOsnJyVCpVNi9e7erzW63Y//+/Rg+fDgAICkpCUqlEvv27XPdx2g04vjx427HGj169EU/+FvaunUrsrOzcdNNN3W4r0ajEWPHjsVVV12FHTt2uNpLS0vRr18/188JCQk4ffp0u8c5cuQI+vfvjwMHDuDhhx92rRu+7rrr8L///Q/Z2dmIjo7Grl27kJ6e7npNdrsdzz//PJ555hlYrVYsXrwYb775Jg4cOICbb74Za9euRU1NDd5880189913yMnJwZo1awAAx48fx5AhQ9p8DgDIycnBoEGDsHfvXtx333347LPPWvU7JycH6enp2Lt3LyZMmIBf/epX+OCDD/Dpp59i/fr1ANBuv9p7fR19bgDtvrbc3FwMHToUJpMJERERrvc4NTUVQNOIzK233oq3334b33//PbZv34709HTY7XYsWLAA69evx5EjR7B7926kpaVd9DU09zchIQHR0dHt/htTcGF4U9AJDQ3FokWL8OSTT2Lz5s04evQo7rvvPpjNZtxzzz0AAL1ejwULFuDJJ5/Etm3bkJubi1/84heQyWRuZ+OzZs1Cbm5uq7Pv5uuTp0+fxsGDB/HCCy9gzpw5uP7663HXXXd1uK9FRUU4cOAA/vrXv+Kuu+5yrfW9cAQAaD1K0LIvNpvNdfacnp6OyspKSJKEN998E+PHj8eoUaOwceNGaDQaKBQKJCQkoKSkBJmZmZg7dy5iY2OxadMmHD16FNdffz0uu+wyvP7661AqlVAoFKiqqsKvfvUr5ObmIjw8HHV1ddDpdJDL5W0+R11dHZRKpWstu0qlQnh4uFu/6+rqoFKpXPfRaDR49NFHERoaCrVa7ZqN316/2nt9HXnuZm29NrPZDJlMhuLiYqSkpLju2zK8N27ciKlTp2LEiBEAgKFDhyI9PR2ffPIJrrzySgwbNgwAMHz4cKSnp7f7Gprt2rULGRkZbfaRghOveVNQ+tOf/gSn04n58+ejvr4e48aNw1dffeU6iwKAFStW4IEHHsD1118Pg8GA//u//0NJSYnbNe60tDSMGzcO//jHP3D//fe72jdv3oz4+HgoFApERERg1KhRWL16NRYsWACZrOPfmZsnw40cORIjRoxAfn4+xo0bh379+rmdaZ86dQqXX355m8fIzc3FiBEjXM976NAhpKenY8OGDSgoKMDOnTsREhKCAQMGuMJmwoQJ2Lp1K9566y3s3bsXAJCdnY2XX34Zt912W6vnyM7OxqZNm3DzzTfjpZdeQkREBFJTU9t9jpycHLf5BDk5OfjlL3/pdsycnByMHz/e7Tl+//vfu/4+cuTIi/Zr/fr1XX7uZnq9vtVri4mJQWpqKnJyclx9AID9+/fjqaeecr3nLa+JHzx4EPPmzcMXX3zh1t78pfCDDz5o9721WCzYuHHjRS+LUPDhmTcFje3bt+OVV14B0HQWt3r1apw9exYWiwW7d+92Cwqg6YP7vffeQ0NDA8rKyvDLX/4Sx44dQ3Jystv9fvvb32LVqlWu6mkbNmyAJEmQJAl2ux0VFRXIysrC3Xff3W5wL1y4ELW1tW5tNTU1rqVBp06dwtGjRzF48GAATeGak5OD06dPo76+Hl9++SVmzZoFALjmmmvcgv3IkSOuSXoVFRXYsGEDHnzwQeTm5mLSpEkICQlx9b/5y8uECROwdOlSPPTQQwgNDQXQtC69ZYBkZ2cDaBoe1+v1mD9/PiZPngyr1eoKtvaeIycnB2lpaW7HahmEANzuI0kSzpw5g7i4uFa3tdevrjz3he9dW6+t+Xp3dXW1ayLZzp07cezYMfTv3x8AEBUV5br0sGXLFmzfvh1paWmIiopyXXrZunUrdu7ciaFDh7b7GgBg3bp1uPzyyzFx4kQQNWN4E7Xj0KFD+OCDD1BYWIiDBw/ijjvuAADMmTPH7X7XXXcd7r///otec+6KvLw8jBs3DqNGjcL111+PVatWuWaTKxQKvPzyy5g2bRpGjx6NJ598ElFRUZAkCQUFBW6zzpuvs48fPx4zZszAn/70J0RHR2P+/Pn4wx/+gClTpqCqqsot0FJSUhATE+O2PO3uu+9GbW0thg0bhlGjRuH9998HAPzhD3/A0KFDMXr0aGg0GsybNw+5ubkYOXJku8+Rm5vr+rvD4YDJZGo1dN3yPhfO1G4ZwO31q7PP3dZ719Zry87ORnp6Oq699lps3LgRt99+O77++msMHz7cdenizjvvxM6dOzFmzBj8/e9/x6BBg6DX63HnnXdi27ZtmDhxIj7//HNcfvnlUCgU7b4GoGklxKuvvtqp3x0KfILU1sUzIsKhQ4dw77334tixY1CpVBg7dixWrFjhFnK+Ji8vD2+99Va3N7K4++67cdNNN7lmQgcDT713F9PQ0IDQ0FA4nU783//9H4YPH+6aZ0HUGQxvInIpLCzEddddh1mzZmH16tXe7k7AefbZZ/HPf/4TCoUCP/nJT/DHP/6xU+v+iZoxvImIiPwMr3kTERH5GYY3ERGRn2F4ExER+RmGNxERkZ9heBMREfkZhjcREZGfYXgTERH5GYY3ERGRn2F4ExER+RmGNxERkZ9heBMREfkZhjcREZGf+X+7eUhbrLRidwAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 500x500 with 1 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "from scipy import stats\n",
     "model1 = ols('hl_log_bayesian_mean_x ~ hl_log_bayesian_mean_y', data=df_read_across).fit(cov_type = 'HC3')\n",
     "slope, intercept, r_value, p_value, std_err = stats.linregress(df_read_across['hl_log_bayesian_mean_x'],df_read_across['hl_log_bayesian_mean_y'])\n",
     "sns.lmplot(data=df_read_across, x=\"hl_log_bayesian_mean_x\", y=\"hl_log_bayesian_mean_y\", ci=95, line_kws={'label':\"y={0:.2f}x+{1:.2f}\".format(slope, intercept)}).set(xlabel='log(DT$_{50, bayesian\\;mean, sludge}$)', ylabel='log(DT$_{50, bayesian\\; mean, soil}$)')\n",
     "plt.annotate('R$^2$: {}'.format(round(model1.rsquared_adj,2)), (-2, 2.5))\n",
     "plt.legend()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 147,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "<matplotlib.legend.Legend at 0x1e9206f3fd0>"
       ]
      },
      "execution_count": 147,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 500x500 with 1 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "from scipy import stats\n",
     "model1 = ols('hl_log_bayesian_mean_x ~ hl_log_bayesian_mean_y_calculated', data=df_read_across).fit(cov_type = 'HC3')\n",
     "slope, intercept, r_value, p_value, std_err = stats.linregress(df_read_across['hl_log_bayesian_mean_x'],df_read_across['hl_log_bayesian_mean_y_calculated'])\n",
     "\n",
     "MSE = np.square(np.subtract(df_read_across['hl_log_bayesian_mean_x'], df_read_across['hl_log_bayesian_mean_y_calculated'])).mean()   \n",
     "rmse = math.sqrt(MSE) \n",
     "\n",
     "sns.lmplot(data=df_read_across, x=\"hl_log_bayesian_mean_x\", y=\"hl_log_bayesian_mean_y_calculated\", ci=95, line_kws={'label':\"y={0:.2f}x+{1:.2f}\".format(slope, intercept)}).set(xlabel='log(DT$_{50, bayesian mean, sludge}$)', ylabel='calculated log(DT$_{50, bayesian mean, soil}$)')\n",
     "plt.annotate('R$^2$: {}'.format(round(model1.rsquared_adj,2)), (-2, 5))\n",
     "plt.annotate('RMSE: {}'.format(round(rmse, 2)), (-2,4.6))\n",
     "plt.legend()"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3.9.13 ('envipath')",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.9.13"
   },
   "orig_nbformat": 4,
   "vscode": {
    "interpreter": {
     "hash": "2347b11aabc7676a0034671a85ea3c0a49e970a2c62f233a06be25b5abf82f7b"
    }
   }
  },
  "nbformat": 4,
  "nbformat_minor": 2
 }
diff --git a/output/bay_area/extract_all_compounds_.py b/output/bay_area/extract_all_compounds_.py
new file mode 100644
index 0000000..a1e8e6e
--- /dev/null
+++ b/output/bay_area/extract_all_compounds_.py
@@ -0,0 +1,669 @@
+import sys
+import numpy as np
+import pandas as pd
+# pd.set_option('display.max_columns', None)
+sys.path.insert(0, "C:\\Users\\leetseng\\enviPath-python\\enviPath_python\\")     #previous address C:\envipath_code\Users\leetseng\enviPath-python   C:\\Users\\leetseng\\enviPath-python\\enviPath_python\\
+sys.path.insert(1, "C:\\Users\\leetseng\\enviPath-python\\")
+from enviPath import *
+from objects import *
+import rdkit
+from rdkit import Chem
+from rdkit.Chem.MolStandardize import rdMolStandardize
+from rdkit.Chem import Descriptors
+from rdkit.Chem.rdMolDescriptors import CalcMolFormula
+
+file_location = "C:\\Users\\leetseng\\TWtest"
+# input_file_path = file_location+'input/sludge_compounds_final.txt'
+output_file_path_full = file_location+'\\output\\sludge_Rich_raw.tsv'
+
+# Define the instance to use
+INSTANCE_HOST = 'https://envipath.org'
+USERNAME = 'leetseng'
+PASSWORD = getpass.getpass(prompt = "Enter your password:")
+
+eP = enviPath(INSTANCE_HOST)
+eP.login(USERNAME, PASSWORD)   #getpass.getpass()
+# eP.logout()
+print(eP.who_am_i().get_name())
+package_id = 'https://envipath.org/packag3e/8dd7ca2-ae4e-4779-a6a2-d3539237c439'
+#Leo Sludge     'https://envipath.org/package/195bc500-f0c6-4bcb-b2fe-f1602b5f20a2'
+#Rich Sludge  'https://envipath.org/package/8d3d7ca2-ae4e-4779-a6a2-d3539237c439'
+#Original Sludge  'https://envipath.org/package/4a3cd0f4-4d2b-4f00-b3e6-a29e721f7038'
+package = Package(eP.requester, id=package_id)
+all_scenarios = package.get_scenarios()
+all_pathways = package.get_pathways()
+print('Number of scenarios found:', len(all_scenarios))
+print('Number of pathways found:', len(all_pathways))
+
+
+def __main__():
+    D = {
+
+         "scenario_id": [], "compound_id": [], "compound_name": [], "smiles": [], "reduced_smiles": [],
+         "halflife_raw": [], "halflife_unit": [], "halflife_model_TF": [], "halflife_comment": [],
+         "rateconstant": [], "rateconstant_unit": [], "rateconstant_comment": [], "halflife_model": [],
+         "acidity": [], "acidity_unit": [],
+         "temperature": [], "temperature_unit": [],
+         "original_sludge_amount": [], "original_sludge_amount_unit": [],
+         "sludge_retention_time": [], "sludge_retention_time_unit": [], "sludge_retention_time_type": [],
+         "total_suspended_solids_concentration_start": [], "total_suspended_solids_concentration_end": [], "total_suspended_solids_concentration_unit": [],
+         # "volatile_suspended_solids_concentration_start": [], "volatile_suspended_solids_concentration_end": [], "volatile_suspended_solids_concentration_unit": [],
+         "addition_of_nutrients": [], "biological_treatment_technology": [],
+         "bioreactor_type": [], "bioreactor_value": [], "bioreactor_value_unit": [],
+         "nitrogen_content_type": [], "nitrogen_content_influent": [],
+         "oxygen_demand_type": [], "oxygen_demand_value": [],
+         "oxygen_uptake_rate": [], "oxygen_uptake_rate_unit": [],
+         "phosphorus_content": [],
+         "redox": [],
+         "source_of_liquid_matrix": [],
+         "type_of_addition": [],
+         "type_of_aeration": [],
+         "inoculum_source": [],
+         "location": [],
+         "purpose_of_wwtp": [],
+          }
+    #testing
+    # scenario_id = ''
+    # test_scenario = Scenario(eP.requester, id=scenario_id)
+    # add_info = test_scenario.get_additional_information()
+    # rateconstant_test = add_info.get_rateconstant()
+    #
+    # print(rateconstant_test)
+
+    i = 0
+    for pathway in all_pathways:
+        for node in pathway.get_nodes():
+            print(node.get_id())  #this is not compound_id, it should be the Node id.
+            i += 1
+            print("checking node # ", i)
+            try:
+                scenarios = node.get_scenarios()
+            except:
+                continue
+            else:
+                for scenario in scenarios:
+                    D = add_scenario_information(D, scenario, node)
+    sludge_df = pd.DataFrame.from_dict(D)
+    sludge_df.index = np.arange(1, len(sludge_df) + 1)
+    sludge_df.index.name = 'index'
+    print(sludge_df.describe())
+    sludge_df.to_csv(output_file_path_full, mode='w', sep="\t") #a, w, r
+
+
+
+
+def add_scenario_information(D, scenario, node):
+    full_scenario = Scenario(eP.requester, id=scenario.get_id())
+    add_info = full_scenario.get_additional_information()
+    try:
+        halflife_object = add_info.get_halflife()
+        has_hf = True
+    except AttributeError:
+        has_hf = False
+    try:
+        rateconstant_object = add_info.get_rateconstant()
+        has_rateconstant = True
+    except AttributeError:
+        has_rateconstant = False
+    if has_hf or has_rateconstant:  ###
+        D['compound_id'].append(arcessere_compound_id(node))
+        D['compound_name'].append(arcessere_compound_name(node))
+        D['smiles'].append(arcessere_smiles(node))
+        D['reduced_smiles'].append(canonicalize_smiles(arcessere_smiles(node)))
+        # D['reduced_smiles'].append(reduced_smiles)  # cropped_canonical_smiles_no_stereo
+
+        print(full_scenario.get_id())
+        D['acidity'].append(arcessere_acidity(add_info))
+        D['acidity_unit'].append(arcessere_acidity_unit(add_info))
+        D['addition_of_nutrients'].append(arcessere_addition_of_nutrients(add_info))
+        D['biological_treatment_technology'].append(arcessere_biological_treatment_technology(add_info))
+        D['bioreactor_type'].append(arcessere_bioreactor_type(add_info))
+        D['bioreactor_value'].append(arcessere_bioreactor_value(add_info))
+        D['bioreactor_value_unit'].append(arcessere_bioreactor_value_unit(add_info))
+        # D['confidencelevel'].append(arcessere_confidencelevel(add_info))
+        D['halflife_raw'].append(arcessere_halflife(add_info))
+        D['halflife_unit'].append(arcessere_halflife_unit(add_info))
+        D['halflife_model_TF'].append(arcessere_halflife_model(add_info))
+        D['halflife_comment'].append(arcessere_halflife_comment(add_info))
+        D['inoculum_source'].append(arcessere_inoculum_source(add_info))
+        D['location'].append(arcessere_location(add_info))
+        D['nitrogen_content_type'].append(arcessere_nitrogen_content_type(add_info))
+        D['nitrogen_content_influent'].append(arcessere_nitrogen_content_influent(add_info))
+        D['original_sludge_amount'].append(arcessere_original_sludge_amount(add_info))
+        D['original_sludge_amount_unit'].append(arcessere_original_sludge_amount_unit(add_info))
+        D['oxygen_demand_type'].append(arcessere_oxygen_demand_type(add_info))
+        D['oxygen_demand_value'].append(arcessere_oxygen_demand_value(add_info))
+        D['oxygen_uptake_rate_unit'].append(arcessere_oxygen_uptake_rate_unit(add_info))
+        D['oxygen_uptake_rate'].append(arcessere_oxygen_uptake_rate(add_info))
+        D['phosphorus_content'].append(arcessere_phosphorus_content(add_info))
+        D['purpose_of_wwtp'].append(arcessere_purpose_of_wwtp(add_info))
+        D['rateconstant'].append(arcessere_rate_constant(add_info))
+        D['rateconstant_unit'].append(arcessere_rate_constant_unit(add_info))
+        D['halflife_model'].append(arcessere_reaction_order(add_info))
+        D['rateconstant_comment'].append(arcessere_rate_constant_comment(add_info))
+        D['redox'].append(arcessere_redox(add_info))
+        D['scenario_id'].append(scenario.get_id())
+        D['sludge_retention_time_type'].append(arcessere_sludge_retention_time_type(add_info))
+        D['sludge_retention_time'].append(arcessere_sludge_retention_time(add_info))
+        D['sludge_retention_time_unit'].append(arcessere_sludge_retention_time_unit(add_info))
+        D['source_of_liquid_matrix'].append(arcessere_source_of_liquid_matrix(add_info))
+        D['temperature'].append(arcessere_temperature(add_info))
+        D['temperature_unit'].append(arcessere_temperature_unit(add_info))
+        D['total_suspended_solids_concentration_start'].append(arcessere_tss_start(add_info))
+        D['total_suspended_solids_concentration_end'].append(arcessere_tss_end(add_info))
+        D['total_suspended_solids_concentration_unit'].append(arcessere_tss_unit(add_info))
+        D['type_of_addition'].append(arcessere_type_of_addition(add_info))
+        D['type_of_aeration'].append(arcessere_type_of_aeration(add_info))
+        # D['volatile_suspended_solids_concentration_start'].append(arcessere_volatile_ss_start(add_info))
+        # D['volatile_suspended_solids_concentration_end'].append(arcessere_volatile_ss_end(add_info))
+        # D['volatile_suspended_solids_concentration_unit'].append(arcessere_volatile_ss_unit(add_info))
+    return D
+
+
+def arcessere_compound_id(node):
+    try:
+        id_from_node = node.get_default_structure().get_id()
+    except:
+        return ''
+    else:
+        return id_from_node
+
+def arcessere_compound_name(node):
+    try:
+        name_from_node = node.get_default_structure().get_name()
+    except ValueError:
+        return ''
+    else:
+        return name_from_node             #.split(',')[0]  only pick up one compound name
+
+def arcessere_smiles(node):
+    try:
+        smiles_from_node = node.get_default_structure().get_smiles()
+    except:
+        return ''
+    else:
+        return smiles_from_node
+
+def canonicalize_smiles(smiles_from_node):
+    mol = Chem.MolFromSmiles(smiles_from_node) # creates mol object from SMILES
+    uncharger = rdMolStandardize.Uncharger() # easier to access
+    uncharged = uncharger.uncharge(mol) # protonates or deprotonates the mol object
+    new_smiles = rdkit.Chem.rdmolfiles.MolToSmiles(uncharged) # converts mol object to canonical SMILES
+    can_smiles = Chem.CanonSmiles(new_smiles)
+    return can_smiles
+
+def arcessere_acidity(add_info):
+    try:
+        raw_pH = add_info.get_acidity().get_value()
+    except:
+        return np.NaN
+    else:
+        if ';' in raw_pH:
+            if ' - ' in raw_pH:
+                pH = range_to_average(raw_pH.split(';')[0])
+            else:
+                pH = float(raw_pH.split(';')[0])
+            return np.round(pH, 1)
+
+def arcessere_acidity_unit(add_info):
+    try:
+        pH_unit = add_info.get_acidity().get_unit()
+    except:
+        return ''
+    else:
+        return pH_unit
+
+def arcessere_addition_of_nutrients(add_info):
+    try:
+        addition_of_nutrients = add_info.get_additionofnutrients().get_value()
+    except:
+        return ''
+    else:
+        return addition_of_nutrients
+
+def arcessere_biological_treatment_technology(add_info):
+    try:
+        biological_treatment_technology = add_info.get_biologicaltreatmenttechnology().get_value()
+    except:
+        return ''
+    else:
+        return biological_treatment_technology
+
+def arcessere_bioreactor_type(add_info):    #########################################
+    try:
+        bioreactor_type = add_info.get_bioreactor().get_value().split(',')[0]
+    except:
+        return ''
+    else:
+        return bioreactor_type
+
+
+def arcessere_bioreactor_value(add_info):
+    try:
+        bioreactor = float(add_info.get_bioreactor().get_value().split(',')[1])
+    except ValueError:
+        return np.NaN
+    except:
+        return np.NaN
+    else:
+        return bioreactor
+
+def arcessere_bioreactor_value_unit(add_info):
+    try:
+        bioreactor_unit = add_info.get_bioreactor().get_unit()
+    except:
+        return ''
+    else:
+        return bioreactor_unit
+
+def arcessere_confidencelevel(add_info):
+    try:
+        confidencelevel = add_info.get_confidencelevel().get_value()
+    except:
+        return np.NaN
+    else:
+        return float(confidencelevel)
+
+def arcessere_inoculum_source(add_info):
+    try:
+        inoculumsource = add_info.get_inoculumsource().get_value()
+    except:
+        return ''
+    else:
+        return inoculumsource
+
+def arcessere_location(add_info):
+    try:
+        location = add_info.get_location().get_value()
+    except:
+        return ''
+    else:
+        return location
+
+def arcessere_minormajor(add_info):
+    try:
+        minormajor = add_info.get_minormajor().get_value()
+    except:
+        return ''
+    else:
+        return minormajor
+
+def arcessere_nitrogen_content_type(add_info):
+    try:
+        nitrogencontent = add_info.get_nitrogencontent().get_value()
+    except:
+        return ''
+    else:
+        if '&#8322' in nitrogencontent.split(';')[0]:
+            return nitrogencontent.split(';')[0].replace('&#8322', '\u2082')
+        elif '&#8323' in nitrogencontent.split(';')[0]:
+            return nitrogencontent.split(';')[0].replace('&#8323', '\u2083')
+        elif '&#8324' in nitrogencontent.split(';')[0]:
+            return nitrogencontent.split(';')[0].replace('&#8324', '\u2084')
+
+
+def arcessere_nitrogen_content_influent(add_info):
+    try:
+        nitrogencontent = add_info.get_nitrogencontent().get_value()
+    except:
+        return np.NaN
+    else:
+        return float(nitrogencontent.split(';')[1])
+
+def arcessere_original_sludge_amount(add_info):
+    try:
+        originalsludgeamount = add_info.get_originalsludgeamount().get_value()
+    except:
+        return np.NaN
+    else:
+        return originalsludgeamount
+
+def arcessere_original_sludge_amount_unit(add_info):
+    try:
+        originalsludgeamount_unit = add_info.get_originalsludgeamount().get_unit()
+    except:
+        return ''
+    else:
+        return originalsludgeamount_unit
+
+def arcessere_oxygen_demand_type(add_info):           #checking scenario 298
+    try:
+        oxygendemand = add_info.get_oxygendemand().get_value()
+    except:
+        return ''
+    else:
+        return oxygendemand.split(';')[0]             #return chemical oxygen demand or biological oxygen demand
+
+def arcessere_oxygen_demand_value(add_info):
+    try:
+        oxygendemand = add_info.get_oxygendemand().get_value()
+    except:
+        return np.NaN
+    else:
+        return float(oxygendemand.split(';')[1])
+
+def arcessere_oxygen_uptake_rate(add_info):
+    try:
+        our = add_info.get_oxygenuptakerate.get_value()
+    except:
+        return np.NaN
+    else:
+        return range_to_average(our)
+def arcessere_oxygen_uptake_rate_unit(add_info):
+    try:
+        sludgeretentiontime_unit = add_info.get_oxygenuptakerate().get_unit()
+    except:
+        return ''
+    else:
+        # return sludgeretentiontime_unit
+        if "&#8315&#185" in sludgeretentiontime_unit.split(' ')[1] and "&#8315&#185" in sludgeretentiontime_unit.split(' ')[2]:
+            return sludgeretentiontime_unit.split(' ')[0] + '/(L * h)'
+
+def arcessere_phosphorus_content(add_info):
+    try:
+        phosphoruscontent = add_info.get_phosphoruscontent().get_value()
+    except:
+        return np.NaN
+    else:
+        return phosphoruscontent.split(';')[0]
+
+def arcessere_proposed_intermediate(add_info):
+    try:
+        proposedintermediate = add_info.get_proposedintermediate().get_value()
+    except:
+        return ''
+    else:
+        return proposedintermediate
+
+def arcessere_purpose_of_wwtp(add_info):
+    try:
+        purposeofwwtp = add_info.get_purposeofwwtp().get_value()
+    except:
+        return ''
+    else:
+        return purposeofwwtp
+
+def arcessere_redox(add_info):
+    try:
+        redox = add_info.get_redox().get_value()
+    except:
+        return ''
+    else:
+        return redox
+
+def arcessere_sludge_retention_time_type(add_info):
+    try:
+        sludgeretentiontime = add_info.get_sludgeretentiontime().get_value()
+    except:
+        return ''
+    else:
+        return sludgeretentiontime.split(';')[0]
+
+def arcessere_sludge_retention_time(add_info):
+    try:
+        sludgeretentiontime = add_info.get_sludgeretentiontime().get_value()
+    except:
+        return np.NaN
+    else:
+        return float(sludgeretentiontime.split(';')[1])
+
+def arcessere_sludge_retention_time_unit(add_info):
+    try:
+        sludgeretentiontime_unit = add_info.get_sludgeretentiontime().get_unit()
+    except:
+        return ''
+    else:
+        return sludgeretentiontime_unit
+
+def arcessere_source_of_liquid_matrix(add_info):
+    try:
+        sourceofliquidmatrix = add_info.get_sourceofliquidmatrix().get_value()
+    except:
+        return ''
+    else:
+        return sourceofliquidmatrix
+def arcessere_tss_start(add_info):
+    try:
+        tts = add_info.get_tts().get_value()
+    except:
+        return np.NaN    #not sure if this return type is correct or not
+    else:
+        return float(tts.split(' _ ')[0].split(' - ')[0])
+
+def arcessere_tss_end(add_info):
+    try:
+        tts = add_info.get_tts().get_value()
+    except:
+        return np.NaN   #not sure if this return type is correct or not
+    else:
+        return float(tts.split(' _ ')[0].split(' - ')[1])
+
+def arcessere_tss_unit(add_info):
+    try:
+        tts_unit = add_info.get_tts().get_unit()
+    except:
+        return ''
+    else:
+        return tts_unit
+
+def arcessere_type_of_addition(add_info):
+    try:
+        typeofaddition = add_info.get_typeofaddition().get_value()
+    except:
+        return ''
+    else:
+        return typeofaddition
+def arcessere_type_of_aeration(add_info):
+    try:
+        typeofaeration = add_info.get_typeofaeration().get_value()
+    except:
+        return ''
+    else:
+        return typeofaeration
+
+def arcessere_volatile_ss_start(add_info):
+    try:
+        vss_start = add_info.get_volatiletts().get_value()
+    except:
+        return np.NaN   #not sure if this return type is correct or not
+    else:
+        if ' - ' in vss_start:
+            return float(vss_start.split(' - ')[0])
+        else:
+            return float(vss_start)
+
+def arcessere_volatile_ss_end(add_info):
+    try:
+        vss_end = add_info.get_volatiletts().get_value()
+    except:
+        return np.NaN  #not sure if this return type is correct or not
+    else:
+        if ' - ' in vss_end:
+            return float(vss_end.split(' - ')[1])
+        else:
+            return float(vss_end)
+def arcessere_volatile_ss_unit(add_info):
+    try:
+        vss_unit = add_info.get_volatiletts().get_unit()
+    except:
+        return ''
+    else:
+        return vss_unit
+
+def range_to_average(input_string):
+    if '-' in input_string:
+        min = float(input_string.split(' - ')[0])
+        max = float(input_string.split(' - ')[1])
+        average = np.average([min, max])
+    elif ';' in input_string:
+        min = float(input_string.split(';')[0])
+        max = float(input_string.split(';')[1])
+        average = np.average([min, max])
+    else:
+        average = input_string
+    return average
+
+def arcessere_rate_constant(add_info):
+    try:
+        rate_constant = add_info.get_rateconstant().get_value()
+    except:
+        return np.NaN
+    else:
+        # return float(rate_constant.split(';')[2].split(' - ')[0])
+        min = rate_constant.split(';')[2].split(' - ')[0]
+        max = rate_constant.split(';')[2].split(' - ')[1]
+        if min != 'NaN' and max != 'NaN':
+            average = np.average([float(min), float(max)])
+        elif min != 'NaN' and max == 'NaN':
+            average = float(min)
+        elif min == 'NaN' and max != 'NaN':
+            average = float(max)
+        return average
+
+def arcessere_rate_constant_unit(add_info):
+    try:
+        rate_constant_unit = add_info.get_rateconstant().get_unit()
+    except:
+        return ''
+    else:
+        if '&#956;g' in rate_constant_unit:
+            return rate_constant_unit.replace('&#956;g', '\u338D')
+        else:
+            return rate_constant_unit
+
+def arcessere_reaction_order(add_info):
+    try:
+        rate_constant = add_info.get_rateconstant().get_value()
+    except:
+        return ''
+    else:
+        return rate_constant.split(';')[0]
+
+def arcessere_rate_constant_comment(add_info):
+    try:
+        rate_constant_comment = add_info.get_rateconstant().get_value().split(';')[3]
+    except:
+        return ''
+    else:
+        return rate_constant_comment
+
+def arcessere_halflife(add_info):
+    try:
+        hf = add_info.get_halflife().get_value()
+    except:
+        return np.NaN
+    else:
+        # return float(hf.split(';')[3].split(' - ')[0])
+        min = float(hf.split(';')[3].split(' - ')[0])
+        max = float(hf.split(';')[3].split(' - ')[1])
+        average = np.average([min, max])
+        return average
+
+
+def arcessere_halflife_unit(add_info):
+    try:
+        hf_unit = add_info.get_halflife().get_unit()
+    except:
+        return ''
+    else:
+        return hf_unit
+
+def arcessere_halflife_model(add_info):
+    try:
+        hl = add_info.get_halflife().get_value()
+    except:
+        return ''
+    else:
+        return hl.split(';')[0]
+
+def arcessere_halflife_comment(add_info):
+    try:
+        hl = add_info.get_halflife().get_value()
+    except:
+        return ''
+    else:
+        return hl.split(';')[2]
+
+def arcessere_halflife_source(add_info):
+    try:
+        hl = add_info.get_halflife().get_value()
+    except:
+        return ''
+    else:
+        return hl.split(';')[4]
+
+def arcessere_temperature(add_info):
+    try:
+        temp = add_info.get_temperature().get_value()
+    except:
+        return np.NaN
+    else:
+        min = float(temp.split(';')[0])
+        max = float(temp.split(';')[1])
+        return np.round(np.average([min, max]), 0)
+
+def arcessere_temperature_unit(add_info):
+    try:
+        temp_unit = add_info.get_temperature().get_unit()
+    except:
+        return ''
+    else:
+        return '\u2103'
+#Do not iterate all the scenarios at once.
+# scenario_datatypes = set()
+# for scenario in all_scenarios[350:494]:
+#     scen = Scenario(eP.requester, id=scenario.get_id())
+#     addinfo = scen.get_additional_information()
+#     if addinfo:
+#         for dt in addinfo.get_data_types():
+#             scenario_datatypes.add(dt)
+# print(scenario_atatypes)
+#
+# "Dissolvedoxygenconcentrationaerationtype": "No attribute",
+# "finalcompoundconcentration": "No attribute",
+# "solventforcompoundsolution": "No attribute",
+# "dissolvedorganiccarbonamionauptakerate": 0,
+# "typeofaerationoxygenuptakerate": 0,
+#
+# scenario_data_types_count = {
+# "acidity": 439,
+# "additionofnutrients": 38,
+# "biologicaltreatmenttechnology": 356,
+# "bioreactor_type": 491,
+# "bioreactor_value": 491,
+# "confidencelevel": 164,
+# "halflife": 15,
+# "halflife_model": 15,
+# "halflife_comment": 15,
+# "inoculumsource": 449,
+# "location": 473,
+# "minormajor": 18,
+# "nitrogencontent_type": 105,
+# "nitrogencontent_influent": 105,
+# "originalsludgeamount": 408,
+# "oxygendemand": 99,
+# "phosphoruscontent": 88,
+# "proposedintermediate": 18,
+# "purposeofwwtp": 475,
+# "rateconstant": 218,
+# "rateconstant_comment": 218,
+# "reaction_order": 218,
+# "redox": 482,
+# "sludgeretentiontime": 381,
+# "sludgeretentiontimetype": 381,
+# "sourceofliquidmatrix": 403,
+# "temperature": 403,
+# "tts_start": 398,
+# "tts_end": 398,
+# "typeofaddition": 426,
+# "typeofaeration": 470,
+# "volatiletts_start": 15,
+# "volatiletts_end": 15,
+# }
+# df2 = pd.DataFrame.from_dict(scenario_data_types_count, orient='index')
+# print(df2)
+# sns.countplot(data=df2, x=)
+# plt.show()
+
+
+__main__()
\ No newline at end of file
diff --git a/output/bay_area/find_tautomers.ipynb b/output/bay_area/find_tautomers.ipynb
new file mode 100644
index 0000000..835418d
--- /dev/null
+++ b/output/bay_area/find_tautomers.ipynb
@@ -0,0 +1,38 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.13 ('envipath')",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13 (main, Aug 25 2022, 23:51:50) [MSC v.1916 64 bit (AMD64)]"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "2347b11aabc7676a0034671a85ea3c0a49e970a2c62f233a06be25b5abf82f7b"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/output/bay_area/prepare_descriptors.ipynb b/output/bay_area/prepare_descriptors.ipynb
index 4f8c7a1..c475138 100644
--- a/output/bay_area/prepare_descriptors.ipynb
+++ b/output/bay_area/prepare_descriptors.ipynb
@@ -1,2715 +1,2768 @@
 {
  "cells": [
   {
    "cell_type": "code",
    "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
     "import pandas as pd\n",
     "import numpy as np\n",
     "import seaborn as sns\n",
     "import matplotlib.pyplot as plt\n",
     "from scipy.stats import gmean\n",
     "pd.options.display.max_columns = None "
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
     "# input_file_path = \"C:\\\\Users\\\\leetseng\\\\TWtest\\\\input\\\\\"\n",
     "output_path = \"C:\\\\Users\\\\leetseng\\\\TWtest\\\\output\\\\bay_area\\\\\"\n",
     "output_path_des = output_path + \"descriptors\\\\\"\n",
     "\n",
     "#This files already contain the bay mean and bay std.\n",
     "#The reduced SMILES of previous files were generated from other toolkit. This file lead to inconsistant of SMILES.\n",
     "file_name_soil = \"soil_model_input_full.txt\"      #soil_model_input_bayes_curated_full.txt\n",
     "file_name_sludge = \"sludge_bay_PriorMuStd_3.tsv\"   #sludge_bayesian_PriorMuStd_09.tsv\n",
     "df_soil_original = pd.read_csv(output_path + file_name_soil, sep='\\t')\n",
     "df_sludge_original = pd.read_csv(output_path + file_name_sludge, sep='\\t')\n",
     "\n",
     "#Use the copy of dataframe for the later test and manipulation\n",
     "df_soil_ = df_soil_original.copy()\n",
     "df_sludge_ = df_sludge_original.copy()\n",
     "df_sludge_.loc[:, 'package'] = 0  # O: sludge, 1: soil\n",
     "df_soil_.loc[:, 'package'] = 1"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
     "def index_merge_descriptor(df1, df2):\n",
     "    df_new = pd.merge(df1, df2, how='inner', on='index')\n",
     "    # print(df_new.shape)\n",
     "    return df_new\n",
     "\n",
     "soil_padel_descriptor = pd.read_csv(output_path_des + 'soil_PaDEL_descriptors.txt', sep='\\t')\n",
     "soil_maccs_descriptor = pd.read_csv(output_path_des  + 'soil_MACCS_descriptors.txt', sep='\\t')  # shape = (160, 485)\n",
     "soil_rule_descriptor = pd.read_csv(output_path_des  + 'soil_rule_descriptors_TRIG.txt', sep='\\t')  # shape = (160, 192)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 141,
    "metadata": {},
    "outputs": [],
    "source": [
     "# from txt file to descriptor.tsv\n",
     "# for soil_descriptor, from index to reduced_smiles\n",
     "# generate the pure descriptor\n",
     "\n",
     "def non_nan_mean(x):\n",
     "    if x.empty:   \n",
     "        return None\n",
     "    else:\n",
     "        x = x.dropna()\n",
     "        return np.mean(x)\n",
     "\n",
     "def index_to_smiles(df_target_Y, des_):  # des_X: df of descriptor,  Y: df_soil or df_sludge, X, should be from the same package   sludge=0, soil=1\n",
     "    target_Y_ = df_target_Y.copy()\n",
     "    # target_Y_.loc[:, 'package'] = package_label\n",
     "    aggs = [non_nan_mean]\n",
     "    df_subset_XY = target_Y_[[\"reduced_smiles\", \"index\"]]  # \"temperature\", \"log_hl_combined\", \"log_hl_biomass_corrected\"\n",
     "    XY = df_subset_XY.groupby([\"reduced_smiles\"]).agg(aggs).reset_index()\n",
     "    XY.columns = XY.columns.droplevel(1)\n",
     "    XY['index'] = XY['index'].astype(np.int64)\n",
     "\n",
     "    XY_merge_des = pd.merge(XY, des_, how='left', on='index')\n",
     "    # XY_merge_des.dropna(axis=0, inplace=True)\n",
     "    XY_merge_des.drop(columns=['index'], inplace=True)\n",
     "    # XY_merge_des.drop(columns=['Unnamed: 0','topoShape'], inplace=True)\n",
     "    return XY_merge_des\n",
     "\n",
     "df_soil_all = pd.read_csv(output_path+\"soil_model_input_full.txt\", sep='\\t')\n",
     "\n",
     "soil_padel_descriptor = pd.read_csv(output_path_des + 'soil_PaDEL_descriptors.txt', sep='\\t')\n",
     "soil_maccs_descriptor = pd.read_csv(output_path_des  + 'soil_MACCS_descriptors.txt', sep='\\t')  # shape = (160, 485)\n",
     "soil_rule_descriptor = pd.read_csv(output_path_des  + 'soil_rule_descriptors_TRIG.txt', sep='\\t')  # shape = (160, 192)\n",
     "\n",
     "\n",
     "\n",
     "soil_padel_descriptor = index_to_smiles(df_soil_all, soil_padel_descriptor)\n",
     "# soil_maccs_descriptor = index_to_smiles(df_soil_all, soil_maccs_descriptor)\n",
     "soil_rule_descriptor = index_to_smiles(df_soil_all, soil_rule_descriptor)\n",
     "\n",
     "soil_padel_descriptor.to_csv(output_path_des  + \"soil_padel_descriptor.tsv\", sep='\\t', index=False)\n",
     "soil_maccs_descriptor.to_csv(output_path_des  + \"soil_maccs_descriptor.tsv\", sep='\\t', index=False)\n",
     "soil_rule_descriptor.to_csv(output_path_des  + \"soil_rule_descriptor.tsv\", sep='\\t', index=False)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 142,
    "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>index</th>\n",
        "      <th>struct-1</th>\n",
        "      <th>struct-2</th>\n",
        "      <th>struct-3</th>\n",
        "      <th>struct-4</th>\n",
        "      <th>struct-5</th>\n",
        "      <th>struct-6</th>\n",
        "      <th>struct-7</th>\n",
        "      <th>struct-8</th>\n",
        "      <th>struct-9</th>\n",
        "      <th>struct-10</th>\n",
        "      <th>struct-11</th>\n",
        "      <th>struct-12</th>\n",
        "      <th>struct-13</th>\n",
        "      <th>struct-14</th>\n",
        "      <th>struct-15</th>\n",
        "      <th>struct-16</th>\n",
        "      <th>struct-17</th>\n",
        "      <th>struct-18</th>\n",
        "      <th>struct-19</th>\n",
        "      <th>struct-20</th>\n",
        "      <th>struct-21</th>\n",
        "      <th>struct-22</th>\n",
        "      <th>struct-23</th>\n",
        "      <th>struct-24</th>\n",
        "      <th>struct-25</th>\n",
        "      <th>struct-26</th>\n",
        "      <th>struct-27</th>\n",
        "      <th>struct-28</th>\n",
        "      <th>struct-29</th>\n",
        "      <th>struct-30</th>\n",
        "      <th>struct-31</th>\n",
        "      <th>struct-32</th>\n",
        "      <th>struct-33</th>\n",
        "      <th>struct-34</th>\n",
        "      <th>struct-35</th>\n",
        "      <th>struct-36</th>\n",
        "      <th>struct-37</th>\n",
        "      <th>struct-38</th>\n",
        "      <th>struct-39</th>\n",
        "      <th>struct-40</th>\n",
        "      <th>struct-41</th>\n",
        "      <th>struct-42</th>\n",
        "      <th>struct-43</th>\n",
        "      <th>struct-44</th>\n",
        "      <th>struct-45</th>\n",
        "      <th>struct-46</th>\n",
        "      <th>struct-47</th>\n",
        "      <th>struct-48</th>\n",
        "      <th>struct-49</th>\n",
        "      <th>struct-50</th>\n",
        "      <th>struct-51</th>\n",
        "      <th>struct-52</th>\n",
        "      <th>struct-53</th>\n",
        "      <th>struct-54</th>\n",
        "      <th>struct-55</th>\n",
        "      <th>struct-56</th>\n",
        "      <th>struct-57</th>\n",
        "      <th>struct-58</th>\n",
        "      <th>struct-59</th>\n",
        "      <th>struct-60</th>\n",
        "      <th>struct-61</th>\n",
        "      <th>struct-62</th>\n",
        "      <th>struct-63</th>\n",
        "      <th>struct-64</th>\n",
        "      <th>struct-65</th>\n",
        "      <th>struct-66</th>\n",
        "      <th>struct-67</th>\n",
        "      <th>struct-68</th>\n",
        "      <th>struct-69</th>\n",
        "      <th>struct-70</th>\n",
        "      <th>struct-71</th>\n",
        "      <th>struct-72</th>\n",
        "      <th>struct-73</th>\n",
        "      <th>struct-74</th>\n",
        "      <th>struct-75</th>\n",
        "      <th>struct-76</th>\n",
        "      <th>struct-77</th>\n",
        "      <th>struct-78</th>\n",
        "      <th>struct-79</th>\n",
        "      <th>struct-80</th>\n",
        "      <th>struct-81</th>\n",
        "      <th>struct-82</th>\n",
        "      <th>struct-83</th>\n",
        "      <th>struct-84</th>\n",
        "      <th>struct-85</th>\n",
        "      <th>struct-86</th>\n",
        "      <th>struct-87</th>\n",
        "      <th>struct-88</th>\n",
        "      <th>struct-89</th>\n",
        "      <th>struct-90</th>\n",
        "      <th>struct-91</th>\n",
        "      <th>struct-92</th>\n",
        "      <th>struct-93</th>\n",
        "      <th>struct-94</th>\n",
        "      <th>struct-95</th>\n",
        "      <th>struct-96</th>\n",
        "      <th>struct-97</th>\n",
        "      <th>struct-98</th>\n",
        "      <th>struct-99</th>\n",
        "      <th>struct-100</th>\n",
        "      <th>struct-101</th>\n",
        "      <th>struct-102</th>\n",
        "      <th>struct-103</th>\n",
        "      <th>struct-104</th>\n",
        "      <th>struct-105</th>\n",
        "      <th>struct-106</th>\n",
        "      <th>struct-107</th>\n",
        "      <th>struct-108</th>\n",
        "      <th>struct-109</th>\n",
        "      <th>struct-110</th>\n",
        "      <th>struct-111</th>\n",
        "      <th>struct-112</th>\n",
        "      <th>struct-113</th>\n",
        "      <th>struct-114</th>\n",
        "      <th>struct-115</th>\n",
        "      <th>struct-116</th>\n",
        "      <th>struct-117</th>\n",
        "      <th>struct-118</th>\n",
        "      <th>struct-119</th>\n",
        "      <th>struct-120</th>\n",
        "      <th>struct-121</th>\n",
        "      <th>struct-122</th>\n",
        "      <th>struct-123</th>\n",
        "      <th>struct-124</th>\n",
        "      <th>struct-125</th>\n",
        "      <th>struct-126</th>\n",
        "      <th>struct-127</th>\n",
        "      <th>struct-128</th>\n",
        "      <th>struct-129</th>\n",
        "      <th>struct-130</th>\n",
        "      <th>struct-131</th>\n",
        "      <th>struct-132</th>\n",
        "      <th>struct-133</th>\n",
        "      <th>struct-134</th>\n",
        "      <th>struct-135</th>\n",
        "      <th>struct-136</th>\n",
        "      <th>struct-137</th>\n",
        "      <th>struct-138</th>\n",
        "      <th>struct-139</th>\n",
        "      <th>struct-140</th>\n",
        "      <th>struct-141</th>\n",
        "      <th>struct-142</th>\n",
        "      <th>struct-143</th>\n",
        "      <th>struct-144</th>\n",
        "      <th>struct-145</th>\n",
        "      <th>struct-146</th>\n",
        "      <th>struct-147</th>\n",
        "      <th>struct-148</th>\n",
        "      <th>struct-149</th>\n",
        "      <th>struct-150</th>\n",
        "      <th>struct-151</th>\n",
        "      <th>struct-152</th>\n",
        "      <th>struct-153</th>\n",
        "      <th>struct-154</th>\n",
        "      <th>struct-155</th>\n",
        "      <th>struct-156</th>\n",
        "      <th>struct-157</th>\n",
        "      <th>struct-158</th>\n",
        "      <th>struct-159</th>\n",
        "      <th>struct-160</th>\n",
        "      <th>struct-161</th>\n",
        "      <th>struct-162</th>\n",
        "      <th>struct-163</th>\n",
        "      <th>struct-164</th>\n",
        "      <th>struct-165</th>\n",
        "      <th>struct-166</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>4</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>5</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>6</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>11</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
        "      <td>15</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>889</th>\n",
        "      <td>2593</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>890</th>\n",
        "      <td>2599</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>891</th>\n",
        "      <td>2600</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>892</th>\n",
        "      <td>2601</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>893</th>\n",
        "      <td>2605</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "<p>894 rows × 167 columns</p>\n",
        "</div>"
       ],
       "text/plain": [
        "     index  struct-1  struct-2  struct-3  struct-4  struct-5  struct-6  \\\n",
        "0        4         0         0         0         0         0         0   \n",
        "1        5         0         0         0         0         0         0   \n",
        "2        6         0         0         0         0         0         0   \n",
        "3       11         0         0         0         0         0         0   \n",
        "4       15         0         0         0         0         0         0   \n",
        "..     ...       ...       ...       ...       ...       ...       ...   \n",
        "889   2593         0         0         0         0         0         0   \n",
        "890   2599         0         0         0         0         0         0   \n",
        "891   2600         0         0         0         0         0         0   \n",
        "892   2601         0         0         0         0         0         0   \n",
        "893   2605         0         0         0         0         0         0   \n",
        "\n",
        "     struct-7  struct-8  struct-9  struct-10  struct-11  struct-12  struct-13  \\\n",
        "0           0         0         0          0          0          0          0   \n",
        "1           0         0         0          0          0          0          0   \n",
        "2           0         0         0          0          0          0          0   \n",
        "3           0         0         0          0          0          0          0   \n",
        "4           0         0         0          0          0          0          0   \n",
        "..        ...       ...       ...        ...        ...        ...        ...   \n",
        "889         0         0         0          0          0          0          0   \n",
        "890         0         0         0          0          0          0          0   \n",
        "891         0         0         0          0          0          0          0   \n",
        "892         0         0         0          0          0          0          0   \n",
        "893         0         0         0          0          0          0          0   \n",
        "\n",
        "     struct-14  struct-15  struct-16  struct-17  struct-18  struct-19  \\\n",
        "0            0          0          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          0          0          0          0   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          0          0          0          0          0   \n",
        "892          0          0          0          0          0          0   \n",
        "893          0          0          0          0          0          0   \n",
        "\n",
        "     struct-20  struct-21  struct-22  struct-23  struct-24  struct-25  \\\n",
        "0            0          0          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          0          0          0          0   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          0          0          0          0          0   \n",
        "892          0          0          0          0          0          0   \n",
        "893          0          0          0          0          0          0   \n",
        "\n",
        "     struct-26  struct-27  struct-28  struct-29  struct-30  struct-31  \\\n",
        "0            0          0          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          0          0          0          0   \n",
        "890          0          0          1          0          0          0   \n",
        "891          0          0          1          0          0          0   \n",
        "892          0          0          1          0          0          0   \n",
        "893          0          0          0          0          0          0   \n",
        "\n",
        "     struct-32  struct-33  struct-34  struct-35  struct-36  struct-37  \\\n",
        "0            0          0          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          1   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          0          0          0          0   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          0          0          0          0          0   \n",
        "892          0          0          0          0          0          0   \n",
        "893          0          0          0          0          0          0   \n",
        "\n",
        "     struct-38  struct-39  struct-40  struct-41  struct-42  struct-43  \\\n",
        "0            0          0          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          1          1          0          0          0   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          0          0          0          0          0   \n",
        "892          0          1          1          0          0          0   \n",
        "893          0          0          0          0          0          0   \n",
        "\n",
        "     struct-44  struct-45  struct-46  struct-47  struct-48  struct-49  \\\n",
        "0            0          0          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          0          0          1          0   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          0          0          0          0          0   \n",
        "892          0          0          0          0          1          0   \n",
        "893          0          0          0          0          0          0   \n",
        "\n",
        "     struct-50  struct-51  struct-52  struct-53  struct-54  struct-55  \\\n",
        "0            0          0          1          0          0          0   \n",
        "1            0          0          1          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          1          0          1          0          1   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          1          0          0          0          0   \n",
        "892          0          1          0          0          0          1   \n",
        "893          0          0          0          0          0          0   \n",
        "\n",
        "     struct-56  struct-57  struct-58  struct-59  struct-60  struct-61  \\\n",
        "0            0          0          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          1          0          1          1   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          0          0          0          1          1   \n",
        "892          0          0          1          0          1          1   \n",
        "893          0          1          0          0          0          0   \n",
        "\n",
        "     struct-62  struct-63  struct-64  struct-65  struct-66  struct-67  \\\n",
        "0            0          0          0          1          0          0   \n",
        "1            0          0          0          1          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          0          0          0          1   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          0          0          0          0          1   \n",
        "892          0          0          0          0          0          1   \n",
        "893          1          0          0          0          0          0   \n",
        "\n",
        "     struct-68  struct-69  struct-70  struct-71  struct-72  struct-73  \\\n",
        "0            0          1          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          1          0          0          0          1   \n",
        "890          0          0          0          0          1          0   \n",
        "891          0          0          0          0          0          1   \n",
        "892          0          1          0          0          0          1   \n",
        "893          0          0          0          0          0          0   \n",
        "\n",
        "     struct-74  struct-75  struct-76  struct-77  struct-78  struct-79  \\\n",
        "0            0          0          0          1          0          1   \n",
        "1            0          1          0          1          0          1   \n",
        "2            0          0          0          0          0          0   \n",
        "3            1          0          0          1          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          0          0          0          0   \n",
        "890          0          0          0          0          0          0   \n",
        "891          0          0          0          0          0          0   \n",
        "892          0          0          0          0          0          0   \n",
        "893          0          1          0          0          0          0   \n",
        "\n",
        "     struct-80  struct-81  struct-82  struct-83  struct-84  struct-85  \\\n",
        "0            1          0          0          1          0          0   \n",
        "1            1          0          0          1          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          0          1          0          0          1   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          0          0          0          0   \n",
        "890          0          0          0          0          0          1   \n",
        "891          0          0          0          0          0          1   \n",
        "892          0          0          0          0          0          1   \n",
        "893          0          0          0          0          0          1   \n",
        "\n",
        "     struct-86  struct-87  struct-88  struct-89  struct-90  struct-91  \\\n",
        "0            0          0          0          0          0          0   \n",
        "1            0          0          0          0          0          0   \n",
        "2            0          0          0          0          0          0   \n",
        "3            1          0          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          0          0          1          1          1          0   \n",
        "890          1          0          0          1          0          1   \n",
        "891          1          0          1          1          0          1   \n",
        "892          1          0          1          1          0          0   \n",
        "893          1          0          0          0          0          0   \n",
        "\n",
        "     struct-92  struct-93  struct-94  struct-95  struct-96  struct-97  \\\n",
        "0            0          0          1          0          1          0   \n",
        "1            0          0          1          1          1          1   \n",
        "2            0          0          0          0          0          0   \n",
        "3            0          1          0          0          0          0   \n",
        "4            0          0          0          0          0          0   \n",
        "..         ...        ...        ...        ...        ...        ...   \n",
        "889          1          0          0          0          0          1   \n",
        "890          1          0          0          1          0          0   \n",
        "891          1          0          0          0          0          1   \n",
        "892          1          0          0          0          0          1   \n",
        "893          0          0          0          1          0          0   \n",
        "\n",
        "     struct-98  struct-99  struct-100  struct-101  struct-102  struct-103  \\\n",
        "0            0          0           0           0           0           0   \n",
        "1            0          0           1           0           0           0   \n",
        "2            0          1           0           0           0           1   \n",
        "3            0          0           0           0           0           0   \n",
        "4            0          0           0           1           0           0   \n",
        "..         ...        ...         ...         ...         ...         ...   \n",
        "889          0          0           0           0           1           0   \n",
        "890          0          0           1           0           0           0   \n",
        "891          0          0           1           0           1           0   \n",
        "892          0          0           1           0           1           0   \n",
        "893          1          0           1           1           0           0   \n",
        "\n",
        "     struct-104  struct-105  struct-106  struct-107  struct-108  struct-109  \\\n",
        "0             0           0           0           0           0           0   \n",
        "1             1           0           0           0           0           0   \n",
        "2             0           0           0           0           0           0   \n",
        "3             0           0           1           0           0           1   \n",
        "4             0           1           0           0           0           0   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           1           0           1           0           1           0   \n",
        "890           0           0           0           0           1           1   \n",
        "891           1           0           0           0           1           1   \n",
        "892           1           0           1           0           1           1   \n",
        "893           0           0           0           0           1           0   \n",
        "\n",
        "     struct-110  struct-111  struct-112  struct-113  struct-114  struct-115  \\\n",
        "0             0           0           0           0           0           0   \n",
        "1             0           1           0           0           0           0   \n",
        "2             0           0           0           0           0           0   \n",
        "3             1           0           0           0           0           1   \n",
        "4             0           0           0           0           0           0   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           1           1           1           0           1           0   \n",
        "890           1           0           0           0           1           0   \n",
        "891           1           1           0           0           1           0   \n",
        "892           1           1           1           0           1           0   \n",
        "893           0           1           0           0           0           1   \n",
        "\n",
        "     struct-116  struct-117  struct-118  struct-119  struct-120  struct-121  \\\n",
        "0             0           0           0           0           1           1   \n",
        "1             0           0           0           0           1           1   \n",
        "2             0           0           0           0           0           0   \n",
        "3             0           1           0           0           0           0   \n",
        "4             0           0           0           0           0           0   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           0           1           0           0           0           0   \n",
        "890           1           1           0           0           0           0   \n",
        "891           1           1           0           0           0           0   \n",
        "892           1           1           0           0           0           0   \n",
        "893           0           0           1           0           1           1   \n",
        "\n",
        "     struct-122  struct-123  struct-124  struct-125  struct-126  struct-127  \\\n",
        "0             0           0           1           0           0           0   \n",
        "1             1           1           1           0           0           0   \n",
        "2             0           0           0           0           0           0   \n",
        "3             1           0           0           0           0           0   \n",
        "4             0           1           0           1           0           0   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           0           0           1           0           0           0   \n",
        "890           1           1           0           0           1           0   \n",
        "891           1           1           1           0           1           0   \n",
        "892           1           0           1           0           1           0   \n",
        "893           1           0           0           0           0           0   \n",
        "\n",
        "     struct-128  struct-129  struct-130  struct-131  struct-132  struct-133  \\\n",
        "0             0           0           0           0           0           0   \n",
        "1             0           0           0           0           1           0   \n",
        "2             0           0           0           0           0           0   \n",
        "3             0           0           0           1           0           1   \n",
        "4             0           0           0           0           0           0   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           0           0           1           1           1           1   \n",
        "890           1           0           0           0           0           1   \n",
        "891           1           1           0           0           1           1   \n",
        "892           1           1           1           0           1           1   \n",
        "893           1           1           0           0           1           1   \n",
        "\n",
        "     struct-134  struct-135  struct-136  struct-137  struct-138  struct-139  \\\n",
        "0             0           0           0           1           0           0   \n",
        "1             0           0           0           1           0           1   \n",
        "2             1           0           0           0           0           0   \n",
        "3             0           1           0           0           0           1   \n",
        "4             0           0           0           0           0           1   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           0           1           1           0           0           1   \n",
        "890           0           1           1           0           1           1   \n",
        "891           0           1           1           0           1           1   \n",
        "892           0           1           1           0           1           1   \n",
        "893           0           0           0           1           1           0   \n",
        "\n",
        "     struct-140  struct-141  struct-142  struct-143  struct-144  struct-145  \\\n",
        "0             0           0           1           0           0           0   \n",
        "1             0           0           1           0           0           0   \n",
        "2             0           0           0           0           0           0   \n",
        "3             0           1           1           0           0           0   \n",
        "4             0           0           0           0           0           1   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           1           0           0           0           1           0   \n",
        "890           1           1           0           0           1           0   \n",
        "891           1           1           0           0           1           0   \n",
        "892           1           1           0           0           1           0   \n",
        "893           0           0           0           0           0           0   \n",
        "\n",
        "     struct-146  struct-147  struct-148  struct-149  struct-150  struct-151  \\\n",
        "0             0           0           0           0           0           1   \n",
        "1             0           0           1           0           0           0   \n",
        "2             0           0           0           0           0           0   \n",
        "3             0           0           1           1           0           1   \n",
        "4             0           0           0           0           0           0   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           1           0           1           1           1           1   \n",
        "890           1           0           1           1           1           0   \n",
        "891           1           0           1           1           1           0   \n",
        "892           1           0           1           1           1           0   \n",
        "893           0           1           1           1           0           0   \n",
        "\n",
        "     struct-152  struct-153  struct-154  struct-155  struct-156  struct-157  \\\n",
        "0             0           0           0           0           0           0   \n",
        "1             0           1           1           1           1           1   \n",
        "2             0           1           0           1           0           0   \n",
        "3             0           1           1           1           1           1   \n",
        "4             0           0           1           0           0           1   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           0           1           1           1           1           0   \n",
        "890           0           1           1           1           1           1   \n",
        "891           0           1           1           1           1           1   \n",
        "892           0           1           1           1           1           1   \n",
        "893           1           1           0           0           1           1   \n",
        "\n",
        "     struct-158  struct-159  struct-160  struct-161  struct-162  struct-163  \\\n",
        "0             0           0           0           1           1           0   \n",
        "1             1           1           0           1           1           0   \n",
        "2             0           0           0           0           0           0   \n",
        "3             1           1           1           1           1           1   \n",
        "4             0           1           0           0           1           1   \n",
        "..          ...         ...         ...         ...         ...         ...   \n",
        "889           1           1           1           1           1           1   \n",
        "890           1           1           1           1           1           1   \n",
        "891           1           1           1           1           1           1   \n",
        "892           1           1           1           1           1           1   \n",
        "893           1           0           1           1           0           1   \n",
        "\n",
        "     struct-164  struct-165  struct-166  \n",
        "0             0           1           0  \n",
        "1             1           1           0  \n",
        "2             0           0           0  \n",
        "3             1           1           0  \n",
        "4             1           1           0  \n",
        "..          ...         ...         ...  \n",
        "889           1           1           0  \n",
        "890           1           1           0  \n",
        "891           1           1           0  \n",
        "892           1           1           0  \n",
        "893           1           1           0  \n",
        "\n",
        "[894 rows x 167 columns]"
       ]
      },
      "execution_count": 142,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "soil_maccs_descriptor"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# prepare the mixed descriptor\n",
     "def merge_descriptor(df1, df2):\n",
     "    df_new = pd.merge(df1, df2, how='left', on ='reduced_smiles')\n",
     "    print(df_new.shape)\n",
     "    return df_new\n",
     "\n",
     "soil_padel_maccs_descriptor = merge_descriptor(soil_padel_descriptor, soil_maccs_descriptor)\n",
     "soil_padel_maccs_descriptor.drop_duplicates(inplace=True)\n",
     "soil_padel_maccs_descriptor.to_csv(output_path_des+\"soil_padel_maccs_descriptor.tsv\", sep='\\t', index=False)\n",
     "\n",
     "\n",
     "soil_padel_rule_descriptor = merge_descriptor(soil_padel_descriptor, soil_rule_descriptor)\n",
     "soil_padel_rule_descriptor.drop_duplicates(inplace=True)\n",
     "soil_padel_rule_descriptor.to_csv(output_path_des+\"soil_padel_rule_descriptor.tsv\", sep='\\t', index=False)\n",
     "\n",
     "soil_maccs_rule_descriptor = merge_descriptor(soil_maccs_descriptor, soil_rule_descriptor)\n",
     "soil_maccs_rule_descriptor.drop_duplicates(inplace=True)\n",
     "soil_maccs_rule_descriptor.to_csv(output_path_des+\"soil_maccs_rule_descriptor.tsv\", sep='\\t', index=False)\n",
     "\n",
     "soil_all_descriptor = merge_descriptor(soil_padel_maccs_descriptor, soil_rule_descriptor)\n",
     "soil_all_descriptor.drop_duplicates(inplace=True)\n",
     "soil_all_descriptor.to_csv(output_path_des+\"soil_all_descriptor.tsv\", sep='\\t', index=False)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 130,
    "metadata": {},
    "outputs": [],
    "source": [
     "def non_nan_mean(x):\n",
     "    if x.empty:   \n",
     "        return None\n",
     "    else:\n",
     "        x = x.dropna()\n",
     "        return np.mean(x)\n",
     "\n",
     "def get_subset_target_variable(df_target_Y, des_X, package_label):  # des_X: df of descriptor,  Y: df_soil or df_sludge, X, should be from the same package   sludge=0, soil=1\n",
     "    target_Y_ = df_target_Y.copy()\n",
     "    target_Y_.loc[:, 'package'] = package_label\n",
     "    aggs = [non_nan_mean]\n",
     "    df_subset_XY = target_Y_[[\"reduced_smiles\", \"hl_log_bayesian_mean\", \"package\"]]  # \"temperature\", \"log_hl_combined\", \"log_hl_biomass_corrected\"\n",
     "    XY = df_subset_XY.groupby([\"reduced_smiles\"]).agg(aggs).reset_index()\n",
     "    XY.columns = XY.columns.droplevel(1)\n",
     "    XY_merge_des = pd.merge(XY, des_X, how='left', on='reduced_smiles')\n",
     "    # XY_merge_des.dropna(axis=0, inplace=True)\n",
     "    # XY_merge_des.drop(columns=['index'], inplace=True)\n",
     "    return XY_merge_des\n",
     "\n",
     "soil_XY_merge_padel = get_subset_target_variable(df_soil_, soil_padel_descriptor, 1)\n",
     "soil_XY_merge_maccs = get_subset_target_variable(df_soil_, soil_maccs_descriptor, 1)\n",
     "soil_XY_merge_rule = get_subset_target_variable(df_soil_, soil_rule_descriptor, 1)\n",
     "soil_XY_merge_padel_maccs = get_subset_target_variable(df_soil_, soil_padel_maccs_descriptor, 1)\n",
     "soil_XY_merge_padel_rule = get_subset_target_variable(df_soil_, soil_padel_rule_descriptor, 1)\n",
     "soil_XY_merge_maccs_rule = get_subset_target_variable(df_soil_, soil_maccs_rule_descriptor, 1)\n",
     "soil_XY_merge_all = get_subset_target_variable(df_soil_, soil_all_descriptor, 1)\n",
     "soil_XY_merge_padel_maccs\n",
     "# X_sludge_des, X_validate, y_sludge_des, y_validate = train_test_split(sludge_XY_merge_des.iloc[:, 2:], sludge_XY_merge_des['hl_log_bayesian_mean'], test_size=0.10, random_state=62)\n",
     "\n",
     "soil_XY_merge_padel.to_csv(output_path_des+\"soil_XY_merge_padel.tsv\", sep='\\t', index=False)\n",
     "soil_XY_merge_maccs.to_csv(output_path_des+\"soil_XY_merge_maccs.tsv\", sep='\\t', index=False)\n",
     "soil_XY_merge_rule.to_csv(output_path_des+\"soil_XY_merge_rule.tsv\", sep='\\t', index=False)\n",
     "soil_XY_merge_padel_maccs.to_csv(output_path_des+\"soil_XY_merge_padel_maccs.tsv\", sep='\\t', index=False)\n",
     "soil_XY_merge_padel_rule.to_csv(output_path_des+\"soil_XY_merge_padel_rule.tsv\", sep='\\t', index=False)\n",
     "soil_XY_merge_maccs_rule.to_csv(output_path_des+\"soil_XY_merge_maccs_rule.tsv\", sep='\\t', index=False)\n",
     "soil_XY_merge_all.to_csv(output_path_des+\"soil_XY_merge_all.tsv\", sep='\\t', index=False)\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 211,
    "metadata": {},
    "outputs": [],
    "source": [
     "sludge_padel_descriptor = pd.read_csv(output_path_des+\"sludge_padel_descriptor.tsv\", sep='\\t')\n",
     "sludge_maccs_descriptor = pd.read_csv(output_path_des+\"sludge_maccs_descriptor.tsv\", sep='\\t')\n",
     "sludge_rule_descriptor = pd.read_csv(output_path_des+\"sludge_rule_descriptor.tsv\", sep='\\t')\n",
     "\n",
     "sludge_padel_maccs_descriptor = pd.read_csv(output_path_des+\"sludge_padel_maccs_descriptor.tsv\", sep='\\t')\n",
     "sludge_padel_rule_descriptor = pd.read_csv(output_path_des+\"sludge_padel_rule_descriptor.tsv\", sep='\\t')\n",
     "sludge_maccs_rule_descriptor = pd.read_csv(output_path_des+\"sludge_maccs_rule_descriptor.tsv\", sep='\\t')\n",
     "\n",
     "sludge_all_descriptor = pd.read_csv(output_path_des+\"sludge_all_descriptor.tsv\", sep='\\t')\n",
     "# sludge_all_descriptor = pd.read_csv(output_path+\"sludge_all_descriptor.tsv\", sep='\\t')\n",
     "# sludge_maccs_rule_descriptor.drop(columns='struct-0', inplace=True)\n",
     "sludge_maccs_descriptor.drop(columns=sludge_maccs_descriptor.iloc[:, 167:], inplace=True)\n",
     "# sludge_maccs_descriptor.to_csv(output_path_des+\"sludge_maccs_descriptor.tsv\", sep='\\t', index=False)\n",
     "\n",
     "# sludge_padel_maccs_descriptor.drop(columns='struct-0', inplace=True)\n",
     "# sludge_padel_maccs_descriptor.drop(columns=sludge_padel_maccs_descriptor.iloc[:, 1614:], inplace=True)\n",
     "# sludge_padel_maccs_descriptor.to_csv(output_path_des+\"sludge_padel_maccs_descriptor.tsv\", sep='\\t', index=False)\n",
     "\n",
     "# sludge_maccs_rule_descriptor.drop(columns='struct-0', inplace=True)\n",
     "# sludge_maccs_rule_descriptor.drop(columns=sludge_maccs_rule_descriptor.iloc[:, 167:193], inplace=True)\n",
     "# sludge_maccs_rule_descriptor.to_csv(output_path_des+\"sludge_maccs_rule_descriptor.tsv\", sep='\\t', index=False)\n",
     "\n",
     "# sludge_all_descriptor.drop(columns='struct-0', inplace=True)\n",
     "# sludge_all_descriptor.drop(columns=sludge_all_descriptor.iloc[:, 1611:1636], inplace=True)\n",
     "# sludge_all_descriptor.to_csv(output_path_des+\"sludge_all_descriptor.tsv\", sep='\\t', index=False)\n",
     "\n",
     "sludge_XY_merge_padel = get_subset_target_variable(df_sludge_, sludge_padel_descriptor, 0)\n",
     "sludge_XY_merge_maccs = get_subset_target_variable(df_sludge_, sludge_maccs_descriptor, 0)\n",
     "sludge_XY_merge_rule = get_subset_target_variable(df_sludge_, sludge_rule_descriptor, 0)\n",
     "\n",
     "sludge_XY_merge_padel_maccs = get_subset_target_variable(df_sludge_, sludge_padel_maccs_descriptor, 0)\n",
     "sludge_XY_merge_padel_rule = get_subset_target_variable(df_sludge_, sludge_padel_rule_descriptor, 0)\n",
     "sludge_XY_merge_maccs_rule = get_subset_target_variable(df_sludge_, sludge_maccs_rule_descriptor, 0)\n",
     "\n",
     "sludge_XY_merge_all = get_subset_target_variable(df_sludge_, sludge_all_descriptor, 0)\n",
     "\n",
     "sludge_XY_merge_padel.to_csv(output_path_des+\"sludge_XY_merge_padel.tsv\", sep='\\t', index=False)\n",
     "sludge_XY_merge_maccs.to_csv(output_path_des+\"sludge_XY_merge_maccs.tsv\", sep='\\t', index=False)\n",
     "sludge_XY_merge_rule.to_csv(output_path_des+\"sludge_XY_merge_rule.tsv\", sep='\\t', index=False)\n",
     "sludge_XY_merge_padel_maccs.to_csv(output_path_des+\"sludge_XY_merge_padel_maccs.tsv\", sep='\\t', index=False)\n",
     "\n",
     "sludge_XY_merge_padel_rule.to_csv(output_path_des+\"sludge_XY_merge_padel_rule.tsv\", sep='\\t', index=False)\n",
     "sludge_XY_merge_maccs_rule.to_csv(output_path_des+\"sludge_XY_merge_maccs_rule.tsv\", sep='\\t', index=False)\n",
     "sludge_XY_merge_all.to_csv(output_path_des+\"sludge_XY_merge_all.tsv\", sep='\\t', index=False)\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 214,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sludge_vec_descriptor = pd.read_csv(output_path_des+\"sludge_vec_descriptor.tsv\", sep='\\t')\n",
+    "soil_vec_descriptor = pd.read_csv(output_path_des+\"soil_vec_descriptor.tsv\", sep='\\t')\n",
+    "sludge_XY_merge_vec = get_subset_target_variable(df_sludge_, sludge_vec_descriptor, 0)\n",
+    "soil_XY_merge_vec = get_subset_target_variable(df_soil_, soil_vec_descriptor, 1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 217,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sludge_XY_merge_vec.to_csv(output_path_des+\"sludge_XY_merge_vec.tsv\", sep='\\t', index=False)\n",
+    "soil_XY_merge_vec.to_csv(output_path_des+\"soil_XY_merge_vec.tsv\", sep='\\t', index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 222,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0      [[ 3.75860065e-01 -5.16975820e-01  3.04236203e...\n",
+       "1      [[ 0.4711976  -0.55014855  0.16992049  0.34950...\n",
+       "2      [[ 0.36134678 -0.18154728  0.02233491 -0.01184...\n",
+       "3      [[-0.18096934  0.02644509 -0.239617    0.20880...\n",
+       "4      [[ 9.00694355e-02 -9.96635780e-02 -2.27172539e...\n",
+       "                             ...                        \n",
+       "155    [[ 0.33386835 -0.2263216  -0.19296879  0.46654...\n",
+       "156    [[ 3.01284581e-01  2.92636994e-02 -1.98752340e...\n",
+       "157    [[ 6.13241017e-01 -2.64540642e-01 -2.28865877e...\n",
+       "158    [[-2.25752279e-01 -7.45686233e-01  2.86516100e...\n",
+       "159    [[ 7.78277069e-02  5.80310643e-01 -3.66891086e...\n",
+       "Name: encoded_vectors, Length: 160, dtype: object"
+      ]
+     },
+     "execution_count": 222,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sludge_XY_merge_vec.iloc[:, 3]"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3.9.13 ('envipath')",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.13"
+   "version": "3.9.13 (main, Aug 25 2022, 23:51:50) [MSC v.1916 64 bit (AMD64)]"
   },
   "orig_nbformat": 4,
   "vscode": {
    "interpreter": {
     "hash": "2347b11aabc7676a0034671a85ea3c0a49e970a2c62f233a06be25b5abf82f7b"
    }
   }
  },
  "nbformat": 4,
  "nbformat_minor": 2
 }