{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PPAM '24: Composing & Modeling Parallel Sorting Performance Data (Part B): Thicket Tutorial\n",
    "\n",
    "In part B, we use machine learning to predict the parallel algorithm class from the performance data we processed and composed in part A. Running notebook `08A_composing_parallel_sorting_data.ipynb` is necessary to generate the data that we will use in this notebook.\n",
    "\n",
    "## 1. Import Necessary Packages\n",
    "\n",
    "Import packages:\n",
    "- `numpy` and `pandas` for help with data operations.\n",
    "- `sklearn` for modeling.\n",
    "- `matplotlib` to plot our model's performance statistics.\n",
    "- `thicket` to unpickle the Thicket from part A.\n",
    "- `tqdm` for modeling progress bars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn import metrics, svm\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.preprocessing import LabelEncoder, OrdinalEncoder, StandardScaler\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from tqdm import tqdm\n",
    "\n",
    "import thicket as th"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Define Modeling Helper Functions\n",
    "- `prep_data` first performs standardization scaling on the numerical columns to boost model accuracy (for models that require normally distributed data). Then `prep_data` converts categorical columns to integer labels using the `sklearn.preprocessing.LabelEncoder()` function.\n",
    "- `split_X_y` splits a dataset into input features (X) and labels (y).\n",
    "- `compute_model_metrics` computes model statistics given the true labels, predicted labels, and probabilities. The model statistics we compute are accuracy, precision, recall, F1-score, the confusion matrix, and the ROC_AUC score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def configure_categorical(model_data, categories):\n",
    "    for col in categories:\n",
    "        # Encode any \"string\" categorical variables\n",
    "        if model_data[col].dtype == \"object\":\n",
    "            # Strings to ints\n",
    "            model_data.loc[:, [col]] = LabelEncoder().fit_transform(model_data[col])\n",
    "        else:\n",
    "            # anything else to int\n",
    "            model_data[col] = model_data[col].astype(int)\n",
    "            model_data.loc[:, [col]] = model_data[col]\n",
    "        # Set to categorical\n",
    "        model_data[col] = model_data[col].astype(\"category\")\n",
    "\n",
    "    return model_data\n",
    "\n",
    "def prep_data(\n",
    "    data,\n",
    "    numerical_columns,\n",
    "    categorical_columns,\n",
    "    scaling=False,\n",
    "):\n",
    "    # preprocessing\n",
    "    if scaling:\n",
    "        scaler = StandardScaler().set_output(transform=\"pandas\")\n",
    "        data[numerical_columns] = scaler.fit_transform(data[numerical_columns])\n",
    "\n",
    "    if len(categorical_columns) > 0:\n",
    "        data = configure_categorical(data, categorical_columns)\n",
    "\n",
    "    return data\n",
    "\n",
    "def split_X_y(data):\n",
    "    y = pd.get_dummies(data[\"Algorithm\"], dtype=np.float64)\n",
    "    y_index = y.index\n",
    "    y_values = y.values.argmax(axis=1)\n",
    "    y = pd.Series(y_values, index=y_index)\n",
    "    X = data.drop(columns=[\"Algorithm\"])\n",
    "    return X, y\n",
    "\n",
    "def compute_model_metrics(y_true, y_pred, y_proba):\n",
    "\n",
    "    def ravel(tlist, max_num):\n",
    "        tarr = []\n",
    "        for y in tlist:\n",
    "            t1 = np.zeros(max_num + 1)\n",
    "            t1[y] = 1\n",
    "            tarr += t1.tolist()\n",
    "        return tarr\n",
    "\n",
    "    def unravel_true_pred(y_true, y_pred):\n",
    "        max_num = max(max(y_pred), max(y_true))\n",
    "        unravel_true = ravel(y_true, max_num)\n",
    "        unravel_pred = ravel(y_pred, max_num)\n",
    "        return unravel_true, unravel_pred\n",
    "\n",
    "    acc = metrics.accuracy_score(y_true=y_true, y_pred=y_pred)  # Accuracy\n",
    "    pre = metrics.precision_score(\n",
    "        y_true=y_true, y_pred=y_pred, average=\"weighted\", zero_division=0\n",
    "    )  # Precision\n",
    "    rec = metrics.recall_score(\n",
    "        y_true=y_true, y_pred=y_pred, average=\"weighted\", zero_division=0\n",
    "    )  # Recall\n",
    "    f1 = metrics.f1_score(\n",
    "        y_true=y_true, y_pred=y_pred, average=\"weighted\", zero_division=0\n",
    "    )  # F1\n",
    "    conf_matrix = metrics.confusion_matrix(\n",
    "        y_true=y_true, y_pred=y_pred\n",
    "    )  # Confusion matrix\n",
    "    unravel_true, unravel_pred = unravel_true_pred(y_true, y_pred)\n",
    "    y_proba = y_proba.ravel()\n",
    "    try:  # case where class sample didnt get into data\n",
    "        roc_auc_score = metrics.roc_auc_score(\n",
    "            y_true=unravel_true,\n",
    "            y_score=y_proba,\n",
    "            multi_class=\"ovr\",\n",
    "            average=\"weighted\",\n",
    "        )\n",
    "    except ValueError:\n",
    "        roc_auc_score = 0\n",
    "    return acc, pre, rec, f1, conf_matrix, roc_auc_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Modeling Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3A. Unpickle the Thicket from part A\n",
    "\n",
    "Running `08A_composing_parallel_sorting_data.ipynb` is necessary before this step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "modeldata_file = \"thicket-modeldata.pkl\"\n",
    "if not os.path.isfile(modeldata_file):\n",
    "    raise FileNotFoundError(f'You must run notebook \"08A_composing_parallel_sorting_data.ipynb\" before running this notebook to generate the model data \"{modeldata_file}\"')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "tk = th.Thicket.from_pickle(\"thicket-modeldata.pkl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3B. Concatenate Features\n",
    "To match the expected format of the Scikit-learn models, we concatenate the features together such that each row in the `model_data` DataFrame is a data sample (profile). We can achieve this desired format by using `pd.DataFrame.unstack()` to pivot the node index into the column labels, and using `pd.concat()` to concatenate the results. \n",
    "\n",
    "As a simple example: applying the unstack operation to a MultiIndex DataFrame (node and profile) with two unique values for node and two columns will result in a DataFrame with one index level (profile) and 4 columns (2 nodes x 2 columns). We are essentially extending the DataFrame on the column axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_data = pd.concat(\n",
    "    [\n",
    "        tk.dataframe.loc[tk.perf_idx].unstack(level=\"node\"),\n",
    "        tk.dataframe.loc[tk.presence_idx].unstack(level=\"node\"),\n",
    "        tk.metadata[\"Algorithm\"]\n",
    "    ],\n",
    "    axis=\"columns\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3C. Define Categorical and Numerical Columns\n",
    "\n",
    "We manually define the two categorical \"Present\" columns we created in notebook 08A and then define the numerical columns, which are by definition the remaining columns in the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical_columns = [\n",
    "    (\"Present\", tk.get_node(\"comp_small\")),\n",
    "    (\"Present\", tk.get_node(\"comm_small\"))\n",
    "]\n",
    "numerical_columns = list(set(model_data.columns) - set(categorical_columns + [\"Algorithm\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3D. Discretize the Dataset (Optional)\n",
    "\n",
    "By converting the numerical columns to integer labels (like the categorical columns) we improve accuracy for the SVM significantly. We do this for each numerical feature separately by computing at most `n` quantiles, where `n` is the number of samples. We then convert the quantile ranges to integer labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 15/15 [00:04<00:00,  3.43it/s]\n"
     ]
    }
   ],
   "source": [
    "q = len(model_data)\n",
    "for i in tqdm(range(len(numerical_columns))):\n",
    "    col = numerical_columns[i]\n",
    "    model_data[col] = pd.qcut(\n",
    "        model_data[col],\n",
    "        q=q,\n",
    "        duplicates=\"drop\"\n",
    "    )\n",
    "    model_data[col] = OrdinalEncoder(dtype=np.int64).fit_transform(model_data[[col]])\n",
    "model_data = configure_categorical(model_data, numerical_columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3E. Define Dictionary of Models\n",
    "\n",
    "Here we create a dictionary of each of the machine learning models we want to use to classify our algorithm dataset so that we can use them in the step 4 loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifiers = {\n",
    "    \"DecisionTree\": DecisionTreeClassifier(\n",
    "            class_weight=\"balanced\",\n",
    "            min_samples_leaf=1,\n",
    "        ),\n",
    "    \"RandomForest\": RandomForestClassifier(\n",
    "            class_weight=\"balanced\",\n",
    "            n_estimators=100,\n",
    "            bootstrap=False,\n",
    "        ),\n",
    "    \"SVM\": svm.SVC(\n",
    "            kernel=\"rbf\",\n",
    "            probability=True,\n",
    "            class_weight=\"balanced\",\n",
    "            C=1000,\n",
    "        )\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Model Training Loop\n",
    "For each model we run for multiple trials where:    \n",
    "- We use `prep_data` which can be configured differently for different models.\n",
    "- We use `KFold` cross validation to ensure we are testing the entire dataset.\n",
    "    - Initialize a new model and fit it to the training data set.\n",
    "    - Compute the model statistics and store them in a dataframe with any other model metadata.\n",
    "\n",
    "We concatenate all of the model result information into `model_results`, which we will use to plot the model performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DecisionTree: Trial 3/3, Fold 10/10: 100%|██████████| 3/3 [00:02<00:00,  1.15it/s]\n",
      "RandomForest: Trial 3/3, Fold 10/10: 100%|██████████| 3/3 [00:57<00:00, 19.32s/it]\n",
      "SVM: Trial 3/3, Fold 10/10: 100%|██████████| 3/3 [01:10<00:00, 23.49s/it]\n"
     ]
    }
   ],
   "source": [
    "model_results = pd.DataFrame()\n",
    "folds = 10\n",
    "trials = 3\n",
    "for model_name in classifiers.keys():\n",
    "    pbar = tqdm(range(trials))\n",
    "    for t in pbar:\n",
    "        metadata_list = []\n",
    "        mdc = model_data.copy()\n",
    "        mdc = prep_data(\n",
    "            data=mdc,\n",
    "            numerical_columns=numerical_columns,\n",
    "            categorical_columns=categorical_columns,\n",
    "            scaling=True,\n",
    "        )\n",
    "        kf = KFold(\n",
    "            n_splits=folds, \n",
    "            random_state=None,\n",
    "            )\n",
    "        for fold, (train_indices, test_indices) in enumerate(kf.split(mdc)):\n",
    "            pbar.set_description(f\"{model_name}: Trial {t+1}/{trials}, Fold {fold+1}/{folds}\")\n",
    "            \n",
    "            train_data = mdc.iloc[train_indices]\n",
    "            test_data = mdc.iloc[test_indices]\n",
    "            \n",
    "            X_train, y_train = split_X_y(train_data)\n",
    "            X_test, y_test = split_X_y(test_data)\n",
    "\n",
    "            # Init\n",
    "            model = classifiers[model_name]\n",
    "            \n",
    "            # Train\n",
    "            model.fold = fold\n",
    "            model.fit(X_train, y_train)\n",
    "\n",
    "            # Compute scores\n",
    "            y_pred = model.predict(X_test)\n",
    "            y_proba = model.predict_proba(X_test.astype(np.float32))\n",
    "            acc, pre, rec, f1, conf_matrix, roc_auc_score = compute_model_metrics(\n",
    "                y_true=y_test, y_pred=y_pred, y_proba=y_proba\n",
    "            )\n",
    "\n",
    "            y_proba = [tuple(i for i in j) for j in y_proba]\n",
    "            profile_labels = [mdc.index[i] for i in test_indices]\n",
    "            assert len(profile_labels) == len(test_indices)\n",
    "\n",
    "            values_dict = {\n",
    "                # Profile labels\n",
    "                \"profile\": profile_labels,\n",
    "                # Model preds\n",
    "                \"y_pred\": y_pred.tolist(),\n",
    "                \"y_proba\": y_proba,\n",
    "                \"y_true\": y_test.tolist(),\n",
    "                # Model Performance data\n",
    "                \"classifier\": model_name,\n",
    "                \"trial\": t+1,\n",
    "                \"test_acc\": acc,\n",
    "                \"test_pre\": pre,\n",
    "                \"test_rec\": rec,\n",
    "                \"test_f1\": f1,\n",
    "                \"test_roc_auc\": roc_auc_score,\n",
    "                \"trials\": trials,\n",
    "                \"fold\": fold,\n",
    "                \"n_fold\": folds,\n",
    "                \"num_files\": len(tk.profile),\n",
    "            }\n",
    "\n",
    "            tdf = pd.DataFrame.from_dict(values_dict)\n",
    "            metadata_list.append(tdf)\n",
    "        df = pd.concat(metadata_list)\n",
    "        model_results = pd.concat([model_results, df])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Visualize Model Performance\n",
    "With the `_plot_bars()` function, we can visualize the per-fold accuracy of each classifier for each model performance statistic. We notice that the SVM and random forest perform comparibly, with the decision tree slightly less accurate than both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _plot_bars(\n",
    "        mean_df, \n",
    "        std_df,  \n",
    "        grouper, \n",
    "        x_group, \n",
    "        xlabel=None, \n",
    "        ylabel=None, \n",
    "        title=None, \n",
    "        font=None,\n",
    "        legend_dict=None,\n",
    "        legend=None,\n",
    "        color=None,\n",
    "        random=False,\n",
    "        ylim=(0, 1),\n",
    "        colorbar=None,\n",
    "        kind=\"bar\",\n",
    "    ):\n",
    "    unstacker = list(set(grouper) - set([x_group]))\n",
    "    mu_df = mean_df.unstack(level=unstacker)\n",
    "    su_df = std_df.unstack(level=unstacker)\n",
    "\n",
    "    if font:\n",
    "        plt.rcParams.update(font)\n",
    "\n",
    "    for col in mu_df.columns.get_level_values(0).unique():\n",
    "        tdf1 = mu_df[col]\n",
    "        if col == \"test_acc\" and random:\n",
    "            tdf1[\"Random Classifier\"] = [1/num_classes for num_classes in tdf1.index.get_level_values(0)]\n",
    "        ax = tdf1.plot(kind=kind, yerr=su_df[col], capsize=5, figsize=(10, 5), color=color, legend=legend)\n",
    "        plt.ylim(ylim)\n",
    "        if xlabel:\n",
    "            plt.xlabel(xlabel)\n",
    "        if ylabel:\n",
    "            plt.ylabel(ylabel)\n",
    "        if title:\n",
    "            plt.title(title)\n",
    "        plt.grid(False)\n",
    "        if legend_dict and legend:\n",
    "            plt.legend(\n",
    "                **legend_dict\n",
    "            )\n",
    "        if colorbar is not None:\n",
    "            plt.colorbar(colorbar, label='Parameter', ax=ax)\n",
    "        plt.xticks(rotation=90)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAHRCAYAAABdD+k+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABVbUlEQVR4nO3deVxUZf//8fewL4obCIgouKWWiuKSS2ZJYXq7pOWSpbiXW0pm7mAbZWlYWdrikm2uqX3NldJud9MsMzRz1wC3W01UUOb8/vDX1AQ4DiIz4Ov5eMzjZq5zXed85sSNvDnXuY7JMAxDAAAAAIBcuTi6AAAAAABwdgQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAHOzixYvq27evgoKCZDKZNGzYMLvGm0wmxcfH2+wXHx8vk8mUtyIB4A5HcAIAaNOmTYqPj9e5c+du63FeffVVLVmy5LYeozB69dVXNXv2bD3zzDOaO3eunnrqKUeXBAD4F4ITAECbNm3SxIkTCU4O8u233+ree+9VXFycnnzySUVGRjq6JADAvxCcAACF0rVr15SZmenoMvLFyZMnVbJkSUeXAQC4AYITANzh4uPj9fzzz0uSwsPDZTKZZDKZdPjwYUufTz/9VJGRkfL29lbp0qXVtWtXHTt2zGo/+/fvV6dOnRQUFCQvLy+VL19eXbt21fnz5yVdvw8nPT1dc+bMsRwjJibmpmo8fPiwTCaT3nzzTSUmJqpy5cry9PTUr7/+Kknau3evHnvsMZUuXVpeXl6qX7++li1blm0/586d0/DhwxUWFiZPT0+VL19ePXr00OnTp3M99j333KMHHnggW7vZbFZISIgee+wxS9uXX36pyMhIFS9eXH5+fqpVq5amTp2a677XrVsnk8mkQ4cOafny5dnO/cmTJ9WnTx8FBgbKy8tLderU0Zw5c27qnG3YsEENGjSQl5eXKleurBkzZtzUOABAztwcXQAAwLE6duyo3377TV988YXeeust+fv7S5ICAgIkSa+88orGjx+vzp07q2/fvjp16pTeeecdNW/eXD/++KNKliypzMxMRUdHKyMjQ0OGDFFQUJBOnDih//u//9O5c+dUokQJzZ07V3379lXDhg3Vv39/SVLlypXtqnXWrFm6cuWK+vfvL09PT5UuXVp79uxR06ZNFRISolGjRsnX11fz589Xhw4dtGjRIj366KOSri/AcN999yk5OVm9e/dWvXr1dPr0aS1btkzHjx+3fO5/69Kli+Lj45WamqqgoCBL+4YNG/THH3+oa9eukqQ1a9aoW7duatmypV5//XVJUnJysjZu3Khnn302x33XqFFDc+fO1fDhw1W+fHk999xzlnN/+fJltWjRQr///rsGDx6s8PBwLViwQDExMTp37lyu+5Sk3bt36+GHH1ZAQIDi4+N17do1xcXFKTAw0K7zDQD4BwMAcMd74403DEnGoUOHrNoPHz5suLq6Gq+88opV++7duw03NzdL+48//mhIMhYsWHDD4/j6+ho9e/a0u75Dhw4Zkgw/Pz/j5MmTVttatmxp1KpVy7hy5YqlzWw2G02aNDGqVq1qaZswYYIhyVi8eHG2/ZvN5lyPvW/fPkOS8c4771i1Dxw40ChWrJhx6dIlwzAM49lnnzX8/PyMa9eu2f35KlasaLRp08aqLTEx0ZBkfPrpp5a2zMxMo3HjxkaxYsWMCxcuWNolGXFxcZb3HTp0MLy8vIwjR45Y2n799VfD1dXV4J9+AMgbpuoBAHK1ePFimc1mde7cWadPn7a8goKCVLVqVX333XeSpBIlSkiSVq1apUuXLt22ejp16mS5EiZJZ8+e1bfffqvOnTvrzz//tNR35swZRUdHa//+/Tpx4oQkadGiRapTp47lCtQ/3WiJ7mrVqikiIkLz5s2ztGVlZWnhwoVq27atvL29JUklS5ZUenq61qxZky+f9ZtvvlFQUJC6detmaXN3d9fQoUN18eJFrV+/PsdxWVlZWrVqlTp06KAKFSpY2mvUqKHo6Oh8qQ0A7kQEJwBArvbv3y/DMFS1alUFBARYvZKTk3Xy5ElJ1++Nio2N1UcffSR/f39FR0dr2rRplvub8kt4eLjV+99//12GYWj8+PHZ6ouLi5MkS40HDhzQPffck6fjdunSRRs3brSEsHXr1unkyZPq0qWLpc/AgQNVrVo1PfLIIypfvrx69+6tlStX5ul4knTkyBFVrVpVLi7W/1TXqFHDsj0np06d0uXLl1W1atVs2+6666481wMAdzrucQIA5MpsNstkMmnFihVydXXNtr1YsWKWrydPnqyYmBgtXbpUq1ev1tChQ5WQkKAtW7aofPny+VLPX1d3/lmfJI0YMSLXqylVqlS55eN26dJFo0eP1oIFCzRs2DDNnz9fJUqUUKtWrSx9ypYtq127dmnVqlVasWKFVqxYoVmzZqlHjx43vaADAMB5EZwAALlOVatcubIMw1B4eLiqVatmcz+1atVSrVq1NG7cOG3atElNmzbV9OnT9fLLL9/wOHlVqVIlSdensEVFRd2wb+XKlfXLL7/k6Tjh4eFq2LCh5s2bp8GDB2vx4sXq0KGDPD09rfp5eHiobdu2atu2rcxmswYOHKgZM2Zo/Pjxdge4ihUr6ueff5bZbLa66rR3717L9pwEBATI29tb+/fvz7Zt3759dtUAAPgbU/UAAPL19ZWkbA/A7dixo1xdXTVx4kQZhmG1zTAMnTlzRpJ04cIFXbt2zWp7rVq15OLiooyMDKvj5OdDdsuWLasWLVpoxowZSklJybb91KlTlq87deqkn376SV999VW2fv/+bDnp0qWLtmzZopkzZ+r06dNW0/QkWc7FX1xcXFS7dm1JsjoHN6t169ZKTU21urfq2rVreuedd1SsWDHdf//9OY5zdXVVdHS0lixZoqNHj1rak5OTtWrVKrvrAABcxxUnAIAiIyMlSWPHjlXXrl3l7u6utm3bqnLlynr55Zc1evRoHT58WB06dFDx4sV16NAhffXVV+rfv79GjBihb7/9VoMHD9bjjz+uatWq6dq1a5o7d65cXV3VqVMnq+OsXbtWU6ZMUbly5RQeHq5GjRrdUu3Tpk1Ts2bNVKtWLfXr10+VKlVSWlqaNm/erOPHj+unn36SJD3//PNauHChHn/8cfXu3VuRkZE6e/asli1bpunTp6tOnTo3PE7nzp01YsQIjRgxQqVLl852hatv3746e/asHnzwQZUvX15HjhzRO++8o4iICMt9Sfbo37+/ZsyYoZiYGO3YsUNhYWFauHChNm7cqMTERBUvXjzXsRMnTtTKlSt13333aeDAgZbAdffdd+vnn3+2uxYAgFiTFABw3UsvvWSEhIQYLi4u2ZYmX7RokdGsWTPD19fX8PX1NapXr24MGjTI2Ldvn2EYhnHw4EGjd+/eRuXKlQ0vLy+jdOnSxgMPPGCsXbvW6hh79+41mjdvbnh7exuSbnpp8r+WI3/jjTdy3H7gwAGjR48eRlBQkOHu7m6EhIQY//nPf4yFCxda9Ttz5owxePBgIyQkxPDw8DDKly9v9OzZ0zh9+vRN1dG0aVNDktG3b99s2xYuXGg8/PDDRtmyZQ0PDw+jQoUKxoABA4yUlBSb+81pOXLDMIy0tDSjV69ehr+/v+Hh4WHUqlXLmDVrVrZ++tdy5IZhGOvXrzciIyMNDw8Po1KlSsb06dONuLg4liMHgDwyGcZNzE8AAAAAgDsY9zgBAAAAgA3c4wQAcJisrCyrBRxyUqxYMatlzwEAcASCEwDAYY4dO5btobb/FhcXp/j4+IIpCACAXDg0OH3//fd64403tGPHDqWkpOirr75Shw4dbjhm3bp1io2N1Z49exQaGqpx48YpJiamQOoFAOSvoKAgrVmz5oZ9/npWEwAAjuTQ4JSenq46deqod+/e6tixo83+hw4dUps2bfT000/rs88+U1JSkvr27avg4OBcnxgPAHBeXl5eNh9cCwCAM3CaVfVMJpPNK04vvPCCli9fbvXk965du+rcuXNauXJlAVQJAAAA4E5UqO5x2rx5c7a/TEZHR2vYsGG5jsnIyLB6YrvZbNbZs2dVpkwZmUym21UqAAAAACdnGIb+/PNPlStXTi4uN15wvFAFp9TUVAUGBlq1BQYG6sKFC7p8+bK8vb2zjUlISNDEiRMLqkQAAAAAhcyxY8dUvnz5G/YpVMEpL0aPHq3Y2FjL+/Pnz6tChQo6duyY/Pz8HFgZAAAAAEe6cOGCQkNDVbx4cZt9C1VwCgoKUlpamlVbWlqa/Pz8crzaJEmenp7y9PTM1u7n50dwAgAAAHBTt/DceCKfk2ncuLGSkpKs2tasWaPGjRs7qCIAAAAAdwKHBqeLFy9q165d2rVrl6Try43v2rVLR48elXR9ml2PHj0s/Z9++mkdPHhQI0eO1N69e/Xee+9p/vz5Gj58uCPKBwAAAHCHcGhw+uGHH1S3bl3VrVtXkhQbG6u6detqwoQJkqSUlBRLiJKk8PBwLV++XGvWrFGdOnU0efJkffTRRzzDCQAAAMBt5TTPcSooFy5cUIkSJXT+/HnucQIAAADuYPZkg0J1jxMAAAAAOALBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADW6OLuBOlJKSopSUFLvHBQcHKzg4+DZUBAAAAOBGCE4OMGPGDE2cONHucXFxcYqPj8//ggAAQJHGH22BW0dwcoABAwaoXbt2Vm2XL19Ws2bNJEkbNmyQt7d3tnH84AIAAHnx5ptvasqUKXaPi42N1eTJk29DRUDhQ3BygJz+epOenm75OiIiQr6+vgVdFgAAKKo2vZOnYcnJyfrss89uuv/dd9+tiIiIPB0LcHYmwzAMRxdRkC5cuKASJUro/Pnz8vPzc1wh8SWs3qZnGiqW8Kck6eLo4vL1MP2r//mCqgy44zGlBUBRk/JccaVcvPlf+fotu6ydqWa7j3P//fdr3bp1do8DHMWebMAVJwe4/ktZllXb5at//zDblZolb/d/BaedO/mlDCgg3IcIoKgJLu6i4OI33//jdl5qq9J2HyfxmUS7xwCFBcHJAWbMmKGJH6Tnur3ZrEvZGz+I5JcyoIB0SHlDVTt6WbVlXJX6fH1FkvRxWy95uv9rUMePdPfddxdQhQBwe0UEu6lkeEn7xzFND0UYwckBBgwYoHYpb9o56HuuNsFuTDnLmyX7rmni+sxct/8VoKwsflJxcXH80gAAQBFFcHKA67+Uuto3qF6921MMirS8Tjnr2LGjOnbsaNeYonRD8IBID7W769+XlGwN4o8bAAAUZQQnoAjL6erm5auGZTrohl4+2e6na7oqS4sXL9bixYvtOlZRuiHY3nsBdqVc057kZCUnJ9t1nKIUNvNydXPv3r06e/asSpUqZde4onTeAACFB8EJgJUyrcooKz1Lbj43/+Phteav3dH39wxbdUXrP3jS7nFFKWzm9epmXhSl8wYAKDwIToXErl27tGfPHrvH8ZfZO1ueFiJRugLaB8g/yv+mj9O9e/c8VFd0JEaz+lRerm62M5UkpAMACg2CUyHRtGtTXdqX0y+5N8ZfZu9seVmIpHO5ILmV5EeDPVh9Km+8gr3kVtJN7iVv/n6yohbSWcAFwJ2uMF0c4LejQiL4iWBlnMiwawx/mUVeFiLxDvO+TdWgKMvb1c0DCmgfoMBHA29fYU6OZ4YBuNMNGzZM69evt3ucIy4OEJwKCe+K3vKuaN8vtEXtL7MAnBdXN/OGZ4YBKGrsvZLev39/JZdJlouPi11Ttx0x3f3O/hcLAJAvuLqZN3l9Zpi9jwzgflcABSWvV9Ltvb/aET/TCE4osgrTnFkAdyZ7nxnWb9ll7Uw12/3IgDv9flf+PQAKTl6upI/y95dniGdBlZhnBCcUWYVpziyAO5O9zwz7uB0rOOYFCywBBSdPV9J1XAHtA+y+LaWgEZxQZCUmJqrt+23tH3eH/4IBwHmxgmPesMASUHDsvZIuFZ57Xp2/QiCPIiIiVLJJyTyNAwAUHSywhILCtFD7r6RLheeeV4ITCo28PO/k8uHLdj8nBgAAIC+YFlq0EZxQaNzKKi138nNiAABAwWBaaNFGcEKhMWDAALVr186q7fLly2rWrJkkacOGDfL2tr7U2/nrzoViziwAAHAueZnpIkPyrelr10wXpoUWHvxGicLjzWrSRcO67eo/3n/8sORust5eLuj21wUAKDBM20ZBYaYL/o3ghEJjxo7MGy5v2WxWTnOKD/ADDACKEH6ZRUHp0KGDqu5+3aqtqDyPCHlDcEKhUZSXtwQA3BymbaOgLFmyRBMX5/TMoesK8/OIkDf8FEGhUZSXtwQA3Jzg4GAFz6hu1Zae+fe07Yjlj8jXw3ratnd4hQKpDUXLgAED1C7lTbvG8Afboo3/sgAAAMC/BAcHKzjY1a4x/MG2aCM4AQCAQuP64hBZVm2X/7FQ0K7ULHn/a6GgyyYWhwBw6whOAACg0JgxY4YmfpCe63YWCgJwuxCcAABAocF9JwAchZ8iAACg0OC+EwCO4uLoAgAAAADA2RGcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgQfgAgAAFCIpKSlKSUmxc1CWgouZFFycv5kDeUVwAgAAKERmzJihiRMn2j0u7n4Pxbfwug0VAXcGghMAAEAhMmDAALVr186q7fLly2rWrJkkacOGDfL29rYeNKO5gouZCqpEoEgiOAEAABQiwcHBCg4OtmpLT0+3fB0RESFfX99/DXItiNKAIo3gBAAAUIiEjVqerc2cecXydY3xK+XiYT0l7zAz9IBbRnACCok83QwsKfhPMzcDA0ARcu3iWWVdPGvVZlzNtHydmXZQJncPq+07PVkcArhVBCegkOBm4Lxh9SkARc3FXSt0fuMXuW5P+3xktrZI8e8BcKscHpymTZumN954Q6mpqapTp47eeecdNWzYMMe+V69eVUJCgubMmaMTJ07orrvu0uuvv65WrVoVcNVAwcvTzcCSgj+7v0Dqc1YETgBFTbGIR+RdpZFdY5Z7jmVxCOAWOTQ4zZs3T7GxsZo+fboaNWqkxMRERUdHa9++fSpbtmy2/uPGjdOnn36qDz/8UNWrV9eqVav06KOPatOmTapbt64DPgFQsNq8/V+r9/+cmtHpvU3ZpmZI0s4yt70sp8bqUwCKGrdipeVWrLRdY+p5sTgEcKscGpymTJmifv36qVevXpKk6dOna/ny5Zo5c6ZGjRqVrf/cuXM1duxYtW7dWpL0zDPPaO3atZo8ebI+/fTTAq0dKGgzZsxQ6pzcr5zkNDVDkmbc4VdOGk/dma3tnzdRd1uUmv0malafAgAA/+Kw4JSZmakdO3Zo9OjRljYXFxdFRUVp8+bNOY7JyMiQl5f1Lzje3t7asGFDrsfJyMhQRkaG5f2FCxdusXLAMQYMGKAZh0vZP67MuNtQTeHBTdQAAOQN9wlbc1hwOn36tLKyshQYGGjVHhgYqL179+Y4Jjo6WlOmTFHz5s1VuXJlJSUlafHixcrKysr1OAkJCXm6vwFwNsHBwfIMqmL/OK+i94PLHtxEDQBA3nCfsDWHLw5hj6lTp6pfv36qXr26TCaTKleurF69emnmzJm5jhk9erRiY2Mt7y9cuKDQ0NCCKBeAE+AmagAA8ob7hK05LDj5+/vL1dVVaWlpVu1paWkKCgrKcUxAQICWLFmiK1eu6MyZMypXrpxGjRqlSpUq5XocT09PeXp65mvtAAoPbqIGAPAsxLwJDg5WcHCwVVt6errl64iICPn6+v5rUNH9N9RhwcnDw0ORkZFKSkpShw4dJElms1lJSUkaPHjwDcd6eXkpJCREV69e1aJFi9S5c+cCqBgAAACFEVPOkB8cOlUvNjZWPXv2VP369dWwYUMlJiYqPT3dsspejx49FBISooSEBEnS1q1bdeLECUVEROjEiROKj4+X2WzWyJE5ryYG58XNhoDz4i+zAIqanBZYMq5mWu5zDXxiUo6P9LjTF1iCNYcGpy5duujUqVOaMGGCUlNTFRERoZUrV1oWjDh69KhcXP7+R/jKlSsaN26cDh48qGLFiql169aaO3euSpYs6aBPwC8YecVffgDnxf8/AQCSFDZqeba2fz7So8b4ldkf6VGE/xlw+OIQgwcPznVq3rp166ze33///fr1118LoKqbxy8YecPNhoDzytP/PyUFf3Z/gdQHAPbiWYjIDw4PToUdv2DkTYNX1t7w2Tqd3tuU7ZL5ctb4AApMm7f/a/Xe1v8/JWlnmdteFgDkCc9CRH4gON2iPK02IknL7txpehLP1gGcGX+ZBVDU8CxE5AeCUz749/xPW3M/paI9//Nm8GwdwHnxl9m8YdEbAEXNtYtnbzhDKDPtYLYZCDs9i+7PNYITHIJn6wDOi7/M5g33vAIoapghZI3gdItSUlKUkfq7VZutJC5JKWXu7FX1AKCoYdEb+7EyLeDcmCFkjeB0i7gXAAAgSY2n7szW9s+p290WpWZftjf4zr6SzlU6wLkxQ8gawekWcS8AAAB5w8q0AAoTgtMt4l4AAIDETdR5wcq0AAoTghMAAPmAm6jzhpVpARQWBCcAAPIBN1HbjwWWABQmBCcAAPIBN1HbjwWWABQmBCcAAOAQLLAEoDAhOAEAAIdggSUAhQk/eQAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbHB4cJo2bZrCwsLk5eWlRo0aadu2bTfsn5iYqLvuukve3t4KDQ3V8OHDdeXKlQKqFgAAAMCdyKHBad68eYqNjVVcXJx27typOnXqKDo6WidPnsyx/+eff65Ro0YpLi5OycnJ+vjjjzVv3jyNGTOmgCsHAAAAcCdxaHCaMmWK+vXrp169eqlmzZqaPn26fHx8NHPmzBz7b9q0SU2bNtUTTzyhsLAwPfzww+rWrZvNq1QAAAAAcCscFpwyMzO1Y8cORUVF/V2Mi4uioqK0efPmHMc0adJEO3bssASlgwcP6ptvvlHr1q1zPU5GRoYuXLhg9QIAAAAAe7g56sCnT59WVlaWAgMDrdoDAwO1d+/eHMc88cQTOn36tJo1aybDMHTt2jU9/fTTN5yql5CQoIkTJ+Zr7QAAAADuLA5fHMIe69at06uvvqr33ntPO3fu1OLFi7V8+XK99NJLuY4ZPXq0zp8/b3kdO3asACsGAAAAUBQ47IqTv7+/XF1dlZaWZtWelpamoKCgHMeMHz9eTz31lPr27StJqlWrltLT09W/f3+NHTtWLi7Zc6Cnp6c8PT3z/wMAAAAAuGM47IqTh4eHIiMjlZSUZGkzm81KSkpS48aNcxxz6dKlbOHI1dVVkmQYxu0rFgAAAMAdzWFXnCQpNjZWPXv2VP369dWwYUMlJiYqPT1dvXr1kiT16NFDISEhSkhIkCS1bdtWU6ZMUd26ddWoUSP9/vvvGj9+vNq2bWsJUAAAAACQ3xwanLp06aJTp05pwoQJSk1NVUREhFauXGlZMOLo0aNWV5jGjRsnk8mkcePG6cSJEwoICFDbtm31yiuvOOojAAAAALgDODQ4SdLgwYM1ePDgHLetW7fO6r2bm5vi4uIUFxdXAJUBAAAAwHWFalU9AAAAAHAEghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA12B6ft27dr69at2dq3bt2qH374IV+KAgAAAABnYndwGjRokI4dO5at/cSJExo0aFC+FAUAAAAAzsTu4PTrr7+qXr162drr1q2rX3/9NV+KAgAAAABnYndw8vT0VFpaWrb2lJQUubm55UtRAAAAAOBM7A5ODz/8sEaPHq3z589b2s6dO6cxY8booYceytfiAAAAAMAZ2H2J6M0331Tz5s1VsWJF1a1bV5K0a9cuBQYGau7cufleIAAAAAA4mt3BKSQkRD///LM+++wz/fTTT/L29lavXr3UrVs3ubu7344aAQAAAMCh8nRTkq+vr/r375/ftQAAAACAU8rTA3Dnzp2rZs2aqVy5cjpy5Igk6a233tLSpUvztTgAAAAAcAZ2B6f3339fsbGxeuSRR/S///1PWVlZkqRSpUopMTExv+sDAAAAAIezOzi98847+vDDDzV27Fir5cfr16+v3bt352txAAAAAOAM7A5Ohw4dsqym90+enp5KT0/Pl6IAAAAAwJnYHZzCw8O1a9eubO0rV65UjRo18qMmAAAAAHAqdq+qFxsbq0GDBunKlSsyDEPbtm3TF198oYSEBH300Ue3o0YAAAAAcCi7g1Pfvn3l7e2tcePG6dKlS3riiSdUrlw5TZ06VV27dr0dNQIAAACAQ9kVnK5du6bPP/9c0dHR6t69uy5duqSLFy+qbNmyt6s+AAAAAHA4u+5xcnNz09NPP60rV65Iknx8fAhNAAAAAIo8uxeHaNiwoX788cfbUQsAAAAAOCW773EaOHCgnnvuOR0/flyRkZHy9fW12l67du18Kw4AAAAAnIHdwemvBSCGDh1qaTOZTDIMQyaTSVlZWflXHQAAAAA4AbuD06FDh25HHQAAAADgtOwOThUrVrypfm3atNFHH32k4OBgu4sCAAAAAGdi9+IQN+v777/X5cuXb9fuAQAAAKDA3LbgBAAAAABFBcEJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANtgdnL7//ntdu3YtW/u1a9f0/fffW96PGTNGpUuXvrXqAAAAAMAJ2B2cHnjgAZ09ezZb+/nz5/XAAw9Y3o8ePVolS5a8peIAAAAAwBnYHZwMw5DJZMrWfubMGfn6+uZLUQAAAADgTNxutmPHjh0lSSaTSTExMfL09LRsy8rK0s8//6wmTZrkf4UAAAAA4GA3HZxKlCgh6foVp+LFi8vb29uyzcPDQ/fee6/69euX/xUCAAAAgIPddHCaNWuWJCksLEwjRoxgWh4AAACAO4bd9ziNHDnS6h6nI0eOKDExUatXr87XwgAAAADAWdgdnNq3b69PPvlEknTu3Dk1bNhQkydPVvv27fX+++/ne4EAAAAA4Gh2B6edO3fqvvvukyQtXLhQQUFBOnLkiD755BO9/fbb+V4gAAAAADia3cHp0qVLKl68uCRp9erV6tixo1xcXHTvvffqyJEj+V4gAAAAADia3cGpSpUqWrJkiY4dO6ZVq1bp4YcfliSdPHlSfn5++V4gAAAAADia3cFpwoQJGjFihMLCwtSwYUM1btxY0vWrT3Xr1s33AgEAAADA0W56OfK/PPbYY2rWrJlSUlJUp04dS3vLli316KOP5mtxAAAAAOAM7L7iJElBQUEqXry41qxZo8uXL0uSGjRooOrVq+drcQAAAADgDOwOTmfOnFHLli1VrVo1tW7dWikpKZKkPn366Lnnnsv3AgEAAADA0ewOTsOHD5e7u7uOHj0qHx8fS3uXLl20cuXKfC0OAAAAAJyB3fc4rV69WqtWrVL58uWt2qtWrcpy5AAAAACKJLuvOKWnp1tdafrL2bNn5enpmS9FAQAAAIAzsTs43Xffffrkk08s700mk8xmsyZNmqQHHnggX4sDAAAAAGdg91S9SZMmqWXLlvrhhx+UmZmpkSNHas+ePTp79qw2btx4O2oEAAAAAIey+4qTn5+fkpOT1axZM7Vv317p6enq2LGjfvzxR7m7u9+OGgEAAADAoey+4hQeHq6UlBSNHTvWqv3MmTMqX768srKy8q04AAAAAHAGdl9xMgwjx/aLFy/Ky8vrlgsCAAAAAGdz01ecYmNjJV1fDGLChAlWK+tlZWVp69atioiIyPcCAQAAAMDRbjo4/fjjj5KuX3HavXu3PDw8LNs8PDxUp04djRgxIv8rBAAAAAAHu+ng9N1330mSevXqpalTp8rPz++2FQUAAAAAzsTuxSFmzZp1O+oAAAAAAKdl9+IQAAAAAHCnITgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABqcITtOmTVNYWJi8vLzUqFEjbdu2Lde+LVq0kMlkyvZq06ZNAVYMAAAA4E7i8OA0b948xcbGKi4uTjt37lSdOnUUHR2tkydP5th/8eLFSklJsbx++eUXubq66vHHHy/gygEAAADcKRwenKZMmaJ+/fqpV69eqlmzpqZPny4fHx/NnDkzx/6lS5dWUFCQ5bVmzRr5+PgQnAAAAADcNg4NTpmZmdqxY4eioqIsbS4uLoqKitLmzZtvah8ff/yxunbtKl9f3xy3Z2Rk6MKFC1YvAAAAALCHQ4PT6dOnlZWVpcDAQKv2wMBApaam2hy/bds2/fLLL+rbt2+ufRISElSiRAnLKzQ09JbrBgAAAHBncfhUvVvx8ccfq1atWmrYsGGufUaPHq3z589bXseOHSvACgEAAAAUBW6OPLi/v79cXV2VlpZm1Z6WlqagoKAbjk1PT9eXX36pF1988Yb9PD095enpecu1AgAAALhzOfSKk4eHhyIjI5WUlGRpM5vNSkpKUuPGjW84dsGCBcrIyNCTTz55u8sEAAAAcIdz6BUnSYqNjVXPnj1Vv359NWzYUImJiUpPT1evXr0kST169FBISIgSEhKsxn388cfq0KGDypQp44iyAQAAANxBHB6cunTpolOnTmnChAlKTU1VRESEVq5caVkw4ujRo3Jxsb4wtm/fPm3YsEGrV692RMkAAAAA7jAOD06SNHjwYA0ePDjHbevWrcvWdtddd8kwjNtcFQAAAABcV6hX1QMAAACAgkBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADYQnAAAAADABoITAAAAANhAcAIAAAAAGwhOAAAAAGADwQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYIObowtwVllZWbp69epN9Q0p7mr3/q94htrVP9gj2P5jXLli95iCUhDnTHKO8+bh4SEXF/5GAQAAUJgRnP7FMAylpqbq3LlzNz0m/oGydh/nkGmyXf1fcLP/P9WhQ4fsHlNQCuKcSc5x3lxcXBQeHi4PD4983S8AAAAKDsHpX/4KTWXLlpWPj49MJpPNMZneF+w+TridFyCuubvbf4xS4XaPKSgFcc4kx583s9msP/74QykpKapQocJNfT8BAADA+RCc/iErK8sSmsqUKXPT40xu9k/t8nKx7xdoF3f7U4OXl5fdYwpKQZwzyTnOW0BAgP744w9du3ZN7nkIcgAAAHA8brz4h7/uafLx8XFwJShK/pqil5WV5eBKAAAAkFcEpxwwnQr5ie8nAACAwo/gBAAAAAA2EJyKuMOHD8tkMmnXrl23/VizZ89WyZIlrdo++OADhYaGysXFRYmJiYqPj1dERMRtrwUAAADITywOgXzTpUsXtW7d2vL+woULGjx4sKZMmaJOnTqpRIkSMpvNGjJkiE5cdmChAAAAgJ0ITsg33t7e8vb2trw/evSorl69qjZt2ig4+O8H0RYrVkwnjp/L83GuXr3K6nQAAAAoUEzVKyLMZrNmvjNTjzR4RHVD6ioqIkqvvPJKtn5ZWVnq06ePwsPD5e3trbvuuktTp0616rNu3To1bNhQvr6+KlmypJo2baojR45Ikn766Sc98MADKl68uPz8/BQZGakffvhBkvVUvdmzZ6tWrVqSpEqVKslkMunw4cM5TtVb/MUn6vBAIzWoEqT2LRpq3pyPLNtOHDuqOqGltHLZYt3fqa+8Kt2rzxavyK/TBgAAANwUrjgVEYkvJ2rh3IV64aUXVLdRXZ1OO62M1Ixs/cxms8qXL68FCxaoTJky2rRpk/r376/g4GB17txZ165dU4cOHdSvXz998cUXyszM1LZt2ywrw3Xv3l1169bV+++/L1dXV+3atSvHqz9dunRRaGiooqKitG3bNoWGhiogICBbv+Vfzdd7byZo1MuTVP3u2tq752e9OPJZefv4qt3j3Sz9pr42Ue9MGKK691SXl6dHPp45AAAAwDaCUxGQfjFdn37wqcYkjFH7ru0lSRXCK+hu/7t1+PBhq77u7u6aOHGi5X14eLg2b96s+fPnq3Pnzrpw4YLOnz+v//znP6pcubIkqUaNGpb+R48e1fPPP6/q1atLkqpWrZpjTd7e3paHCAcEBCgoKCjHfu9Pfk3PjX9JUY+0lSSVr1BRB3/bp4WfzbIKTk/2eUYdW7e057QAAAAA+YbgVAQc/O2gMjMydW/ze2+q/7Rp0zRz5kwdPXpUly9fVmZmpmX6XOnSpRUTE6Po6Gg99NBDioqKUufOnS33KMXGxqpv376aO3euoqKi9Pjjj1sClr0uXUrXsSOHFP/8UE18YZilPSvrmooV97PqW7N2RJ6OAQAAAOQH7nEqAjy9PG+675dffqkRI0aoT58+Wr16tXbt2qVevXopMzPT0mfWrFnavHmzmjRponnz5qlatWrasmWLJCk+Pl579uxRmzZt9O2336pmzZr66quv8lT35fR0SdKESYmav/J7y2vRmk2au3SNVV9vH988HQMAAADIDw4PTtOmTVNYWJi8vLzUqFEjbdu27Yb9z507p0GDBik4OFienp6qVq2avvnmmwKq1jlVrFRRXt5e2vL9Fpt9N27cqCZNmmjgwIGqW7euqlSpogMHDmTrV7duXY0ePVqbNm3SPffco88//9yyrVq1aho+fLhWr16tjh07atasWXmqu0xAWQUEBuv4kSOqEF7J6lW+QsU87RMAAAC4HRw6VW/evHmKjY3V9OnT1ahRIyUmJio6Olr79u1T2bJls/XPzMzUQw89pLJly2rhwoUKCQnRkSNHsj109U7j6eWp3kN6a8qLU+Tu4a66Devqf2f+py0ntqhlS+v7gqpWrapPPvlEq1atUnh4uObOnavt27crPDxcknTo0CF98MEHateuncqVK6d9+/Zp//796tGjhy5fvqznn39ejz32mMLDw3X8+HFt375dnTp1ynPtA58bpdcnjFIxPz81bdFSVzMytOfnXbpw/px69B90S+cFAAAAyC8ODU5TpkxRv3791KtXL0nS9OnTtXz5cs2cOVOjRo3K1n/mzJk6e/asNm3aZFnJLSwsrCBLdlpPP/e0XF1dNe31aTqZelIBgQEaMnBItn4DBgzQjz/+qC5dushkMqlbt24aOHCgVqy4vsS3j4+P9u7dqzlz5ujMmTMKDg7WoEGDNGDAAF27dk1nzpxRjx49lJaWJn9/f3Xs2NFqsQl7dezWQ15e3po94x299coEeXv7qGr1mure55k87xMAAADIbw4LTpmZmdqxY4dGjx5taXNxcVFUVJQ2b96c45hly5apcePGGjRokJYuXaqAgAA98cQTeuGFF+Tq6prjmIyMDGVk/L0s94ULF/L3gzgJFxcXDYgdoAGxAyxtd/vfLUkyDMPS5unpqVmzZmWbXpeQkCBJCgwMzPWeJQ8PD33xxRe51hATE6OYmBjL+4iICKtjS9fvkYqPj9fP/3gAbutHH1frRx/PcZ8hoRX007H//f93h3I9NgAAAHA7Oewep9OnTysrK0uBgYFW7YGBgUpNTc1xzMGDB7Vw4UJlZWXpm2++0fjx4zV58mS9/PLLuR4nISFBJUqUsLxCQ0Pz9XMAAAAAKPocvjiEPcxms8qWLasPPvhAkZGR6tKli8aOHavp06fnOmb06NE6f/685XXs2LECrBgAAABAUeCwqXr+/v5ydXVVWlqaVXtaWlquD0sNDg6Wu7u71bS8GjVqKDU1VZmZmfLw8Mg2xtPTU56eN79cNwAAAAD8m8OuOHl4eCgyMlJJSUmWNrPZrKSkJDVu3DjHMU2bNtXvv/8us9lsafvtt98UHBycY2gCAAAAgPzg0Kl6sbGx+vDDDzVnzhwlJyfrmWeeUXp6umWVvR49elgtHvHMM8/o7NmzevbZZ/Xbb79p+fLlevXVVzVoEMtWAwAAALh9HLoceZcuXXTq1ClNmDBBqampioiI0MqVKy0LRhw9elQuLn9nu9DQUK1atUrDhw9X7dq1FRISomeffVYvvPCCoz4CAAAAgDuAQ4OTJA0ePFiDBw/Ocdu6deuytTVu3Fhbtmy5zVUBAAAAwN8K1ap6AAAAAOAIBCcAAAAAsIHgBLuEhYUpMTEx3/sCAAAAzszh9zgVFmGjlhfo8Q4PLWdX/7GDx2rpvKWSJDc3N/mV8lO9OvXUrVs3xcTEWC2ycSu2b98uX1/ffO97M0wh9W64PS62v+KfezrfjgcAAAD8heBUhDR7sJlefvtlZZmzdObkGe3ful/PPvusFi5cqGXLlsnN7db/cwcEBNyWvjcj5cfVlq/nLVutCW9O177vF1vaivn6WL42DENZWVkSz/cCAABAPmCqXhHi4ekh/0B/BQYHqmadmhozZoyWLl2qFStWaPbs2ZKkc+fOqW/fvgoICJCfn58efPBB/fTTT1b7+frrr9WgQQN5eXnJ399fjz76qGXbP6ffGYah+Ph4VahQQZ6enipXrpyGDh2aY1/p+vLy7du3V7FixdSkRgU9/0wvnTl10rL9/SmvqXP0ffp60Zd6pHFtNa1ZQSMH9lb6xT8lSUFl/S2vEsWLyWT6u23v74dVvFozrfh2oyJbPSHP8EbasG2XzGazPkz8UNGR0YoMjVTHFh21etnfAUyS9ifv19NdnlaDig3UvGZzPfXUUzp9+nR+/CcBAABAEUFwKuIefPBB1alTR4sXX78y8/jjj+vkyZNasWKFduzYoXr16qlly5Y6e/asJGn58uV69NFH1bp1a/34449KSkpSw4YNc9z3okWL9NZbb2nGjBnav3+/lixZolq1auXY12w2q3379jp79qzWr1+v6Z8v1vEjhzVyYG+rfseOHNZ3q77R27O+1DuzvtSOrZs0c1riTX/eUa++rdfGDFXyukWqXaOqPkz8UMvmL9OENyZoyX+XqMeAHho1cJS2b9wuSbpw/oL6dOyj6rWqa97aeZrx5QylpaWpc+fON31MAAAAFH1M1bsDVK9eXT///LM2bNigbdu26eTJk/L09JQkvfnmm1qyZIkWLlyo/v3765VXXlHXrl01ceJEy/g6derkuN+jR48qKChIUVFRcnd3V4UKFXINWUlJSdq9e7cOHTqk0NBQuQee08uJ76tjy8b6ZddO3RNx/f4ls9msl6ZMk2+x4pKk/3TsrK0bv9eQm/ysLz7/jB5qfq8kKSMjUx9N/UgfLvxQEQ0iJEmhYaHauXWnFnyyQA2aNtAXH32h6vdU17Bxwyz7mDlzpkJDQ/Xbb7+pWrVqN3lkAAAAFGUEpzuAYRgymUz66aefdPHiRZUpU8Zq++XLl3XgwAFJ0q5du9SvX7+b2u/jjz+uxMREVapUSa1atVLr1q3Vtm3bHO+lSk5OVmhoqEJDQy1tlatVV/ESJXTo998swalcaAVLaJIk/7JBOnvm1E1/1vq1a1q+/v3wMV2+dFn9HrP+PFevXlWNWjUkSfv27NO2jdvUoGIDy3YX0/ULsQcOHCA4AQAAQBLB6Y6QnJys8PBwXbx4UcHBwVq3bl22PiVLlpQkeXt73/R+Q0NDtW/fPq1du1Zr1qzRwIED9cYbb2j9+vVyd3fPU63u/wpdJpNJhtl80+N9ff6u/2L6JUnSe5+/p8DgQOvjeF6v71L6JbV4uIViJ8RatlUtXVWSFBwcbF/xAAAAKLIITkXct99+q927d2v48OEqX768UlNT5ebmprCwsBz7165dW0lJSerVq9dN7d/b21tt27ZV27ZtNWjQIFWvXl27d+9WvXrWS4fXqFFDx44d07FjxyxXnQ78tld/nj+vSlXvuqXPmJua1SrJw9NDKSdS1KBpgxz71KhdQ2v/b63KVShnuVJWxb/KbakHAAAAhRfBqQjJzMjU6bTTluXIl25dqoSEBP3nP/9Rjx495OLiosaNG6tDhw6aNGmSqlWrpj/++MOyIET9+vUVFxenli1bqnLlyuratauuXbumb775Ri+88EK2482ePVtZWVlq1KiRfHx89Omnn8rb21sVK1bM1jcqKkq1atVS9+7dlZiYqOQT/9OrY0eo/r1NdXedurflfBQv5quYgTGaNH6SDLOhuo3q6uKFi/px248qVryY2ndtr259umnRp4s0sv9I9RrSSyVKltDxHcf15Zdf6qOPPpKrq+ttqQ0AAACFC8HpJh1+rU2u234+fs7u/dV2OXQL1eRsw7cb1OKeFtcfgFvST/Ui6untt99Wz549LQ/A/eabbzR27Fj16tVLp06dUlBQkJo3b67AwOtT2Vq0aKEFCxbopZde0muvvSY/Pz81b948x+OVLFlSr732mmJjY5WVlaVatWrp66+/znYPlXR9yt3SpUs1ZMiQ6/szuahpi5Ya9eLr+X4e/mnI6CEqVaaUPpr6kY4dOSa/En6qUauG+g27ft9T2aCymvt/czXlpSka8PgAZWZmKqximFq1apVvDw0GAABA4UdwKiJeefcVvfLuK1Ztd/vfna1f8eLF9fbbb+vtt9/OdV8dO3ZUx44dc9x2+PBhy9cdOnRQhw4dct3PP/tKUoUKFbR06VJJOYfNZ2JH6ZnYUVZtT/Z9Rk/2fSZb35gu7RTTpZ3lfYsm9WWc2Jmtn8lk0lMDntJTA57Ktc6KlStq6uyplvc5nTcAAADc2fiTOgAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwwi0zmUxasmSJo8sAAAAAbhs3RxdQaMSXyHVT7dtxvP7r7Oo+dvBYLZ23VJLk5uamwHKBeqLLE3rxxRfl5eV1GwoseKaQetnamjaI0IYlMx1QzXUmk0lfffWVOnTo4LAaAAAAcPsRnIqQZg8208tvv6yr167q159+1fgh42UymfT66687urR8M2tKvFo90MTy3sPdPc/7unr1qtxvYTwAAADuHEzVK0I8PD3kH+iv4JBgtWzdUlFRUVqzZo0k6cyZM+rWrZtCQkLk4+OjWrVq6YsvvrAa36JFCw0dOlQjR45U6dKlFRQUpPj4eKs++/fvV/PmzeXl5aWaNWta9v9Pu3fv1oMPPihvb2+VKVNG/fv318WLFy3bY2JiNKxPd330zmQ9ULeamt1dUdMTJ+natWua8vJ43XdPuB5qcLeWzPss275LliiuoLL+llfpUtevBJrNZr341gcqH9lKnuGNFPFQV638bqNl3ImjJ3RPwD1a8dUKxbSLUb3y9bR84XJJ0sK5C9W2SVvVK19PbRu31XvvvWcZl5mZqcGDBys4OFheXl6qWLGiEhISJElhYWGSpEcffVQmk8nyHgAAAEUPwamI2p+8X5s2bZKHh4ck6cqVK4qMjNTy5cv1yy+/qH///nrqqae0bds2q3Fz5syRr6+vtm7dqkmTJunFF1+0hCOz2ayOHTvKw8NDW7du1fTp0/XCCy9YjU9PT1d0dLRKlSql7du3a8GCBVq7dq0GDx5s1W/bpv/qZFqqZi1crufGv6L3JydoSExX+ZUoqU+/XqvHn+yll0YPV1rKiZv6vFM/+lyTZ3yqNycM189r5im6RWO16zVcRw4cseqX+HKiuvfvrmUbl6npA031fwv/T9Nen6ahY4Zq2cZlGjp2qMaPH685c+ZIkt5++20tW7ZM8+fP1759+/TZZ59ZAtL27dslSbNmzVJKSorlPQAAAIoepuoVIetXr1eDig2UlZWlzIxMubi46N1335UkhYSEaMSIEZa+Q4YM0apVqzR//nw1bNjQ0l67dm3FxcVJkqpWrap3331XSUlJeuihh7R27Vrt3btXq1atUrly5SRJr776qh555BHL+M8//1xXrlzRJ598Il9fX0nSu+++q7Zt2+r1119XYGCgJKlEyZIa9eLrcnFxUVjlqpo9/W1duXxJfYc8J0nqM3i4Zr6XqJ3btuiR9p0s++82aIxcXf7O+5++87I6tHpAb86YqxcG9lTX9tGSpNfHPqvvNv2guTPmatykcZb+T/Z/Ug/95yHL+2mvT9PzLz5vaStfsbwuHr+oGTNmqGfPnjp69KiqVq2qZs2ayWQyqWLFipaxAQEBkqSSJUsqKCjIzv9aAAAAKEwITkVIg2YNNGHSBF26dElzp8+VfzF/dep0PXRkZWXp1Vdf1fz583XixAllZmYqIyNDPj4+VvuoXdt6qYvg4GCdPHlSkpScnKzQ0FBLaJKkxo0bW/VPTk5WnTp1LKFJkpo2bSqz2ax9+/ZZglPlatXl8o8AVMY/QFXuqmF57+rqqpKlSunsmdNW+38r7jlF3fd30AsODNCFPy/qj9RTatogwqpv0/p1tGnv71Ztd0fcbfn6UvolHTt8TBOGTVDc8DhLuznLrBIlrk8BjImJ0UMPPaS77rpLrVq10n/+8x89/PDDAgAAwJ2F4FSE+Pj4qEKlCpKkl95+SU+0fEIff/yx+vTpozfeeENTp05VYmKiatWqJV9fXw0bNkyZmZlW+/j3Ygkmk0lmsznfa3Vzy34ctxyObfzr2EFly6hKeAWrtgt/XtTN+mdQvJR+SZIUPyVetev9HRirlq4qV1dXSVK9evV06NAhrVixQmvXrlXnzp0VFRWlhQsX3vQxAQAAUPhxj1MR5eLiojFjxmjcuHG6fPmyNm7cqPbt2+vJJ59UnTp1VKlSJf3222927bNGjRo6duyYUlJSLG1btmzJ1uenn35Senq6pW3jxo1ycXHRXXfddWsfKhd+xYupXFCANm7fZdW+8YefVLla5VzH+Zf1V9mgsjp+5LgqVKpgeVWpUkXh4eF/79/PT126dNGHH36oefPmadGiRTp79qyk60EzKyvrtnwuAAAAOA+CUxH2+OOPy9XVVdOmTVPVqlW1Zs0abdq0ScnJyRowYIDS0tLs2l9UVJSqVaumnj176qefftJ///tfjR071qpP9+7d5eXlpZ49e+qXX37Rd999pyFDhuipp56yTNO7HZ5/uodef2+O5i1dpX2/H9aoV9/Wrj379GT/J284buDIgfpo6kf69INPdfjAYf3262+aNWuWpkyZIkmaMmWKvvjiC+3du1e//fabFixYoKCgIJUsWVLS9ZX1kpKSlJqaqv/973+37fMBAADAsZiqd7Piz+e66efj5+zeXW2XQ7dQzM1xc3PT4MGDNWnSJP344486ePCgoqOj5ePjo/79+6tDhw46fz73z/VvLi4u+uqrr9SnTx81bNhQYWFhevvtt9WqVStLHx8fH61atUrPPvusGjRoIB8fH3Xq1MkSRG6XoX266fyfF/Xci2/p5Jmzqlm1kpbNekuhlSvecNxjTz0mbx9vzXp3liZPnCxvH29F1I7QsGHDJEnFixfXpEmTtH//frm6uqpBgwb65ptvLPdnTZ48WbGxsfrwww8VEhKiw4cP39bPCQAAAMcgOBURr7z7So7to0aN0qhRoyRJS5YsueE+1q1bl63t32OqVaum//73v1ZthmFYva9Vq5a+/fbbXI8ze/bsbGHz4wX/l63fis0/Wx/nxM5c9+ni4qK42AGKix1g1b7n//9vSIUQ/XLqlxzHtunURm06tbG8v9v/7wUk+vXrp379+uV63LZt26pt27a5bgcAAEDRwFQ9AAAAALCB4AQAAAAANhCcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AAAAAYAPBCQAAAABsIDgBAAAAgA0EJwAAAACwgeAEAAAAADa4ObqAwqLWnFoFerzdD31i95izp8/q3dff1fdrvteZU2dUulRp1alTR2PGjFGnTp00YsQIjRo1Ktu4l156Se+++66OHz+uzz77TL169VL16tWVnJxs1W/BggXq3LmzKlasqMOHD+f1owEAAACFDlecipDhvYZr7+69evXdV7V8y3ItW7ZMLVq00Pnz5/Xkk09q1qxZ2cYYhqHZs2erR48ecnd3lyT5+vrq5MmT2rx5s1Xfjz/+WBUqVCiQzwIAAAA4E4JTEXHh/AXt2LJDw8cPV8NmDVUutJwaNmyo0aNHq127durTp49+++03bdiwwWrc+vXrdfDgQfXp08fS5ubmpieeeEIzZ860tB0/flzr1q3TE088UWCfCQAAAHAWBKciwsfXRz6+Pvp2xbfKzMjMtr1WrVpq0KCBVRiSpFmzZqlJkyaqXr26VXvv3r01f/58Xbp0SZI0e/ZstWrVSoGBgbfvQwAAAABOiuBURLi5uemVd17R0nlL1bhKYz3Z+kmNGTNGP//8s6VPnz59tGDBAl28eFGS9Oeff2rhwoXq3bt3tv3VrVtXlSpV0sKFCy3T+XLqBwAAANwJCE5FyENtH9J3u7/TO3PfUbOWzbRu3TrVq1dPs2fPliR169ZNWVlZmj9/viRp3rx5cnFxUZcuXXLcX+/evTVr1iytX79e6enpat26dUF9FAAAAMCpEJyKGE8vTzVp0URPP/e0Nm3apJiYGMXFxUmS/Pz89Nhjj1kWiZg1a5Y6d+6sYsWK5biv7t27a8uWLYqPj9dTTz0lNzcWYQQAAMCdieBUxNWsWVPp6emW93369NGGDRv0f//3f9q0aZPVohD/Vrp0abVr107r169nmh4AAADuaASnIuLc2XPq/Whvfb3ga+3bs0/HjxzXggULNGnSJLVv397Sr3nz5qpSpYp69Oih6tWrq0mTJjfc7+zZs3X69Olsi0cAAAAAdxLmXt2k3T1357rt5+Pn7N5fbZdDt1BNdj6+PqpVr5bmTp+rY4eP6dq1a6oQWkH9+vXTmDFjLP1MJpN69+6tMWPGaPTo0Tb36+3tLW9v73ytFQAAAChsCE5FhIenh4aPH67h44db2u72vzvHvqNHj841NMXExCgmJibX4wwbNkzDhg27lVIBAACAQoepegAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4JQDwzAcXQKKEL6fAAAACj+C0z+4u7tLki5duuTgSlCUZGZmSpJcXV0dXAkAAADyiuXI/8HV1VUlS5bUyZMnJUk+Pj4ymUw2xxnXMu0+1hUX+65CmE1m+49x5YrdYwpKQZwzyfHnzWw269SpU/Lx8ZGbG/93AwAAKKz4Te5fgoKCJMkSnm7Gyf9dtvs4HqZTdvU/mYdfut3OOe9/3oI4Z5JznDcXFxdVqFDhpkI4AAAAnJPz/mbtICaTScHBwSpbtqyuXr16U2P6Ll5n93GSPEfY1f/ZkHJ2H2PZo8vsHlNQCuKcSc5x3jw8POTiwqxYAACAwozglAtXV9ebviflxJ9Zdu/f6+oxu/qnZNp/tcLLy8vuMQWlIM6ZVPTOGwAAABzDKf4MPm3aNIWFhcnLy0uNGjXStm3bcu07e/ZsmUwmqxe/6AIAAAC4nRwenObNm6fY2FjFxcVp586dqlOnjqKjo294j5Gfn59SUlIsryNHjhRgxQAAAADuNA4PTlOmTFG/fv3Uq1cv1axZU9OnT5ePj49mzpyZ6xiTyaSgoCDLKzAwsAArBgAAAHCnceg9TpmZmdqxY4dGjx5taXNxcVFUVJQ2b96c67iLFy+qYsWKMpvNqlevnl599VXdfffdOfbNyMhQRkaG5f358+clSRcuXMinTyGZM+x/7tMFk31La2ddtv+eoPz8jPmtIM6ZxHmT+F7jey1v+F6zH99recP3mv34Xssbvtfsdyd8r/21H8OwXbfJuJlet8kff/yhkJAQbdq0SY0bN7a0jxw5UuvXr9fWrVuzjdm8ebP279+v2rVr6/z583rzzTf1/fffa8+ePSpfvny2/vHx8Zo4ceJt/RwAAAAACq9jx47lmCX+qdCtqte4cWOrkNWkSRPVqFFDM2bM0EsvvZSt/+jRoxUbG2t5bzabdfbsWZUpU8bpnqtz4cIFhYaG6tixY/Lz83N0OYUG581+nLO84bzZj3OWN5w3+3HO8obzZj/OWd4463kzDEN//vmnypWz/QgbhwYnf39/ubq6Ki0tzao9LS3N8iBaW9zd3VW3bl39/vvvOW739PSUp6enVVvJkiXzVG9B8fPzc6pvqMKC82Y/zlnecN7sxznLG86b/ThnecN5sx/nLG+c8byVKFHipvo5dHEIDw8PRUZGKikpydJmNpuVlJRkdVXpRrKysrR7924FBwffrjIBAAAA3OEcPlUvNjZWPXv2VP369dWwYUMlJiYqPT1dvXr1kiT16NFDISEhSkhIkCS9+OKLuvfee1WlShWdO3dOb7zxho4cOaK+ffs68mMAAAAAKMIcHpy6dOmiU6dOacKECUpNTVVERIRWrlxpWWL86NGjcnH5+8LY//73P/Xr10+pqakqVaqUIiMjtWnTJtWsWdNRHyHfeHp6Ki4uLtvUQtwY581+nLO84bzZj3OWN5w3+3HO8obzZj/OWd4UhfPm0FX1AAAAAKAwcPgDcAEAAADA2RGcAAAAAMAGghMAAAAA2EBwAgAAAAAbCE4AgNuKNYgAAEWBw5cjv5OdPn1aM2fO1ObNm5WamipJCgoKUpMmTRQTE6OAgAAHVwgAt87T01M//fSTatSo4ehSAAAFICUlRe+//742bNiglJQUubi4qFKlSurQoYNiYmLk6urq6BLzhOXIHWT79u2Kjo6Wj4+PoqKiLM+tSktLU1JSki5duqRVq1apfv36Dq60cDl27Jji4uI0c+ZMR5fiVC5fvqwdO3aodOnS2Z55duXKFc2fP189evRwUHXOKzk5WVu2bFHjxo1VvXp17d27V1OnTlVGRoaefPJJPfjgg44u0anExsbm2D516lQ9+eSTKlOmjCRpypQpBVlWoZOenq758+fr999/V3BwsLp162Y5d7hu586dKlWqlMLDwyVJc+fO1fTp03X06FFVrFhRgwcPVteuXR1cpfMZMmSIOnfurPvuu8/RpRQq7777rrZt26bWrVura9eumjt3rhISEmQ2m9WxY0e9+OKLcnPjWsRffvjhB0VFRalKlSry9vbW5s2b9cQTTygzM1OrVq1SzZo1tXLlShUvXtzRpdrPgEM0atTI6N+/v2E2m7NtM5vNRv/+/Y17773XAZUVbrt27TJcXFwcXYZT2bdvn1GxYkXDZDIZLi4uRvPmzY0//vjDsj01NZVzloMVK1YYHh4eRunSpQ0vLy9jxYoVRkBAgBEVFWU8+OCDhqurq5GUlOToMp2KyWQyIiIijBYtWli9TCaT0aBBA6NFixbGAw884OgynU6NGjWMM2fOGIZhGEePHjXCwsKMEiVKGA0aNDBKly5tlC1b1jh48KCDq3QutWvXNtasWWMYhmF8+OGHhre3tzF06FDj/fffN4YNG2YUK1bM+Pjjjx1cpfP569+BqlWrGq+99pqRkpLi6JKc3ksvvWQUL17c6NSpkxEUFGS89tprRpkyZYyXX37ZePXVV42AgABjwoQJji7TqTRt2tSIj4+3vJ87d67RqFEjwzAM4+zZs0ZERIQxdOhQR5V3SwhODuLl5WUkJyfnuj05Odnw8vIqwIoKh6VLl97w9dZbbxEC/qVDhw5GmzZtjFOnThn79+832rRpY4SHhxtHjhwxDIPglJvGjRsbY8eONQzDML744gujVKlSxpgxYyzbR40aZTz00EOOKs8pJSQkGOHh4dkCpZubm7Fnzx4HVeX8TCaTkZaWZhiGYXTv3t1o0qSJce7cOcMwDOPPP/80oqKijG7dujmyRKfj7e1tHD582DAMw6hbt67xwQcfWG3/7LPPjJo1azqiNKdmMpmMtWvXGs8++6zh7+9vuLu7G+3atTO+/vprIysry9HlOaXKlSsbixYtMgzj+h9nXV1djU8//dSyffHixUaVKlUcVZ5T8vb2Ng4cOGB5n5WVZbi7uxupqamGYRjG6tWrjXLlyjmqvFtCcHKQsLAwY86cOblunzNnjlGxYsWCK6iQ+OuvZSaTKdcXIcBa2bJljZ9//tny3mw2G08//bRRoUIF48CBAwSnXPj5+Rn79+83DOP6D303Nzdj586dlu27d+82AgMDHVWe09q2bZtRrVo147nnnjMyMzMNwyA42fLP4FSpUiVj9erVVts3btxohIaGOqI0p1WmTBnjhx9+MAzj+s+4Xbt2WW3//fffDW9vb0eU5tT++b2WmZlpzJs3z4iOjjZcXV2NcuXKGWPGjLH83MN13t7elj80GoZhuLu7G7/88ovl/eHDhw0fHx9HlOa0KlasaGzYsMHy/o8//jBMJpNx6dIlwzAM49ChQ4X24gCr6jnIiBEj1L9/fz377LNatmyZtm7dqq1bt2rZsmV69tln9fTTT2vkyJGOLtPpBAcHa/HixTKbzTm+du7c6egSnc7ly5et5l6bTCa9//77atu2re6//3799ttvDqzOuZlMJkmSi4uLvLy8VKJECcu24sWL6/z5844qzWk1aNBAO3bs0KlTp1S/fn398ssvlvOI3P11jq5cuaLg4GCrbSEhITp16pQjynJajzzyiN5//31J0v3336+FCxdabZ8/f76qVKniiNIKDXd3d3Xu3FkrV67UwYMH1a9fP3322We66667HF2aUwkKCtKvv/4qSdq/f7+ysrIs7yVpz549Klu2rKPKc0odOnTQ008/rZUrV+q7775T9+7ddf/998vb21uStG/fPoWEhDi4yrzhTjYHGTRokPz9/fXWW2/pvffeU1ZWliTJ1dVVkZGRmj17tjp37uzgKp1PZGSkduzYofbt2+e43WQysfTxv1SvXl0//PBDthXN3n33XUlSu3btHFGW0wsLC9P+/ftVuXJlSdLmzZtVoUIFy/ajR49m+wUX1xUrVkxz5szRl19+qaioKMvPN+SuZcuWcnNz04ULF7Rv3z7dc889lm1HjhxhcYh/ef3119W0aVPdf//9ql+/viZPnqx169apRo0a2rdvn7Zs2aKvvvrK0WUWGhUqVFB8fLzi4uK0du1aR5fjVLp3764ePXqoffv2SkpK0siRIzVixAidOXNGJpNJr7zyih577DFHl+lUXn75ZaWkpKht27bKyspS48aN9emnn1q2m0wmJSQkOLDCvGNVPSdw9epVnT59WpLk7+8vd3d3B1fkvP773/8qPT1drVq1ynF7enq6fvjhB91///0FXJnzSkhI0H//+1998803OW4fOHCgpk+fLrPZXMCVObfp06crNDRUbdq0yXH7mDFjdPLkSX300UcFXFnhcvz4ce3YsUNRUVHy9fV1dDlOaeLEiVbv7733XkVHR1veP//88zp+/Li++OKLgi7NqZ07d06vvfaavv76ax08eFBms1nBwcFq2rSphg8fzqq0OQgPD9cPP/xAELeD2WzWa6+9ps2bN6tJkyYaNWqU5s2bp5EjR+rSpUtq27at3n33XX6+5eDKlSu6du2aihUr5uhS8g3BCQAAAABs4B4nAAAAALCB4AQAAAAANhCcAAAAAMAGghMAoMgwDEP9+/dX6dKlZTKZtGvXrhv2X7dunUwmk86dO5drn9mzZ6tkyZL5WicAoPBhOXIAQJGxcuVKzZ49W+vWrVOlSpXk7+/v6JIAAEUEwQkAUGQcOHBAwcHBatKkiaNLAQAUMUzVAwAUCTExMRoyZIiOHj0qk8mksLAwZWRkaOjQoSpbtqy8vLzUrFkzbd++/Yb7mT17tipUqCAfHx89+uijOnPmTAF9AgCAMyM4AQCKhKlTp+rFF19U+fLllZKSou3bt2vkyJFatGiR5syZo507d6pKlSqKjo7W2bNnc9zH1q1b1adPHw0ePFi7du3SAw88oJdffrmAPwkAwBkRnAAARUKJEiVUvHhxubq6KigoSD4+Pnr//ff1xhtv6JFHHlHNmjX14YcfytvbWx9//HGO+5g6dapatWqlkSNHqlq1aho6dKiio6ML+JMAAJwRwQkAUCQdOHBAV69eVdOmTS1t7u7uatiwoZKTk3Mck5ycrEaNGlm1NW7c+LbWCQAoHAhOAAAAAGADwQkAUCRVrlxZHh4e2rhxo6Xt6tWr2r59u2rWrJnjmBo1amjr1q1WbVu2bLmtdQIACgeWIwcAFEm+vr565pln9Pzzz6t06dKqUKGCJk2apEuXLqlPnz45jhk6dKiaNm2qN998U+3bt9eqVau0cuXKAq4cAOCMuOIEACiyXnvtNXXq1ElPPfWU6tWrp99//12rVq1SqVKlcux/77336sMPP9TUqVNVp04drV69WuPGjSvgqgEAzshkGIbh6CIAAAAAwJlxxQkAAAAAbCA4AQAAAIANBCcAAAAAsIHgBAAAAAA2EJwAAAAAwAaCEwAAAADYQHACAAAAABsITgAAAABgA8EJAAAAAGwgOAEAAACADQQnAAAAALCB4AQAAAAANvw/vL4/YU9sx6oAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We can optionally join information from the Thicket metadata table to use in analysis of model performance.\n",
    "model_results = model_results.join(tk.metadata[[\"Algorithm\", \"InputSize\", \"InputType\", \"num_procs\", \"group_num\", \"Datatype\"]], on=\"profile\")\n",
    "\n",
    "for met in [\"test_acc\", \"test_pre\", \"test_rec\", \"test_f1\", \"test_roc_auc\"]:\n",
    "    config = [\n",
    "        \"fold\",\n",
    "        \"classifier\",\n",
    "    ]\n",
    "    mean_df = model_results[[met]+config].groupby(config).mean()\n",
    "    std_df = model_results[[met]+config].groupby(config).std()\n",
    "    _plot_bars(\n",
    "        mean_df=mean_df, \n",
    "        std_df=std_df, \n",
    "        grouper=config, \n",
    "        x_group=\"fold\",\n",
    "        ylabel=met,\n",
    "        xlabel=\"fold\",\n",
    "        legend=True,\n",
    "        title=f\"{met} vs fold\",\n",
    "        ylim=(0.5, 1),\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tk-3.9.12",
   "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}