final_project_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a9ac6c6d",
   "metadata": {},
   "source": [
    "## GRASPHPO Evaluation/Data Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85fa271d",
   "metadata": {},
   "source": [
    "Python Modules Required:\n",
    "\n",
    "To install Python modules, run `pip install _module_name_here_` in either a Windows or Linux terminal.\n",
    "If you don't already have `pip` installed, see [here](https://pip.pypa.io/en/stable/installation/) for instructions on how to do so.\n",
    "- `sklearn`\n",
    "- `xgboost`\n",
    "- `numpy`\n",
    "- `ray`\n",
    "- `hyperopt`\n",
    "- `pandas`\n",
    "- `ConfigSpace`\n",
    "- `matplotlib`\n",
    "\n",
    "Once all the required modules are installed, you can go to Cell/Run All to start testing.\n",
    "\n",
    "To add a new HPO algorithm to the setup for testing, you'll need to write a new Class that inherits HPOStrategy, and then overwrite the `hyperparameter_optimization()` method with whatever you want the HPO algorithm to be, and have it return `best_parameters_found, f1_score_of_best_parameters`. To then have it run against the other HPO algorithms, first add a new elif statement to the `create_hpo_strategy()` method below with the string you want to use to identify the class and return the class function. Then add the HPO id string to the list in the main method with the other HPO algorithm id strings, and it should now call your new HPO algorithm method.\n",
    "\n",
    "To add a new dataset to the setup for testing, have whatever method your use to load/create the new dataset return an instance of the `Dataset()` class shown, with a data matrix (number of samples (rows) x number of features (cols)) implemented as a Pandas DataFrame and a target array (length equal to the number of samples) implemented as a Pandas Series. Then add a new elif statement to the `load_dataset()` method in the DatasetFactory class with the string you want to use to identify the class and return the class function. Then add the dataset id string to the list in the main method with the other dataset id strings, and it should now use your new dataset in the testing routine."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96fb72bb",
   "metadata": {},
   "source": [
    "#### Factory Method Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "62f183dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import abstractmethod, ABC\n",
    "\n",
    "class HPOStrategy(ABC):\n",
    "    @abstractmethod\n",
    "    def hyperparameter_optimization(self, x_train, x_test, y_train, y_test, search_space):\n",
    "        pass#method should return\n",
    "    \n",
    "class HPOFactory:\n",
    "    @staticmethod\n",
    "    def create_hpo_strategy(strategy_name):\n",
    "        if strategy_name == 'GraspHpo':\n",
    "            return GraspHpo()\n",
    "        elif strategy_name == 'Hyperband':\n",
    "            return Hyperband()\n",
    "        elif strategy_name == \"HyperOpt\":\n",
    "            return HyperOpt()\n",
    "        elif strategy_name == \"BOHB\":\n",
    "            return BOHB()\n",
    "        elif strategy_name == 'None':\n",
    "            return Default()\n",
    "        #new HPO algorithms go here\n",
    "        else:\n",
    "            raise ValueError(\"Invalid HPO strategy name\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80514086",
   "metadata": {},
   "source": [
    "#### Construction Phase (GRASPHPO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "2ef0718c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import uuid\n",
    "import random\n",
    "import time\n",
    "import math\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from queue import PriorityQueue\n",
    "\n",
    "\n",
    "class Construction:\n",
    "\n",
    "    \n",
    "    def __init__(self, evaluate, MAX, INT_RESULT_SIZE) -> None:\n",
    "        self.evaluate = evaluate\n",
    "        self.max_iter = MAX\n",
    "        self.int_res_size = INT_RESULT_SIZE\n",
    "\n",
    "    def get_random_hyperparameter_value(self, hyperparameter, hyperparameter_range):\n",
    "        if hyperparameter in ['max_depth','n_estimators']:\n",
    "            return random.randint(hyperparameter_range[0], hyperparameter_range[1])\n",
    "        elif hyperparameter in ['learning_rate']:\n",
    "            return random.lognormvariate(hyperparameter_range[0], hyperparameter_range[1])\n",
    "        else:\n",
    "            return random.uniform(hyperparameter_range[0], hyperparameter_range[1])\n",
    "    \n",
    "    def random_search(self, x_train, x_test, y_test, search_space):\n",
    "        max_score = 0.0\n",
    "        print(\"construct search\")\n",
    "        start_time = time.time()\n",
    "        global hyperband_time\n",
    "        best_intermediate_combinations = PriorityQueue()\n",
    "        intermediate_results_size = self.int_res_size\n",
    "        for i in range(int(self.max_iter)):\n",
    "            if time.time()-start_time < hyperband_time:\n",
    "                selected_hyperparameters = {\n",
    "                    'n_estimators': self.get_random_hyperparameter_value('n_estimators', search_space['n_estimators']),\n",
    "                    'max_depth': self.get_random_hyperparameter_value('max_depth', search_space['max_depth']),\n",
    "                    'colsample_bytree': self.get_random_hyperparameter_value('colsample_bytree', search_space['colsample_bytree']),\n",
    "                    'reg_lambda': self.get_random_hyperparameter_value('reg_lambda', search_space['reg_lambda']),\n",
    "                    'subsample': self.get_random_hyperparameter_value('subsample', search_space['subsample']),\n",
    "                    \"min_child_weight\":  self.get_random_hyperparameter_value('min_child_weight', search_space['min_child_weight']),\n",
    "                    \"learning_rate\":  self.get_random_hyperparameter_value('learning_rate', search_space['learning_rate']),\n",
    "                    \"gamma\":  self.get_random_hyperparameter_value('gamma', search_space['gamma'])\n",
    "                }\n",
    "\n",
    "                f1_score = self.evaluate(selected_hyperparameters, x_train, x_test, y_test)\n",
    "                if f1_score > max_score:\n",
    "                    print(time.time()-start_time, f1_score, i)\n",
    "                    max_score=f1_score\n",
    "                best_intermediate_combinations.put((f1_score, uuid.uuid4(), selected_hyperparameters))\n",
    "                if best_intermediate_combinations.qsize() > intermediate_results_size:\n",
    "                    best_intermediate_combinations.get()\n",
    "            else:\n",
    "                break\n",
    "\n",
    "        # print('Finished building phase.')\n",
    "        #print()\n",
    "        return best_intermediate_combinations\n",
    "\n",
    "\n",
    "    def building_phase(self, x_train, x_test, y_test, search_space):\n",
    "        return self.random_search(x_train, x_test, y_test, search_space)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea629eae",
   "metadata": {},
   "source": [
    "## Local Search Phase (GRASPHPO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "1c397c76",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import time\n",
    "from queue import PriorityQueue\n",
    "\n",
    "class LocalSearch:\n",
    "\n",
    "    # for functions that tweak: this number is the +/-% for how much the tweaked parameter is changed (/2)\n",
    "    margin = .3 #GRASP-specific parameter that can be tweaked\n",
    "    gen_neighbor_def = True # tweak all HPs is default | reinitialize one random HP is alternative\n",
    "\n",
    "    # dictionary of HPs and their ranges\n",
    "    def __init__ (self, evaluate, MAX) -> None:\n",
    "        self.evaluate = evaluate\n",
    "        self.max_iter = MAX\n",
    "\n",
    "    def set_param (self, ranges: dict):\n",
    "        self.hp_ranges = ranges\n",
    "        self.int_hps = []\n",
    "        # for when we need to know whether to generate a random int vs float\n",
    "        for k, v in ranges.items():\n",
    "            if type(v[0]) == int: self.int_hps.append(k)\n",
    "\n",
    "    def set_margin (self, num):\n",
    "        if num >= .00 and num <= 2.0: self.margin = num\n",
    "        \n",
    "    def set_iter (self, num):\n",
    "        if num > 0 and num < 512: self.max_iter = num\n",
    "\n",
    "\n",
    "\n",
    "    def local_search (self, intermed_best_sols: PriorityQueue, x_train, x_test, y_test, ranges: dict, verbose=False):\n",
    "        start_time = time.time()\n",
    "        print(\"local search\")\n",
    "        self.set_param(ranges)\n",
    "        \n",
    "        itera = 1\n",
    "        local_best_sol, local_best_score = {}, 0\n",
    "\n",
    "        while not intermed_best_sols.empty():\n",
    "        \n",
    "            cur = intermed_best_sols.get()\n",
    "\n",
    "            if verbose: print('LS iteration {}: \\nBest solution after phase 1: {}\\nCorresponding score: {}'.format(iter, cur[2], cur[0]))\n",
    "            tmp_score, tmp_sol = self.hill_climb(cur[2], x_train, x_test, y_test)\n",
    "            if verbose: print('LS iteration {}: \\nBest solution after phase 2: {}\\nCorresponding score: {}\\n'.format(iter, tmp_sol, tmp_score))\n",
    "\n",
    "            if tmp_score > local_best_score:\n",
    "                local_best_score = tmp_score\n",
    "                print(time.time()-start_time, tmp_score, itera)\n",
    "                local_best_sol = tmp_sol\n",
    "                if verbose: print('After LS iteration {}: LS found neighbor solution w/ higher f-1 mean than phase 1'.format(iter, local_best_sol, local_best_score))\n",
    "            itera += 1\n",
    "\n",
    "        return local_best_sol, local_best_score\n",
    "\n",
    "    def hill_climb (self, cur_sol: dict, x_train, x_test, y_test):\n",
    "\n",
    "        best_sol = cur_sol\n",
    "        best_score = self.evaluate(cur_sol, x_train, x_test, y_test)\n",
    "\n",
    "        for _ in range(self.max_iter):\n",
    "\n",
    "            neighbor_sol = self.generate_neighbor(cur_sol)\n",
    "            neighbor_score = self.evaluate(neighbor_sol, x_train, x_test, y_test)\n",
    "\n",
    "            if neighbor_score > best_score:\n",
    "                best_sol = neighbor_sol\n",
    "                best_score = neighbor_score\n",
    "            cur_sol = neighbor_sol\n",
    "\n",
    "        return best_score, best_sol\n",
    "\n",
    "    def random_reinit(self, current_solution):\n",
    "        neighbor_solution = current_solution.copy()\n",
    "        param_to_perturb = random.choice(list(neighbor_solution.keys()))\n",
    "        neighbor_solution[param_to_perturb] = self.get_random_hyperparameter_value(param_to_perturb)\n",
    "        return neighbor_solution\n",
    "        \n",
    "    def get_random_hyperparameter_value(self, hyperparameter):\n",
    "        if hyperparameter in ['max_depth', 'n_estimators']:\n",
    "            return random.randint(self.hp_ranges[hyperparameter][0], self.hp_ranges[hyperparameter][1])\n",
    "        elif hyperparameter in ['learning_rate']:\n",
    "            return random.lognormvariate(self.hp_ranges[hyperparameter][0], self.hp_ranges[hyperparameter][1])\n",
    "        else:\n",
    "            return random.uniform(self.hp_ranges[hyperparameter][0], self.hp_ranges[hyperparameter][1])\n",
    "    \n",
    "    \n",
    "    # change all hp's of cur_solution slightly (by self.margin)\n",
    "    # do not go over or under original HP bounds\n",
    "    def generate_neighbor (self, cur_solution: dict):\n",
    "        if self.gen_neighbor_def:\n",
    "\n",
    "            neighbor = cur_solution.copy()\n",
    "            for hp in neighbor.keys():\n",
    "                plus_minus = (self.hp_ranges[hp][1] - self.hp_ranges[hp][0]) * (self.margin / 2.0)\n",
    "                param_range = (max((neighbor[hp] - plus_minus), self.hp_ranges[hp][0]),\n",
    "                                min((neighbor[hp] + plus_minus), self.hp_ranges[hp][1]))\n",
    "                \n",
    "                if hp in ['max_depth', 'n_estimators']:\n",
    "                    neighbor[hp] = random.randint(int(param_range[0]), int(param_range[1]))\n",
    "                elif hp in ['learning_rate']:\n",
    "                    neighbor[hp] = random.lognormvariate(param_range[0], param_range[1])\n",
    "                else:\n",
    "                    neighbor[hp] = random.uniform(param_range[0], param_range[1])\n",
    "\n",
    "                return neighbor\n",
    "        \n",
    "        else: return self.random_reinit(cur_solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40fceb1b",
   "metadata": {},
   "source": [
    "#### GRASPHPO Main Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "f00d6966",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "import xgboost as xgb\n",
    "import time\n",
    "from sklearn.metrics import f1_score\n",
    "\n",
    "#GRASP-specific parameters that can be tweaked\n",
    "LOCAL_SEARCH_ITERATIONS = 1\n",
    "BUILDING_PHASE_ITERATIONS = 30\n",
    "INTERMEDIATE_RESULTS_SIZE = 1\n",
    "\n",
    "\n",
    "class GraspHpo(HPOStrategy):\n",
    "\n",
    "    def __init__(self) -> None:\n",
    "        self.phase1 = Construction(self.evaluate_solution, BUILDING_PHASE_ITERATIONS, INTERMEDIATE_RESULTS_SIZE)\n",
    "        self.phase2 = LocalSearch(self.evaluate_solution, LOCAL_SEARCH_ITERATIONS)\n",
    "\n",
    "    def hyperparameter_optimization(self,  x_train, x_test, y_train, y_test, search_space):\n",
    "        dtrain, dtest = self.format_dataset(x_train, x_test, y_train, y_test)\n",
    "        \n",
    "        start_time = time.time()\n",
    "        best_intermediate_combinations = self.phase1.building_phase(dtrain, dtest, y_test, search_space)\n",
    "        mid_time = time.time()\n",
    "        best_sol, best_score =  self.phase2.local_search(best_intermediate_combinations, dtrain, dtest, y_test, search_space)\n",
    "        end_time = time.time()\n",
    "        print(end_time-mid_time, mid_time-start_time)\n",
    "        return best_sol, best_score\n",
    "    \n",
    "    def format_dataset(self, xtrain, xtest, ytrain, ytest):\n",
    "        dtrain = xgb.DMatrix(xtrain, label=ytrain)\n",
    "        dtest = xgb.DMatrix(xtest, label=ytest)\n",
    "        return dtrain, dtest\n",
    "\n",
    "\n",
    "    #def evaluate_solution(self, params, x_train, x_test, y_train, y_test):\n",
    "    #    xgboost_classifier = XGBClassifier(**params)\n",
    "    #    xgboost_classifier.fit(x_train, y_train)\n",
    "    #    y_pred = xgboost_classifier.predict(x_test)\n",
    "    #    return f1_score(y_test, y_pred, average='weighted')\n",
    "    \n",
    "    \n",
    "    \n",
    "    def evaluate_solution(self, config, dtrain, dtest, y_test):\n",
    "        params = {\n",
    "            \"max_depth\": config[\"max_depth\"],\n",
    "            \"min_child_weight\": config[\"min_child_weight\"],\n",
    "            \"subsample\": config[\"subsample\"],\n",
    "            \"colsample_bytree\": config[\"colsample_bytree\"],\n",
    "            \"eta\": config[\"learning_rate\"],\n",
    "            \"gamma\": config[\"gamma\"],\n",
    "            \"lambda\": config[\"reg_lambda\"],\n",
    "        }\n",
    "\n",
    "        # Change objective for multi-class\n",
    "        if len(np.unique(y_test)) > 2:\n",
    "            params[\"objective\"] = \"multi:softmax\"\n",
    "            params[\"num_class\"] = str(len(np.unique(y_test)))\n",
    "\n",
    "        evals = [(dtest, \"eval\")]\n",
    "        bst = xgb.train(\n",
    "            params, \n",
    "            dtrain, \n",
    "            num_boost_round = config[\"n_estimators\"], \n",
    "            evals=evals, \n",
    "            verbose_eval=False, \n",
    "            custom_metric=evaluate_f1_score,\n",
    "        )\n",
    "\n",
    "        # Predict\n",
    "        preds = bst.predict(dtest)\n",
    "\n",
    "        # Calculate F1 score\n",
    "        y = dtest.get_label()\n",
    "        if len(np.unique(y)) == 2:\n",
    "            threshold = 0.5\n",
    "            binary_preds = [1 if p > threshold else 0 for p in preds]\n",
    "            f1 = f1_score(y, binary_preds, average=\"weighted\")\n",
    "        else:\n",
    "            f1 = f1_score(y, preds, average=\"weighted\")\n",
    "        return f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "06eaeea7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import xgboost\n",
    "def train_xgboost(config: dict):\n",
    "    global x_train, y_train, x_test, y_test\n",
    "    train_set = xgboost.DMatrix(data=x_train, label=y_train)\n",
    "    test_set = xgboost.DMatrix(data=x_test, label=y_test)\n",
    "    xgboost.train(\n",
    "        config,\n",
    "        train_set,\n",
    "        evals=[(test_set, \"eval\")],\n",
    "        verbose_eval=False,\n",
    "        num_boost_round = config[\"n_estimators\"],\n",
    "        custom_metric=evaluate_f1_score,\n",
    "        callbacks=[TuneReportCheckpointCallback({\"f1_score\": \"eval-f1_score\"})],\n",
    "    )\n",
    "def evaluate_f1_score(predt: np.ndarray, dtrain: xgboost.DMatrix) -> np.ndarray:\n",
    "            \"\"\"Compute the f1 score\"\"\"\n",
    "            y = dtrain.get_label()\n",
    "            if len(np.unique(y)) == 2:\n",
    "                threshold = 0.5\n",
    "                binary_preds = [1 if p > threshold else 0 for p in predt]\n",
    "                f1 = sklearn.metrics.f1_score(y, binary_preds, average=\"weighted\")\n",
    "            else:\n",
    "                f1 = sklearn.metrics.f1_score(y, predt, average=\"weighted\")\n",
    "            return (\"f1_score\", f1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89fa7b8b",
   "metadata": {},
   "source": [
    "#### Hyperband Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "ab82dd47",
   "metadata": {},
   "outputs": [],
   "source": [
    "from ray.tune.integration import xgboost\n",
    "from sklearn.metrics import f1_score\n",
    "import sklearn.datasets\n",
    "import numpy as np\n",
    "import sklearn.metrics\n",
    "import xgboost\n",
    "from ray import tune\n",
    "from ray.tune.schedulers import ASHAScheduler\n",
    "from ray.tune.integration.xgboost import TuneReportCheckpointCallback\n",
    "from ray.train import RunConfig\n",
    "import time\n",
    "\n",
    "hyperband_time = 0\n",
    "class Hyperband(HPOStrategy):\n",
    "    def hyperparameter_optimization(self,  x_train, x_test, y_train, y_test, search_space):\n",
    "        # Define the hyperparameter search space\n",
    "        start = time.time()\n",
    "        tuner_search_space = {\n",
    "            \"max_depth\": tune.randint(search_space['max_depth'][0], search_space['max_depth'][1]),\n",
    "            \"subsample\": tune.uniform(search_space['subsample'][0], search_space['subsample'][1]),\n",
    "            \"colsample_bytree\": tune.uniform(search_space['colsample_bytree'][0], search_space['colsample_bytree'][1]),\n",
    "            \"n_estimators\": tune.choice(search_space['n_estimators']),\n",
    "            \"reg_lambda\": tune.uniform(search_space['reg_lambda'][0], search_space['reg_lambda'][1]),\n",
    "            \"min_child_weight\": tune.uniform(search_space['min_child_weight'][0], search_space['min_child_weight'][1]),\n",
    "            \"learning_rate\": tune.loguniform(search_space['learning_rate'][0], search_space['learning_rate'][1]),\n",
    "            \"gamma\": tune.uniform(search_space['gamma'][0], search_space['gamma'][1]),\n",
    "        }\n",
    "        # Change objective for multi-class\n",
    "        if len(np.unique(y_train)) > 2:\n",
    "            tuner_search_space[\"objective\"] = \"multi:softmax\"\n",
    "            tuner_search_space[\"num_class\"] = str(len(np.unique(y_train)))\n",
    "\n",
    "        # Define the ASHA scheduler for hyperparameter optimization\n",
    "        scheduler = ASHAScheduler(\n",
    "            max_t=100,  # Maximum number of training iterations\n",
    "            grace_period=20,  # Minimum number of iterations for each trial\n",
    "            reduction_factor=2,  # Factor by which trials are pruned\n",
    "        )\n",
    "\n",
    "        # Config to reduce verbosity\n",
    "        run_config = RunConfig(verbose=0)\n",
    "\n",
    "        # Run the hyperparameter search\n",
    "        tuner = tune.Tuner(\n",
    "            train_xgboost,\n",
    "            tune_config=tune.TuneConfig(\n",
    "                mode=\"max\", metric=\"f1_score\", scheduler=scheduler, num_samples=10\n",
    "            ),\n",
    "            param_space=tuner_search_space,\n",
    "            run_config=run_config,\n",
    "        )\n",
    "        results = tuner.fit()\n",
    "        best_param = results.get_best_result().config\n",
    "        best_result = results.get_best_result().metrics[\"f1_score\"]\n",
    "        global hyperband_time \n",
    "        hyperband_time = time.time()-start\n",
    "        print(hyperband_time)\n",
    "        return best_param, best_result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0381131",
   "metadata": {},
   "source": [
    "#### HyperOpt Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "3acb2299",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn.datasets\n",
    "import numpy as np\n",
    "import sklearn.metrics\n",
    "import xgboost\n",
    "from ray import tune\n",
    "from ray.tune.search import ConcurrencyLimiter\n",
    "from ray.tune.integration.xgboost import TuneReportCheckpointCallback\n",
    "from ray.train import RunConfig\n",
    "from ray.tune.search.hyperopt import HyperOptSearch\n",
    "from hyperopt import hp\n",
    "\n",
    "\n",
    "class HyperOpt(HPOStrategy):\n",
    "    def hyperparameter_optimization(self, x_train, x_test, y_train, y_test, search_space):\n",
    "        # Define the hyperparameter search space\n",
    "        tuner_search_space = {\n",
    "            \"max_depth\": tune.randint(search_space['max_depth'][0], search_space['max_depth'][1]),\n",
    "            \"subsample\": tune.uniform(search_space['subsample'][0], search_space['subsample'][1]),\n",
    "            \"colsample_bytree\": tune.uniform(search_space['colsample_bytree'][0], search_space['colsample_bytree'][1]),\n",
    "            \"n_estimators\": tune.choice(search_space['n_estimators']),\n",
    "            \"reg_lambda\": tune.uniform(search_space['reg_lambda'][0], search_space['reg_lambda'][1]),\n",
    "            \"min_child_weight\": tune.uniform(search_space['min_child_weight'][0], search_space['min_child_weight'][1]),\n",
    "            \"learning_rate\": tune.loguniform(search_space['learning_rate'][0], search_space['learning_rate'][1]),\n",
    "            \"gamma\": tune.uniform(search_space['gamma'][0], search_space['gamma'][1]),\n",
    "        }\n",
    "\n",
    "        # Change objective for multi-class\n",
    "        if len(np.unique(y_train)) > 2:\n",
    "            tuner_search_space[\"objective\"] = \"multi:softmax\"\n",
    "            tuner_search_space[\"num_class\"] = str(len(np.unique(y_train)))\n",
    "\n",
    "        default_config = {\n",
    "            \"max_depth\": 3,\n",
    "            \"learning_rate\": 0.1,\n",
    "            \"n_estimators\": 100,\n",
    "            \"silent\": True,\n",
    "            \"booster\": 'gbtree',\n",
    "            \"n_jobs\": 1,\n",
    "            \"nthread\": None,\n",
    "            \"gamma\": 0,\n",
    "            \"min_child_weight\": 1,\n",
    "            \"max_delta_step\": 0,\n",
    "            \"subsample\": 1,\n",
    "            \"colsample_bytree\": 1,\n",
    "            \"colsample_bylevel\": 1,\n",
    "            \"reg_alpha\": 0,\n",
    "            \"reg_lambda\": 1,\n",
    "            \"scale_pos_weight\": 1,\n",
    "            \"base_score\": 0.5,\n",
    "            \"random_state\":0,\n",
    "            \"seed\": None,\n",
    "            \"missing\": None,\n",
    "        }\n",
    "\n",
    "        # Define the HyperOpt search algorithm\n",
    "        algo = HyperOptSearch(\n",
    "            metric=\"f1_score\",\n",
    "            mode=\"max\",\n",
    "            # points_to_evaluate=[default_config],\n",
    "            n_initial_points=4,\n",
    "        )\n",
    "\n",
    "        algo = ConcurrencyLimiter(algo, max_concurrent=2)\n",
    "\n",
    "        # Config to reduce verbosity\n",
    "        run_config = RunConfig(verbose=0)\n",
    "\n",
    "        # Run the hyperparameter search\n",
    "        tuner = tune.Tuner(\n",
    "            train_xgboost,\n",
    "            tune_config=tune.TuneConfig(\n",
    "                mode=\"max\", metric=\"f1_score\", num_samples=10, search_alg=algo\n",
    "            ),\n",
    "            param_space=tuner_search_space,\n",
    "            run_config=run_config,\n",
    "        )\n",
    "        results = tuner.fit()\n",
    "        best_param = results.get_best_result().config\n",
    "        best_result = results.get_best_result().metrics[\"f1_score\"]\n",
    "        return best_param, best_result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f095bf39",
   "metadata": {},
   "source": [
    "#### BOHB Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "93fa0500",
   "metadata": {},
   "outputs": [],
   "source": [
    "from ray.tune.schedulers import HyperBandForBOHB\n",
    "from ray.tune.integration.xgboost import TuneReportCheckpointCallback\n",
    "from ray.train import RunConfig\n",
    "from ray.tune.search.bohb import TuneBOHB\n",
    "from ConfigSpace import ConfigurationSpace\n",
    "from ConfigSpace.hyperparameters import UniformFloatHyperparameter, UniformIntegerHyperparameter, CategoricalHyperparameter\n",
    "\n",
    "class BOHB(HPOStrategy):\n",
    "    def hyperparameter_optimization(self, x_train, x_test, y_train, y_test, search_space):\n",
    "        # Define the hyperparameter search space\n",
    "        config_space = ConfigurationSpace()\n",
    "        config_space.add_hyperparameter(UniformIntegerHyperparameter(\"max_depth\", search_space['max_depth'][0], search_space['max_depth'][1]))\n",
    "        config_space.add_hyperparameter(UniformFloatHyperparameter(\"subsample\", search_space['subsample'][0], search_space['subsample'][1]))\n",
    "        config_space.add_hyperparameter(UniformFloatHyperparameter(\"colsample_bytree\", search_space['colsample_bytree'][0], search_space['colsample_bytree'][1]))\n",
    "        config_space.add_hyperparameter(CategoricalHyperparameter(\"n_estimators\", search_space['n_estimators']))\n",
    "        config_space.add_hyperparameter(UniformFloatHyperparameter(\"reg_lambda\", search_space['reg_lambda'][0], search_space['reg_lambda'][1]))\n",
    "        config_space.add_hyperparameter(UniformFloatHyperparameter(\"min_child_weight\", search_space['min_child_weight'][0], search_space['min_child_weight'][1]))\n",
    "        config_space.add_hyperparameter(UniformFloatHyperparameter(\"learning_rate\", search_space['learning_rate'][0], search_space['learning_rate'][1]))\n",
    "        config_space.add_hyperparameter(UniformFloatHyperparameter(\"gamma\", search_space['gamma'][0], search_space['gamma'][1]))\n",
    "\n",
    "        # Change objective for multi-class\n",
    "        if len(np.unique(y_train)) > 2:\n",
    "            config_space.add_hyperparameter(CategoricalHyperparameter(\"objective\", [\"multi:softmax\"]))\n",
    "            config_space.add_hyperparameter(CategoricalHyperparameter(\"num_class\", [str(len(np.unique(y_train)))]))\n",
    "\n",
    "        # Define the BOHB search algorithm\n",
    "        bohb_search = TuneBOHB(space=config_space, metric=\"f1_score\", mode=\"max\")\n",
    "\n",
    "        # Define the HyperBandForBOHB scheduler\n",
    "        scheduler = HyperBandForBOHB(\n",
    "            time_attr=\"training_iteration\",\n",
    "            max_t=100,\n",
    "            reduction_factor=2,\n",
    "            stop_last_trials=True\n",
    "        )\n",
    "\n",
    "        # Config to reduce verbosity\n",
    "        run_config = RunConfig(verbose=0)\n",
    "\n",
    "        # Run the hyperparameter search\n",
    "        tuner = tune.Tuner(\n",
    "            train_xgboost,\n",
    "            tune_config=tune.TuneConfig(\n",
    "                mode=\"max\", metric=\"f1_score\", scheduler=scheduler, num_samples=10, search_alg=bohb_search\n",
    "            ),\n",
    "            run_config=run_config,\n",
    "        )\n",
    "        results = tuner.fit()\n",
    "        best_param = results.get_best_result().config\n",
    "        best_result = results.get_best_result().metrics[\"f1_score\"]\n",
    "        return best_param, best_result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7ac7c05",
   "metadata": {},
   "source": [
    "#### Default Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "84bd250b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Default(HPOStrategy):\n",
    "    def hyperparameter_optimization(self,  x_train, x_test, y_train, y_test, search_space):\n",
    "        params = {}\n",
    "        dtrain = xgb.DMatrix(x_train, label=y_train)\n",
    "        dtest = xgb.DMatrix(x_test, label=y_test)\n",
    "        class_quantity = len(np.unique(y_train))\n",
    "        if class_quantity > 2:\n",
    "            params[\"objective\"] = \"multi:softmax\"\n",
    "            params[\"num_class\"] = str(class_quantity)\n",
    "            \n",
    "        evals = [(dtest, \"eval\")]\n",
    "        bst = xgb.train(\n",
    "            params, \n",
    "            dtrain,  \n",
    "            evals=evals, \n",
    "            verbose_eval=False, \n",
    "            custom_metric=evaluate_f1_score,\n",
    "        )\n",
    "\n",
    "        # Predict\n",
    "        preds = bst.predict(dtest)\n",
    "\n",
    "        # Calculate F1 score\n",
    "        y = dtest.get_label()\n",
    "        if len(np.unique(y)) == 2:\n",
    "            threshold = 0.5\n",
    "            binary_preds = [1 if p > threshold else 0 for p in preds]\n",
    "            f1 = f1_score(y, binary_preds, average=\"weighted\")\n",
    "        else:\n",
    "            f1 = f1_score(y, preds, average=\"weighted\")\n",
    "        return params, f1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eda30a34",
   "metadata": {},
   "source": [
    "#### Dataset Loading and Factory Method Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "5cbace4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_breast_cancer, load_digits, load_iris, load_wine\n",
    "\n",
    "class DatasetFactory:\n",
    "    @staticmethod\n",
    "    def load_dataset(dataset_name):\n",
    "        if dataset_name == 'Ereno':\n",
    "            return ErenoProcessor.load_data()\n",
    "        elif dataset_name == 'Breast Cancer':\n",
    "            return load_breast_cancer()\n",
    "        elif dataset_name == 'Digits':\n",
    "            return load_digits()\n",
    "        elif dataset_name == 'Iris':\n",
    "            return load_iris()\n",
    "        elif dataset_name == 'Wine':\n",
    "            return load_wine()\n",
    "        #add new dataset function here\n",
    "        else:\n",
    "            raise ValueError(\"Invalid HPO strategy name\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "bc051b32",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from pathlib import Path\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "\n",
    "class Dataset:\n",
    "    def __init__(self, data, target) -> None:\n",
    "        self.data = data\n",
    "        self.target = target\n",
    "\n",
    "\n",
    "class ErenoProcessor:\n",
    "    @staticmethod\n",
    "    def load_data():\n",
    "        data_df = pd.read_csv(\"hybridGoose.csv\", sep=',')\n",
    "\n",
    "        data = data_df.drop(columns=['@class@']).apply(pd.to_numeric, errors='coerce').dropna(axis=1)\n",
    "\n",
    "        label_encoder = LabelEncoder()\n",
    "        labels = data_df['@class@']\n",
    "        target = label_encoder.fit_transform(labels)\n",
    "\n",
    "        return Dataset(data, target)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6a8e34c",
   "metadata": {},
   "source": [
    "#### Main Test Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "f1d402d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "import ray\n",
    "\n",
    "#from src.input.dataset_factory import DatasetFactory\n",
    "#from src.hpo.hpo_factory import HPOFactory\n",
    "import time\n",
    "\n",
    "#from src.output.chart_builder import plot\n",
    "\n",
    "HYPERPARAMETER_RANGES = {\n",
    "    'n_estimators': (50, 500),\n",
    "    'max_depth': (3, 10),\n",
    "    'colsample_bytree': (0.5, 1),\n",
    "    'reg_lambda': (0.01, 1.0),\n",
    "    'subsample': (0.5, 1.0),\n",
    "    \"min_child_weight\": (1, 10),\n",
    "    \"learning_rate\": (1e-3, 0.1),\n",
    "    \"gamma\": (0, 1)\n",
    "}\n",
    "\n",
    "\n",
    "class Main:\n",
    "    \n",
    "    @staticmethod\n",
    "    def prepare_dataset(dataset, rand_state):\n",
    "        x = dataset.data\n",
    "        y = dataset.target\n",
    "        return train_test_split(x, y, test_size=0.2, random_state=rand_state)\n",
    "    \n",
    "    @staticmethod\n",
    "    def evaluate_hpo(strategy_name, dataset, rand_state):\n",
    "        global x_train, x_test, y_train, y_test\n",
    "        x_train, x_test, y_train, y_test = Main.prepare_dataset(dataset, rand_state)\n",
    "        hpo_alg = HPOFactory.create_hpo_strategy(strategy_name)\n",
    "        start_time = time.time()\n",
    "        best_trial_config, best_trial_score = hpo_alg.hyperparameter_optimization(\n",
    "            x_train, x_test, y_train, y_test, HYPERPARAMETER_RANGES\n",
    "        )\n",
    "        end_time = time.time()\n",
    "        evaluation_time = end_time - start_time\n",
    "        return best_trial_score, evaluation_time\n",
    "\n",
    "    @staticmethod\n",
    "    def main():\n",
    "        dataset_names = ['Ereno']#add dataset names to the list here to have the hpo strategies below run on them\n",
    "        strategies = ['Hyperband','GraspHpo','HyperOpt','BOHB','None']#add hpo algorithm names here to test on the datasets above\n",
    "\n",
    "        data = []\n",
    "\n",
    "        for dataset_name in dataset_names:\n",
    "            dataset = DatasetFactory.load_dataset(dataset_name)\n",
    "            rand_state_val = random.randint(0,100000)\n",
    "            for strategy in strategies:\n",
    "                f1_score, evaluation_time = Main.evaluate_hpo(strategy, dataset, rand_state_val)\n",
    "                data.append({\n",
    "                    \"input\": dataset_name,\n",
    "                    \"hpo_strategy\": strategy,\n",
    "                    \"f1_score\": f1_score,\n",
    "                    \"evaluation_time\": evaluation_time\n",
    "                })\n",
    "\n",
    "        #plot(data, \"output/results\")\n",
    "        return data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "3cead578",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, shutil\n",
    "def clear_folder():\n",
    "    folder = 'C:/Users/GROOB/ray_results'#REPLACE THIS FOLDER PATH WITH THE ray_results PATH ON YOUR MACHINE\n",
    "    for filename in os.listdir(folder):\n",
    "        file_path = os.path.join(folder, filename)\n",
    "        try:\n",
    "            if os.path.isfile(file_path) or os.path.islink(file_path):\n",
    "                os.unlink(file_path)\n",
    "            elif os.path.isdir(file_path):\n",
    "                shutil.rmtree(file_path)\n",
    "        except Exception as e:\n",
    "            print('Failed to delete %s. Reason: %s' % (file_path, e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "eafd992a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import pickle\n",
    "#plotting commands/subroutines for the scatterplots and barplots\n",
    "def plot_f1_over_time(run):\n",
    "    point_styles = {#dict with the marker styles for each HPO alg for the scatterplot\n",
    "        'HyperOpt': ('^','green'),\n",
    "        'Hyperband': ('s','blue'),\n",
    "        'BOHB': ('*','orange'),\n",
    "        'GraspHpo': ('o','red'),\n",
    "        'None': ('P','purple'),\n",
    "        #add the id string for any new HPO methods here as a dict entry following the style of the other entries\n",
    "    }\n",
    "    plt.scatter(float(run[2]), round(float(run[1]),6), marker=point_styles[run[0]][0], color=point_styles[run[0]][1])\n",
    "    \n",
    "                \n",
    "    \n",
    "def plot_multi_run(full_data, dataset):\n",
    "    for i in range(len(full_data)):\n",
    "        for run in full_data[i]:\n",
    "            if run['input'] == dataset:\n",
    "                plot_f1_over_time((run['hpo_strategy'],run['f1_score'],run['evaluation_time']))\n",
    "    plt.xlabel(\"time (s)\")\n",
    "    plt.ylabel('f1 score')\n",
    "    red_patch = mpatches.Patch(color='red', label='GraspHpo')\n",
    "    blue_patch = mpatches.Patch(color='blue', label='Hyperband')\n",
    "    orange_patch = mpatches.Patch(color='orange', label='BOHB')\n",
    "    green_patch = mpatches.Patch(color='green', label='HyperOpt')\n",
    "    purple_patch = mpatches.Patch(color='purple', label='Default')\n",
    "    #add a new patch variable here for new HPO algs to show up on the legend, color should match the color in the\n",
    "    #point_styles dict above\n",
    "    plt.legend(handles=[red_patch,blue_patch,orange_patch,green_patch,purple_patch], loc='upper right')\n",
    "    plt.show()\n",
    "    \n",
    "def plot_multi_boxplot_f1(full_data, dataset):\n",
    "    f1_dict = {}\n",
    "    for i in range(len(full_data)):\n",
    "        for run in full_data[i]:\n",
    "            if run['input'] == dataset:\n",
    "                if run['hpo_strategy'] not in f1_dict:\n",
    "                    f1_dict[run['hpo_strategy']]=[]\n",
    "                f1_dict[run['hpo_strategy']].append(run['f1_score'])\n",
    "    plot_list=[]\n",
    "    plot_labels=[]\n",
    "    for strat in f1_dict:\n",
    "        plot_list.append(f1_dict[strat])\n",
    "        plot_labels.append(strat)\n",
    "    plt.boxplot(plot_list,labels=plot_labels)\n",
    "    plt.ylabel('f1 score')\n",
    "    plt.show()\n",
    "    \n",
    "def plot_multi_boxplot_time(full_data, dataset):\n",
    "    f1_dict = {}\n",
    "    for i in range(len(full_data)):\n",
    "        for run in full_data[i]:\n",
    "            if run['input'] == dataset:\n",
    "                if run['hpo_strategy'] not in f1_dict:\n",
    "                    f1_dict[run['hpo_strategy']]=[]\n",
    "                f1_dict[run['hpo_strategy']].append(run['evaluation_time'])\n",
    "    plot_list=[]\n",
    "    plot_labels=[]\n",
    "    for strat in f1_dict:\n",
    "        plot_list.append(f1_dict[strat])\n",
    "        plot_labels.append(strat)\n",
    "    plt.boxplot(plot_list,labels=plot_labels)\n",
    "    plt.ylabel('time (s)')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "2b8d14ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-15 14:13:21,673\tWARNING worker.py:2058 -- Warning: The actor ImplicitFunc is very large (11 MiB). Check that its definition is not implicitly capturing a large array or other object in scope. Tip: use ray.put() to put large objects in the Ray object store.\n",
      "2023-12-15 14:13:23,920\tWARNING tune.py:194 -- Stop signal received (e.g. via SIGINT/Ctrl+C), ending Ray Tune run. This will try to checkpoint the experiment state one last time. Press CTRL+C (or send SIGINT/SIGKILL/SIGTERM) to skip. \n",
      "2023-12-15 14:13:25,808\tWARNING tune.py:1158 -- Experiment has been interrupted, but the most recent state was saved.\n",
      "Resume experiment with: Tuner.restore(path=\"C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20\", trainable=...)\n",
      "2023-12-15 14:13:25,816\tWARNING experiment_analysis.py:205 -- Failed to fetch metrics for 10 trial(s):\n",
      "- train_xgboost_0294e_00000: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00000: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00000_0_colsample_bytree=0.7314,gamma=0.0688,learning_rate=0.0037,max_depth=3,min_child_weight=5.3621,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00001: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00001: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00001_1_colsample_bytree=0.9849,gamma=0.7982,learning_rate=0.0183,max_depth=7,min_child_weight=7.6609,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00002: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00002: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00002_2_colsample_bytree=0.6324,gamma=0.1505,learning_rate=0.0031,max_depth=9,min_child_weight=2.3386,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00003: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00003: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00003_3_colsample_bytree=0.7532,gamma=0.1836,learning_rate=0.0025,max_depth=7,min_child_weight=8.5059,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00004: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00004: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00004_4_colsample_bytree=0.8014,gamma=0.0143,learning_rate=0.0020,max_depth=7,min_child_weight=2.3707,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00005: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00005: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00005_5_colsample_bytree=0.8588,gamma=0.7964,learning_rate=0.0138,max_depth=6,min_child_weight=4.8196,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00006: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00006: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00006_6_colsample_bytree=0.8615,gamma=0.7132,learning_rate=0.0125,max_depth=4,min_child_weight=9.2911,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00007: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00007: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00007_7_colsample_bytree=0.6378,gamma=0.0467,learning_rate=0.0611,max_depth=9,min_child_weight=9.7556,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00008: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00008: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00008_8_colsample_bytree=0.8258,gamma=0.7905,learning_rate=0.0025,max_depth=7,min_child_weight=8.5948,n_estima_2023-12-15_14-13-21')\n",
      "- train_xgboost_0294e_00009: FileNotFoundError('Could not fetch metrics for train_xgboost_0294e_00009: both result.json and progress.csv were not found at C:/Users/GROOB/ray_results/train_xgboost_2023-12-15_14-13-20/train_xgboost_0294e_00009_9_colsample_bytree=0.9271,gamma=0.4129,learning_rate=0.0048,max_depth=5,min_child_weight=3.7133,n_estima_2023-12-15_14-13-21')\n",
      "2023-12-15 14:13:25,818\tWARNING experiment_analysis.py:596 -- Could not find best trial. Did you pass the correct `metric` parameter?\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "No best trial found for the given metric: f1_score. This means that no trial has reported this metric, or all values reported for this metric are NaN. To not ignore NaN values, you can set the `filter_nan_and_inf` arg to False.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[67], line 11\u001b[0m\n\u001b[0;32m      9\u001b[0m run_data_list \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m     10\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m10\u001b[39m):\n\u001b[1;32m---> 11\u001b[0m     run_data_list\u001b[38;5;241m.\u001b[39mappend(\u001b[43mMain\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmain\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[0;32m     12\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m10_run_grasp_rand_early_\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;28mstr\u001b[39m(j)\u001b[38;5;241m+\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.pickle\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mwb\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m handle:\u001b[38;5;66;03m#change the filename string here to set filenames\u001b[39;00m\n\u001b[0;32m     13\u001b[0m     \u001b[38;5;66;03m#for the pickled output\u001b[39;00m\n\u001b[0;32m     14\u001b[0m     pickle\u001b[38;5;241m.\u001b[39mdump(run_data_list, handle, protocol\u001b[38;5;241m=\u001b[39mpickle\u001b[38;5;241m.\u001b[39mHIGHEST_PROTOCOL)\n",
      "Cell \u001b[1;32mIn[64], line 55\u001b[0m, in \u001b[0;36mMain.main\u001b[1;34m()\u001b[0m\n\u001b[0;32m     53\u001b[0m     rand_state_val \u001b[38;5;241m=\u001b[39m random\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m100000\u001b[39m)\n\u001b[0;32m     54\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m strategy \u001b[38;5;129;01min\u001b[39;00m strategies:\n\u001b[1;32m---> 55\u001b[0m         f1_score, evaluation_time \u001b[38;5;241m=\u001b[39m \u001b[43mMain\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevaluate_hpo\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstrategy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrand_state_val\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     56\u001b[0m         data\u001b[38;5;241m.\u001b[39mappend({\n\u001b[0;32m     57\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m\"\u001b[39m: dataset_name,\n\u001b[0;32m     58\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhpo_strategy\u001b[39m\u001b[38;5;124m\"\u001b[39m: strategy,\n\u001b[0;32m     59\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mf1_score\u001b[39m\u001b[38;5;124m\"\u001b[39m: f1_score,\n\u001b[0;32m     60\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mevaluation_time\u001b[39m\u001b[38;5;124m\"\u001b[39m: evaluation_time\n\u001b[0;32m     61\u001b[0m         })\n\u001b[0;32m     63\u001b[0m \u001b[38;5;66;03m#plot(data, \"output/results\")\u001b[39;00m\n",
      "Cell \u001b[1;32mIn[64], line 37\u001b[0m, in \u001b[0;36mMain.evaluate_hpo\u001b[1;34m(strategy_name, dataset, rand_state)\u001b[0m\n\u001b[0;32m     35\u001b[0m hpo_alg \u001b[38;5;241m=\u001b[39m HPOFactory\u001b[38;5;241m.\u001b[39mcreate_hpo_strategy(strategy_name)\n\u001b[0;32m     36\u001b[0m start_time \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n\u001b[1;32m---> 37\u001b[0m best_trial_config, best_trial_score \u001b[38;5;241m=\u001b[39m \u001b[43mhpo_alg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhyperparameter_optimization\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m     38\u001b[0m \u001b[43m    \u001b[49m\u001b[43mx_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mHYPERPARAMETER_RANGES\u001b[49m\n\u001b[0;32m     39\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     40\u001b[0m end_time \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n\u001b[0;32m     41\u001b[0m evaluation_time \u001b[38;5;241m=\u001b[39m end_time \u001b[38;5;241m-\u001b[39m start_time\n",
      "Cell \u001b[1;32mIn[58], line 53\u001b[0m, in \u001b[0;36mHyperband.hyperparameter_optimization\u001b[1;34m(self, x_train, x_test, y_train, y_test, search_space)\u001b[0m\n\u001b[0;32m     44\u001b[0m tuner \u001b[38;5;241m=\u001b[39m tune\u001b[38;5;241m.\u001b[39mTuner(\n\u001b[0;32m     45\u001b[0m     train_xgboost,\n\u001b[0;32m     46\u001b[0m     tune_config\u001b[38;5;241m=\u001b[39mtune\u001b[38;5;241m.\u001b[39mTuneConfig(\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     50\u001b[0m     run_config\u001b[38;5;241m=\u001b[39mrun_config,\n\u001b[0;32m     51\u001b[0m )\n\u001b[0;32m     52\u001b[0m results \u001b[38;5;241m=\u001b[39m tuner\u001b[38;5;241m.\u001b[39mfit()\n\u001b[1;32m---> 53\u001b[0m best_param \u001b[38;5;241m=\u001b[39m \u001b[43mresults\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_best_result\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mconfig\n\u001b[0;32m     54\u001b[0m best_result \u001b[38;5;241m=\u001b[39m results\u001b[38;5;241m.\u001b[39mget_best_result()\u001b[38;5;241m.\u001b[39mmetrics[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mf1_score\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[0;32m     55\u001b[0m \u001b[38;5;28;01mglobal\u001b[39;00m hyperband_time \n",
      "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\ray\\tune\\result_grid.py:165\u001b[0m, in \u001b[0;36mResultGrid.get_best_result\u001b[1;34m(self, metric, mode, scope, filter_nan_and_inf)\u001b[0m\n\u001b[0;32m    154\u001b[0m     error_msg \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m    155\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo best trial found for the given metric: \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    156\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmetric\u001b[38;5;250m \u001b[39m\u001b[38;5;129;01mor\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_experiment_analysis\u001b[38;5;241m.\u001b[39mdefault_metric\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    157\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThis means that no trial has reported this metric\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    158\u001b[0m     )\n\u001b[0;32m    159\u001b[0m     error_msg \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m    160\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m, or all values reported for this metric are NaN. To not ignore NaN \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    161\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalues, you can set the `filter_nan_and_inf` arg to False.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    162\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m filter_nan_and_inf\n\u001b[0;32m    163\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    164\u001b[0m     )\n\u001b[1;32m--> 165\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(error_msg)\n\u001b[0;32m    167\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_trial_to_result(best_trial)\n",
      "\u001b[1;31mRuntimeError\u001b[0m: No best trial found for the given metric: f1_score. This means that no trial has reported this metric, or all values reported for this metric are NaN. To not ignore NaN values, you can set the `filter_nan_and_inf` arg to False."
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "import time\n",
    "#this loop set runs the code for 3*10 iterations, the use of the inner loop is to clear the ray_results folder\n",
    "#to prevent it from getting too large; if you want to change the number of iterations, start by adjusting the outer loop\n",
    "#count first, the inner loop count generally shouldn't be set larger than 10, and may have to be decreased with \n",
    "#larger datasets\n",
    "\n",
    "for j in range(3):\n",
    "    run_data_list = []\n",
    "    for i in range(10):\n",
    "        run_data_list.append(Main.main())\n",
    "    with open('10_run_grasp_rand_early_'+str(j)+'.pickle', 'wb') as handle:#change the filename string here to set filenames\n",
    "        #for the pickled output\n",
    "        pickle.dump(run_data_list, handle, protocol=pickle.HIGHEST_PROTOCOL)\n",
    "    clear_folder()\n",
    "    time.sleep(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "cb1774ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "#one way you can load a list of previous runs from a set of pickle files back into a python list for plotting\n",
    "rand_early_runs = []\n",
    "for i in range(3):\n",
    "    with open('10_run_grasp_rand_early_'+str(i)+'.pickle', 'rb') as handle:\n",
    "        rand_early_runs = rand_early_runs + pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "31f1718a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAGwCAYAAACJjDBkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAACKOklEQVR4nO3deVxU9f748dewr4oCsgiKIrhk7mnoT9M019RcSkvTvGW3ktK8VnrTNOumt8W0NFu1vmKSIpptlHHFm11zQU3LjRRFEUVxYVFBZs7vj+OMDMzAgAPDDO/n4zGP4XzOZ8585ojw5rO8PxpFURSEEEIIIUSlONm6AUIIIYQQ9kiCKCGEEEKIKpAgSgghhBCiCiSIEkIIIYSoAgmihBBCCCGqQIIoIYQQQogqkCBKCCGEEKIKXGzdAEem0+k4c+YMvr6+aDQaWzdHCCGEEBZQFIW8vDxCQ0NxcjLf3yRBVDU6c+YM4eHhtm6GEEIIIarg1KlThIWFmT0vQVQ18vX1BdR/hHr16tm4NUIIIYSwRG5uLuHh4Ybf4+ZIEFWN9EN49erVkyBKCCGEsDMVTcWRieVCCCGEEFUgQZQQQgghRBVIECWEEEIIUQUyJ0oIIUSdp9PpKCoqsnUzRA1xdXXF2dn5tq8jQZQQQog6raioiPT0dHQ6na2bImqQn58fwcHBt5XHUYIoIYQQdZaiKGRlZeHs7Ex4eHi5iRWFY1AUhatXr5KdnQ1ASEhIla8lQZQQQog6q7i4mKtXrxIaGoqXl5etmyNqiKenJwDZ2dk0atSoykN7EnILIYSos7RaLQBubm42bomoafqg+caNG1W+hgRRQggh6jzZ37Tusca/uQzn2aGctByK8opw83XDP8rf1s0RQghRTRRF4eqNq3i5ekmgVwtJEGVnctJyWBq91HAcezRWAikhhLC2jAy4cKHm3i8gAJo0KVN88dpF0i+n08yvGf5e8rO+tpEgys4U5RWVeyyEEOI2ZWRAy5Zw/XrNvaeHBxw5YhRIKYrCmbwzAJzJO0NDz4bSG1XLyJwoO5GTlkPWnizOHzpvVH7+0Hmy9mSRk5Zjo5YJIYSDuXChZgMoUN+vVM/XxWsXKdQWAlCoLeTitYtlXnb27FmmTp1KixYt8PDwICgoiB49erB8+XKuXr1aI003Z968eXTo0KFM+YkTJ9BoNOzbt6/G22Rt0hNlB0oP4ZW0YfwGw9cytCeEEI6hZC+UXuneqOPHj9OjRw/8/Px44403uPPOO3F3d+fAgQN8/PHHNG7cmGHDhpW59o0bN3B1da2Rz+HopCfKDlg6ZCdDe0II4RhK9kLple6NeuaZZ3BxcWH37t089NBDtG7dmubNmzN8+HC+++47hg4dCqir0JYvX86wYcPw9vbmX//6F1qtlscff5xmzZrh6elJy5YtWbJkidH7paSk0LVrV7y9vfHz86NHjx6cPHkSuNXL9NFHHxEeHo6XlxcPPfQQV65cqfRnTUlJQaPR8N1339GuXTs8PDy4++67+eOPP4zqrV+/njvuuAN3d3ciIiJ45513Kv1e1iZBlB1w87Usf4ml9YQQQtRepnqh9M7knUFRFHJycvjpp5+YMmUK3t7eJuuWnD81b948RowYwYEDB/jb3/6GTqcjLCyMdevWcfDgQV555RX++c9/snbtWkBNQvrAAw9wzz33sH//frZv386TTz5pdM2//vqLtWvX8s0335CUlMTevXt55plnqvy5X3jhBd555x127dpFYGAgQ4cONeRwSk1N5aGHHmLs2LEcOHCAefPmMWfOHD7//PMqv581yHCeHfCP8if2aCxFeUWcP3TeaAhvRNwIAlsHSroDIYRwEKZ6ofT0vVF//fUXiqLQsmVLo/MBAQFcvzmfa8qUKfz73/8G4JFHHmHSpElGdV999VXD182aNWP79u2sXbuWhx56iNzcXK5cucL9999PZGQkAK1btzZ6/fXr1/m///s/GjduDMD777/PkCFDeOeddwgODgbgwIED+Pj4GL1OURSTn23u3Lncd999AHzxxReEhYWxYcMGHnroIRYtWkTfvn2ZM2cOANHR0Rw8eJC33nqLxx57zOT1aoIEUXbCXIAU2DqQkE5V3/dHCCFE7VFeL5SevjfKlJ07d6LT6Rg3bhyFhbcCsS5dupSpu2zZMlasWEFGRgbXrl2jqKjIMBG8YcOGPPbYYwwYMID77ruPfv368dBDDxntM9ekSRNDAAUQExODTqfjyJEjhiCqZcuWbNq0yeh9MzMz6d27d5n2xMTEGL5u2LAhLVu25NChQwAcOnSI4cOHG9Xv0aMHixcvRqvVVnnbltslw3l2pvSQnQzhCSGE48gvyjfbC6VXqC0kuEkwGo2GI0eOGJ1r3rw5LVq0MOwNp1d6yC8+Pp4ZM2bw+OOP89NPP7Fv3z4mTZpEUdGtubUrV65k+/btdO/ena+++oro6Gh+++23Sn0eNzc3WrRoYfRo2rRppa5Rm0lPlJ0pObQnQ3jVTKuFX36BrCwICYGePcFGf+0IIeoGbzdvmjdobranCdS5Tn4eftx3330sXbqUZ5991uy8KHN+/fVXunfvbjSH6dixY2XqdezYkY4dOzJr1ixiYmL48ssvufvuuwHIyMjgzJkzhIaGAvDbb7/h5ORUZojRUr/99htNbubJunTpEkePHjUMIbZu3Zpff/21zGeIjo62WS8USBBllxwpcEpLg7w88+d9fSEqqubaY5CYCFOnwunTt8oCA+GDD2D0aBs0SAhRFzhpnGjo2dCiuh988AE9evSgS5cuzJs3j3bt2uHk5MSuXbs4fPgwnTt3NvvaqKgo/u///o8ff/yRZs2asWrVKnbt2kWzZs0ASE9P5+OPP2bYsGGEhoZy5MgR0tLSmDBhguEaHh4eTJw4kbfffpvc3Fyee+45HnroIcNQXmXNnz8ff39/goKCePnllwkICOCBBx4A4B//+Ad33XUXr732GmPGjGH79u0sXbqUDz74oErvZS0SRAmbSUuD6OiK6x09WsOBVGKiGiiV/kvw/Hl48EF44QV4880abJAQokYFBKgZxGs6Y3lAQKVeEhkZyd69e3njjTeYNWsWp0+fxt3dnTZt2jBjxoxyV8r9/e9/Z+/evYwZMwaNRsPDDz/MM888ww8//ACAl5cXhw8f5osvviAnJ4eQkBCmTJnC3//+d8M1WrRowciRIxk8eDAXL17k/vvvv62gZuHChUydOpW0tDQ6dOjAN998g5ubOmWlU6dOrF27lldeeYXXXnuNkJAQ5s+fb9NJ5QAapbw+Q3FbcnNzqV+/PleuXKFevXpWu66jbEC8Zw+U84eSQWoqdOpkpTetaIhOq4WICOMeKFPWrlUDKiGEXbt+/Trp6ek0a9YMDw+PWycs3DtPURSuF1/Hw8Xj9rZkMbN3Xm01b948Nm7caJWs4ykpKfTp04dLly7h5+d329ezlNl/eyz//S09UXbGkTYgzsiwvJ5VgihTQ3RhYbBkCYwcqR7/8kvFARTAlCnqa2SOlBCOqUkTi4Kai1dzbm4QHCEbBNdBsjrPzjjSBsQFBdatVy79EF3pACkzUy1PTFSPs7Isu97582rAJRyWoijsytxV7gRfUbeV3iBYvlfqHgmi7IRsQHwbtFq1B8rUDzh92bRpar2QSuTcsjTgEnYpbn8cXT/tyuoDq23dFFFLWbJBsKOaN2+e1TYQ7t27N4qi1OhQnrXIcJ4dkA2Ib1NFQ3SKAqdOqfV69lRX4Z0/b76+XmUCLmFXinXFzE2ZC8DclLmMbTsWFyf5cSlusWSDYOH4pCfKDsgGxLfJ0h6jrCx1jpMlq0vCw9WASzikNQfWkH45HYDjl44T/0e8jVskahtLNggWjs/mQdSyZcuIiIjAw8ODbt26sXPnTrN1b9y4wfz584mMjMTDw4P27duTlJRktv7ChQvRaDRMmzbNUHbixAk0Go3Jx7p16wz1TJ2Pj7fND1LZgPg2WdpjpK83erSaxsAcjQYWL5ZJ5Q5K3wulQe1NcMKJuSlzKdYV27hlorawZINgUTfYNIj66quvmD59OnPnzmXPnj20b9+eAQMGkJ2dbbL+7Nmz+eijj3j//fc5ePAgTz31FCNGjGDv3r1l6u7atYuPPvqIdu3aGZWHh4eTlZVl9Hj11Vfx8fFh0KBBRnVXrlxpVE+f9Kum6bOUP5n6JCPiRhidGxE3gidTn7TLoTxLE+xWMhFvWT17qqvwzHWxazRle5befFNNY1A6b0t4OCQk3FrNJxyOvhdKQf1FqEMnvVHCiCUbBIu6waZB1KJFi5g8eTKTJk2iTZs2fPjhh3h5ebFixQqT9VetWsU///lPBg8eTPPmzXn66acZPHgw77zzjlG9/Px8xo0bxyeffEKDBg2Mzjk7OxMcHGz00O8SXXqnaT8/P6N6pfNIlFZYWEhubq7Rw1r8o/wJ6RRCYOtAo3L9BsT2FkCB5SlRbjt1irOzmsYAygZS+mNTPUsPPghnz8KWLfDll+pzeroEUA6sdC+UnvRGCb3b3SBYOBabzZQsKioiNTWVWbNmGcqcnJzo168f27dvN/mawsLCMoGMp6cn27ZtMyqbMmUKQ4YMoV+/frz++uvltiM1NZV9+/axbNmyMuemTJnCE088QfPmzXnqqaeYNGlSuRMGFyxYwKuvvlru+90uR9qA2NfXuvUA88k0R45Ue5BM5YlavNh8YOTsDCZ2GxeOqeRcqJJK9kaNbzfeBi0TNc1crs2CoqucvOIMeJX7+sv1r+LtZnk3up3l2rSYRqNhw4YNNhnJ6d27Nx06dGDx4sXV9h42C6IuXLiAVqslKCjIqDwoKIjDhw+bfM2AAQNYtGgRvXr1IjIykuTkZBITE9FqtYY68fHx7Nmzh127dlnUjs8++4zWrVvTvXt3o/L58+dz77334uXlxU8//cQzzzxDfn4+zz33nNlrzZo1i+nTpxuOc3NzCQ8Pt6gddVFUlLqli9X2zqsomebIkTB8uGwqXJsoCmRvhUb3mB9urSEle6H0Q3kl6XujZKWe48vIgJYtze364g20sfp7enjAkSOVC6Qee+wxLl++zMaNG43KbZUBvKYpisLVG1fxcvWy2YpIu/pJsGTJEiZPnkyrVq3QaDRERkYyadIkw/DfqVOnmDp1Kps3b65w6A3g2rVrfPnll8yZM6fMuZJlHTt2pKCggLfeeqvcIMrd3R13d/cqfDLLOVKyTbDinnjm9rvTJ9PUz2OSnqXaJSsJUgZD7x8gdKBNm7ItY5vJXig9fW/Utoxt9I7oXXMNEzXuwoWa3TYP1Pe7cMFxeqOKiooM+95Vl4vXLt7MFt/MZtnibTYnKiAgAGdnZ86dO2dUfu7cObM7QAcGBrJx40YKCgo4efIkhw8fxsfHh+bNmwPq0Fx2djadOnXCxcUFFxcXtm7dynvvvYeLi4tRjxVAQkICV69eNdqV2pxu3bpx+vRpCgtNTyasbpJssxyVSaYpapeMdcbPoP6bnUsx/e9ZjWLCYlg7ei2rRqwy+1g7ei0xYTE12i4hqqqgoIB69eqRkJBgVL5x40a8vb3Jy8szrFiPj4+ne/fueHh40LZtW7Zu3Wr0mj/++INBgwbh4+NDUFAQjz76KBdKjHf27t2b2NhYpk2bRkBAAAMGDDCcy8rKYtCgQXh6etK8efMy7XnppZeIjo7Gy8uL5s2bM2fOHG7cuGE4P2/ePDp06MCqVauIiIigfv36jB07lrSsNECdg5afn8+ECRPw8fEhJCSkzFzp6mKznig3Nzc6d+5McnKyYaxUp9ORnJxMbGxsua/18PCgcePG3Lhxg/Xr1/PQQw8B0LdvXw4cOGBUd9KkSbRq1YqXXnoJ51LDNp999hnDhg0jMNB4srYp+/bto0GDBtXe02SKJNusQGWSaUovlG0pOkhbDkWX1eOTX918jgcf9Y8hrmWqdWq4d8rdxZ0H75BNpYXj8Pb2ZuzYsaxcuZLRo0cbyvXHvr6+5OSof4C/8MILLF68mDZt2rBo0SKGDh1Keno6/v7+XL58mXvvvZcnnniCd999l2vXrvHSSy/x0EMP8Z///Mdw3S+++IKnn36aX3/91agdc+bMYeHChSxZsoRVq1YxduxYDhw4QOvWrQHw9fXl888/JzQ0lAMHDjB58mR8fX158cUXDdc4duwYGzdu5Ntvv+XSpUuMfnA0Xku8eGbmMxRqC3lu+nNs3bqVr7/+mkaNGvHPf/6TPXv20KFDh2q8wzYezps+fToTJ06kS5cudO3alcWLF1NQUMCkSZMAmDBhAo0bN2bBggUA7Nixg8zMTDp06EBmZibz5s1Dp9MZbrSvry9t27Y1eg9vb2/8/f3LlP/111/897//5fvvvy/Trm+++YZz585x99134+HhwebNm3njjTeYMWNGddyGCkmyzQpUJpmmsK3iAtj/ChRdhJIr4LTXYP8cQAGnm3+onEqw+RCfELXdt99+W2ZleclRlyeeeILu3buTlZVFSEgI2dnZfP/99/z8889Gr4mNjWXUqFEALF++nKSkJD777DNefPFFli5dSseOHXnjjTcM9VesWEF4eDhHjx4lOjoagKioKN58880ybXzwwQd54oknAHjttdfYvHkz77//Ph/cTGw8e/ZsQ92IiAhmzJhBfHy8URCl0+n4/PPP8fX1RVEUBo8azK5t6tznqwVXifsijrhVcfTt2xdQA7qwsLBK3s3Ks2kQNWbMGM6fP88rr7zC2bNn6dChA0lJSYbJ5hkZGTg53RpxvH79OrNnz+b48eP4+PgwePBgVq1aVaWJcytWrCAsLIz+/fuXOefq6sqyZct4/vnnURSFFi1aGNIx2IIk26xAZZNpVoW5VX+icly8oeU0OPYpXM0oceLm0J1rfSi+ORklIwG8m6lfu/lB1NOgsXl+YCFqlT59+rB8+XKjsh07djB+vLqKtGvXrtxxxx188cUXzJw5k7i4OJo2bUqvXr2MXhMTc2uY2sXFhS5dunDo0CEAfv/9d7Zs2VImWAO1h0gfRHXu3NlkG0teW39cct+9r776ivfee49jx46Rn59PcXEx9erVM3pNREQEvjeXal+8dpEGgQ24mKPm4zp94jQ3im7Qsn1LQ/2GDRvSsmVLqpvNJ5bHxsaaHb5LSUkxOr7nnns4ePBgpa5f+hp6b7zxhlFUXdLAgQMZOLD2/AWsT7ZZlFfE+UPnjYbwRsSNILB1IG6+bnVzKA9uJdMsb0jvdrZpqWjVn7BccQEcWXyzJ8qEG1dK1M2/1Tvl1hCaTQDXyuS7EMLxeXt706JFC6Oy06V+Fj7xxBMsW7aMmTNnsnLlygrT9ZSWn5/P0KFD+fe//13mXEiJP069q5AZefv27YwbN45XX32VAQMGUL9+feLj48vMaXJ1dQVK5OnSgKIznjd5Lv8ciqLU6Eo9+bPOTjhisk2rcXaGhx8uv87YsVXrOdKv+isdoOlX/SUmVv6adZmrLwzaC/XbVlxXuTkkEdAdBu2TAEqIKho/fjwnT57kvffe4+DBg0ycOLFMnd9++83wdXFxMampqYY5S506deLPP/8kIiKCFi1aGD0sCZxKXlt/rL/2//73P5o2bcrLL79Mly5diIqK4uTJk2avZSpbfFhEGC6uLuzZvceQLf7SpUscPXq0wrbdLgmi7IwjJdu0Gq0W1qwpv058fOVX58mqv+rh3QRCBpg5Wapz3MUL+qWAt+RbE6KqGjRowMiRI3nhhRfo37+/yblCy5YtY8OGDRw+fJgpU6Zw6dIl/va3vwFq4umLFy/y8MMPs2vXLo4dO8aPP/7IpEmTyqx6N2XdunWsWLGCo0ePMnfuXHbu3GkYgYqKiiIjI4P4+HiOHTvGe++9x4YNG0xex1y2eC9vL4aPHc57r7/Hhh82cODAAR577DGj6UDVRYIoO1NyH706uxqvtIpW58Gt1XnWvG7JVX+icvQr8coota1KcQHkmN+UXAhhmccff5yioiJDYFTawoULWbhwIe3bt2fbtm1s2rSJgJt7h4aGhvLrr7+i1Wrp378/d955J9OmTcPPz8+iQOXVV18lPj6edu3a8X//93+sWbOGNm3UhKXDhg3j+eefJzY2lg4dOvC///3PZO5GgPyifLN7Fj435zk6dO3As48+S7/7+vH//t//MztHy5o0imzwU21yc3OpX78+V65cKTNJTljRmjXwyCMV1/vyy4qH/WriugL2vgSH3oSwB6Dj27D3H3D6a/Vc6bLWL0LHsnMxhLCG69evk56eTrNmzQxJmsvPWF49qpKxvDJWrVrF888/z5kzZ4ySYJ44cYJmzZqxd+/eak8HcLt0io7L1y+Xuy+hRqPBz8MPJwsWoZj6t9ez9Pe3zSeWC3Hbqmt1Xk2s+qurwoZBg/bQ9GF1u5eeG+DAPPXcnfNulZ1cA95NbdlSUQc1aaIGNKb2zqsu1bV33tWrV8nKymLhwoX8/e9/r/Ys4tXJSeNEQ8+Gtm6GEQmihM2lpd3m/nn61XmZmabnL2k06vnKrs6rrusKCOyhPvQ0GmhXavNujQYiLOgJFKIaNGniGFuwvPnmm/zrX/+iV69ezJo1y9bNcTgSRAmbSkuDmylGynX0aDmBlLOzmm5g9Gj1F2/JgEe/1HXx4sqvzquu6wohRA2ZN28e8+bNM3s+IiKi3OExUT6ZWC5sqrweqErVGzlS3WS4cWPj8rCwW5sPV0V1XVcIIYTdk54o4ThGjoThw62fWby6riuEEMKuSRAlHIuzc/VsMlxd1xVCCGG3ZDhPCCGEEKIKJIgSQgghhKgCGc4TNqFPa3Bzk/DqpdXKfCYhhBBWJ0GUqHGWpjWwisREdf+7ktu3hIWpqQtkZZ0QwpyCDCiswWyb7gHqvpLCrkgQJWqcpWkNSvL1rcIbJSaqOZ5K50DJzFTLJUWBEMKUggz4piXoanDfFycPGHqkUoHUY489xhdffGE4btiwIXfddRdvvvkm7dq1A0Cr1fLee++xYsUK0tLS8PT05O6772b27Nn06HEr4e3nn3/OtGnTuHz5cpn30Wg0bNiwgQceeMBwrOfs7ExoaCijR49mwYIFuLu7V/KD2zeZEyVqrbg4SE2tINGmOVqt2gNlKomcvmzaNLWeEEKUVHihZgMoUN+vCj1fAwcOJCsri6ysLJKTk3FxceH+++8HQFEUxo4dy/z585k6dSqHDh0iJSWF8PBwevfuzcaNG6vc3JUrV5KVlUV6ejoffPABq1at4vXXX6/y9eyV9ESJWqt1a+jUqYov/uUX4yG80hQFTp1S60nqAiGEnXJ3dyc4OBiA4OBgZs6cSc+ePTl//jz/+c9/SEhIYNOmTQwdOtTwmo8//picnByeeOIJ7rvvPry9vSv9vn5+fob3DQ8PZ/jw4ezZs8c6H8qOSE+UHcpJyyFrTxY5aTm2bkrtlZVl3XpCCFHL5efnExcXR4sWLfD39+fLL78kOjraKIDS+8c//kFOTg6bN2++7fc9evQo//nPf+jWrdttX8veSE+UnclJy2Fp9FLDcezRWPyj/G3YoupTcuVehZsQlxYSUrV6spJP2DlFUdh9ZjddQrsYzV0Rjunbb7/Fx8cHgIKCAkJCQvj2229xcnLi6NGjtG7d2uTr9OVHjx41lF25csVwrYo8/PDDODs7U1xcTGFhIffff3+d3OBYeqLsTPaf2eUeO5Lx46FzZ/URHa2u6rNYz57qKjxzv0Q0GggPV+vpJSZCRAT06QOPPKI+R0So5ULYibj9cXT9tCurD6y2dVNEDejTpw/79u1j37597Ny5kwEDBjBo0CBOnjwJUKnNhX19fQ3XKvkw5d1332Xfvn38/vvvfPvttxw9epRHH33UGh/JrkhPlJ3IScuhKK+I83+cNyo//8d5/Jr44ebr5rA9UnqVWtXn7KymMRg9Wg2YSv4g0QdWixff6mWSlXzCARTripmbMheAuSlzGdt2LC5O8mPekXl7e9OiRQvD8aeffkr9+vX55JNPiI6O5pCZZHz68ugS+WacnJyMrlWe4OBgQ92WLVuSl5fHww8/zOuvv27xNRyB9ETZAf0Q3sedP2bLnC1G57bM2cLHnT9mafRSu5kjVaV0BVUxcqQa/DRubFweFmYcFMlKPuEg1hxYQ/rldACOXzpO/B/xNm6RqGkajQYnJyeuXbvG2LFjSUtL45tvvilT75133sHf35/77rvPKu/rfPMP0mvXrlnlevZC/kSxA5YO2WX/mW0XvVFRUWraAn3P0qFD6tBdtRg5EoYPL3+ek6zkEw5A3wulQYOCghNO0htVBxQWFnL27FkALl26xNKlS8nPz2fo0KHcc889rFu3jokTJ/LWW2/Rt29fcnNzWbZsGZs2bWLdunVVWpkHcPnyZc6ePYtOpyMtLY358+cTHR1tdg6Wo5L/WXZAg2WTQy2tVxtUOu/T7XB2Lj/4ud2VfDIZXdQCJXuhAHToDL1R49tV118pwtaSkpIIublAxtfXl1atWrFu3Tp63/yZt3btWhYvXsy7777LM888g4eHBzExMaSkpBgl26ysSZMmAWrPV3BwML169eKNN97AxaVuhRV169PaqcA7Aq1aT5RS1ZV8INvKiFqhdC+UnvRGVZF7gJpBvKYzlrsHVOoln3/+Oe988A7pl9Np5tcMf6+yIxEuLi7MmDGDGTNmlHutxx57jMcee8zkudKT0yszWd3Ryf8qO+Af5U/s0ViK8opI+z7NaF5Un9f6EDU4qk5MLK82+pV8mZmm50VpNOr5kiv5QCaji1qjdC+UnvRGVZF3E3ULlkpmEFcUhb8u/sUN3Q1cnVxp0bCF5WkmqrB3nqIonMk7A8CZvDM09GwoaS1qmARRdkIfIF3JuGJU3qhtI0I6WdiTIkyr7Eo+qHgyukajTkYfPlyG9uqYms7TZK4XSk96o6rIu0mlg5qLV3O44n3r3+CiZ4TJ3iFruXjtIoXaQgAKtYVcvHaxWt9PlCWr8+xM6SE7RxjCs3S1XrWu6rN0JZ9eZSajizqlpvM0bcvYRvrldJMBFNzqjdqWsa1G2lNXlewV0juTd6bahr5q+v2EafJniZ3xj/Jn/E/juZp9Fa9GXg4xhFd6tZ4plc5YXhWWrOTTk21lhAm2yNMUExbD2tFrDT0Sprg7uxMTFlOt7ajrSvYK6VVn71BNv58wTYIoO5OTlkNc/zjDsSNv+2ITFa3k07udyeiifIoC2Vuh0T3mM87XUqbyNFX3XCR3F3cevOPBan0PUT5TvUJ61TFXqabfT5gnQZSdMbXti70HUWlp6rYuFTl6tIZTI5SnqpPRRcWykiBlMPT+AUIH2ro1FpM8TXWXqV4hveroHarp9xPmyZwoO5GTlkPWniyT275k7cmym2zlpli6nUultn2pKq0WUlJgzRr12VyWcv1kdCjbW2JuMrqwTEaC+nwqwbbtqCR9L5R+blLJlXHCcZXXK6RnzblKNf1+laUoCgVFBXVmbpb8eWQH9Nu+mLJlzhZDygMZ2rtNlc35pJ+Mbuo1ixdLegNLKTpIWw5Fl9VjfRCVkQDezdSv3fwg6mnQ1M6/+yRPU92VX5Rf7nw0UHuH8ovy8XW//dUxNf1+lXXx2sVy81Y5GvlfbQccbduXWsmSnE+mJp1XZjK6UJWe81RcAPtfgaKLNyvcDJSK82H/HEABt4bQbAK41vwvBUtInqa6y9vNm+YNmpfb86LRaPB2q9r2KrZ+v8qoi3mrJIiyA4647UutYknOpyefhOeeU4MqvZK9VLKnnuVKz3ly9YVBe2HLQMg9BOjUeooW0EBAd+gRX2sDKMnT5JgyrmRw4Wrlkm3ejgCvAJrUrzgvlZPGiYaeDWugRZVXF/NWyf9oOyDbvlQzS3I+5ZiYcyaZyaum5Jwn/cRx7ybg3+1mEFWCixf0SwEn1xptYmXo8zSZUzJPU++I3jXXMFFlGVcyaLm0JdeLa27bFw8XD47EHrEokNJ77LHHuHz5Mhs3bjQqT0lJoU+fPly6dAk/Pz/rNtQMc3mrGno2ZPv27bz++uts376da9euERUVxaRJk5g6dSrOlei1t8XnqogEUXag5LYvv6/6nR2LdxjOdZvWjfaPtpdtX25HVXM5SWZyy5ib83RyHVw7B9rr4OwB5/5T9rXFBXDhN2hUe1c5Sp4mx3Ph6oUaDaAArhdf58LVC5UKomqT0isGbxTdADdY9dUqHn/0cSZNmsSWLVvw8/Pj559/5sUXX2T79u2sXbvWrof8bD5Lc9myZURERODh4UG3bt3YuXOn2bo3btxg/vz5REZG4uHhQfv27UlKSjJbf+HChWg0GqZNm2ZU3rt3bzQajdHjqaeeMqqTkZHBkCFD8PLyolGjRrzwwgsUFxff1me9Hf5R/oR0CqGooMiovKigiJBOIRJA3Y7byeUkmckrpp/ztH+2OsdJW3CzPB/OfAvnflaftdduvkBz83FTxvqabnGl6PM0jW833uzjwTsexN3F3dZNFXVMQUEB9erVIyHBeKXrxo0b8fb2Ji8vjxMnTqDRaIiPj6d79+54eHjQtm1btm7davSaP/74g0GDBuHj40NQUBCPPvooFy6ow52KojCw30DefPlN3nnlHfq17cezjzzLtavXmDplKsOGDePjjz+mQ4cORERE8MQTT/DFF1+QkJDA2rVrASpsx4kTJ+jTpw8ADRo0QKPRmN0wuSbZNIj66quvmD59OnPnzmXPnj20b9+eAQMGkJ1teiL17Nmz+eijj3j//fc5ePAgTz31FCNGjGDv3r1l6u7atYuPPvqIdu3ambzW5MmTycrKMjzefPNNwzmtVsuQIUMoKirif//7H1988QWff/45r7zyinU+eBXoUxzcyL9hVH4j/4bdpziw+bYv+pxPt/PXkGQmN08/5ymgO6DcnOsEhrlPLvp/WMX4OaA7dH4PmkoiSSGqwtvbm7Fjx7Jy5Uqj8pUrVzJ69Gh8S/xQfeGFF/jHP/7B3r17iYmJYejQoeTcnMZw+fJl7r33Xjp27Mju3btJSkri3LlzPPTQQ4DaC6VDx3frvsPVzZVPN37KzIUz+W3rb1y+eJnJsZPLtG3o0KFER0ezZs0ao3Jz7QgPD2f9evUPqiNHjpCVlcUSfZoZG7LpcN6iRYuYPHkykyZNAuDDDz/ku+++Y8WKFcycObNM/VWrVvHyyy8zePBgAJ5++ml+/vln3nnnHeLibmXxzs/PZ9y4cXzyySe8/vrrJt/by8uL4OBgk+d++uknDh48yM8//0xQUBAdOnTgtdde46WXXmLevHm4ubnd7kevlPJSHPyx5g/+WPMHYL8pDmy+7UvJDYirSjKTl8+7CfTdAuvqga7EsJeLN4zIgsSgWz1UYBdzoYSoDb799lt8fHyMyrQl8ts98cQTdO/enaysLEJCQsjOzub777/n559/NnpNbGwso0aNAmD58uUkJSXx2Wef8eKLL7J06VI6duzIG2+8Yai/YsUKwsPDOXLkCEV+6ghJeLNwnpv9nKHO1h/VXiTfxr4oilJm2K5Vq1YcPXrU4nY0bKhOqG/UqFGtmRNls56ooqIiUlNT6dev363GODnRr18/tm/fbvI1hYWFeHh4GJV5enqybZvxxppTpkxhyJAhRtcubfXq1QQEBNC2bVtmzZrF1atXDee2b9/OnXfeSVBQkKFswIAB5Obm8ueff5q9ZmFhIbm5uUYPazi2+ZhV69VGUVHQqZP5R43sm5eQAAEBlXudRgPh4ZKZ3BI5O40DKFCH+tK/MA6g9OU55of2hRCqPn36sG/fPqPHp59+ajjftWtX7rjjDr744gsA4uLiaNq0Kb169TK6TkzMrTl7Li4udOnShUOH1IUev//+O1u2bMHHx8fwaNWqFQB/HPnDMBeqVbtWJttYWKzmrbJEee2ojWzWE3XhwgW0Wq1RoAIQFBTE4cOHTb5mwIABLFq0iF69ehEZGUlycjKJiYlGUXd8fDx79uxh165dZt/7kUceoWnTpoSGhrJ//35eeukljhw5QmJiIgBnz5412S79OXMWLFjAq6++Wv4HrwLtNTNZs6tYT5gxciRcuwbjLcznI5nJK1ZyUnnWj7fKnT3BuynkHoZDN4fSwx6Ajm/D3n/A6a/h9CYI7GGLVgthN7y9vWnRooVR2elSq42feOIJli1bxsyZM1m5ciWTJk2q1GTu/Px8hg4dyr///e8y54KCg7jhfAMPFw+C/YJp5tfMcO6uO+8CoOhcEd6ty+atOnToEG3atLG4HbWRXa3OW7JkCZMnT6ZVq1ZoNBoiIyOZNGkSK1asAODUqVNMnTqVzZs3l+mxKunJJ580fH3nnXcSEhJC3759OXbsGJGRkVVu36xZs5g+fbrhODc3l/Dw8CpfT69Ru0ZWrVebpaXV8LCeVmucKNPMEK9Jkpm8YmUSad6kvQ65R9Svr5+Hbp9C87+pgWnPDXByjRpkOQhFUdh9ZjddQrvY9UokYZ/Gjx/Piy++yHvvvcfBgweZOHFimTq//faboXequLiY1NRUYmNjAejUqRPr168nIiICFxfTYYOrkyserh5GeaFGDR3F8w2f55OlnzCwj/E+mJs2bSItLY3XXnvN4nbop9JozW3HZQM2C6ICAgJwdnbm3LlzRuXnzp0zO1cpMDCQjRs3cv36dXJycggNDWXmzJk0b94cgNTUVLKzs+nUqZPhNVqtlv/+978sXbqUwsJCkzkpunXrBsBff/1FZGQkwcHBZVYJ6ttprm0A7u7uuLtbfwVO5H2RjP9pPFezr3Jo4yEOJdzq2mw9ujWtH2iNVyMvIu+regBYG9T4RsTmtnnx94eLF00n3wT1/FdfqQk2pQeqfC7e0HIaHPsUrmaUOHHz3ro3guhYaD7pVs+eRgMRj9R0S6tV3P44JmycwKoRqyRzuahxDRo0YOTIkbzwwgv079+fsLCwMnWWLVtGVFQUrVu35t133+XSpUv87W9/A9QpMp988gkPP/ywYW7SX3/9RXx8PJ9++qnZXE/e3t589NFHjB07lieffJLY2Fjq1atHcnIyL7zwAqNHjzZMTrekHU2bNkWj0fDtt98yePBgPD09y8wHq2k2mxPl5uZG586dSU5ONpTpdDqSk5ONxkRN8fDwoHHjxhQXF7N+/XqGDx8OQN++fTlw4IDR2HCXLl0YN24c+/btM/sPvW/fPgBCbk4OjomJ4cCBA0arBDdv3ky9evVs1vUYeV8kd467k/C7jXu2wu8O585xd9p9AAU1vBFxQgKMGlU2yWZmpppYU58DqiSNRn18/DH07SsBlCWKC+DI4lIBVAmF2epwXnGB6fMOQJ/RHGBuylyKdbZLlSIsE+AVgIeL+dGM6uDh4kGAVyXnZFbC448/TlFRkSEgKW3hwoUsXLiQ9u3bs23bNjZt2kTAzTmioaGh/Prrr2i1Wvr378+dd97JtGnT8PPzw8mp/DBi9OjRbNmyhYyMDHr27EnLli159913efnll4mPjy/TM1teOxo3bsyrr77KzJkzCQoKMvRQ2ZJNh/OmT5/OxIkT6dKlC127dmXx4sUUFBQYVutNmDCBxo0bs2DBAgB27NhBZmYmHTp0IDMzk3nz5qHT6XjxxRcB8PX1pW3btkbv4e3tjb+/v6H82LFjfPnllwwePBh/f3/279/P888/T69evQzpEPr370+bNm149NFHefPNNzl79iyzZ89mypQp1dLTVBmlh+wcYQgP1F6oGps7uG4dPPyw6XP64KlhQ/DwKLvNiwzfVY4+vUHKELjyh+k6offX2i1drKHkvnrHLx3njf++wZx75siwXi3WpH4TjsQeqZXbvpT0+eefmyzv3bt3mb31MjMz8ff3N3Q6lNa6dWt27Nhh8hxAVFSUYd6wKSkpKWbP9ezZs9ycjpVpx5w5c5gzZ45F16oJNg2ixowZw/nz53nllVc4e/YsHTp0ICkpyTCJOyMjwyjKvX79OrNnz+b48eP4+PgwePBgVq1aVamljm5ubvz888+GgC08PJxRo0Yxe/ZsQx1nZ2e+/fZbnn76aWJiYvD29mbixInMnz/fap+9qkoO7TnCEB5YPoxnFYmJUKr7uAz9Ni8//6z2NsnGwrfHuwmEDDAfRGX9AH/8S/3azQ+ingaNzfMAW0XpffU0aJi7dS5N/ZoysUPZeSmi9mhSv4ndZg8v6erVq2RlZbFw4UL+/ve/13iKHkdn84nlsbGxZrvkSke299xzDwcPHqzU9UtfIzw8vEwmVlOaNm3K999/X6n3qimOEDjppaVBOUnqrUu/0bClsrPN91iJyvFpbv5ccb6ayRwF3BpCswkO0zNVshcKMGxQ/MLmFxjXbpxsSFwLKIpCYXFhmZ4bR/Hmm2/yr3/9i169ejFr1ixbN8fhyP9gYTM12gMFFW80XJok0LSegpPqc3B/KLwAl/bcOqdoAY2aobxHvMMEUKV7oUo6f/U8q/evlt6oWmDTkU3Uv1afoOtBeHp62ro5Vjdv3jzmzZtn9nxEREStCCBrSzsqyzH6zIVdssoE8cqozNYskkDTusKGQffV0CcJ+m8H51I5Y/QZyr1vPyVIbaHvhSodQOm9sPkFmWRuY8W6Yt7f+T4A5wvO2+UvcWFbEkSJuqMyPUuSQNO6AnuoaQs0GjUTuYNnKC/ZC2WOvjdK2M6aA2s4nav2Thfpirh47WIFrxDCmARRwu5UeSNiSzYadnZWV+/JCrzqk/mN+hz2AAz9C8JurhY6vclmTbK2bRnbyu2F0puVPEt6o2zEVKB7Ju+M9EaJSpEgyg7lpOWQtSeLnLQcWzfltmSYSR1kzttv32aiTf1Gw2A+kFqz5vY2IhYV0w/t9UwE30g1Q3n31Wq5g4gJi2Ht6LWsGrGKv3f+u9l6WflZxP8RX4MtE3qmhlsLtYXSG1WLKIpCQVFBrQ5sJYiyMzlpOSyNXsrHnT9mafRSuw2k0tJgxIjKvWbGDCu8sX6j4caNjcvDw2H9enjwQSu8iShXyaE9RYHsrdD0YYfaJ8/dxZ0H73iQsW3H8tOxn8wO6znhJAk4baC84Vbpjao9Ll67yKELh2p1YCtBlJ0pyisq99heVHVSuVUmo48cCSdOwJYt8OWX6nN6ugzh2UJWEiT3Md6c2IFUNKynQ8fxS8fZlrGthltWt5U36V96o2oHRVE4k3cGqN2BraQ4sBM5aTkU5RVx/tB5o3L9sZuvG/5R/qZeKkxxdlb3vhO2lZGgPp9KgNCB5de1Q/phvUJtodk67s7uxISVv9WVsJ7yUk/onck7g/N5Z67lXKuxdnkFeFG/Sf0ae7/SPv74Y1577TUyMzNZtGgR06ZNu+1rnjhxgmbNmrF37146dOhQqddevHbR8P9GH9iW3Ny4tpAgyg7oh/BM2TB+g+Hr2KOxEkiJ2k3RQdpyKLqsHuuDqIwE8G6mfu1AWcv1w3qi9tD3DpbncsZlvu75NdpCbQ21Clw8XIg9ElupQOqxxx7jiy++UF/v4kLDhg1p164dDz/8MI899liF+9rp5ebmEhsby6JFixg1ahT161dPMJeSkkKfPn24dOlSuTuNlOyF0juTd4aGng1r3XZJEkTZAUuH7Ox1aE/UIcUFsP8VKLoIaG4FSg6ctVzULqV7B90UN/zxp7FvY9zc1S1Rzp84X6MBFEDx9WKuXrha6d6ogQMHsnLlSrRaLefOnSMpKYmpU6eSkJDApk2bcHGp+Nd8RkYGN27cYMiQIYTUgiTDJXuh9Gprb5T9/6lXB7j5WrbXkaX1hLAZ/YbEAd3VY0Vr/BzQHQbtq3IApSgKuzJ31dr5E8L29L2D49uNZ3y78QxrOQwfNx8aeDbA38sffy9/6nvYblitstzd3QkODqZx48Z06tSJf/7zn3z99df88MMPhg2KL1++zBNPPEFgYCD16tXj3nvv5ffffwfUTYzvvPNOAJo3b45Go+HEiRMcO3aM4cOHExQUhI+PD3fddRc///yz0XtrNBo2btxoVObn52dyY+QTJ07Qp08fABo0aIBGo+Gxxx4rU89UL5RebZwbJUGUHfCP8if2aCxPpj7JiDjjJW0j4kbwZOqTMpQn7Id3E+i7BZy9jMutkLU8bn8cXT/tyuoDksRS1F333nsv7du3JzExEYAHH3yQ7OxsfvjhB1JTU+nUqRN9+/bl4sWLjBkzxhAc7dy5k6ysLMLDw8nPz2fw4MEkJyezd+9eBg4cyNChQ8mobG6am8LDw1m/fj0AR44cISsriyX6lDMlmOqF0quNk/4liLIT/lH+hHQKIbB1oFF5YOtAQjqFSAAlaj9FgXMp6nM1ZC3XTxgGJG2AqPNatWrFiRMn2LZtGzt37mTdunV06dKFqKgo3n77bfz8/EhISMDT0xN/f/X3R2BgIMHBwTg7O9O+fXv+/ve/07ZtW6KionjttdeIjIxk06aqJcV1dnamYcOGADRq1Ijg4OAyc6/K64XSq229URJE2ZmrOVfLPbYXVc06XuVs5cL2SqYzqIas5fpl6wDHLx2XJJaiTlMUBY1Gw++//05+fj7+/v74+PgYHunp6Rw7dszs6/Pz85kxYwatW7fGz88PHx8fDh06VOWeKEvkF+WXu5IV1N6o/KL8amtDZcnEcjvj5e9V7rG9iIpSs4//+adlSTc3bIA77riNbOXC9kqmM2g+CRq0V5NsajRq1vKTa8C7aZUuXXrZuj6J5di2Y3Fxkh9zou45dOgQzZo1Iz8/n5CQEFJSUsrUKW+F3IwZM9i8eTNvv/02LVq0wNPTk9GjR1NUdGsBk0ajKdMrdOPGjSq32dvNm+YNmpfb06TRaPB28zZ7vqbJTxc74Yh5oqKibgVT5SXR9PWV4MkumUtncHKdOqTn3QzSPriVziDikSq/VcleKLiVxDL+j3jGtxt/Gx9CCPvzn//8hwMHDvD8888TFhbG2bNncXFxISIiwuJr/Prrrzz22GOMuPlXbn5+PidOnDCqExgYSFZWluE4LS2Nq1fNj464uamLn7Ra0ysfnTRONPRsaHEbawMJouyAo+eJkgDJQZWXzuD4CvVrK6QzMJc8UXqjRF1QWFjI2bNnjVIcLFiwgPvvv58JEybg5ORETEwMDzzwAG+++SbR0dGcOXOG7777jhEjRtClSxeT142KiiIxMZGhQ4ei0WiYM2cOOp3OqM69997L0qVLiYmJQavV8tJLL+Hq6mq2rU2bNkWj0fDtt98yePBgPD098fHxser9qGkyJ8oOOHqeqLQ02LPH/CMtzdYtFFViLp0BN38Quze6rXQGeua28CjZGyVEZXgFeOHiUbOBt4uHC14BlZ+ekZSUREhICBEREQwcOJAtW7bw3nvv8fXXX+Ps7IxGo+H777+nV69eTJo0iejoaMaOHcvJkycJCgoye91FixbRoEEDunfvztChQxkwYACdOnUyqvPOO+8QHh5Oz549eeSRR5gxYwZeXuY/Q+PGjXn11VeZOXMmQUFBxMbGVvrz1jYapTZNc3cwubm51K9fnytXrlCvXr0qX6e8nqiS7LEnKi0NoqMrrnf0qPRY2a3i67CuPiilgnzXetD6RfXrKmYpL9YVE/1+NCcunzC5hYcTTkQ0iOBI7BHpjRImXb9+nfT0dJo1a4aHh4eh/ErGFa5eqLmFO7be9qUuMvdvD5b//pafKnZAnydKPyeq5BDeiLgRBLYOtMs5UWlpsNPCFe1W2XhY2Eb2f8sGUAA3Cm47S3lFW3iU3OC3d0TvyrVb1Gn1m9SXoEZUSIIoO2EuQNLnibI3lvZA1QitFn75BbKyICQEevZUNygW1nEuWX12a3hzfpSeFtCow3094qs0rCcb/AohbEmCKDtTemsXe93qpdb0LCUmwtSpcPr0rbKwMFiyBEaOtF27HEnYMDWdQdgoWO9vnGRTn6Xcyfxk1PLIBr9CCFuSIMrOlBzas8chvFolMRFGj1aX25eUmamWJyRIIGUNgT3UR/Y281nKA3vYpm1CCHEbZHWeHdJvASMB1G3QatUeKFPrKvRl06ap9YR1VEOWciGsRdZY1T3W+DeXnihRN/3yi/EQXmmKAqdOqfV6966xZjk0/bCelbKUC2ENzjfnPxYVFeHp6Wnj1oiapE8MWl5uq4pIECXqphJZdq1ST1RMP6ynp9HcVpZyIazBxcUFLy8vzp8/j6urK05OpgdoFEXh2o1reLp6otFoariVwpoUReHq1atkZ2fj5+dnCKSrQoIoYResvvFwiIUrGi2tpycr/YSwKxqNhpCQENLT0zl58qTZevlF+eRczcHfyx8fN/vOsi1Ufn5+BAcH39Y1JIgStVpcHHTtWg2JNnv2VFfhZWaanhel0ajne/a0/Jqy0k8Iu+Tm5kZUVJTR5rolFeuKGRg3kNO5pwmvH84P436Q5K12ztXV9bZ6oPTku0DYhKU9S9USQIHaO7RkiboKT6MxDqT0XfWLF1veiyQr/W6PokD2Vmh0z637L0QNcnJyKpO1Wm/V76v4NetXAE4WnGTjXxtlY2sByLYv1cpa2744qrS08vNF+frWwFYvpnqPwsPVAMrSoEerhYgI8xPV9b1a6ekytGfOmR8gZTD0/gFCB9q6NUIYlN5aSLYSqhtk2xdR69WKvfBGjoThw29vHpOs9Lt9GQnq86kECaJEraLf4Fqv5MbW0hslJIgSwtn59oIbWelXeYoO0pZD0WX1WB9EZSSAdzP16ypuSiyEtRTripmbMhcNGqMNrp1wYm7KXMa2HSu9UXWc/OsL+1SbVsFV10o/R1ZcAPtfubmXnuZWoFScf9ubEgthLaV7ofSkN0royZ94wv4kJqpzkPr0gUceUZ8jItRyW9Cv9DM3IVqjUedZVWaln6Nz9YVBe9XNhwEUrfFzQHcYtM8mAZSiKOzK3CUZrOu4kr1Qpuh7o4p1xTXcMlGbSBAl7It+FVzpOUj6VXC2CKT0K/2gbCBVlZV+dYV3E+i7BZy9jMud3NVNib3DbdKsuP1xdP20K6sPrLbJ+4vaYVvGNtIvpxsN45Wk743alrGthlsmahNZnVeNZHWeZSxepVfRKjhQe4ROnLBNwGKNlX51TfY2+NlED91922yyKbF+JVb65XSaN2guK7DqsMLiQjYd2UShttBsHXdnd4a1HIa7i3uV3kNRFHaf2U2X0C6SBb2WsfT3twRR1UiCqIqlpUF0dMX1jh6FqMwUdeiuInPnqhPFbTFfqjbN1artFB1sGQBnf4Z6raHgFGjz1XOBPSFkQI1PLl/1+yombJxw63jEKpnzIqqN/vtNvs9qHwmiagEJoiq2cSOMGFFxvQ0b4IFra9Q5UJUlWcNrpxt5sKExFN/shtQ435wTpQH9EIpbQxh+okbmRkk+IFGTpNezdrP097fN50QtW7aMiIgIPDw86NatGzt37jRb98aNG8yfP5/IyEg8PDxo3749SUlJZusvXLgQjUbDtGnTDGUXL17k2WefpWXLlnh6etKkSROee+45rly5YvRajUZT5hEfH3/bn9cactJyyNqTRU5ajq2bctsKCipRr6qr22w5X0qY5+oLQ/64Oblcc2tSOYp6XMOTy/UrsfRzYEquwBLC2kqu/JPvM/tl0yDqq6++Yvr06cydO5c9e/bQvn17BgwYQHZ2tsn6s2fP5qOPPuL999/n4MGDPPXUU4wYMYK9e/eWqbtr1y4++ugj2rVrZ1R+5swZzpw5w9tvv80ff/zB559/TlJSEo8//niZa6xcuZKsrCzD44EHHrDK574dOWk5LI1eysedP2Zp9FKHCKQspl8FV1n6ztZp09ThNlF7mJtc7uJVo5PLza3EkhVYojqU/n6T7zP7ZdMgatGiRUyePJlJkybRpk0bPvzwQ7y8vFixYoXJ+qtWreKf//wngwcPpnnz5jz99NMMHjyYd955x6hefn4+48aN45NPPqFBgwZG59q2bcv69esZOnQokZGR3HvvvfzrX//im2++objY+BtYv8Oz/mFuXyW9wsJCcnNzjR7WVpRXVO6xQyu5Cq6ySmYNF7VLzk7QluqSLC5Qy2tI6V4ovdvpjZJUCcIc6fV0HDYLooqKikhNTaVfv363GuPkRL9+/di+fbvJ1xQWFpYJZDw9Pdm2zXiJ6ZQpUxgyZIjRtcujH/N0cTEej54yZQoBAQF07dqVFStWVPjDcMGCBdSvX9/wCA+33l/R+iG89C3Gid/St6Tb9dDe2bOVfMHIkfDqq1V/Q8kaXvtkfqM+hz0AQ/+CsOHq8elNNfL21ZUPSFIlCFOk19Ox2GwW24ULF9BqtQQFBRmVBwUFcfjwYZOvGTBgAIsWLaJXr15ERkaSnJxMYmIi2hJDNPHx8ezZs4ddu3ZZ3I7XXnuNJ5980qh8/vz53HvvvXh5efHTTz/xzDPPkJ+fz3PPPWf2WrNmzWL69OmG49zcXKsEUvohPFM2z9hs+Dr2aCz+Uf63/X41JS0NZsyowgtffhk+/lid61RZkjXcNhQFsrdCo3vK5tIKGwYN2kPTh9VzPTfAyTXg3bRGmqbPB2ROyXxAvSN6W3RN/S9KQLYHEUYkC7pjsav/1UuWLGHy5Mm0atUKjUZDZGQkkyZNMgz/nTp1iqlTp7J58+YKh95ADXKGDBlCmzZtmDdvntG5OXPmGL7u2LEjBQUFvPXWW+UGUe7u7ri7Vy1fSHksHbKzt6G98nJDlcvZGd57T50sDrfmPJVHo1HnU0nWcNvISoKUwdD7h7IbDAf2MM4JpdFARBVWYVZRTFgMa0evrTAfUExYjMXXNDVpWH4xCnN78enJnnz2x2b/SgEBATg7O3Pu3Dmj8nPnzhEcHGzyNYGBgWzcuJHr16+Tk5NDaGgoM2fOpHnz5gCkpqaSnZ1Np06dDK/RarX897//ZenSpRQWFuJ8M2dPXl4eAwcOxNfXlw0bNuDq6lpue7t168Zrr71GYWFhtQRK5bmac9Wq9eyRt3epgpEjISGhbHJLUyRruO3pNxg+lVA2iLIxdxd3HrzjQatdr/QvSvnFWL66lHCyOno9hW3Z7H+0m5sbnTt3Jjk52bDqTafTkZycTGxsbLmv9fDwoHHjxty4cYP169fz0EMPAdC3b18OHDhgVHfSpEm0atWKl156yRBA5ebmMmDAANzd3dm0aZNFvVb79u2jQYMGNR5AAXj5e1VcqRL17NEdd9z8onQyy2PH4H//u3V84QI8/7xxYBUWJlnDa5qig7TlUHRZPdYHURkJ4N1M/bqGE2nWlNLDNTJMU764/XEOnXCyZJBYHb2ewrZs+mfR9OnTmThxIl26dKFr164sXryYgoICJk2aBMCECRNo3LgxCxYsAGDHjh1kZmbSoUMHMjMzmTdvHjqdjhdffBEAX19f2rZta/Qe3t7e+Pv7G8pzc3Pp378/V69eJS4uzmgVXWBgIM7OznzzzTecO3eOu+++Gw8PDzZv3swbb7zBjCpN4Ll9br5uVq1nbzZsuLnti6ltVfSJNB9++FbZiBGSNdzWigtg/ytQdBHQ3AqUivNh/xxAURNpNptgk02Gq4u54RrpjTKtLswdKx0kWrPXU9ieTb9bx4wZw/nz53nllVc4e/YsHTp0ICkpyTDZPCMjAyenW3+lXr9+ndmzZ3P8+HF8fHwYPHgwq1atws/Pz+L33LNnDzt27ACgRYsWRufS09OJiIjA1dWVZcuW8fzzz6MoCi1atDCkY7AF/yh/Yo/GUpRXxO+rfmfH4h2Gc92mdaP9o+1x83Wzq0nlldGkCbc2Hi49/0mfSDMh4VZPk7Ozuu2LsB1XXxi0F359GC5sv5VIU5+RPKA79Ih3qAAKZNJwZTn63LG6ECTWdbLtSzWy5rYvOWk5FOUVkfZ9GlvmbDGU93mtD1GDo+wyiNqzBzp3rrhe6k4tnUZGmJ/7pJ80np4uPU61jbYIEhoa54Fy8YbRl8DJxDzE8lbx1XKlt40pTbaRMVYXttmRvRjtl91s+yIqVjJLeckACmDLnC2On718797yJ49LIs3aqzKJNBUFDr4JyX0g68eaaZ8V6ScNmwqgwHjSsHD8hJOSlbxucIxw38E5aooDXwtHcnzzLUyQKYk0a5+SiTQ7vg17/wGnv1YTaZZMawBqGoTfZ6pf18JVfBWRScOWqwtzx2SBQd1g39+ldYQjTyzfsMH8JsTe3uqqvKhMC6MtSaRZ+1SUSLPkKr5TJTaItsNVfNZOleDIHH3uWF0IEoVK5kRVI2vOiTq2+RhXs6/ye9zvHEs6ZiiPHBhJ+/Ht8WrkReR9kbfb5BqTlgbR0RXX++knuO9eLUREqJPITX27ypwo+6To4PC76mo97bVSJzWg/+Xj1hCGn3C4Seh1VV2YO1Z6LlSZ8zI3qtaTOVEOJCcth7j+cSSOTzQKoACOJR0jcXwicf3j7GpOlKXZyvv3h43fOHPmpZsbD5eebFxRIk2tFlJSYM0a9bnEFkHCxooL4M83TARQYAigNC5w3za7DqBkI2Jjjj53rLr2YhS1k32G+XXM+T/PW1zP3lboWWLECICRZL6fQOi/TeSJMpdIs7y8UpJ40/aM0iD8z0QFJ7j/CPg2r/GmWZOjJ5OsLEefOyZZyesWCaLsQO6ZXKvWs1dnu48k9MRwyxJpViavlLAd7ybQdwusqw+666VO6uB6ll0HUZInqCxHnzvm6EGiMFa3/zfbiXqhls2nsrSeXbMkkaZWq/ZAmRo+URR1CHDaNBg+XOZQ1QY5O00EUDeZWsVnRxw9maQoy9GDRGFM5kTZAVfv8jdHrmw9h/fLL5JXyp7o0yA07Az3p0HYcPU49H51dZ+dkjxBQjg+CaLsgGxAXEmW5ouSvFK2oShwLuVWT2HYMOi+Ggbsgnot1DQI3VfDHTNrbS+UJZPFHT2ZpBBCgii74Mh5oiojI8PCipbmi5K8UraRlWSclTywB0Q8cmulpUajHtfSAArUyeJdP+3K6gOrTZ43t0JLeqOEcCwSRNkB/yh/xv80npFxI2n7SFujc20facvIuJGM/2m8Xa3MszRbeUnmknKW0bOnugrP3N5rGg2Eh6v1RM3LSFCfTyXYth1VVHqyuKmAqHQvlJ70RgnhWGRiuR3Q54ky5Y8v/+CPL/8AIPZorN0EUlFRaiLN/v2r4eLOzmoag9Gj1YCp5JBLRXmlhPWVzEoOt4IoQ1ZyBa6fh06LwKn2/5tUNFncXLZqPclaLYTjkJ4oO+Coe+fddx8cPQpvv21ZfW/vSlx85Eg1jUHjxsblYWGS3qCmFRfA/ldg/+yb2clvdikW56vH++fA0ffUPfVqOUsmizt6MkkhxC3yZ5AdcOQ5UVFR0KePZXWbNKnkxUeOVNMYWJJXSlQfo6Sa20G5mTVe0QIacG8EhdmQ9T00qd3BrSWbykqeICHqDtk7rxpZc++8nLQcivKKOH/oPBvGbzCUj4gbQWDrQNx83exmKK+0PXugc+eK66WmQqdO1d8eUU20RWWTajq5gsYDtHngWh9av6CW18JNh83t+eYIe70JIYxZ+vtb/sfbCXMBUmDrQEI6ySozYQdMJdXU3QBu9kzph/dQ1E2Hm02oVXvmle6F0jPVGyWEqBtqz595wiKlh+zscQhP1CGKDo4ugz/+Bb//81a5szc4ed480N2sezOYCugOg/bVqgBKNpUVQpgiPVF2xj/Kn9ijsRTlFdn1EF5JlqY7qEpahGqj1cpcK0voJ5UXXbxZoAEUtUdKHzSV5OIF/VLUYb5aRDaVFUKYIkGUHXKEwKmkqCh1lV5envk6vr5qvVohMVHdm6/k1jJhYWpaBVn1Z6z0pHL9XCJTARSoQVfOzlqXaFMmiwshTJGJ5dXImhPLRS2RmKjmnyr930aff0rSJ5imLYKEhrfSGwBoXEG5AWEPQMe3Ye8/1DQHrV+Ejv+2WVOFEMLS399VmhP1yy+/MH78eGJiYsjMzARg1apVbNsmeU+EA9Nq1R4oU3936MumTVPrCWM5O40DKFADqLavQM9E8I28tWeeHW86LISoWyodRK1fv54BAwbg6enJ3r17KSxUu7evXLnCG2+8YfUGClFr/PKL8RBeaYoCp06p9YSxzG/U54Cbw13+N5+11+1qzzwhhCip0kHU66+/zocffsgnn3yCq+utyZ89evRgz549Vm2cELVKVpZ169UlYcPUXibfVupx/dbS6ySEsHuVnlh+5MgRevXqVaa8fv36XL582RptEqJ2CrEwH5el9eqC0vvmnVp/69mnOeSnw6V9tS6xphBCWKLSQVRwcDB//fUXERERRuXbtm2jefPm1mqXELVPz57qKrzMTNPzojQa9XzPnjXfttrKKMWB5lagVMsTawohhCUq/aff5MmTmTp1Kjt27ECj0XDmzBlWr17NjBkzePrpp6ujjULUDs7OahoDuDWPR09/vHix5IsqSZ/iIKC7emy0bx61MrGmEEJYqtI9UTNnzkSn09G3b1+uXr1Kr169cHd3Z8aMGTz77LPV0UbhoNLS7Cg3lN7IkWoaA1N5ohYvlvQGpng3gb5bYF0D0F29VV5LE2sKIYSlKpUnSqvV8uuvv9KuXTu8vLz466+/yM/Pp02bNvj4+FRnO+2S5IkyLy0NoqMrrnf0aC0MpEAylldW9jb42cQw533bZDWeEKLWqZYNiJ2dnenfvz+HDh3Cz8+PNm3a3HZDRd1UXg9UVerVOGdn6N3b1q2wH/oUBwBNHgRdkZpY8/QmCaKEEHar0sN5bdu25fjx4zRr1qw62iOEcBQlV+YVXQJnT9Beg6yfoPUMcHJTE24qOlmZJ4SwS5UOol5//XVmzJjBa6+9RufOnfH29jY6L8NWQgiggpV5r2BYmXfnqzKxXAhhlyodRA0ePBiAYcOGoSmxQklRFDQaDVrZ8kIIAWU3HzZamadRV+b1iJcASghhtyodRG3ZsqU62iGEcET6lXmlNx+WlXlCCAdQ6SDqnnvuqY52CCEclanNh4sL1HKZVC6EsGOVDqIALl++zGeffcahQ4cAuOOOO/jb3/5G/fr1rdo4IYQD0K/MC3sAOr4Ne/8hK/OEEA6h0ktidu/eTWRkJO+++y4XL17k4sWLLFq0iMjISNmAWFjM18JpMJbWE7WYfvPhnongGwk9N8jmw0IIh1DpIOr5559n2LBhnDhxgsTERBITE0lPT+f+++9n2rRplW7AsmXLiIiIwMPDg27durFz506zdW/cuMH8+fOJjIzEw8OD9u3bk5SUZLb+woUL0Wg0Zdp1/fp1pkyZgr+/Pz4+PowaNYpz584Z1cnIyGDIkCF4eXnRqFEjXnjhBYqLiyv9+YRpUVFqIs3UVPOPWptoU1ROYA+IeOTW1jgajXosvVBCCHunVJKHh4dy6NChMuV//vmn4unpWalrxcfHK25ubsqKFSuUP//8U5k8ebLi5+ennDt3zmT9F198UQkNDVW+++475dixY8oHH3ygeHh4KHv27ClTd+fOnUpERITSrl07ZerUqUbnnnrqKSU8PFxJTk5Wdu/erdx9991K9+7dDeeLi4uVtm3bKv369VP27t2rfP/990pAQIAya9asSn2+K1euKIBy5cqVSr1OCCGEELZj6e/vSgdRjRo1Un788ccy5UlJSUqjRo0qda2uXbsqU6ZMMRxrtVolNDRUWbBggcn6ISEhytKlS43KRo4cqYwbN86oLC8vT4mKilI2b96s3HPPPUZB1OXLlxVXV1dl3bp1hrJDhw4pgLJ9+3ZFURTl+++/V5ycnJSzZ88a6ixfvlypV6+eUlhYaPHnkyBKCCGEsD+W/v6u9HDemDFjePzxx/nqq684deoUp06dIj4+nieeeIKHH37Y4usUFRWRmppKv379DGVOTk7069eP7du3m3xNYWEhHh4eRmWenp5s27bNqGzKlCkMGTLE6Np6qamp3Lhxw+hcq1ataNKkieF9t2/fzp133klQUJChzoABA8jNzeXPP/80+5kKCwvJzc01egghhBDCMVV6dd7bb7+NRqNhwoQJhjlCrq6uPP300yxcuNDi61y4cAGtVmsUqAAEBQVx+PBhk68ZMGAAixYtolevXkRGRpKcnExiYqJRgs/4+Hj27NnDrl27TF7j7NmzuLm54efnV+Z9z549a6hjql36c+YsWLCAV1991ex5IYQQQjiOSvdEubm5sWTJEi5dusS+ffvYt28fFy9e5N1338Xd3b062miwZMkSoqKiaNWqFW5ubsTGxjJp0iScnNSPcerUKaZOncrq1avL9FjVhFmzZnHlyhXD49SpUzXeBiGEEELUjEoHUVeuXOHixYt4eXlx5513cuedd+Ll5cXFixcrNXwVEBCAs7NzmVVx586dIzg42ORrAgMD2bhxIwUFBZw8eZLDhw/j4+ND8+bNAXWoLjs7m06dOuHi4oKLiwtbt27lvffew8XFBa1WS3BwMEVFRVy+fNns+wYHB5tsl/6cOe7u7tSrV8/oIYQQQgjHVOkgauzYscTHx5cpX7t2LWPHjrX4Om5ubnTu3Jnk5GRDmU6nIzk5mZiYmHJf6+HhQePGjSkuLmb9+vUMHz4cgL59+3LgwAFDD9m+ffvo0qUL48aNY9++fTg7O9O5c2dcXV2N3vfIkSNkZGQY3jcmJoYDBw6QnZ1tqLN582bq1atHmzZtLP6MQgghhHBclZ4TtWPHDhYtWlSmvHfv3rz88suVutb06dOZOHEiXbp0oWvXrixevJiCggImTZoEwIQJE2jcuDELFiwwvHdmZiYdOnQgMzOTefPmodPpePHFFwHw9fWlbdu2Ru/h7e2Nv7+/obx+/fo8/vjjTJ8+nYYNG1KvXj2effZZYmJiuPvuuwHo378/bdq04dFHH+XNN9/k7NmzzJ49mylTplT7kKUQQggh7EOlg6jCwkKTSSdv3LjBtWvXKnWtMWPGcP78eV555RXOnj1Lhw4dSEpKMkzizsjIMMx3AjVJ5uzZszl+/Dg+Pj4MHjyYVatWlZkkXpF3330XJycnRo0aRWFhIQMGDOCDDz4wnHd2dubbb7/l6aefJiYmBm9vbyZOnMj8+fMr9T5CCCGEcFwaRVGUyrygT58+tG3blvfff9+ofMqUKezfv59ffvnFqg20Z7m5udSvX58rV67I/CghhBDCTlj6+7vSPVGvv/46/fr14/fff6dv374AJCcns2vXLn766aeqt1gIIYQQwo5UemJ5jx492L59O+Hh4axdu5ZvvvmGFi1asH//fnr27FkdbRRCCCGEqHUqPZwnLCfDeUIIIYT9sfT3d6V7ovbs2cOBAwcMx19//TUPPPAA//znPykqKqpaa4WoCVotpKTAmjXqc4lM90KYoigKuzJ3IX9rCiFMqXQQ9fe//52jR48CcPz4ccaMGYOXlxfr1q0zpBoQotZJTISICOjTBx55RH2OiFDLhTAjbn8cXT/tyuoDq23dFCFELVTpIOro0aN06NABgHXr1nHPPffw5Zdf8vnnn7N+/Xprt0+I25eYCKNHw+nTxuWZmWq5BFLChGJdMXNT5gIwN2UuxbqyqV2EEHVbpYMoRVHQ6XQA/PzzzwwePBiA8PBwLly4YN3WCXG7tFqYOhVMDcfoy6ZNk6E9UcaaA2tIv5wOwPFLx4n/o+xODUKIuq3SQVSXLl14/fXXWbVqFVu3bmXIkCEApKenG5JkClFr/PJL2R6okhQFTp1S6wlxk74XSoMGACecpDdKCFFGpYOoxYsXs2fPHmJjY3n55Zdp0aIFAAkJCXTv3t3qDRSi0kpOIC+xR2K5srKqtUnCvuh7oRTU3kodOumNEkKUYbUUB9evX8fZ2RlXV1drXM4hSIoDG0hMVIfvyut9MmXLFujdu1qaJOxLsa6Y6PejOXH5hCGIArU3KqJBBEdij+DiVOk8xUIIO1JtKQ7M8fDwkABK2Ja5CeTl0WggPBwkUay4qXQvlJ70RgkhSrNaECVqTk5aDll7sshJy7F1U2qP8iaQm6NR57uweDE4O1dLs4R9KT0XqjSZGyWEKEn6pO1MTloOS6OXGo5jj8biH+VvwxbVEhVNIDclLEwNoEaOrJYmCfuzLWObYUWeKfreqG0Z2+gd0bvmGiaEqJUkiLIzRXlF5R7XWZZODJ89G9q0gZAQdQhPeqBECTFhMawdvZZCbaHZOu7O7sSExdRgq4QQtZUEUXYiJy2Horwizh86b1SuP3bzdavbPVIhIZbV69tXJpALs9xd3Hnwjgdt3QwhhJ2w2uq8U6dOMXfuXFasWGGNyzkEa63OKz2EZ06dHtrTatVtXDIzTc+L0mjU4bv0dOl9EkIIUa4aX5138eJFvvjiC2tdTpRg6ZBdnR7ac3aGJUvUrzWlJgXLBHIhhBDVwOLhvE2bNpV7/vjx47fdGGGam6+bVes5rJEjISGhbJ4omUAuhBCiGlg8nOfk5IRGo6G86hqNBq3sQWZgzWSbJedEbRi/wVA+Im4Ega0DZU5USVqtulovK0smkAshhKg0S39/W9wTFRISwgcffMDw4cNNnt+3bx+dO3eufEuFRfQB0uWMy0blrt6uhHSycFJ1XeHsLJPHhRBCVDuL50R17tyZ1NRUs+cr6qUS1lE6CaC5pIBCCCGEqF4W90S98MILFBQUmD3fokULtmzZYpVGibL0w3lFBaXyRBUUkbUnS4bzhBBCiBpm0Zyo/fv307ZtW5ycZJeYypAUB5WTlgZ5eebP+/pCVFTNtUcIIUTdZNU5UR07diQrK4tGjRrRvHlzdu3ahb+//f6ytjd1IcVBWhpER1dc7+hRCaSEEPZHURR2n9lNl9AuaEqnYRF2y6KuJT8/P9LT1f2kTpw4gU6nq9ZGCWN1IcVBeT1QVaknhBC1Sdz+OLp+2pXVB1bbuinCiizqiRo1ahT33HMPISEhaDQaunTpgrOZJeOSL8r6/KP8iT0aKykOhBDCDhXripmbMheAuSlzGdt2LC5OsuuaI7DoX/Hjjz9m5MiR/PXXXzz33HNMnjwZX1/f6m6bKMFcgBTYOtDuUxykpcGhQ7ZuhRBCVI81B9aQflkdzTl+6Tjxf8Qzvt14G7dKWIPFofDAgQMBSE1NZerUqRJE2UjpITt7HsIDy+dCCSGEPdL3QmnQoKDghJP0RjmQSv8Lrly5sjraISxUcmjPEYbwZI6TEMKRleyFAtChk94oByI5C+yQf5Q/IZ1C7D6AEkIIR1ayF6okfW9Usa7YRi0T1iJBlBBCCFEN9L1QCsbpGEv2Rgn7JkGUsCsyFU8IYQ/M9ULpSW+UY5Agyg7lpOWQtSeLnLQcWzelxsTFmUi0qdVCSgqsWaM+a7U2ap2wKkWBcynqs3A4iqKwK3OXw++1ui1jm8leKD19b9S2jG013DJhTbI0wM6U3gLG3rd6sVTr1qUCqMREmDoVTp++VRYWBkuWwMiRNd4+YUVZSZAyGHr/AKEDbd0aYWVx++OYsHECq0ascuiJ1TFhMawdvZZCbaHZOu7O7sSExdRgq4S1SRBlZ0pv7WLPW71UWWIijB5dtqciM1MtT0iQQMqeZSSoz6cSJIhyMHUp6aS7izsP3vGgrZshqpljfvc6oJy0HEPG8pL0x/aa7sDSOU6Gelqt2gNlaihAUUCjgWnTYPhwMJNVX9Qyig7SlkPRZfVYH0RlJIB3M/VrNz+Ieho0MgPBnknSSeFoNIqjD0zbkKW7QFek9BCeOfY6tJeWVn6+KF/fEkN5KSnQp0/FF92yBXr3tkLrRLW7kQdfR0DRRUCjBkqKFjTOaoCFAm4NYfgJcJWVBfaqWFdM9PvRnLh8wpB0MqJBBEdijzhsb5SwX5b+/pbvXDtg6ZCdvQ7tGc11qkhWlnXrCdtQFMjeCo3uUQOjQXvh14fhwnY1gIKbzxoI6A494iWAsnOSdFI4Ipv3jS9btoyIiAg8PDzo1q0bO3fuNFv3xo0bzJ8/n8jISDw8PGjfvj1JSUlGdZYvX067du2oV68e9erVIyYmhh9++MFw/sSJE2g0GpOPdevWGeqZOh8fb5ucHpZu7WKPW8CkpcGePeYfaWmlXhBi4T6BltYTtpGVBMl9IOtH9di7CfTdAs5exvVcvKBfCniH13gThfVI0knhqGzaE/XVV18xffp0PvzwQ7p168bixYsZMGAAR44coVGjRmXqz549m7i4OD755BNatWrFjz/+yIgRI/jf//5Hx44dAQgLC2PhwoVERUWhKApffPEFw4cPZ+/evdxxxx2Eh4eTVaqX4uOPP+att95i0KBBRuUrV6407BkI4OfnZ/2bYIGSW72cP3SeDeM3GM6NiBtBYOtAu5wTZem+eUapDXr2VFfhZWaanhel0ajne/a0aluFlZmaPJ6zE7QFxvWKC9TywB412z5hVaV7ofSkN0rYO5vOierWrRt33XUXS5eq8310Oh3h4eE8++yzzJw5s0z90NBQXn75ZaZMmWIoGzVqFJ6ensTFxZl9n4YNG/LWW2/x+OOPmzzfsWNHOnXqxGeffWYo02g0bNiwgQceeKCKn856c6JKytqTxcedPzYcP5n6JCGd7LPXZc8e6Ny54nqpqdCpU4kC/eo8MA6kNDf/ypXVebVPycnjigJ/LgDdVXCtD61fUOucS4FzP0PYA9Dxbdj7Dzj9NbR+ETr+24aNF7ej9Fyo0mRulKiNLP39bbPhvKKiIlJTU+nXr9+txjg50a9fP7Zv327yNYWFhXh4eBiVeXp6sm2b6WRlWq2W+Ph4CgoKiIkxnYsjNTWVffv2mQywpkyZQkBAAF27dmXFihUVJocrLCwkNzfX6GFtpYfs7HEI77aNHKkGSo0bG5eHhUkAVVsVF8D+V2D/bDgwRw2gAIrzYf8ctTxnJ3T7FHomgm8k9NwA3VdD2DDbtl3cFkk6KRyZzcL+CxcuoNVqCQoKMioPCgri8OHDJl8zYMAAFi1aRK9evYiMjCQ5OZnExES0pTJVHzhwgJiYGK5fv46Pjw8bNmygTZs2Jq/52Wef0bp1a7p3725UPn/+fO699168vLz46aefeOaZZ8jPz+e5554z+5kWLFjAq6++asnHr7KSQ3v2OIRnNSNHqmkMfvlFnUQeEqIO4Ulag9rJaPL4/26Vl548XnLuk0YDEY/UeFOFdUnSSeHI7KrvdMmSJUyePJlWrVqh0WiIjIxk0qRJrFixwqhey5Yt2bdvH1euXCEhIYGJEyeydevWMoHUtWvX+PLLL5kzZ06Z9ypZ1rFjRwoKCnjrrbfKDaJmzZrF9OnTDce5ubmEh1t/QmydDZxKc3aWNAb2oORQXsgA4yAKwMkFmo4Br8YmXy7smySdFI7MZsN5AQEBODs7c+7cOaPyc+fOERwcbPI1gYGBbNy4kYKCAk6ePMnhw4fx8fGhefPmRvXc3Nxo0aIFnTt3ZsGCBbRv354lS5aUuV5CQgJXr15lwoQJFba3W7dunD59msLCcv6acnc3rArUP4So84yG8uaWPa+7Ab/PUesJIYQdsVkQ5ebmRufOnUlOTjaU6XQ6kpOTzc5f0vPw8KBx48YUFxezfv16hg8fXm59nU5nMvj57LPPGDZsGIGBgRW2d9++fTRo0AB3d/cK6wohStAP5QV0N18n4hHJAyWEsDs2Hc6bPn06EydOpEuXLnTt2pXFixdTUFDApEmTAJgwYQKNGzdmwYIFAOzYsYPMzEw6dOhAZmYm8+bNQ6fT8eKLLxquOWvWLAYNGkSTJk3Iy8vjyy+/JCUlhR9//NHovf/66y/++9//8v3335dp1zfffMO5c+e4++678fDwYPPmzbzxxhvMmDGjGu+GEA5MnwcqoT5or98qd/aGuz5QJ5ILIYSdsWkQNWbMGM6fP88rr7zC2bNn6dChA0lJSYbJ5hkZGTg53eosu379OrNnz+b48eP4+PgwePBgVq1aZZS/KTs7mwkTJpCVlUX9+vVp164dP/74I/fdd5/Re69YsYKwsDD69+9fpl2urq4sW7aM559/HkVRaNGiBYsWLWLy5MnVcyMqSb+Pnr1PLK/0vnmW0GplsnltlbPTOIACNS+Ub6TkgRI1SlEUdp/ZTZfQLmg0mopfIIQZsndeNaqOPFGl99Gz1/3y9Cq1b15FEhPVzYlPn75VFhYGS5ZI2oPaYO9LcOhNyQMlbG7V76uYsHECq0askiSfwiTZO89Bld4fz173y9Or1L555dEn4Cz9N0Fmplou+aNsL2wYNGgPTR9W0xf03AAn14B3U1u3TNQh+i1oAOamzGVs27GS5FNUmc33zhOWyUnLIWtPFucPnTcqP3/oPFl7sshJy7FRy2oBrVbtgTLVqaovmzZNrSdsJ7CHOoFcP3yizwMlQ3miBpXcgka/5YwQVSXDedXIWsN5pYfwzLH3ob0qS0mBPn0qrrdli+SVEqIOK70FjWw5I8yp9du+CMtZOmRn70N7VVZqQ+nbrieEcEj6Xij9FjQlN0AWoiokiLIDlu6PVyf30QN1FZ416wkhHI5+LpQG49V4TjgxN2UuxbpiG7VM2DPpv7QDJffLO3/oPBvGbzCcGxE3gsDWgXaf7uC29OyprsLLzDQ9L0qjUc/37FnzbRNC1Aol50KVVLI3SlbqicqSnig74R/lT0inEAJbG2dXD2wdSEinkLobQIGaB0q/rU/pnC/648WLJV+UEHWUuV4oPemNElUlQZSdKT1kV2eH8EobOVJNY9C41Ca2YWGS3kCIOm5bxjajuVCl6XujtmVsq+GWCXsnq/OqUXUk2wTHyVheLSRjuRCilMLiQjYd2UShtpwN5J3dGdZyGO4usj+qsPz3twRR1ai6gighhBBCVB9JcSCEEEIIUY1kdZ4dkuE8IYQQwvYkiLIzjrYBsRBCCGGvZDjPzjjaBsRCCCGEvZKeKDuhH8IztQExIEN7QgghRA2TIMoOlLcBccns5TK0J4QQtYuiKOw+s5suoV3QlE4GLOyeDOfZAdmAWAgh7FPc/ji6ftqV1QdW27opohpIEGUHZANiIYSwP/rtZgDZVsZByXCeHZANiO2EZEsXQpRQctPj45eOs+bAGh5t/6iNWyWsSYIoO2EuQNJvQCxsLDERpk6F06dvlYWFqRsjy759QtQ5JTc91u/ZN+OnGTx858O4OMmvXkchw3l2RjYgriZaLaSkwJo16rNWa/lrExNh9GjjAAogM1MtT0y0ZkuFEHZA3wtVctPj7KvZrN4vc6MciQRRQiQmQkQE9OkDjzyiPkdEWBb8aLVqD5SpLSj1ZdOmVS4oE0LYtZK9UKW9uPlFmRvlQCSIsjOSbNPKbrcX6Zdfyr62JEWBU6fUekKIOsFUL5Se9EY5Fgmi7EROWg5Ze7JMJtvM2pNFTlqOjVpmx6zRi5SVZdl7WVpPCGHXyuuF0pPeKMchs9vsgCTbrCaV6UXq3dt0nRALJ/VbWk8IYde2ZWwzrMgzJ/tqNltPbKVv87411CpRXaQnyg5Iss1qYo1epJ491VV45jIRazQQHq7WE0I4vJiwGNaOXsvfO/+93HoZVzJqqEWiOklPlB1wxGSbaWmQl2f+vK8vREVVcyOs0Yvk7KymMRg9Wg2YSg4N6gOrxYslX5QQdYS7izsjWo/gpZ9fMkpvUJITTrz+y+s82v5RSXdg5zSKYmpCiLCG3Nxc6tevz5UrV6hXr95tXavkBsT2nmwzLQ2ioyuud/RoNQdSWq26Ci8z0/S8KI1G7WVKT684CDKVJyo8XA2gJE+UEHVKyokU+nzRp8J6WyZuoXdE7+pvkKg0S39/SwhsJxwp2WZ5PVBVqVdl1uxFGjkShg+XjOVCCMOQXqG20Gwdd2d3YsJiarBVojpIEGVnJNmmlY0cCQkJprONV7YXydnZ/AR0IUSd4e7izoN3PGjrZogaIEGUnSm5j549DeHVatKLJIQQogokiLJDdSVwOnSohiaYg/QiCSGEqDRJcSBqrfHj1QnoaWm2bokQQghRlgRRotar9gnmQgghRBVIECWEEEIIUQUyJ0rUOF/fytU/dMj0NWpkrpSwDUWB7K3Q6B7z2eCFEMLGJIgSNS4qSk2kuXOnOu+pIubqVHsyTmE7WUmQMhh6/wChA23dGiGEMMnmw3nLli0jIiICDw8PunXrxs6dO83WvXHjBvPnzycyMhIPDw/at29PUlKSUZ3ly5fTrl076tWrR7169YiJieGHH34wqtO7d280Go3R46mnnjKqk5GRwZAhQ/Dy8qJRo0a88MILFBfLrtvWEhUFrVvf3jVkrpQDy0hQn08l2LYdQghRDpv2RH311VdMnz6dDz/8kG7durF48WIGDBjAkSNHaNSoUZn6s2fPJi4ujk8++YRWrVrx448/MmLECP73v//RsWNHAMLCwli4cCFRUVEoisIXX3zB8OHD2bt3L3fccYfhWpMnT2b+/PmGYy8vL8PXWq2WIUOGEBwczP/+9z+ysrKYMGECrq6uvPHGG9V4R4SooxQdpC2HosvqsT6IykgA72bq125+EPU0aGz+t58QQgA23juvW7du3HXXXSxduhQAnU5HeHg4zz77LDNnzixTPzQ0lJdffpkpU6YYykaNGoWnpydxcXFm36dhw4a89dZbPP7444DaE9WhQwcWL15ssv4PP/zA/fffz5kzZwgKCgLgww8/5KWXXuL8+fO4uVmWJdyae+c5oj17oHPnqr8+NRU6dbJee4QN3ciDryOg6CKgUQMlRQsaZzXAQgG3hjD8BLhWclKdEEJUkqW/v232J11RURGpqan069fvVmOcnOjXrx/bt283+ZrCwkI8PDyMyjw9Pdm2bZvJ+lqtlvj4eAoKCoiJMd6jaPXq1QQEBNC2bVtmzZrF1atXDee2b9/OnXfeaQigAAYMGEBubi5//vmn2c9UWFhIbm6u0UOYV9kJ5sKBufrCoL0Q0F09VrTGzwHdYdA+CaCEELWKzYbzLly4gFarNQpUAIKCgjh8+LDJ1wwYMIBFixbRq1cvIiMjSU5OJjExEa1Wa1TvwIEDxMTEcP36dXx8fNiwYQNt2rQxnH/kkUdo2rQpoaGh7N+/n5deeokjR46QmJgIwNmzZ022S3/OnAULFvDqq69afhPqOP0E89Jzmw4dsmzCuXAw3k2g7xZIaAjaglvlLl7QLwWcXG3WNCGEMMWuVuctWbKEyZMn06pVKzQaDZGRkUyaNIkVK1YY1WvZsiX79u3jypUrJCQkMHHiRLZu3WoIpJ588klD3TvvvJOQkBD69u3LsWPHiIyMrHL7Zs2axfTp0w3Hubm5hIeHV/l6dYGsrhNGcnYaB1AAxQVqeWAP27RJCCHMsNlwXkBAAM7Ozpw7d86o/Ny5cwQHB5t8TWBgIBs3bqSgoICTJ09y+PBhfHx8aN68uVE9Nzc3WrRoQefOnVmwYAHt27dnyZIlZtvSrVs3AP766y8AgoODTbZLf84cd3d3w6pA/UMIUQmZ36jPYQ/A0L8gbLh6fHqTzZokhBDm2CyIcnNzo3PnziQnJxvKdDodycnJZeYvlebh4UHjxo0pLi5m/fr1DB8+vNz6Op2OwsJCs+f37dsHQEhICAAxMTEcOHCA7OxsQ53NmzdTr149o2FBUT0snSslc6ocUNgw6L4aeiaCbyT03KAehw2zdcuEEKIMmw7nTZ8+nYkTJ9KlSxe6du3K4sWLKSgoYNKkSQBMmDCBxo0bs2DBAgB27NhBZmYmHTp0IDMzk3nz5qHT6XjxxRcN15w1axaDBg2iSZMm5OXl8eWXX5KSksKPP/4IwLFjx/jyyy8ZPHgw/v7+7N+/n+eff55evXrRrl07APr370+bNm149NFHefPNNzl79iyzZ89mypQpuLu71/BdqnvMzZUqSTKWO6jAHsbDdhoNRDxiu/YIIUQ5bBpEjRkzhvPnz/PKK69w9uxZOnToQFJSkmESd0ZGBk5OtzrLrl+/zuzZszl+/Dg+Pj4MHjyYVatW4efnZ6iTnZ3NhAkTyMrKon79+rRr144ff/yR++67D1B7wH7++WdDwBYeHs6oUaOYPXu24RrOzs58++23PP3008TExODt7c3EiRON8kqJ6iUBkhBCiNrOpnmiHF115YnKScuhKK8IN183/KP8rXZdIYQQQlj++9uuVucJNYBaGr3UcBx7NFYCKSGEEMIGZP8EO1OUV1TusRC1nqLAuRT1WQgh7Jj0RNkJ/RDe+UPnjcr1xzK0J+xGVhKkDIbeP0DoQFu3RgghqkyCKDtQegivpA3jNxi+lqE9YRf0mwufSpAgSghh1ySIsgOWDtnJ0J6olRQdpC2HosvqsT6IykgA72bq125+EPW0uvGwEELYCQmi7ICbr5tV6wlRo4oLYP8rUHQR0NwKlIrzYf8cQAG3htBsgmwwLISwKxJE2QH/KH9ij8Ya5kSVHMIbETeCwNaBMidK1F6uvjBoL/z6MFzYDsrNDcMVLaCBgO7QI14CKCGE3ZEgyk6YC5ACWwcS0imkhlsjRCV5N4G+WyChofEGwy5e0C8FnFzVY0WB7K3Q6B41W7kQQtRiMgHBzpQespMhPGE3cnYaB1CgDvXl7Lx1nJUEyX0g68eabZsQQlSB9ETZmZJDezKEJ+xK5jfqc9gD0PFt2PsPOP01nN50a788WbknhLAjEkTZIQmcqolWC7/8AllZEBICPXuCs7OtW+U4woZBg/bQ9GF1qK7nBjixGi7tgT/+pdaRlXtCCDsie+dVo+raO09Ug8REmDoVTp++VRYWBkuWwMiRtmuXo7uRB19HGK/cU7SgcVZTI+hX7g0/IRPPhRA1xtLf3/KnnRCJiTB6tHEABZCZqZYnJtqmXXWBfuVeQHf12GjlHmr5oH0SQAkhaiUJokTdptWqPVCmOmT1ZdOmqfVE9dCv3HP2Mi7Xr9zzDrdJs4QQoiISRIm67ZdfyvZAlaQocOqUWk9UH0tW7gkhRC0jQZSo27KyrFtPVE3JlXtD/4Kw4erx6U02a5IQQlREVufZoZy0HElxYC0hFiYqtbSesFzJxJqmVu6dXAPeTW3dSiGqTFEUdp/ZTZfQLmgkeaxDkp4oO5OTlsPS6KV83PljlkYvJSctx9ZNsm89e6qr8Mz9gNNoIDxcrSesq2RizcAeEPHIrX8HjUY91uePEsIOxe2Po+unXVl9YLWtmyKqiQRRdqYor6jcY1FJzs5qGgMoG0jpjxcvlnxR1aFkYk0hHEyxrpi5KXMBmJsyl2JdsY1bJKqDDOfZCf0Q3vlD543K9ccytHcbRo6EhATTeaIWL5Y8Udai6CBtORRdVo8lsaZwYGsOrCH9cjoAxy8dJ/6PeMa3G2/jVglrk2Sb1chayTb1Q3gViT0aK4HU7ZCM5dVLEmuKOqJYV0z0+9GcuHwCBQUnnIhoEMGR2CO4OEnfhT2QZJsOxNIhOxnau03OztC7Nzz8sPosAZR1SWJNUUfoe6EU1D4KHTpDb5RwLBIS2wE3Xzer1rMXaWmQl2f+vK8vREXdxhtIz1PN0yfWTGhonBdKn1jTydVmTRPCGvRzoTRoDEEUgBNOzE2Zy9i2Y6vcGyWr/WofCaLsgH+UP7FHYw1zojaM32A4NyJuBIGtAx1uTlRaGkRHV1zv6NEqBlKyV57tlJdYU1bjCTtXci5USSV7o6o6NypufxwTNk5g1YhVMr+qlpDhPDvhH+VPSKcQAlsHGpUHtg4kpFOIQwVQUH4PVFXqGZG98mxLEmsKB1WyF8oUfW9UVVbqyWq/2kmCKDtTesjO0Ybwqp3slWd7YcOg+2romQi+kWpize6r1XIh7Ni2jG1Gc6FK0/dGbcvYVulrm1rtJ2xPVudVI2utziutLmQs37MHOneuuF5qKnTqVIkLp6RAnz4V19uyRZ1cLoQQFiosLmTTkU0UagvN1nF3dmdYy2G4u7hbfF1Z7VfzLP39LXffDjlq4FQjZK88IUQ1cXdx58E7HrT6dUvPs7LG/CphHTKcJ+oW2StPCGFHzM2zup35VcJ6JIgSdYvslSeEsCOlc07pSe6p2kGCKFG3yF55Qgg7UZ2r/YR1SBAlaiVfC5NWW1rPiH6vvMaNjcvDwtRyyRMlhKgFqnO1n7AOWZ1XjaprdZ4jKS8reUaG+tykienzkrFcCOHIqmu1n6iYpb+/JYiqRhJEla/as5ILIYQQVSApDhyYo+SJqtas5EIIIUQ1kyDKzuSk5bA0eqnhOPZorF0HUkIIIYS9konldqYor6jcYyGEEELUDOmJshP6Ibzzh84bleuP7X1oTwghhLA3Nu+JWrZsGREREXh4eNCtWzd27txptu6NGzeYP38+kZGReHh40L59e5KSkozqLF++nHbt2lGvXj3q1atHTEwMP/zwg+H8xYsXefbZZ2nZsiWenp40adKE5557jitXrhhdR6PRlHnEx9smqZl+CO/jzh+zYfwGo3Mbxm/g484fszR6KTlpOTZpnxBCCFEX2TSI+uqrr5g+fTpz585lz549tG/fngEDBpCdnW2y/uzZs/noo494//33OXjwIE899RQjRoxg7969hjphYWEsXLiQ1NRUdu/ezb333svw4cP5888/AThz5gxnzpzh7bff5o8//uDzzz8nKSmJxx9/vMz7rVy5kqysLMPjgQceqJb7UBFLh+xkaE8IIYSoOTZNcdCtWzfuuusuli5VJ0rrdDrCw8N59tlnmTlzZpn6oaGhvPzyy0yZMsVQNmrUKDw9PYmLizP7Pg0bNuStt94yGSgBrFu3jvHjx1NQUICLizrCqdFo2LBhw20FTtZKcVB6Mrk59jbJfM8e6Ny54nqpqdCpU/W3RwghhAA7SHFQVFREamoqs2bNMpQ5OTnRr18/tm/fbvI1hYWFeHh4GJV5enqybZvpbK1arZZ169ZRUFBATEyM2bbob5I+gNKbMmUKTzzxBM2bN+epp55i0qRJaMztuXazfYWFt5Ki5ebmmq1bGf5R/sQejTXMiSo5pDcibgSBrQPtck5UtWYlF0IIIaqZzYKoCxcuoNVqCQoKMioPCgri8OHDJl8zYMAAFi1aRK9evYiMjCQ5OZnExES0Wq1RvQMHDhATE8P169fx8fFhw4YNtGnTxmw7XnvtNZ588kmj8vnz53Pvvffi5eXFTz/9xDPPPEN+fj7PPfec2c+0YMECXn31VUs+fqWZC5ACWwcS0imkWt6zukVFqYk0y8sDddtZyYUQQohqYler85YsWcLkyZNp1aoVGo2GyMhIJk2axIoVK4zqtWzZkn379nHlyhUSEhKYOHEiW7duLRNI5ebmMmTIENq0acO8efOMzs2ZM8fwdceOHSkoKOCtt94qN4iaNWsW06dPN7p+eHj4bXzistx83co9tjcSIAkAFAWyt0Kje8puDC2EELWUzSaWBwQE4OzszLlz54zKz507R3BwsMnXBAYGsnHjRgoKCjh58iSHDx/Gx8eH5s2bG9Vzc3OjRYsWdO7cmQULFtC+fXuWLFliVCcvL4+BAwfi6+vLhg0bcHV1Lbe93bp14/Tp00bDdaW5u7sbVgXqH9amH9p7MvVJu5sDJYRZWUmQ3AeyfrR1S4QQwmI2C6Lc3Nzo3LkzycnJhjKdTkdycnK585cAPDw8aNy4McXFxaxfv57hw4eXW1+n05WZq9S/f3/c3NzYtGlTmXlWpuzbt48GDRrg7m77TR79o/wJ6RQiAZRwHBkJ6vOpBNu2QwghKsGmw3nTp09n4sSJdOnSha5du7J48WIKCgqYNGkSABMmTKBx48YsWLAAgB07dpCZmUmHDh3IzMxk3rx56HQ6XnzxRcM1Z82axaBBg2jSpAl5eXl8+eWXpKSk8OOP6l+4+gDq6tWrxMXFkZuba5gAHhgYiLOzM9988w3nzp3j7rvvxsPDg82bN/PGG28wY8aMGr5DQjgoRQdpy6HosnqsD6IyEsC7mfq1mx9EPQ0am6ezE0IIk2waRI0ZM4bz58/zyiuvcPbsWTp06EBSUpJhsnlGRgZOTrd+gF6/fp3Zs2dz/PhxfHx8GDx4MKtWrcLPz89QJzs7mwkTJpCVlUX9+vVp164dP/74I/fddx8Ae/bsYceOHQC0aNHCqD3p6elERETg6urKsmXLeP7551EUhRYtWrBo0SImT55czXdEiDqiuAD2vwJFFwHNrUCpOB/2zwEUcGsIzSaAqyzPFELUTjbNE+XorJUnSgiHVJABvz4MF7YDJX8MaSAgBnrEg7d1F2YIIYQlLP39Lf3kQgjb8G4CfbeAs5dxuYsX9EuRAEoIUetJECWEsJ2cnaAtMC4rLlDLhRCilpMgSghhO5nfqM9hD8DQvyDs5krb05ts1iQhhLCUXSXbFEI4mLBh0KA9NH1YTbLZcwOcXAPeTW3dMiGEqJAEUUII2wnsoT70NBqIeMR27RFCiEqQ4TwhhBBCiCqQIEoIIYQQogokiBJCCCGEqAIJooQQQgghqkCCKCGEEEKIKpAgSgghhBCiCiSIEkIIIYSoAgmihBBCCCGqQIIoIYQQQogqkCBKCCGEEKIKZNsXO5STlkNRXhFuvm74R/nbujlCCCFEnSRBlJ3JScthafRSw3Hs0VgJpIQQQggbkOE8O1OUV1TusRBCCCFqhvRE2Qn9EN75Q+eNyvXHMrQnhBBC1CwJouxA6SG8kjaM32D4Wob2hBBCiJojw3l2wNIhOxnaE0IIIWqOBFF2wM3Xzar1hBBCCHH7ZDjPDvhH+RN7NNYwJ6rkEN6IuBEEtg6UOVFCCCFEDZMgyk6YC5ACWwcS0imkhlsjhBBCCBnOszOlh+xkCE8IIYSwDemJsjMlh/ZkCE8IIYSwHQmi7JAETkIIIYTtyXCeEEIIIUQVSBAlhBBCCFEFEkQJIYQQQlSBBFFCCCGEEFUgQZQQQgghRBVIECWEEEIIUQUSRAkhhBBCVIEEUUIIIYQQVSBBlBBCCCFEFUjG8mqkKAoAubm5Nm6JEEIIISyl/72t/z1ujgRR1SgvLw+A8PBwG7dECCGEEJWVl5dH/fr1zZ7XKBWFWaLKdDodZ86cwdfXF41GY5Vr5ubmEh4ezqlTp6hXr55Vrmmv5F6o5D7cIvfiFrkXKrkPt8i9UFlyHxRFIS8vj9DQUJyczM98kp6oauTk5ERYWFi1XLtevXp1+j9BSXIvVHIfbpF7cYvcC5Xch1vkXqgqug/l9UDpycRyIYQQQogqkCBKCCGEEKIKJIiyM+7u7sydOxd3d3dbN8Xm5F6o5D7cIvfiFrkXKrkPt8i9UFnzPsjEciGEEEKIKpCeKCGEEEKIKpAgSgghhBCiCiSIEkIIIYSoAgmihBBCCCGqQIIoO7Ns2TIiIiLw8PCgW7du7Ny509ZNqnb//e9/GTp0KKGhoWg0GjZu3Gh0XlEUXnnlFUJCQvD09KRfv36kpaXZprHVaMGCBdx11134+vrSqFEjHnjgAY4cOWJU5/r160yZMgV/f398fHwYNWoU586ds1GLq8fy5ctp166dIVFeTEwMP/zwg+F8XbgHpixcuBCNRsO0adMMZXXlXsybNw+NRmP0aNWqleF8XbkPepmZmYwfPx5/f388PT2588472b17t+F8XfmZGRERUeb7QqPRMGXKFMA63xcSRNmRr776iunTpzN37lz27NlD+/btGTBgANnZ2bZuWrUqKCigffv2LFu2zOT5N998k/fee48PP/yQHTt24O3tzYABA7h+/XoNt7R6bd26lSlTpvDbb7+xefNmbty4Qf/+/SkoKDDUef755/nmm29Yt24dW7du5cyZM4wcOdKGrba+sLAwFi5cSGpqKrt37+bee+9l+PDh/Pnnn0DduAel7dq1i48++oh27doZldele3HHHXeQlZVleGzbts1wri7dh0uXLtGjRw9cXV354YcfOHjwIO+88w4NGjQw1KkrPzN37dpl9D2xefNmAB588EHASt8XirAbXbt2VaZMmWI41mq1SmhoqLJgwQIbtqpmAcqGDRsMxzqdTgkODlbeeustQ9nly5cVd3d3Zc2aNTZoYc3Jzs5WAGXr1q2Koqif29XVVVm3bp2hzqFDhxRA2b59u62aWSMaNGigfPrpp3XyHuTl5SlRUVHK5s2blXvuuUeZOnWqoih16/th7ty5Svv27U2eq0v3QVEU5aWXXlL+3//7f2bP1+WfmVOnTlUiIyMVnU5nte8L6YmyE0VFRaSmptKvXz9DmZOTE/369WP79u02bJltpaenc/bsWaP7Ur9+fbp16+bw9+XKlSsANGzYEIDU1FRu3LhhdC9atWpFkyZNHPZeaLVa4uPjKSgoICYmpk7egylTpjBkyBCjzwx17/shLS2N0NBQmjdvzrhx48jIyADq3n3YtGkTXbp04cEHH6RRo0Z07NiRTz75xHC+rv7MLCoqIi4ujr/97W9oNBqrfV9IEGUnLly4gFarJSgoyKg8KCiIs2fP2qhVtqf/7HXtvuh0OqZNm0aPHj1o27YtoN4LNzc3/Pz8jOo64r04cOAAPj4+uLu789RTT7FhwwbatGlTp+4BQHx8PHv27GHBggVlztWle9GtWzc+//xzkpKSWL58Oenp6fTs2ZO8vLw6dR8Ajh8/zvLly4mKiuLHH3/k6aef5rnnnuOLL74A6u7PzI0bN3L58mUee+wxwHr/P1ys2EYhRA2ZMmUKf/zxh9G8j7qkZcuW7Nu3jytXrpCQkMDEiRPZunWrrZtVo06dOsXUqVPZvHkzHh4etm6OTQ0aNMjwdbt27ejWrRtNmzZl7dq1eHp62rBlNU+n09GlSxfeeOMNADp27Mgff/zBhx9+yMSJE23cOtv57LPPGDRoEKGhoVa9rvRE2YmAgACcnZ3LrBw4d+4cwcHBNmqV7ek/e126L7GxsXz77bds2bKFsLAwQ3lwcDBFRUVcvnzZqL4j3gs3NzdatGhB586dWbBgAe3bt2fJkiV16h6kpqaSnZ1Np06dcHFxwcXFha1bt/Lee+/h4uJCUFBQnbkXpfn5+REdHc1ff/1Vp74nAEJCQmjTpo1RWevWrQ3Dm3XxZ+bJkyf5+eefeeKJJwxl1vq+kCDKTri5udG5c2eSk5MNZTqdjuTkZGJiYmzYMttq1qwZwcHBRvclNzeXHTt2ONx9URSF2NhYNmzYwH/+8x+aNWtmdL5z5864uroa3YsjR46QkZHhcPeiNJ1OR2FhYZ26B3379uXAgQPs27fP8OjSpQvjxo0zfF1X7kVp+fn5HDt2jJCQkDr1PQHQo0ePMqlPjh49StOmTYG69TNTb+XKlTRq1IghQ4YYyqz2fVENE+BFNYmPj1fc3d2Vzz//XDl48KDy5JNPKn5+fsrZs2dt3bRqlZeXp+zdu1fZu3evAiiLFi1S9u7dq5w8eVJRFEVZuHCh4ufnp3z99dfK/v37leHDhyvNmjVTrl27ZuOWW9fTTz+t1K9fX0lJSVGysrIMj6tXrxrqPPXUU0qTJk2U//znP8ru3buVmJgYJSYmxoattr6ZM2cqW7duVdLT05X9+/crM2fOVDQajfLTTz8pilI37oE5JVfnKUrduRf/+Mc/lJSUFCU9PV359ddflX79+ikBAQFKdna2oih15z4oiqLs3LlTcXFxUf71r38paWlpyurVqxUvLy8lLi7OUKeu/MxUFHUVe5MmTZSXXnqpzDlrfF9IEGVn3n//faVJkyaKm5ub0rVrV+W3336zdZOq3ZYtWxSgzGPixImKoqhLdufMmaMEBQUp7u7uSt++fZUjR47YttHVwNQ9AJSVK1ca6ly7dk155plnlAYNGiheXl7KiBEjlKysLNs1uhr87W9/U5o2baq4ubkpgYGBSt++fQ0BlKLUjXtgTukgqq7cizFjxighISGKm5ub0rhxY2XMmDHKX3/9ZThfV+6D3jfffKO0bdtWcXd3V1q1aqV8/PHHRufrys9MRVGUH3/8UQFMfj5rfF9oFEVRbrOnTAghhBCizpE5UUIIIYQQVSBBlBBCCCFEFUgQJYQQQghRBRJECSGEEEJUgQRRQgghhBBVIEGUEEIIIUQVSBAlhBBCCFEFEkQJIYQQQlSBBFFCiDohJSUFjUZTZsPRmpKcnEzr1q3RarUV1k1KSqJDhw7odLoaaJkQoqokiBJCOJzevXszbdo0o7Lu3buTlZVF/fr1bdKmF198kdmzZ+Ps7Fxh3YEDB+Lq6srq1atroGVCiKqSIEoIUSe4ubkRHByMRqOp8ffetm0bx44dY9SoURa/5rHHHuO9996rxlYJIW6XBFFCCIfy2GOPsXXrVpYsWYJGo0Gj0XDixIkyw3mff/45fn5+fPvtt7Rs2RIvLy9Gjx7N1atX+eKLL4iIiKBBgwY899xzRkNwhYWFzJgxg8aNG+Pt7U23bt1ISUkpt03x8fHcd999eHh4GMp+//13+vTpg6+vL/Xq1aNz587s3r3bcH7o0KHs3r2bY8eOWfX+CCGsx8XWDRBCCGtasmQJR48epW3btsyfPx+AwMBATpw4Uabu1atXee+994iPjycvL4+RI0cyYsQI/Pz8+P777zl+/DijRo2iR48ejBkzBoDY2FgOHjxIfHw8oaGhbNiwgYEDB3LgwAGioqJMtumXX37hkUceMSobN24cHTt2ZPny5Tg7O7Nv3z5cXV0N55s0aUJQUBC//PILkZGRVro7QghrkiBKCOFQ6tevj5ubG15eXgQHB5db98aNGyxfvtwQpIwePZpVq1Zx7tw5fHx8aNOmDX369GHLli2MGTOGjIwMVq5cSUZGBqGhoQDMmDGDpKQkVq5cyRtvvGHyfU6ePGmor5eRkcELL7xAq1atAEwGYKGhoZw8ebLS90AIUTMkiBJC1FleXl5GvTxBQUFERETg4+NjVJadnQ3AgQMH0Gq1REdHG12nsLAQf39/s+9z7do1o6E8gOnTp/PEE0+watUq+vXrx4MPPlimx8nT05OrV69W+fMJIaqXBFFCiDqr5PAZgEajMVmmTzWQn5+Ps7MzqampZVbZlQy8SgsICODSpUtGZfPmzeORRx7hu+++44cffmDu3LnEx8czYsQIQ52LFy8SGBhYpc8mhKh+EkQJIRyOm5ubRfmYKqtjx45otVqys7Pp2bNnpV538ODBMuXR0dFER0fz/PPP8/DDD7Ny5UpDEHX9+nWOHTtGx44drdZ+IYR1yeo8IYTDiYiIYMeOHZw4cYILFy5YLWlldHQ048aNY8KECSQmJpKens7OnTtZsGAB3333ndnXDRgwgG3bthmOr127RmxsLCkpKZw8eZJff/2VXbt20bp1a0Od3377DXd3d2JiYqzSdiGE9UkQJYRwODNmzMDZ2Zk2bdoQGBhIRkaG1a69cuVKJkyYwD/+8Q9atmzJAw88wK5du2jSpInZ14wbN44///yTI0eOAODs7ExOTg4TJkwgOjqahx56iEGDBvHqq68aXrNmzRrGjRuHl5eX1douhLAujaIoiq0bIYQQju6FF14gNzeXjz76qMK6Fy5coGXLluzevZtmzZrVQOuEEFUhPVFCCFEDXn75ZZo2bWrR0OKJEyf44IMPJIASopaTnighhBBCiCqQnighhBBCiCqQIEoIIYQQogokiBJCCCGEqAIJooQQQgghqkCCKCGEEEKIKpAgSgghhBCiCiSIEkIIIYSoAgmihBBCCCGqQIIoIYQQQogq+P+Pt1TOoqf2zgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "#mpl.rcParams['figure.dpi'] = 300 #uncomment this to make plots with higher resolution\n",
    "\n",
    "plot_multi_run(rand_early_runs,\"Ereno\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "8f5e7a16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_multi_boxplot_f1(rand_early_runs,\"Ereno\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "53a64742",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_multi_boxplot_time(rand_early_runs,\"Ereno\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}