Chapter 6 - Putting Everything Together - Car Sales.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lightgbm import LGBMRegressor,LGBMClassifier\n",
    "from sklearn.linear_model import LinearRegression,LogisticRegression\n",
    "from xgboost import XGBRegressor,XGBClassifier\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.metrics import mean_squared_error,f1_score,precision_score,recall_score\n",
    "\n",
    "from sklearnex import patch_sklearn,unpatch_sklearn\n",
    "\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as sfs\n",
    "from sklearn.feature_selection import RFE\n",
    "\n",
    "from scipy.stats import f_oneway\n",
    "\n",
    "import gc\n",
    "import pickle\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "from Interaction_effect_features import get_data\n",
    "\n",
    "from MetaHeuristics import FeatureSelection\n",
    "\n",
    "# from EvolutionaryFS import GeneticAlgorithmFS\n",
    "# from SimmulatedAnnealingFS import SimulatedAnnealingFS\n",
    "# from ACO import AntColonyOptimizationFS\n",
    "# from PSOFinal import ParticleSwarmOptimizationFS\n",
    "\n",
    "import shap\n",
    "\n",
    "np.seterr(divide = 'ignore')\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "import warnings\n",
    "# suppress warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_plot(metric,test_cost,external_cost):\n",
    "    sns.set(rc={'figure.figsize':(16,8)})\n",
    "    sns.set_context('paper', font_scale = 1.3)\n",
    "    if metric=='RMSE':\n",
    "        fig, ax = plt.subplots(1, 2)\n",
    "    else:\n",
    "        fig, ax = plt.subplots(1, 2, sharey=True)\n",
    "        \n",
    "    validation_name = [' External_Test','External_Test ',' External_Test ',' External_Test  ','  External_Test']\n",
    "\n",
    "    ax[0].bar(list(test_cost.keys()),list(test_cost.values()))\n",
    "    ax[0].set_title(metric + ' for test data and validation data')\n",
    "\n",
    "    ax[1].bar(validation_name,external_cost)\n",
    "    ax[1].set_title(metric + ' for external test data')\n",
    "    plt.show()\n",
    "\n",
    "def get_data_for_FS(data_dict,dependent_variable,features_all):\n",
    "    \n",
    "    data_dict_for_SA = {}\n",
    "    \n",
    "    x_validation = data_dict['data_validation_test'][features_all]\n",
    "    y_validation = data_dict['data_validation_test'][dependent_variable]\n",
    "\n",
    "    #for each training data\n",
    "    for data_fold_index in data_dict['fold_dict'].keys():\n",
    "        \n",
    "        for feature in features_all:\n",
    "            if feature not in data_dict['fold_dict'][data_fold_index]['fold_training'].columns:\n",
    "                print(feature,'not present')\n",
    "\n",
    "        data_dict_for_SA[data_fold_index]={'x_train':data_dict['fold_dict'][data_fold_index]['fold_training'][features_all],\n",
    "                                           'y_train':data_dict['fold_dict'][data_fold_index]['fold_training'][dependent_variable],\n",
    "                                           'x_test':data_dict['fold_dict'][data_fold_index]['fold_test'][features_all],\n",
    "                                           'y_test':data_dict['fold_dict'][data_fold_index]['fold_test'][dependent_variable]}\n",
    "    \n",
    "    \n",
    "    return data_dict_for_SA,x_validation,y_validation,features_all\n",
    "\n",
    "def last_preprocessing(data_dict,problem):\n",
    "    \n",
    "    #'HotelCancellations', 'CouponRecommendation', 'PredictRoomBooking','CarSales'\n",
    "    \n",
    "    if problem == 'PredictRoomBooking':\n",
    "        columns = ['AdjustedLeadTime_Quartile_countRankEncoded', 'CumulativeNumberOfRooms_Quartile_percentEncoded', 'CumulativeNumberOfRooms_Quartile_countRankEncoded', 'CumulativeNumberOfRooms_Quartile_MeanEncoded', 'CumulativeNumberOfRoomsSubstract_Quartile_percentEncoded', 'CumulativeNumberOfRoomsSubstract_Quartile_countRankEncoded', 'CumulativeNumberOfRoomsSubstract_Quartile_MeanEncoded', 'CumulativeNumberOfRoomsNet_Quartile_countEncoded', 'CumulativeNumberOfRoomsNet_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeNumberOfRooms_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeNumberOfRooms_Quartile_percentEncoded', 'AdjustedLeadTimeCumulativeNumberOfRooms_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeNumberOfRooms_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsSubstract_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsSubstract_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsNet_Quartile_percentEncoded', 'CumulativeRevenue_Quartile_countEncoded', 'CumulativeRevenue_Quartile_percentEncoded', 'CumulativeRevenue_Quartile_countRankEncoded', 'CumulativeRevenue_Quartile_MeanEncoded', 'CumulativeRevenueSubstract_Quartile_percentEncoded', 'CumulativeRevenueSubstract_Quartile_countRankEncoded', 'CumulativeRevenueNet_Quartile_percentEncoded', 'CumulativeRevenueNet_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeRevenue_Quartile_percentEncoded', 'AdjustedLeadTimeCumulativeRevenue_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeRevenueSubstract_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeRevenueSubstract_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeRevenueSubstract_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeRevenueNet_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeRevenueNet_Quartile_MeanEncoded','AdjustedLeadTime_Quartile_percentEncoded', 'CumulativeNumberOfRoomsSubstract_Quartile_countEncoded', 'CumulativeNumberOfRoomsNet_Quartile_percentEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsSubstract_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsNet_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsNet_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsNet_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeRevenue_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeRevenueSubstract_Quartile_percentEncoded','AdjustedLeadTime_Quartile_countEncoded', 'CumulativeNumberOfRoomsNet_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsSubstract_Quartile_percentEncoded', 'CumulativeRevenueSubstract_Quartile_countEncoded', 'CumulativeRevenueSubstract_Quartile_MeanEncoded', 'CumulativeRevenueNet_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeRevenueNet_Quartile_countEncoded','AdjustedLeadTime_Quartile_MeanEncoded', 'CumulativeNumberOfRooms_Quartile_countEncoded', 'CumulativeRevenueNet_Quartile_countRankEncoded','AdjustedLeadTimeCumulativeRevenue_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeRevenueNet_Quartile_percentEncoded']\n",
    "    elif problem == 'HotelCancellations':\n",
    "        columns = ['LeadTime_Quartile_countEncoded','LeadTime_Quartile_percentEncoded','LeadTime_Quartile_countRankEncoded','LeadTime_Quartile_MeanEncoded','ADR_Quartile_countEncoded','ADR_Quartile_percentEncoded','ADR_Quartile_countRankEncoded','ADR_Quartile_MeanEncoded']\n",
    "    elif problem == 'CouponRecommendation':\n",
    "        columns = []\n",
    "    elif problem == 'CarSales':\n",
    "        columns = ['ownercountEncodedandkmdrivenQuartileMeanEncoded','sellertypecountEncodedandownercountEncoded','fuelcountEncodedandownerMeanEncoded','ownercountEncodedandmaxpowerQuartileMeanEncoded','ownercountEncodedandkmdrivenQuartilecountEncoded','ownercountEncodedandmileageQuartileMeanEncoded','ownercountEncodedandmileageQuartilecountEncoded','fuelcountEncodedandkmdrivenQuartileMeanEncoded','sellertypecountEncodedandmaxpowerQuartileMeanEncoded','fuelcountEncodedandmaxpowerQuartilecountEncoded','ownercountEncodedandmaxpowerQuartilecountEncoded','sellertypecountEncodedandownerMeanEncoded','fuelcountEncodedandkmdrivenQuartilecountEncoded','sellertypecountEncodedandmileageQuartileMeanEncoded','fuelcountEncodedandownercountEncoded','sellertypecountEncodedandmileageQuartilecountEncoded','sellertypecountEncodedandmaxpowerQuartilecountEncoded','fuelcountEncodedandsellertypecountEncoded','fuelcountEncodedandmileageQuartileMeanEncoded','fuelcountEncodedandmileageQuartilecountEncoded','sellertypecountEncodedandkmdrivenQuartileMeanEncoded','sellertypecountEncodedandkmdrivenQuartilecountEncoded','mileageQuartilecountEncodedandmaxpowerQuartilecountEncoded','kmdrivenQuartilecountEncodedandmileageQuartilecountEncoded','kmdrivenQuartilecountEncodedandmaxpowerQuartilecountEncoded','kmdriven_Quartile_percentEncoded','maxpower_Quartile_percentEncoded','mileage_Quartile_percentEncoded']\n",
    "    \n",
    "    if columns:\n",
    "        for feature in columns:\n",
    "            if feature in data_dict['data_external_test'].columns:\n",
    "                data_dict['data_external_test'][feature] = data_dict['data_external_test'][feature].astype(int)\n",
    "                data_dict['data_validation_test'][feature] = data_dict['data_validation_test'][feature].astype(int)\n",
    "\n",
    "                for index in data_dict['fold_dict'].keys():\n",
    "                    data_dict['fold_dict'][index]['fold_training'][feature] = data_dict['fold_dict'][index]['fold_training'][feature].astype(int)\n",
    "                    data_dict['fold_dict'][index]['fold_test'][feature] = data_dict['fold_dict'][index]['fold_test'][feature].astype(int)\n",
    "        \n",
    "    return data_dict\n",
    "\n",
    "def get_external(data_dict,features,dependent_variable):\n",
    "    x_external = data_dict['data_external_test'][features]\n",
    "    y_external = data_dict['data_external_test'][dependent_variable]\n",
    "    return x_external,y_external\n",
    "\n",
    "def cost_funct(y_true,y_pred):\n",
    "    return np.sqrt(mean_squared_error(y_true,y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_cost(current_at_feature_subset,problem_type,cost_function,data_dict,model,x_validation,y_validation,x_external,y_external,cutoff,sequence):\n",
    "\n",
    "    test_cost = {}\n",
    "    external_cost = []\n",
    "    selected_features = {}\n",
    "    common_features = []\n",
    "    \n",
    "    precision_test = []\n",
    "    recall_test = []\n",
    "    precision_external = []\n",
    "    recall_external = []\n",
    "    \n",
    "    #for each fold\n",
    "    for i in data_dict.keys():\n",
    "        \n",
    "        ### - for the set of + features + dataset + model        \n",
    "        x_train=data_dict[i]['x_train'][current_at_feature_subset]\n",
    "        y_train=data_dict[i]['y_train']\n",
    "\n",
    "        x_test=data_dict[i]['x_test'][current_at_feature_subset]\n",
    "        y_test=data_dict[i]['y_test']\n",
    "\n",
    "        ### do the feature selection process\n",
    "        if sequence == 'filter':\n",
    "            output_list = anova_correlation(current_at_feature_subset,x_train,y_train,dependent_variable,cutoff)\n",
    "        elif sequence in ['forward','backward','step','recursive']:\n",
    "            output_list = sequential_fs(model,current_at_feature_subset,x_train,y_train,dependent_variable,sequence,problem_type)\n",
    "        \n",
    "        #fit model\n",
    "        model.fit(x_train[output_list],y_train)\n",
    "        \n",
    "        ### - obtain + filtered features + cost for test + cost for validation\n",
    "        \n",
    "        #filtered features\n",
    "        selected_features[i] = output_list\n",
    "        \n",
    "        #predict for test and validation\n",
    "        y_test_predict=model.predict(x_test[output_list])\n",
    "        y_validation_predict=model.predict(x_validation[output_list])\n",
    "        \n",
    "        #predict for external test\n",
    "        y_external_predict=model.predict(x_external[output_list])\n",
    "        \n",
    "        cost1 = cost_function(y_test,y_test_predict)\n",
    "        cost2 = cost_function(y_validation,y_validation_predict)\n",
    "        cost3 = cost_function(y_external,y_external_predict)\n",
    "                \n",
    "        if problem_type != 'regression':\n",
    "                        \n",
    "            precision_test.append(np.mean([precision_score(y_test,y_test_predict),precision_score(y_validation,y_validation_predict)]))\n",
    "            recall_test.append(np.mean([recall_score(y_test,y_test_predict),recall_score(y_validation,y_validation_predict)]))\n",
    "            \n",
    "            precision_external.append(precision_score(y_external,y_external_predict))#\n",
    "            recall_external.append(recall_score(y_external,y_external_predict))\n",
    "\n",
    "        #cost for validation and external\n",
    "        #predict for test and calculate cost function\n",
    "        test_cost['CV Sample-'+str(i)] = np.mean([cost1,cost2])\n",
    "        external_cost.append(cost3)\n",
    "    #also obtain common set of features\n",
    "    common_features = list(set(selected_features[0]).intersection(set(selected_features[1])).intersection(set(selected_features[2])).intersection(set(selected_features[3])).intersection(set(selected_features[4])))\n",
    "\n",
    "    print('Total number of input features:',len(current_at_feature_subset),', total number of selected features:',len(common_features))\n",
    "    \n",
    "    if problem_type != 'regression':\n",
    "        print('Combined precision on test and validation data is',np.mean(precision_test),'combined recall on test and validation data is',np.mean(recall_test))\n",
    "        print('Precision on external test data is',np.mean(precision_external),'recall on external test data is',np.mean(recall_external))\n",
    "    else:\n",
    "        print('Combined cost on test and validation data is',np.mean(list(test_cost.values())))\n",
    "        print('Cost on external test data is',np.mean(external_cost))\n",
    "    \n",
    "    return test_cost,external_cost,selected_features,common_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def anova_correlation(features_input,x_train,y_train,dependent_variable,cutoff):\n",
    "    \n",
    "    output_list = []\n",
    "    \n",
    "    x_train[dependent_variable[0]] = y_train\n",
    "    \n",
    "    categorical_features = []\n",
    "    \n",
    "    for feature in features_input:\n",
    "        #if categorical feature\n",
    "        if (1 in x_train[feature].unique() and 0 in x_train[feature].unique() and x_train[feature].nunique()==2) or ((len('1_encoded'.split(\"_\")) == 2) and '_Encoded' in feature):\n",
    "            categorical_features.append(feature)\n",
    "            #do anova\n",
    "            stat,p = f_oneway(*(x_train[x_train[feature] == category][dependent_variable[0]] for category in x_train[feature].unique()))\n",
    "\n",
    "            if p <= 0.05:\n",
    "                output_list.append(feature)\n",
    "        \n",
    "\n",
    "    #correlation for numeric features only\n",
    "    numeric_features = list(set(features_input).difference(set(categorical_features)))\n",
    "    x_train=x_train[numeric_features]\n",
    "    #calculate correlation of all features with dependent variables\n",
    "    x_train['y_train'] = y_train\n",
    "    fold_corr = x_train.corr()\n",
    "\n",
    "    #filter all features below the cutoff and save correlation acceptable features\n",
    "    output_list += list(fold_corr[((fold_corr['y_train'] >=cutoff) | (fold_corr['y_train'] <=-cutoff)) & (fold_corr['y_train'] !=1)].index)\n",
    "\n",
    "    return output_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sequential_fs(model,features_input,x_train,y_train,dependent_variable,sequence,problem_type):\n",
    "    one_tenth = round(len(features_input)/10)\n",
    "    \n",
    "    if problem_type == 'classification':\n",
    "        scoring = 'precision'\n",
    "    else:\n",
    "        scoring = 'r2'\n",
    "    \n",
    "    output_list = []\n",
    "    if sequence == 'forward':\n",
    "        #forward selection\n",
    "        sbs = sfs(model, forward=True,floating=False, scoring=scoring,cv=0,n_jobs=-1)\n",
    "        sbs.fit(x_train[features_input],y_train)\n",
    "        output_list = list(sbs.k_feature_names_)\n",
    "    elif sequence == 'backward':\n",
    "        #backward selection\n",
    "        sbs = sfs(model, forward=False,floating=False, scoring=scoring,cv=0,n_jobs=-1)\n",
    "        sbs.fit(x_train[features_input],y_train)\n",
    "        output_list = list(sbs.k_feature_names_)\n",
    "    elif sequence == 'step':\n",
    "        #Step-wise Selection\n",
    "        sbs = sfs(model, forward=False,floating=False, scoring=scoring,cv=0,n_jobs=-1)\n",
    "        sbs.fit(x_train[features_input],y_train)\n",
    "        output_list = list(sbs.k_feature_names_)\n",
    "\n",
    "    elif sequence == 'recursive':    \n",
    "        #recursive Selection\n",
    "        rfm = RFE(model, n_features_to_select=one_tenth, step=1)\n",
    "        rfm.fit(x_train[features_input],y_train)\n",
    "        \n",
    "        output_list = []\n",
    "        for i,j in zip(features_input,rfm.ranking_):\n",
    "            if j==1:\n",
    "                output_list.append(i)\n",
    "                \n",
    "        \n",
    "    return output_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Car Sales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#'HotelCancellations', 'CouponRecommendation', 'PredictRoomBooking','CarSales'\n",
    "problem = 'CarSales'\n",
    "data_dict,dependent_variable,categorical_linear,categorical_tree,categorical_features,numerical_features_linear,numerical_features_tree,ordinal_features,ordinal_features_engineered = get_data(problem)\n",
    "\n",
    "data_dict = last_preprocessing(data_dict,problem)\n",
    "\n",
    "linear_features_all = categorical_linear+numerical_features_linear+ordinal_features_engineered\n",
    "tree_features_all = categorical_tree+numerical_features_tree+ordinal_features_engineered\n",
    "\n",
    "x_external_tree,y_external_tree = get_external(data_dict,tree_features_all,dependent_variable)\n",
    "x_external_linear,y_external_linear = get_external(data_dict,linear_features_all,dependent_variable)\n",
    "\n",
    "data_dict_for_tree,x_validation_tree,y_validation_tree,features_all = get_data_for_FS(data_dict,dependent_variable,features_all=tree_features_all)\n",
    "data_dict_for_linear,x_validation_linear,y_validation_linear,features_all_linear = get_data_for_FS(data_dict,dependent_variable,features_all=linear_features_all)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lightgbm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 124 , total number of selected features: 42\n",
      "Combined cost on test and validation data is 398263.2549019221\n",
      "Cost on external test data is 230356.5545746276\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = LGBMRegressor(random_state=1,n_jobs=-1,n_estimators=200)\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'filter')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 124 , total number of selected features: 0\n",
      "Combined cost on test and validation data is 316791.7539241518\n",
      "Cost on external test data is 402028.2448307986\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABSwAAAKrCAYAAAD7+cMKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAACtm0lEQVR4nOzdeVxWdd7/8fcFCChggYaWG1YKKS7kgmKJgqbNaDXTMrkOkmNKiplKpIwOSTigoRTiFmrptExpZss0d25TGUrLNM7YjbctjIYG3YDmBSgI5/eHP850iSAY5Lm8X8/Hg0dd53zO95zrfOHyXO+zfG2GYRgCAAAAAAAAAAtwudIbAAAAAAAAAAA1CCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAnAEgzDcMq2rbROXNzV1hdX2/sBAABXxtVwTMF3CODqRWAJ/ETx8fEKDAys9dOrVy+Fh4dr7ty5ys/PN+u//fZbs2bFihV1thsXF6fAwEBNmjTJYXphYaGSkpI0cuRI9erVS/369dMDDzyg559/XhUVFQ61ERERF922H/+UlpbWuQ1nz57V/PnzdeuttyokJESvvfbaZe6lulVUVCg1NVV/+tOfLNd2YGCgnnzyyZ91nT+3mt/HrKysn2V9ERERevjhh83XDdnH27ZtU2BgoP75z382al1ffvmlJk2apJKSkkatr7ld7j7/4YcftHDhQu3cubOZtgwAgObFcbN17NmzRzExMVd6My7q2WefVWBgoIqLi+usudhxXlP5KW035XEr8H+d25XeAOBq4Onpqeeff95h2g8//KCPP/5YGzZs0D//+U+99dZbcnd3N+e7uLjonXfe0Zw5c2q1V15ervfee6/W9KKiIj3wwAPy9PTU1KlT1aVLF5WXl2v//v1atmyZsrOztWbNGodlbr31Vj3++ON1bnvLli3rnPfuu+9qx44dmj59um6//XZ17dq1ztrLVVhYqKysLMXFxTlV21ZapzN75ZVX1LZt22Zp+y9/+YtycnJ+tvU1t//+7//Wa6+9pttvv/1KbwoAAJeN42Zr2LBhg1OHYxc7znOGtq20TsDqCCyBJuDi4qK+ffvWmj506FBVVVUpKytL2dnZCg8PN+f1799fOTk5OnjwoHr37u2w3K5du2Sz2RQQEOAw/ZVXXtF3332nvXv3qn379ub04cOHy8/PT2lpacrJydHAgQPNea1bt77otjXEyZMnJUn33XefOnXqdFltAPW53N9NZ1kfAABwxHEzAKAhuCUcaGatW7eWJNlsNofpt912m6699lq99dZbtZbZsWOH7rjjDnl6ejpM/9///V9JUnV1da1lfv3rX+uxxx6Tn59fk2z3pEmTlJycLEkaMWKEIiIizHm7d+/WuHHj1L9/f/Xv318zZszQ4cOHzfk1t++sX79ev/rVr9SrVy8lJSXVWseBAwcUGRkpSUpNTXVYxxdffKFp06apX79+6tu3r37729/q4MGDDsvn5OSY29G3b1/95je/0V//+tdLtn0x27dv19ixY9W7d2+NGTNGe/bsqVXzww8/aOnSpbrjjjsUHByskJAQPfjgg/rwww8vuc4dO3bowQcf1K233qrg4GCNGDFCK1eu1Llz5+rdroKCAv3+97/X8OHDFRwcrH79+mnKlCkO++LZZ59VaGioPvnkE/3mN79R7969NWTIEKWkpKiystKsMwxDmzZt0h133KFevXrpvvvu0z/+8Y9613/27FkNGDDgoleMzp8/X7fddpv5Hv72t78pKipKAwYMUM+ePRUeHq4nn3yy3tunLrxF2263KzExUUOGDFHfvn01c+ZMff/997WW+/zzzzV9+nQNGjRIPXv2VFhYmObPn6+ioiJJ5285y8jIkCQNHjxYzz777EXXV1lZqU2bNmns2LHq06ePbrvtNi1evNjhioOaW3v+8Y9/KDo6Wn379lVoaKgWLFggu91e7/5r6D6/VD9v27ZNkydPliTNnj3bvOXNMAy98MIL+tWvfqW+ffsqODhYd955pzZt2lTvdgEAYEUcN9d93FyjqKhICQkJGjJkiIKDgzV27Fht377dnH/48GH16tVLU6ZMMacZhqHo6GjdeuutOnr0qCIiIpSTk6MjR44oMDBQBw4ckCSVlZUpJSVFw4YNU3BwsEaNGqWNGzc6PFcxPj5ev/71r/X0009r4MCBGjRokI4dO6ZJkyYpNjZWf/7znzVq1Chz+VdffdVh+xtybHspdR3nSdKLL76oMWPGqFevXrrtttv05JNPOhyvGYahjIwMjRo1Sr169VJYWJjmzp2rY8eOXbLtCzX3ceulvnsAVzuusASayI+DJ8MwdPr0aWVnZysrK0sBAQEaMGCAQ72bm5vuvPNO/eUvf1F8fLxcXM6fPyguLta+ffv03HPP6b//+78dlomIiNCf/vQnjRs3Tvfdd58GDx6sXr16ycPDQ9ddd53DswF/vC11hWIuLi7mei+0ePFi/fnPf9bzzz+vjIwMdejQQZKUlZWl1NRUjRkzRg8//LBOnz6tNWvW6MEHH9SLL76oW265xWzj2Wef1WOPPaauXbte9ICwZ8+eysjI0MyZMzVp0iT9+te/liQdPHhQkyZNUrdu3fTUU0/Jzc1Nzz//vCZOnKgXXnhBffv21bFjxzRt2jTdfvvteuSRR2Sz2bRlyxbFxsbqlVdeqbPti3n11VeVkJCgu+66S3Fxcfr6668vejvQww8/rGPHjmnOnDnq1KmTTpw4oczMTM2aNUu7d++uc51//vOf9fvf/15TpkzR7NmzVVFRoR07dmj16tVq166dxo0bd9HtOnv2rCZOnChXV1fNnTtX/v7++uabb/TMM88oNjZW7733nlq0aCFJKi0t1WOPPaaHHnpIc+bM0XvvvacNGzaoTZs2mjp1qiRp5cqVWrt2rSZPnqyhQ4fq888/14IFC+rcL5Lk4eGhX/7yl3rjjTdUXl5u3gpVWlqq9957T+PHj5ebm5s+/PBDPfzww7rrrrs0depU2Ww27d27Vy+88IJatWqlefPm1bse6fzv6sMPP6wvvvhCjz76qLp27aq33npLzzzzjEPdkSNHNHHiRA0ePFh//OMf5eHhoU8//VSZmZk6d+6cVqxYoZiYGLm6uuq1117Tc889p27dul10nbNmzdKHH36oqVOnasCAAfrqq6/07LPPKicnR6+++qq8vb3N2kceeUTjxo3TtGnT9Omnn+rZZ5+Vh4eHFi9eXOd7asg+b0g/Dxs2TIsWLdKTTz6pxx57zAzGV65cqeeee04zZ87UrbfeKrvdrhdffFFLly7VjTfeqKFDh15yvwMA8HPjuLnxx83S+QBr3LhxKisr06xZs9ShQwe99957evzxx3Xy5ElFRUUpMDBQjz32mP74xz/q1Vdf1f33369NmzZp3759SktLU+fOnZWRkaGFCxfq9OnTWr58uW6++WZVVlYqOjpaR44c0SOPPGIGmampqTp+/LgWLlxobsfhw4fl7u6uFStW6PvvvzevKM3OztZXX32lWbNm6dprr9X69euVkJCgwMBA9e7du1HHtvWp6zgvJSVFGzdu1MSJExUfH69///vfeuaZZ/TPf/5Tf/rTn+Tu7q7169drzZo1mjdvnnr06KETJ07o6aef1sMPP6x33nmnwceQP8dx66W+e/j6+l5yXwFOzQDwkzz++ONG9+7dL/ozcOBAIy4uzvjuu+/M+mPHjhndu3c3nnvuOePjjz82unfvbmRnZ5vzN2/ebNx+++1GVVWVcddddxkTJ050WN9rr71mDBw40FxHz549jXHjxhmbNm0yzpw541A7fPjwOrete/fuRmJiYr3vbePGjUb37t2NY8eOGYZhGKdOnTJ69+5tTJ8+3aGuuLjYGDBggDFlyhSH93hh3cX8eH/UmDhxojF06FCjtLTUnFZZWWn84he/MH7zm98YhmEYb7/9ttG9e3fj448/NmvKysqMp556yvj73/9eZ9sXqq6uNoYMGWJMmDDBYfqOHTsc9lFBQYExefJkY+fOnQ517777rtG9e3dj9+7dda7zj3/8o/H73//eYbmqqiqjX79+xqxZs+rctv/+7/82JkyYYBw8eNBhelZWltG9e3fj8OHDhmEYxjPPPGN0797deOONNxzqIiIizP11+vRpo2fPnsb8+fMdalavXn3JfXTw4EGje/fuxo4dO8xpW7duNbp37258+eWX5jbNmDGj1rJjxowxfvWrX5mvhw8fbkybNs18/eN9/P777xvdu3c3Xn31VYc2pkyZYnTv3t3cD9u3bzcmTpxolJeXO9Q9/PDDxsCBA83XNfulqKjoouv74IMPjO7duxsbN250aOejjz4yunfvbqxevdrhvWZmZjrUTZw40bjtttsutssMw2j4Pm9oP+/fv9/o3r278Ze//MWsmTt3rpGenu6wXHFxsdG9e3fjj3/8Y53bBgDAlcBx8087bn7mmWeMoKAg49ChQw7Tf//73xt9+/Y1Tp06ZRjG+ePb3/72t0a/fv2MDz/80AgODjYWLlzosMzEiRONX/7yl+brmuOd9957z6FuzZo1RmBgoPH1118bhvGfPrxwGyZOnGgEBQUZx48fN6d9++23Rvfu3Y20tDTDMBp/bPvjY7iL7Ysf1xw9etQICgoynnrqKYe6zz77zOjevbvxyiuvGIZhGA899JBxxx13GFVVVWbNRx99ZKxYscL87tGQ9Tf3cWtDv3sAVzOusASagKenp7Zs2SLp/NVS27Zt0xtvvKHo6OiLnr2t0a9fP3Xo0EFvv/22Bg0aJEl68803NXbs2DrP4N57770aO3asDhw4oAMHDujTTz/VwYMH9emnn+rFF1/UCy+8oHbt2jms44knnrhoW23atGnU+/z73/+uM2fO6K677nKY7uvrq+HDh+vtt99WVVWVOb1Hjx6Nal+Szpw5o08//VT33HOP3N3dHc5yDx8+XM8995x++OEH9e3bVy1bttSMGTM0cuRIhYWF6bbbbrvkFYMX+uabb/T999+bVyHWuPPOOx1ug/b39zcfEF9QUKB///vf+ve//629e/dKUq2RJn+s5mpNu92uf//73zp69Khyc3N17ty5epcLCgrSli1bZBiGvv32Wx09elR5eXnm7eoXLtuvXz+H1+3bt9cPP/wg6XzfVVZW6o477nCo+eUvf1nvqJuS1KtXLwUGBmrHjh0aO3aspPO30Pfp00c33XSTJCk6OlrR0dE6c+aM8vLydOzYMf3P//yPioqKGvx7VvOg8Ytt4759+8zXd999t+6++25VVFToq6++0tGjR/Xll1/qq6++qnd/Xig7O1uSav0+Dx48WDfccIM++ugjTZ8+3Zx+4f69/vrrdejQoTrbb+g+b2w//9jy5cslSadOnTL3+7/+9a9LLgcAwJXCcfPlHzfv27dPHTt2VPfu3R2OkSMjI/XKK6/o448/VmRkpGw2m1JSUjR27FhNnTpVN910kxISEi7Ztru7u4YOHVqr7bS0NH3wwQfmQEIuLi4KDAys1cb111+v66+/3uG1JPPxQD/lmOdSPvroI1VXV2vEiBEO29+rVy9dd911ev/99/XAAw8oLCxMKSkpuvvuuxUREaHbb79dAwYM0ODBgxu1vuY+bv0p3z2AqwWBJdAEXFxc1KtXL/N1//795ebmprS0NFVVVSkmJuaiy9lsNv3yl7/Un//8Zy1atEgnTpzQ559/7vCMvYtxd3fX7bffbo4WbLfb9dxzz2n16tV65pln9NRTT5m1Pj4+Dtv2U5w6dUqSdN1119Wad91116myslLl5eXmtFatWl3WOqqqqrR161Zt3br1ojWFhYW6+eab9fLLL2vdunV67733tHXrVrm5uWno0KFavHixw8PV61PzgPQLb71xc3OrNe3dd99VWlqa/v3vf6tVq1bq1q2buR7jR8/2udDx48f15JNP6m9/+5tsNps6deqkPn36qEWLFvUuJ0l/+tOftGbNGhUWFqp169YKDAw0b8u+cNkLR650cXExa2re54W3jvj7+9e7/hq//vWvtWzZMhUVFamiokI5OTn6wx/+YM7/4YcflJiYqL/+9a86d+6cbrjhBvXq1Uuenp6XfI81Tp48KTc3N/P5VTUu/H2rqKhQSkqKtm7dqvLycrVr1049evRo9O/bqVOnLtrPNeu88PmU9e3fut6P1LB93ph+/rHc3FwlJSXp448/VosWLRQQEKBbb731kssBAHClcNx8+cfNxcXFOnr0qHr27HnR+d999535/+3atdPtt9+ut956S7fddlutZ3xerO2Kioo63/+P2/b09JSrq2utmgvfQ02Q/OPniF7uMc+lFBcXS5L5nO+6tn/KlCny8fHR1q1bzdvDfX19NWnSJMXExNR6fmpdfo7j1sv97gFcLQgsgWayYMECHThwQBkZGRo8eLBCQkIuWjdmzBitW7dOH374oQ4dOqSgoKCLnrGsqqrSyJEjFRERUesMqbe3tx599FHt3r1b//M//9Ms70eSrrnmGkm66MOkCwoK5O7uLm9vbzOouRze3t6y2Wz61a9+pfHjx1+0pmPHjpLOn6VNS0tTdXW1vvjiC+3atUvr16/X4sWLtXbt2gatryasqnkwe43q6mrzQFOSPvvsMz322GO666679Nxzz6lTp07mcxprBvq5GMMw9Lvf/U5nz57V888/rz59+sjDw0OSzKsD6vLOO+/oySef1O9+9ztNmjTJvALgT3/6k95///0Gvb9Lvc8fDy5Tn7vuukvLly/XO++8o/LycvPZljUee+wx/etf/zIHAKo5CLv33nt19uzZBm/juXPnVFJS4hDyXbiNTz31lF5//XU9+eSTioyMlI+PjyQpNjZWR48ebdC6pPO/z+fOnVNxcXGt0LKgoEA333xzg9u6mIbu88vtZ7vdrujoaLVv315bt25VYGCgWrRoobKyMr3yyis/adsBAPg5cdzcMDUB349D1h+74YYbzP//29/+prfeeks9e/bUCy+8oJEjR9a6W+TCtv38/LRu3bqLzm/btm2Dt7MuTXlse6Ga4DAjI+OiFy7UhKI2m03333+/7r//ftntduXk5Oill17SM888o5tuukmjR49u0Pqa+7j1cr97AFcTRgkHmomnp6eWLFmiqqoqLVq0qM4HeAcGBqp79+5655139NZbb+nuu+++aJ2rq6vat2+vN954Q/n5+bXm2+12FRYWKigoqEnfx4+FhITI09NTO3bscJh+8uRJ7d27VwMHDmx0mxeenfXy8lKvXr105MgR9ejRQ7169TJ/3n33XW3YsEGurq7685//rNDQUBUVFcnFxUXBwcGaPXu2+vbtq+PHj1+07YsJCAgwby/68ZnK999/32GE7U8//dQ869+5c2fz7Ovu3bsl/efM8YXrLC4u1pdffqkxY8Zo4MCBZlj5+eefq6Sk5KIjV9bIycmRi4uLYmNjHW5XqrltpjFnVkNCQtSyZUu9/fbbDtN37drVoOX9/Pw0fPhwvffee3r77bc1YsQI84BLkj7++GPdfvvtGj58uBlW5ufn6/Dhw/W+xx8LCwuTpEtu48cff6zg4GDdc8895jacPn1an376qcO66ro9rEbNrT8X/j5nZ2fru+++U2hoaIO2uy4N3ecN7ecLf7e+/vprFRUVady4cQoODjYfUl+zXEP3OwAAVxrHzQ0TGhqqY8eOyd/f3+EYuWZwmZqT7cXFxVq4cKH69eunl19+Wd26dVNcXJzD3SMXHieFhoaquLhYLVq0cGi7rKxMK1asuOh+bKymPLa92PZL56+k/PH2d+zYUWlpafr4448lSQ899JBmzZol6Xx4HRERoUWLFkmS+R3iUseQUvMftzb0uwdwNeMKS6AZDRw4UL/61a/0+uuva9OmTbWek1hj7NixeuaZZ1RdXa0xY8bU2d6iRYvM0acnTZqkvn37ysPDQ1999ZU2b94sd3d3PfLIIw7L/PDDD/r888/rbDMgIEDXXnttg95P69at9cgjj+jpp5/W3Llzddddd5mjHZ49e1Zz5sxpUDs/5uPjI5vNpk8//VT9+vVT3759NX/+fEVHR2vatGl68MEH5eXlpXfffVevvPKKHn74YbVo0UKDBg1SRUWFHn74Yf3ud7/Ttddeq5ycHH366ad69NFH62z7Yh5//HHNnj1bM2fO1AMPPKATJ07o2WefdRilsGbZP/7xj5o4caIqKyv1zjvv6I033pAk85aei62zc+fO2rp1q2666Sa1a9dO//rXv7R27VrZbDaHW4Eu1LdvX7300kt68sknNWbMGNntdr322mv68MMPJUllZWUN3s+tWrXSo48+qqVLlyohIUGjR4/W4cOHtX79+ga3ce+992rGjBmqrq6uNYp63759tWvXLr366qvq0qWLvvrqK61bt07nzp2r9z3+WGhoqCIiIpSamqqysjL16NFDO3furHXGvW/fvnrjjTe0ceNG9ezZU/n5+dqwYYOKiooknb+qwtXV1byy4b333lNYWJg5gmWNIUOGaOjQoVq+fLlOnjypgQMHmqOEd+nSpc7R2xuqofu8of1cc+XARx99pC5duujGG29U69attWnTJl177bXy9vbWxx9/rKysrEv+bgEAYDUcN19adHS03nzzTf32t7/VtGnT1KFDBx08eFAZGRnq0aOHAgICJEkJCQk6ffq0li5dKnd3dyUnJ+uBBx7QkiVLlJKSIun8FaCHDh3Svn371LNnT/3617/Wyy+/rN/97neaPn26br75Zn355Zd65plndO211zqMaH65mvLY9sLjvJtvvlkPPPCAli1bpv/93/9VaGioTp48qbVr1+ro0aOaN2+epPPHm08//bSSk5M1fPhwnTlzRs8//7xatmypESNGXLTtC48ha9ppzuPWhn73AK5mBJZAM4uLi9OePXuUkZGhO++886I1Y8aMUVpamsLCwup9pmBQUJB27NihrKwsvfPOO8rKylJlZaVuuOEGDR8+XA8//HCtW1s/++wz/eY3v6mzzfT09Abf+iBJ06ZNU7t27fT8889r5syZatWqlQYMGKCnn376orfkXIq3t7emTJmil19+WTk5Ofroo480cOBAbd68WRkZGYqPj1dVVZW6dOmixYsXm7eJd+7cWRs2bFBGRoYWL14su92uzp076/HHH9dvf/vbOtt2d3evtQ2jRo3SqlWrtGrVKs2cOVPXX3+9Fi5cqD/+8Y9mzYABA5SUlKSsrCxNnz5drVu3Vs+ePc0Du48//lj33nvvRdeZmZmppUuX6g9/+IP5DMvY2Fh9+eWX2r59u0pLS+Xl5VVru+655x4VFBTolVde0RtvvKE2bdqob9++evHFFzV+/Hh9/PHHl7yt/MeioqLk5eWljRs36o033lBAQICefvppRUdHN2j522+/XW3btpWrq2ut9aakpOipp57S8uXLVVFRoRtuuEH333+/XFxctHLlSh07duyiB3sXSk9PV3p6ujZv3qxTp05pwIABWrhwocPtXPHx8TIMQ+vXr1dpaanat2+v4cOHKyoqSgsWLNAnn3yi0NBQ3XHHHdq+fbuWLFmiX//617WecWWz2bRq1SqtWbNGO3bs0HPPPac2bdpozJgxio2NdbiC9HI1ZJ83tJ9vvvlmjRkzRtu3b9cnn3yid955R2vWrNGyZcsUFxcnd3d3BQQE6KmnntJbb72lTz75RIZhNPhZTAAAXGkcN9evTZs2+vOf/6z09HQ9/fTTOnXqlNq1a6cJEybokUcekYuLi1555RXt2rVLTzzxhLp06SJJ6tmzp6ZOnao1a9Zo2LBhuvPOOzVx4kT985//1MMPP6zk5GTddddd2rJli5555hmtW7fOHDhx1KhRio2NveixamM15bHtxY7zEhMTddNNN+nVV19VVlaWvL291bdvXz311FPmcz9/97vfyd3dXa+99pr+/Oc/y8XFRSEhIXrhhRfUuXPnOtu+mOY+bm3Idw/gamYzeForAAAAAAAAAIvgGZYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGW5XegOczQ8/lKuqqvpKb4Yl+Pp6qaSk9EpvBhqAvnIe9JVzoJ+cB331H66uLmrduuWV3gw0AY5H/4O/cedBXzkP+sp50FfOgX5y1NBjUgLLRqqqqta5cxwg2mzn/1tVVS3DuLLbgvrRV86DvnIO9JPzoK9wteJ49Dz+xp0HfeU86CvnQV85B/rp8nFLOAAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBluV3oDAAD4MZvtSm9B/Wq2z+rbWcMwrvQWAACam9X/TeLfzvOc4f3TVwCsgsASAGAZ11zTSu7urld6MxqkTRufK70JDVJRUaVTp8qu9GYAAJoJ/3Y2veb4t9OZ+kn6v91XAKyBwBIAYAk2m+Tu7qqoJ/+qsjPnrvTmXBVaebpp06JRstm4AgEArkb829n0muPfTvqpeXCcA1zdCCwBAJZSduacys9yMA8AQEPxb6dzoJ8AoOEYdAcAAAAAAACAZRBYAgAAAAAAALAMbgkHAAAAAAD4/5xhlHRnGtGdZ4zichBYAgAAAAAAiBHdmwOjueNyEFgCAAAAAID/8xjRvek192juVr/C1JmuhJWsdTUsgSUAAAAAAMD/x4juzsGZroZ1hithJWtdDUtgCQAAAAAAAKfB1bBNr7mvhm0sAksAAAAAAAA4Ha6GvXq5XOkNAAAAAAAAAIAaBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAp1VRUaE777xT8fHx5jTDMJSRkaHw8HD16dNHU6ZM0ddff+2w3NmzZ5WUlKQhQ4YoJCREsbGxKiwsdKg5efKk4uLiFBoaqgEDBighIUF2u92hJj8/XzExMerXr5/CwsKUmpqqyspKh5rc3FxNnjxZISEhGjZsmNavX9/EewEAAODqQmAJAAAAp5WRkVErjMzIyND69es1depUpaWl6fTp05oyZYpD2Lh48WK9+eabmjdvnpYuXarc3FxNnz5d1dXVZs2sWbP06aefKjExUQsWLNCuXbsUFxdnzq+oqFB0dLS+++47paamKiYmRi+++KJSU1PNmqKiIkVHR8vNzU0rV67UAw88oBUrVmjTpk3Nt1MAAACcnNuV3gAAAADgcnzxxRfavHmzfH19zWl2u10bNmzQ7NmzNWnSJElS//79NXz4cG3btk2TJ0/W0aNHtX37dqWnp2vUqFGSpKCgII0ePVp79uxRZGSksrOzlZOTo61btyo4OFiS1L59e0VFRSk3N1dBQUHasWOH8vPztXv3bvn7+0uSPDw8lJiYqBkzZsjPz09btmyRYRjKzMyUp6enwsPDVVFRobVr12rSpElydXX9mfcaAACA9XGFJQAAAJzOuXPntGDBAj300ENq166dOf0f//iHysrKFBERYU675pprNHDgQH3wwQeSpP3798vFxUXh4eFmTUBAgLp16+ZQ4+/vb4aVkhQaGipvb2+zJjs7W8HBwWZYKUkjRoxQZWWl9u/fb9aEhYXJ09PToaa4uFiHDh1qyl0CAABw1SCwBAAAgNNZv369KisrNW3aNIfpeXl5cnFxUceOHR2md+zYUXl5eZKkb775Ru3atXMIES9W06VLF4f5Li4u6tChg1mTl5dXq8bX11fe3t711nTq1Mlcx+Wy2fix2dgXNfsATY9+ch70lXPg8895WOXfLW4JBwAAgFP56quvtGbNGm3atEnu7u4O8+x2uzw9PeXm5niY6+XlZT7DsrS0VF5eXrXa9fLy0vfff3/Jmpp27Hb7ZdXUvL5wAJ+G8vWtvc7/y9q08bnSm4CrEL9XzoO+cg70k/OwSl8RWAIAAMBpVFdXa+HChbrvvvsUEhJSa75hGHUu6+LiYtbY6jjF35gaSU1W0xglJaWqqqq+dOFVzmY7/6WqqOi06un2q1rNPkDTa8rfK/qpedFXzqGpP6vpq+bT3P+uurq6NOjkK4ElAAAAnMbmzZt14sQJrVu3TufOnTOnG4ahc+fOycfHR2fPnlVVVZXDgDalpaXy9vaWJHl7e6u0tLRW26WlpfLx8TFrSkpKLlnTkHYurKl5XVNzOf6vBnQXYxjsDzQ9fq+cB33lHOgn52GVvuIZlsBPcKWfWdSYZ0Rc6W3gOSQAgKawc+dOfffddxowYIB69uypnj17Kjc3V9u3b1fPnj3l5uamqqoqHT9+3GG5b7/9Vl27dpV0foCdwsJCVVRU1Ftz7Ngxh/nV1dXKz8+vt6akpER2u73emprXNTUAAABwxBWWwGW65ppWcnd3vXShRTjL5fIVFVU6darsSm8GAMCiEhMTa12xOG/ePHXt2lWPPPKIunbtqqeeeko7d+7UlClTJEmnTp1STk6OZs+eLUkaPHiwKisrtXfvXt1xxx2Szg+Oc+TIEYeatWvX6tChQ+rZs6ck6cCBA7Lb7Ro8eLAkadCgQXryySdVUFBgjlS+c+dOtWjRQv379zdrXn31VZWXl6tly5ZmjZ+fnwIDA5tzVwEAADgtAksLcoarzH581Z4zaOrLmW02yd3dVVFP/lVlZ85degE0SCtPN21aNEo2mzUuQQcAWM+NN95Ya5qnp6euvfZa9erVS5I0ceJEPf3005Kkzp07a82aNWrdurXuvfdec9ro0aO1YMECnTp1Sj4+PkpLS1OPHj0UEREh6XzQ2KdPH8XExCguLk6VlZVKSUlRZGSkgoKCJEljxozR6tWrNXXqVM2ePVsFBQVatmyZxo0bJz8/P0nS+PHjtXnzZk2bNk3R0dHKzc3VunXrFBcXV2tgIAAAAJzHUZLFcNVe82iuq/bKzpxT+VkCSwAArOSxxx6TzWbT+vXrVV5erltvvVUpKSnmMywlKTk5WUuXLlVqaqoMw1BYWJgSEhLMgXBsNpsyMzO1ZMkSJSQkyN3dXSNHjlR8fLzZRsuWLbVhwwYtWbJEc+fOlY+PjyZMmKA5c+aYNf7+/tq4caOSk5MVGxurtm3bau7cuYqKivrZ9gcAAICzIbC0EK7aax5ctQcAwNXtjTfecHjt5uam+fPna/78+XUu4+XlpaSkJCUlJdVZ07ZtW6Wnp9e77oCAAGVlZdVb07t3b7388sv11gAAAOA/CCwtiKv2gKbnDI8vcKZHLRD+AwAAAACaC4ElgKsej1poegyOBAAAAABoLgSWAK5qPGqh6fGYBQAAAABAcyKwBPB/Ao9aAAAAAADAObhc6Q0AAAAAAAAAgBoElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBluF3pDQAAAM7HZrvSW3BpNdvoDNsqSYZxpbcAAAAAsAYCSwAA0CjXXNNK7u6uV3ozGqxNG58rvQkNUlFRpVOnyq70ZgAAAABXHIElAABoMJtNcnd3VdSTf1XZmXNXenOuGq083bRp0SjZbFxpCQAAABBYAgCARis7c07lZwksAQAAADQ9Bt0BAAAAAAAAYBmNDizPnTunjIwMDR8+XH379tXkyZN16NAhc75hGMrIyFB4eLj69OmjKVOm6Ouvv3Zo4+zZs0pKStKQIUMUEhKi2NhYFRYWOtScPHlScXFxCg0N1YABA5SQkCC73e5Qk5+fr5iYGPXr109hYWFKTU1VZWWlQ01ubq4mT56skJAQDRs2TOvXr2/sWwYAAAAAAADwM2l0YJmWlqasrCxNnTpVq1atkpeXlyZPnqwTJ05IkjIyMrR+/XpNnTpVaWlpOn36tKZMmeIQNi5evFhvvvmm5s2bp6VLlyo3N1fTp09XdXW1WTNr1ix9+umnSkxM1IIFC7Rr1y7FxcWZ8ysqKhQdHa3vvvtOqampiomJ0YsvvqjU1FSzpqioSNHR0XJzc9PKlSv1wAMPaMWKFdq0adPl7CsAAAAAAAAAzaxRz7AsKyvTiy++qJiYGE2YMEGS1L9/fw0cOFBvvvmmxo8frw0bNmj27NmaNGmSOX/48OHatm2bJk+erKNHj2r79u1KT0/XqFGjJElBQUEaPXq09uzZo8jISGVnZysnJ0dbt25VcHCwJKl9+/aKiopSbm6ugoKCtGPHDuXn52v37t3y9/eXJHl4eCgxMVEzZsyQn5+ftmzZIsMwlJmZKU9PT4WHh6uiokJr167VpEmT5OrqPCOcAgAAAAAAAP8XNOoKSw8PD7300ku6//77zWmurq6y2WyqqKjQP/7xD5WVlSkiIsKcf80112jgwIH64IMPJEn79++Xi4uLwsPDzZqAgAB169bNocbf398MKyUpNDRU3t7eZk12draCg4PNsFKSRowYocrKSu3fv9+sCQsLk6enp0NNcXGxw23sAAAAAAAAAKyhUYGlq6urbrnlFvn6+qq6ulrHjh3TggULZLPZNHbsWOXl5cnFxUUdO3Z0WK5jx47Ky8uTJH3zzTdq166dQ4h4sZouXbo4bqiLizp06GDW5OXl1arx9fWVt7d3vTWdOnUy1wEAAAAAAADAWhp1S/iPrV27VitXrpQkzZ49W126dNG7774rT09Pubk5Nuvl5WU+w7K0tFReXl612vPy8tL3339/yZqadux2+2XV1Ly+cACfxrDZLnvRK9IuzmvK/UtfNS/6yjk09b6lr5oPf1POg/0LAAAA/ITAMiIiQv369VNOTo5WrVqlioqKWldN/piLy/mLOQ3DkK2Oo/HG1EhqsprG8PWtHZLCObRp43OlNwENRF85B/rJedBXzoO+AgAAAH5CYBkYGChJGjhwoOx2u7KysjRv3jydPXtWVVVVDgPalJaWytvbW5Lk7e2t0tLSWu2VlpbKx8fHrCkpKblkTUPaubCm5nVNTWOVlJSqqqr60oWXwWbji0pzKio6LcNomrboq+ZFXzmHpuwnib5qTvxNOY+m/rv6MVdXF068AgAAwCk06jLD4uJibdu2TadOnXKYfsstt6iiokLXXHONqqqqdPz4cYf53377rbp27Srp/AA7hYWFqqioqLfm2LFjDvOrq6uVn59fb01JSYnsdnu9NTWva2ouh2E03w+aD33lPOgr58BnoPOgn5wHxxgAAABAIwPLsrIyPfHEE3r77bcdpmdnZ6tNmzYaMWKEPDw8tHPnTnPeqVOnlJOTo8GDB0uSBg8erMrKSu3du9esycvL05EjRzRo0CCz5sSJEw4jeR84cEB2u91sZ9CgQTp48KAKCgrMmp07d6pFixbq37+/WbNv3z6Vl5c71Pj5+ZlXiAIAAAAAAACwjkbdEt6xY0eNHTtWTz/9tAzDUNeuXbVz5069/vrrSk5Olre3tyZOnKinn35aktS5c2etWbNGrVu31r333mtOGz16tBYsWKBTp07Jx8dHaWlp6tGjhyIiIiSdDxr79OmjmJgYxcXFqbKyUikpKYqMjFRQUJAkacyYMVq9erWmTp2q2bNnq6CgQMuWLdO4cePk5+cnSRo/frw2b96sadOmKTo6Wrm5uVq3bp3i4uJqDQwEAAAAAAAA4MprdGr31FNPKTMzU1lZWfr+++914403asWKFfrFL34hSXrsscdks9m0fv16lZeX69Zbb1VKSor5DEtJSk5O1tKlS5WamirDMBQWFqaEhARzIBybzabMzEwtWbJECQkJcnd318iRIxUfH2+20bJlS23YsEFLlizR3Llz5ePjowkTJmjOnDlmjb+/vzZu3Kjk5GTFxsaqbdu2mjt3rqKioi53fwEAAAAAAABoRo0OLD08PDRnzhyHYNChQTc3zZ8/X/Pnz6+zDS8vLyUlJSkpKanOmrZt2yo9Pb3ebQkICFBWVla9Nb1799bLL79cbw0AAAAAAAAAa2jUMywBAAAAAAAAoDkRWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZbhd6Q0AAAAAYD0225XegvrVbJ/Vt7OGYVzpLQAAwHkQWAIAAABwcM01reTu7nqlN6NB2rTxudKb0CAVFVU6darsSm8GAABOgcASAAAAgMlmk9zdXRX15F9Vdubcld6cq0IrTzdtWjRKNhtXWgIA0BAElgAAAABqKTtzTuVnCSwBAMDPj0F3AAAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAABwKufOnVNGRoaGDx+uvn37avLkyTp06JA5/8iRIwoMDKz1k5KSYtacPXtWSUlJGjJkiEJCQhQbG6vCwkKH9Zw8eVJxcXEKDQ3VgAEDlJCQILvd7lCTn5+vmJgY9evXT2FhYUpNTVVlZaVDTW5uriZPnqyQkBANGzZM69evb4a9AgAAcPVg0B0AAAA4lbS0NL300kuaN2+eAgICtGXLFk2ePFlvvfWWrr/+euXm5srDw0MvvPCCw3L+/v7m/y9evFh79uxRfHy8WrZsqbS0NE2fPl2vvfaaXFzOn9OfNWuWjh8/rsTERJWXlys1NVXFxcXKzMyUJFVUVCg6OlpeXl5KTU3ViRMntHz5clVWVmrhwoWSpKKiIkVHRysoKEgrV67UoUOHtGLFCrVo0UJRUVE/zw4DAABwMgSWAAAAcBplZWV68cUXFRMTowkTJkiS+vfvr4EDB+rNN9/UtGnTdPjwYd18883q27fvRds4evSotm/frvT0dI0aNUqSFBQUpNGjR2vPnj2KjIxUdna2cnJytHXrVgUHB0uS2rdvr6ioKOXm5iooKEg7duxQfn6+du/ebYahHh4eSkxM1IwZM+Tn56ctW7bIMAxlZmbK09NT4eHhqqio0Nq1azVp0iS5uro2/04DAABwMtwSDgAAAKfh4eGhl156Sffff785zdXVVTabTRUVFZKkw4cPq3v37nW2sX//frm4uCg8PNycFhAQoG7duumDDz4wa/z9/c2wUpJCQ0Pl7e1t1mRnZys4ONjhys0RI0aosrJS+/fvN2vCwsLk6enpUFNcXOxwGzsAAAD+g8ASAAAATsPV1VW33HKLfH19VV1drWPHjmnBggWy2WwaO3aspPOBZWFhoe655x4FBwdrxIgRev311802vvnmG7Vr184hRJSkjh07Ki8vz6zp0qWLw3wXFxd16NDBrMnLy6tV4+vrK29v73prOnXqZK4DAAAAtXFLOAAAAJzS2rVrtXLlSknS7Nmz1aVLF508eVIFBQVyc3PTvHnz5OvrqzfffFPx8fFycXHR3XffrdLSUnl5edVqz8vLS99//70k1VtTM/CO3W6/rJqa1xcO4NMYNttlL3pF2/6/rqn3LX3VfJpy39JPzYu+cg58/jkPq+xbAksAAAA4pYiICPXr1085OTlatWqVKioqNGPGDG3YsEE33XST2rdvL0kaPHiwCgsLlZmZqbvvvluGYchWx9F4zYA7DamR1GQ1jeHrWzskhXNo08bnSm8CGoi+ch70lXOgn5yHVfqKwBIAAABOKTAwUJI0cOBA2e12ZWVl6ZFHHtGQIUNq1d5+++1KTk7W2bNn5e3trdLS0lo1paWl8vE5f5Du7e2tkpKSS9Y0pJ0La2pe19Q0VklJqaqqqi9r2Yaw2azzZeVqU1R0WobRdO3RV82nKfuKfmpe9JVz4PPPeTR1X13I1dWlQSdfeYYlAAAAnEZxcbG2bdumU6dOOUy/5ZZbVFFRoX/961966aWXVFZW5jD/7NmzatWqlTw8PBQQEKDCwkJzkJ4a3377rbp27Srp/CA8x44dc5hfXV2t/Pz8emtKSkpkt9vrral5XVNzOQyjeX/QPOgr50E/OQ/6yjnw+ec8rHKMQWAJAAAAp1FWVqYnnnhCb7/9tsP07OxstWnTRq6urvrDH/6g3bt3m/MMw9B//dd/qV+/fpLO3yJeWVmpvXv3mjV5eXk6cuSIBg0aZNacOHHCYSTvAwcOyG63a/DgwZKkQYMG6eDBgyooKDBrdu7cqRYtWqh///5mzb59+1ReXu5Q4+fnZ14hCgAAAEfcEg4AAACn0bFjR40dO1ZPP/20DMNQ165dtXPnTr3++utKTk5Wr169FBYWpiVLlqisrEzt2rXTq6++qsOHD+ull16SJHXu3FmjR4/WggULdOrUKfn4+CgtLU09evRQRESEpPNBY58+fRQTE6O4uDhVVlYqJSVFkZGRCgoKkiSNGTNGq1ev1tSpUzV79mwVFBRo2bJlGjdunPz8/CRJ48eP1+bNmzVt2jRFR0crNzdX69atU1xcnNzcOBQHAAC4GI6SAAAA4FSeeuopZWZmKisrS99//71uvPFGrVixQr/4xS8kSenp6Vq5cqVWrVqlkpIS9ejRQxs3blRwcLDZRnJyspYuXarU1FQZhqGwsDAlJCSYA+HYbDZlZmZqyZIlSkhIkLu7u0aOHKn4+HizjZYtW2rDhg1asmSJ5s6dKx8fH02YMEFz5swxa/z9/bVx40YlJycrNjZWbdu21dy5cxUVFfXz7CwAAAAnRGAJAAAAp+Lh4aE5c+Y4BIM/1rp1ay1atEiLFi2qsw0vLy8lJSUpKSmpzpq2bdsqPT293m0JCAhQVlZWvTW9e/fWyy+/XG8NAAAA/oNnWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyj0YHlmTNntGLFCo0cOVIhISG655579M4775jz9+7dq8DAwFo/W7ZsMWtOnjypuLg4hYaGasCAAUpISJDdbndYT35+vmJiYtSvXz+FhYUpNTVVlZWVDjW5ubmaPHmyQkJCNGzYMK1fv77W9ubk5Oi+++5Tnz59dMcdd2jbtm2NfcsAAAAAAAAAfiZujV0gMTFR7733nh599FHdeOON2r17t+bMmSObzaY777xTubm56tChg9LS0hyW69ixo/n/s2bN0vHjx5WYmKjy8nKlpqaquLhYmZmZkqSKigpFR0fLy8tLqampOnHihJYvX67KykotXLhQklRUVKTo6GgFBQVp5cqVOnTokFasWKEWLVooKipKkvTll19q2rRpioyMVGxsrD788EM98cQTat26tUaMGHG5+wwAAAAAAABAM2lUYFlcXKxt27YpKSlJ999/vyQpLCxMR48e1aZNm3TnnXfq8OHD6tmzp/r27XvRNrKzs5WTk6OtW7cqODhYktS+fXtFRUUpNzdXQUFB2rFjh/Lz87V79275+/tLkjw8PJSYmKgZM2bIz89PW7ZskWEYyszMlKenp8LDw1VRUaG1a9dq0qRJcnV11bp169SpUyctX75cNptNQ4cOVUlJiVatWkVgCQAAAAAAAFhQo24JLy0t1YMPPqjbbrvNYXrXrl2Vn58vSTp8+LC6d+9eZxv79++Xv7+/GVZKUmhoqLy9vfXBBx9IOh9qBgcHm2GlJI0YMUKVlZXav3+/WRMWFiZPT0+HmuLiYh06dMisiYiIkM1mc6j54osvVFRU1Ji3DgAAAAAAAOBn0KjAslOnTkpMTNT1119vTquqqtL777+vrl27qqKiQnl5eTp8+LBGjx6tnj17auzYsfrb3/5m1n/zzTfq0qWL40a4uKhDhw7Ky8uTJOXl5dWq8fX1lbe3d701nTp1MtdRVlamwsJCde7cuc4aAAAAAAAAANbyk0cJz8jI0Ndff62pU6fqyJEjqqqq0rFjxzR//nytXr1aHTp00PTp05WTkyPp/FWaXl5etdrx8vIyB96x2+2XVVPz2m63m3V11ZSWll72e7bZmu8HzYe+ch70lXPgM9B50E/Og2MMAAAA4DIG3fmxrKwsZWZmaurUqQoPD9fp06e1bt069e3bV9dcc40kaciQIbr77ru1Zs0aDRw4UIZhONyi/WMuLv/JT39qjWEY9dbUNf1SfH1rB6lwDm3a+FzpTUAD0VfOgX5yHvSV86CvAAAAgMsMLA3DUGpqqjZs2KCJEydq/vz5kiQfHx+Fh4c71Lq6uiosLExvv/22JMnb21slJSW12iwtLZWPj49Zc7ErIC9VU/Pax8dH3t7eDtMuVnM5SkpKVVVVfVnLXorNxheV5lRUdFr/P8f+yeir5kVfOYem7CeJvmpO/E05j6b+u/oxV1cXTrwCAADAKTT6lvDq6mo9/vjj2rBhg6ZPn67f//735rzDhw/rlVdeqbXMmTNndO2110qSAgICdOzYsVpt5ufnq2vXrnXWlJSUyG6311tT87pr167y8vLSddddV2dNQEBAI9/5fxhG8/2g+dBXzoO+cg58BjoP+sl5cIwBAAAAXEZgmZKSojfeeEPx8fGaM2eOw7yvvvpKixYt0t///ndz2pkzZ/T++++rf//+kqTBgwfrxIkT5kjeknTgwAHZ7XYNHjxYkjRo0CAdPHhQBQUFZs3OnTvVokULs51BgwZp3759Ki8vd6jx8/NTYGCgua7du3erurraoeaWW26Rr69vY986AAAAAAAAgGbWqFvCc3Nz9fzzz2vIkCEKCQnR559/bs5zdXVVZGSkunXrprlz5+qxxx5Tq1atlJWVpbKyMk2fPl3S+aCxT58+iomJUVxcnCorK5WSkqLIyEgFBQVJksaMGaPVq1dr6tSpmj17tgoKCrRs2TKNGzdOfn5+kqTx48dr8+bNmjZtmqKjo5Wbm6t169YpLi5Obm7n39ZDDz2k++67T48++qjuvfdeffTRR9qxY4cyMjKaYt8BAAAAAAAAaGKNCix37twpwzC0b98+7du3z2Gej4+PPvnkE2VlZWn58uVaunSpSktL1a9fP23ZskXXX3+9pPOD3WRmZmrJkiVKSEiQu7u7Ro4cqfj4eLOtli1basOGDVqyZInmzp0rHx8fTZgwweGKTn9/f23cuFHJycmKjY1V27ZtNXfuXEVFRZk1QUFByszM1PLlyzVz5kzdcMMNSklJ0ciRIy9nXwEAAAAAAABoZo0KLGfOnKmZM2fWW9OuXTstW7as3pq2bdsqPT293pqAgABlZWXVW9O7d2+9/PLL9dYMHTpUQ4cOrbcGAAAAAAAAgDU0+hmWAAAAAAAAANBcCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAMCpnDt3ThkZGRo+fLj69u2ryZMn69ChQ+Z8wzCUkZGh8PBw9enTR1OmTNHXX3/t0MbZs2eVlJSkIUOGKCQkRLGxsSosLHSoOXnypOLi4hQaGqoBAwYoISFBdrvdoSY/P18xMTHq16+fwsLClJqaqsrKSoea3NxcTZ48WSEhIRo2bJjWr1/fxHsEAADg6kJgCQAAAKeSlpamrKwsTZ06VatWrZKXl5cmT56sEydOSJIyMjK0fv16TZ06VWlpaTp9+rSmTJniEDYuXrxYb775pubNm6elS5cqNzdX06dPV3V1tVkza9Ysffrpp0pMTNSCBQu0a9cuxcXFmfMrKioUHR2t7777TqmpqYqJidGLL76o1NRUs6aoqEjR0dFyc3PTypUr9cADD2jFihXatGlT8+8oAAAAJ+V2pTcAAAAAaKiysjK9+OKLiomJ0YQJEyRJ/fv318CBA/Xmm29q/Pjx2rBhg2bPnq1JkyaZ84cPH65t27Zp8uTJOnr0qLZv36709HSNGjVKkhQUFKTRo0drz549ioyMVHZ2tnJycrR161YFBwdLktq3b6+oqCjl5uYqKChIO3bsUH5+vnbv3i1/f39JkoeHhxITEzVjxgz5+flpy5YtMgxDmZmZ8vT0VHh4uCoqKrR27VpNmjRJrq6uV2AvAgAAWBtXWAIAAMBpeHh46KWXXtL9999vTnN1dZXNZlNFRYX+8Y9/qKysTBEREeb8a665RgMHDtQHH3wgSdq/f79cXFwUHh5u1gQEBKhbt24ONf7+/mZYKUmhoaHy9vY2a7KzsxUcHGyGlZI0YsQIVVZWav/+/WZNWFiYPD09HWqKi4sdbmMHAADAfxBYAgAAwGm4urrqlltuka+vr6qrq3Xs2DEtWLBANptNY8eOVV5enlxcXNSxY0eH5Tp27Ki8vDxJ0jfffKN27do5hIgXq+nSpYvDfBcXF3Xo0MGsycvLq1Xj6+srb2/vems6depkrgMAAAC1cUs4AAAAnNLatWu1cuVKSdLs2bPVpUsXvfvuu/L09JSbm+NhrpeXl/kMy9LSUnl5edVqz8vLS99///0la2rasdvtl1VT8/rCAXwaw2a77EWvaNv/1zX1vqWvmk9T7lv6qXnRV86Bzz/nYZV9S2AJAAAApxQREaF+/fopJydHq1atUkVFRa2rJn/MxeX8zUWGYchWx9F4Y2okNVlNY/j61g5J4RzatPG50puABqKvnAd95RzoJ+dhlb4isAQAAIBTCgwMlCQNHDhQdrtdWVlZmjdvns6ePauqqiqHAW1KS0vl7e0tSfL29lZpaWmt9kpLS+Xj42PWlJSUXLKmIe1cWFPzuqamsUpKSlVVVX3pwstks1nny8rVpqjotAyj6dqjr5pPU/YV/dS86CvnwOef82jqvrqQq6tLg06+8gxLAAAAOI3i4mJt27ZNp06dcph+yy23qKKiQtdcc42qqqp0/Phxh/nffvutunbtKun8ADuFhYWqqKiot+bYsWMO86urq5Wfn19vTUlJiex2e701Na9rai6HYTTvD5oHfeU86CfnQV85Bz7/nIdVjjEILAEAAOA0ysrK9MQTT+jtt992mJ6dna02bdpoxIgR8vDw0M6dO815p06dUk5OjgYPHixJGjx4sCorK7V3716zJi8vT0eOHNGgQYPMmhMnTjiM5H3gwAHZ7XaznUGDBungwYMqKCgwa3bu3KkWLVqof//+Zs2+fftUXl7uUOPn52deIQoAAABH3BIOAAAAp9GxY0eNHTtWTz/9tAzDUNeuXbVz5069/vrrSk5Olre3tyZOnKinn35aktS5c2etWbNGrVu31r333mtOGz16tBYsWKBTp07Jx8dHaWlp6tGjhyIiIiSdDxr79OmjmJgYxcXFqbKyUikpKYqMjFRQUJAkacyYMVq9erWmTp2q2bNnq6CgQMuWLdO4cePk5+cnSRo/frw2b96sadOmKTo6Wrm5uVq3bp3i4uJqDQwEAACA8zhKAgAAgFN56qmnlJmZqaysLH3//fe68cYbtWLFCv3iF7+QJD322GOy2Wxav369ysvLdeuttyolJcV8hqUkJScna+nSpUpNTZVhGAoLC1NCQoI5EI7NZlNmZqaWLFmihIQEubu7a+TIkYqPjzfbaNmypTZs2KAlS5Zo7ty58vHx0YQJEzRnzhyzxt/fXxs3blRycrJiY2PVtm1bzZ07V1FRUT/PzgIAAHBCBJYAAABwKh4eHpozZ45DMPhjbm5umj9/vubPn19nG15eXkpKSlJSUlKdNW3btlV6enq92xIQEKCsrKx6a3r37q2XX3653hoAAAD8B8+wBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMtodGB55swZrVixQiNHjlRISIjuuecevfPOO+b8s2fPKikpSUOGDFFISIhiY2NVWFjo0MbJkycVFxen0NBQDRgwQAkJCbLb7Q41+fn5iomJUb9+/RQWFqbU1FRVVlY61OTm5mry5MkKCQnRsGHDtH79+lrbm5OTo/vuu099+vTRHXfcoW3btjX2LQMAAAAAAAD4mTQ6sExMTNSf/vQn/fa3v9WqVavUv39/zZkzR3/5y18kSYsXL9abb76pefPmaenSpcrNzdX06dNVXV1ttjFr1ix9+umnSkxM1IIFC7Rr1y7FxcWZ8ysqKhQdHa3vvvtOqampiomJ0YsvvqjU1FSzpqioSNHR0XJzc9PKlSv1wAMPaMWKFdq0aZNZ8+WXX2ratGnq0qWLnn32WQ0bNkxPPPGEdu7ceTn7CgAAABZwqRPoe/fuVWBgYK2fLVu2mDWcQAcAALAut8YUFxcXa9u2bUpKStL9998vSQoLC9PRo0e1adMm9ezZU9u3b1d6erpGjRolSQoKCtLo0aO1Z88eRUZGKjs7Wzk5Odq6dauCg4MlSe3bt1dUVJRyc3MVFBSkHTt2KD8/X7t375a/v78kycPDQ4mJiZoxY4b8/Py0ZcsWGYahzMxMeXp6Kjw8XBUVFVq7dq0mTZokV1dXrVu3Tp06ddLy5ctls9k0dOhQlZSUaNWqVRoxYkRT7kcAAAD8TBITE/Xee+/p0Ucf1Y033qjdu3drzpw5stlsuvPOO5Wbm6sOHTooLS3NYbmOHTua/z9r1iwdP35ciYmJKi8vV2pqqoqLi5WZmSnpPyfQvby8lJqaqhMnTmj58uWqrKzUwoULJf3nBHpQUJBWrlypQ4cOacWKFWrRooWioqIk/ecEemRkpGJjY/Xhhx/qiSeeUOvWrTkeBQAAqEOjAsvS0lI9+OCDuu222xymd+3aVW+//bb2798vFxcXhYeHm/MCAgLUrVs3ffDBB4qMjNT+/fvl7+9vhpWSFBoaKm9vb33wwQcKCgpSdna2goODzbBSkkaMGKGEhATt379fv/jFL5Sdna2wsDB5eno61KxevVqHDh1S7969lZ2drV//+tey2WwONTt27FBRUZHatGnTmLcPAACAK+xSJ9DvvPNOHT58WD179lTfvn0v2gYn0AEAAKytUbeEd+rUSYmJibr++uvNaVVVVXr//ffVtWtXffPNN2rXrp1DiCidP5udl5cnSfrmm2/UpUsXx41wcVGHDh3Mmry8vFo1vr6+8vb2rremU6dO5jrKyspUWFiozp0711kDAAAA51LfCfT8/HxJ0uHDh9W9e/c627jUCXRJdZ5Ar6ys1P79+82ai51ALy4u1qFDh8yaiIiIWifQv/jiCxUVFV3ubgAAALiq/eRRwjMyMvT1119r6tSpKi0tlZeXV60aLy8v85lADamx2+2XVVPz2m63m3V11ZSWljbqff6YzdZ8P2g+9JXzoK+cA5+BzoN+ch4cY1zapU6gV1RUKC8vT4cPH9bo0aPVs2dPjR07Vn/729/Mek6gAwAAWFujbgm/UFZWljIzMzV16lSFh4dr586dDmePf8zF5Xw2ahjGJWsk/eQawzDqralr+qX4+tYOUuEc2rTxudKbgAair5wD/eQ86CvnQV9dnpoT6PHx8Tpy5Iiqqqp07NgxzZ8/Xy1atNCLL76o6dOn6/nnn9fAgQOvmhPozeVqCritpqn3LX3VfJpy39JPzYu+cg58/jkPq+zbywosDcNQamqqNmzYoIkTJ2r+/PmSJG9v74seeJWWlsrHx8esKSkpuWRNQ9q5sKbmtY+Pj7y9vR2mXazmcpSUlKqqqvrShZfBZuOLSnMqKjqt/59j/2T0VfOir5xDU/aTRF81J/6mnEdT/139mKury1V54vXCE+inT5/WunXr1LdvX11zzTWSpCFDhujuu+/WmjVrNHDgQE6g44rh89N50FfOg75yDvST87BKXzU6sKyurlZ8fLzeeOMNTZ8+XXPmzDHnBQQEqLCwUBUVFXJ3dzenf/vttwoNDTVrDh48WKvN/Px8/epXvzJrjh075lBTUlIiu92url271llT87pr167y8vLSddddV2dNQEBAY9+6qbm+SKB5GQZ95yzoK+dAPzkP+sp50FcNV9cJdB8fH4cBICXJ1dVVYWFhevvttyVxAv1SODHRfDjZ5zw42ec86CvnwOef82jOE+hSw0+iN/oZlikpKXrjjTcUHx/vEFZK0uDBg1VZWam9e/ea0/Ly8nTkyBENGjTIrDlx4oT5IHJJOnDggOx2uwYPHixJGjRokA4ePKiCggKzZufOnWrRooX69+9v1uzbt0/l5eUONX5+fgoMDDTXtXv3blVXVzvU3HLLLfL19W3sWwcAAIAFVFdX6/HHH9eGDRs0ffp0/f73vzfnHT58WK+88kqtZc6cOaNrr71W0sVPfNecQK/v5LjVTqA35w+aB33lPOgn50FfOQc+/5yHVY4xGhVY5ubm6vnnn9eQIUMUEhKizz//3Pz55z//qc6dO2v06NFasGCBXn31Vb377ruaNm2aevTooYiICEnng8Y+ffooJiZGb7/9trZv367HHntMkZGRCgoKkiSNGTNG1113naZOnaqdO3fqT3/6k5566imNGzdOfn5+kqTx48frzJkzmjZtmvbs2aPVq1dr3bp1evjhh+Xmdv7C0YceekhfffWVHn30Uf3tb3/T0qVLtWPHDj3yyCONedsAAACwkPpOoH/11VdatGiR/v73v5vTzpw5o/fff9888c0JdAAAAGtr1C3hO3fulGEY2rdvn/bt2+cwz8fHR5988omSk5O1dOlSpaamyjAMhYWFKSEhwXzWj81mU2ZmppYsWaKEhAS5u7tr5MiRio+PN9tq2bKlNmzYoCVLlmju3Lny8fHRhAkTHA5I/f39tXHjRiUnJys2NlZt27bV3LlzFRUVZdYEBQUpMzNTy5cv18yZM3XDDTcoJSVFI0eOvJx9BQAAgCvsYifQa7i6uioyMlLdunXT3Llz9dhjj6lVq1bKyspSWVmZpk+fLsnxBHpcXJwqKyuVkpJS6wT66tWrNXXqVM2ePVsFBQVatmxZrRPomzdv1rRp0xQdHa3c3FytW7dOcXFxDifQ77vvPj366KO699579dFHH2nHjh3KyMj4eXccAACAE2lUYDlz5kzNnDmz3hovLy8lJSUpKSmpzpq2bdsqPT293nYCAgKUlZVVb03v3r318ssv11szdOhQDR06tN4aAAAAOIeGnEDPysrS8uXLtXTpUpWWlqpfv37asmWLrr/+ekmcQAcAALC6yxolHAAAALgSGnICvV27dlq2bFm9NZxABwAAsK5GD7oDAAAAAAAAAM2FwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAMCpnDlzRitWrNDIkSMVEhKie+65R++88445/+zZs0pKStKQIUMUEhKi2NhYFRYWOrRx8uRJxcXFKTQ0VAMGDFBCQoLsdrtDTX5+vmJiYtSvXz+FhYUpNTVVlZWVDjW5ubmaPHmyQkJCNGzYMK1fv77W9ubk5Oi+++5Tnz59dMcdd2jbtm1NuDcAAACuPm5XegMAAACAxkhMTNR7772nRx99VDfeeKN2796tOXPmyGaz6c4779TixYu1Z88excfHq2XLlkpLS9P06dP12muvycXl/Pn6WbNm6fjx40pMTFR5eblSU1NVXFyszMxMSVJFRYWio6Pl5eWl1NRUnThxQsuXL1dlZaUWLlwoSSoqKlJ0dLSCgoK0cuVKHTp0SCtWrFCLFi0UFRUlSfryyy81bdo0RUZGKjY2Vh9++KGeeOIJtW7dWiNGjLgi+w8AAMDqCCwBAADgNIqLi7Vt2zYlJSXp/vvvlySFhYXp6NGj2rRpk3r27Knt27crPT1do0aNkiQFBQVp9OjR2rNnjyIjI5Wdna2cnBxt3bpVwcHBkqT27dsrKipKubm5CgoK0o4dO5Sfn6/du3fL399fkuTh4aHExETNmDFDfn5+2rJliwzDUGZmpjw9PRUeHq6KigqtXbtWkyZNkqurq9atW6dOnTpp+fLlstlsGjp0qEpKSrRq1SoCSwAAgDpwSzgAAACcRmlpqR588EHddtttDtO7du2q/Px87d+/Xy4uLgoPDzfnBQQEqFu3bvrggw8kSfv375e/v78ZVkpSaGiovL29zZrs7GwFBwebYaUkjRgxQpWVldq/f79ZExYWJk9PT4ea4uJiHTp0yKyJiIiQzWZzqPniiy9UVFTUVLsFAADgqkJgCQAAAKfRqVMnJSYm6vrrrzenVVVV6f3331fXrl31zTffqF27dg4hoiR17NhReXl5kqRvvvlGXbp0cZjv4uKiDh06mDV5eXm1anx9feXt7V1vTadOncx1lJWVqbCwUJ07d66zBgAAALURWAIAAMCpZWRk6Ouvv9bUqVNVWloqLy+vWjVeXl7moDoNqbHb7ZdVU/PabrebdXXVlJaWNup9/pjN1rw/aB70lfOgn5wHfeUc+PxzHlY5xuAZlgAAAHBaWVlZyszM1NSpUxUeHq6dO3fKVsfRcM2AO4ZhXLJG0k+uMQyj3pq6pl+Kr2/tIBXOoU0bnyu9CWgg+sp50FfOgX5yHlbpKwJLAAAAOB3DMJSamqoNGzZo4sSJmj9/viTJ29v7olculpaWysfHx6wpKSm5ZE1D2rmwpua1j4+PvL29HaZdrOZylJSUqqqq+rKWbQibzTpfVq42RUWn9f9z7CZBXzWfpuwr+ql50VfOgc8/59HUfXUhV1eXBp18JbAEAACAU6murlZ8fLzeeOMNTZ8+XXPmzDHnBQQEqLCwUBUVFXJ3dzenf/vttwoNDTVrDh48WKvN/Px8/epXvzJrjh075lBTUlIiu92url271llT87pr167y8vLSddddV2dNQEDA5e6CZv0igeZjGPSds6CvnAd95RzoJ+dhlb7iGZYAAABwKikpKXrjjTcUHx/vEFZK0uDBg1VZWam9e/ea0/Ly8nTkyBENGjTIrDlx4oQ5krckHThwQHa7XYMHD5YkDRo0SAcPHlRBQYFZs3PnTrVo0UL9+/c3a/bt26fy8nKHGj8/PwUGBprr2r17t6qrqx1qbrnlFvn6+jbRHgEAALi6cIUlAAAAnEZubq6ef/55DRkyRCEhIfr888/Nea6ururVq5dGjx6tBQsW6NSpU/Lx8VFaWpp69OihiIgISeeDxj59+igmJkZxcXGqrKxUSkqKIiMjFRQUJEkaM2aMVq9eralTp2r27NkqKCjQsmXLNG7cOPn5+UmSxo8fr82bN2vatGmKjo5Wbm6u1q1bp7i4OLm5nT/Mfuihh3Tffffp0Ucf1b333quPPvpIO3bsUEZGxs+74wAAAJwIgSUAAACcxs6dO2UYhvbt26d9+/Y5zPPx8dEnn3yi5ORkLV26VKmpqTIMQ2FhYUpISDAHy7HZbMrMzNSSJUuUkJAgd3d3jRw5UvHx8WZbLVu21IYNG7RkyRLNnTtXPj4+mjBhgsMVnf7+/tq4caOSk5MVGxurtm3bau7cuYqKijJrgoKClJmZqeXLl2vmzJm64YYblJKSopEjRzbvjgIAAHBiBJYAAABwGjNnztTMmTPrrfHy8lJSUpKSkpLqrGnbtq3S09PrbScgIEBZWVn11vTu3Vsvv/xyvTVDhw7V0KFD660BAADAf/AMSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMv4SYHlrl27NGDAAIdpR44cUWBgYK2flJQUs+bs2bNKSkrSkCFDFBISotjYWBUWFjq0c/LkScXFxSk0NFQDBgxQQkKC7Ha7Q01+fr5iYmLUr18/hYWFKTU1VZWVlQ41ubm5mjx5skJCQjRs2DCtX7/+p7xlAAAAAAAAAM3oskcJ/+yzzzR//ny5uDhmnrm5ufLw8NALL7zgMN3f39/8/8WLF2vPnj2Kj49Xy5YtlZaWpunTp+u1114z25s1a5aOHz+uxMRElZeXKzU1VcXFxcrMzJQkVVRUKDo6Wl5eXkpNTdWJEye0fPlyVVZWauHChZKkoqIiRUdHKygoSCtXrtShQ4e0YsUKtWjRQlFRUZf71gEAAAAAAAA0k0YHlhUVFXr++eeVnp6uVq1aqbq62mH+4cOHdfPNN6tv374XXf7o0aPavn270tPTNWrUKElSUFCQRo8erT179igyMlLZ2dnKycnR1q1bFRwcLElq3769oqKilJubq6CgIO3YsUP5+fnavXu3GYZ6eHgoMTFRM2bMkJ+fn7Zs2SLDMJSZmSlPT0+Fh4eroqJCa9eu1aRJk+Tq6trYtw8AAAAAAACgGTX6lvD3339f69atU1xcnCZOnFhr/uHDh9W9e/c6l9+/f79cXFwUHh5uTgsICFC3bt30wQcfmDX+/v5mWClJoaGh8vb2Nmuys7MVHBzscOXmiBEjVFlZqf3795s1YWFh8vT0dKgpLi7WoUOHGvvWAQAAAAAAADSzRgeWvXr10q5duzR58mTZbLZa8w8fPqzCwkLdc889Cg4O1ogRI/T666+b87/55hu1a9fOIUSUpI4dOyovL8+s6dKli+OGurioQ4cOZk1eXl6tGl9fX3l7e9db06lTJ3MdAAAAAAAAAKyl0beEt2vXrs55J0+eVEFBgdzc3DRv3jz5+vrqzTffVHx8vFxcXHT33XertLRUXl5etZb18vLS999/L0n11tQMvGO32y+rpub1hQP4NMZFctom0Vzt4rym3L/0VfOir5xDU+9b+qr58DflPNi/AAAAwE8YdOdiWrZsqQ0bNuimm25S+/btJUmDBw9WYWGhMjMzdffdd8swjItemSnJHHCnITWSmqymMXx9a4ekcA5t2vhc6U1AA9FXzoF+ch70lfOgrwAAAIAmDiw9PDw0ZMiQWtNvv/12JScn6+zZs/L29lZpaWmtmtLSUvn4nD9I9/b2VklJySVrGtLOhTU1r2tqGqukpFRVVdWXLrwMNhtfVJpTUdFpGUbTtEVfNS/6yjk0ZT9J9FVz4m/KeTT139WPubq6cOIVAAAATuHyLjOsw7Fjx/TSSy+prKzMYfrZs2fVqlUreXh4KCAgQIWFhaqoqHCo+fbbb9W1a1dJ5wfhOXbsmMP86upq5efn11tTUlIiu91eb03N65qay2EYzfeD5kNfOQ/6yjnwGeg86CfnwTEGAAAA0MSBZUlJif7whz9o9+7d5jTDMPRf//Vf6tevn6Tzt4hXVlZq7969Zk1eXp6OHDmiQYMGmTUnTpxwGMn7wIEDstvtGjx4sCRp0KBBOnjwoAoKCsyanTt3qkWLFurfv79Zs2/fPpWXlzvU+Pn5KTAwsCnfOgAAAAAAAIAm0KS3hPfq1UthYWFasmSJysrK1K5dO7366qs6fPiwXnrpJUlS586dNXr0aC1YsECnTp2Sj4+P0tLS1KNHD0VEREg6HzT26dNHMTExiouLU2VlpVJSUhQZGamgoCBJ0pgxY7R69WpNnTpVs2fPVkFBgZYtW6Zx48bJz89PkjR+/Hht3rxZ06ZNU3R0tHJzc7Vu3TrFxcXJza1J3zoAAAAAAACAJtCkqZ3NZlN6erpWrlypVatWqaSkRD169NDGjRsVHBxs1iUnJ2vp0qVKTU2VYRgKCwtTQkKCORCOzWZTZmamlixZooSEBLm7u2vkyJGKj48326gZ4GfJkiWaO3eufHx8NGHCBM2ZM8es8ff318aNG5WcnKzY2Fi1bdtWc+fOVVRUVFO+bQAAAAAAAABN5CcFlrNmzdKsWbMcprVu3VqLFi3SokWL6lzOy8tLSUlJSkpKqrOmbdu2Sk9Pr3f9AQEBysrKqremd+/eevnll+utAQAAAAAAAGANTfoMSwAAAAAAAAD4KQgsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAADgtHbt2qUBAwY4TDty5IgCAwNr/aSkpJg1Z8+eVVJSkoYMGaKQkBDFxsaqsLDQoZ2TJ08qLi5OoaGhGjBggBISEmS32x1q8vPzFRMTo379+iksLEypqamqrKx0qMnNzdXkyZMVEhKiYcOGaf369U28FwAAAK4ubld6AwAAAIDL8dlnn2n+/PlycXE8B5+bmysPDw+98MILDtP9/f3N/1+8eLH27Nmj+Ph4tWzZUmlpaZo+fbpee+01s71Zs2bp+PHjSkxMVHl5uVJTU1VcXKzMzExJUkVFhaKjo+Xl5aXU1FSdOHFCy5cvV2VlpRYuXChJKioqUnR0tIKCgrRy5UodOnRIK1asUIsWLRQVFdWMewcAAMB5EVgCAADAqVRUVOj5559Xenq6WrVqperqaof5hw8f1s0336y+fftedPmjR49q+/btSk9P16hRoyRJQUFBGj16tPbs2aPIyEhlZ2crJydHW7duVXBwsCSpffv2ioqKUm5uroKCgrRjxw7l5+dr9+7dZhjq4eGhxMREzZgxQ35+ftqyZYsMw1BmZqY8PT0VHh6uiooKrV27VpMmTZKrq2vz7SgAAAAnxS3hAAAAcCrvv/++1q1bp7i4OE2cOLHW/MOHD6t79+51Lr9//365uLgoPDzcnBYQEKBu3brpgw8+MGv8/f3NsFKSQkND5e3tbdZkZ2crODjY4crNESNGqLKyUvv37zdrwsLC5Onp6VBTXFysQ4cOXeYeAAAAuLoRWAIAAMCp9OrVS7t27dLkyZNls9lqzT98+LAKCwt1zz33KDg4WCNGjNDrr79uzv/mm2/Url07hxBRkjp27Ki8vDyzpkuXLg7zXVxc1KFDB7MmLy+vVo2vr6+8vb3rrenUqZO5jstlszXvD5oHfeU86CfnQV85Bz7/nIdVjjG4JRwAAABOpV27dnXOO3nypAoKCuTm5qZ58+bJ19dXb775puLj4+Xi4qK7775bpaWl8vLyqrWsl5eXvv/+e0mqt6Zm4B273X5ZNTWvLxzAp6F8fWuvE86hTRufK70JaCD6ynnQV86BfnIeVukrAksAAABcNVq2bKkNGzbopptuUvv27SVJgwcPVmFhoTIzM3X33XfLMAxd7MpMSeaAOw2pkdRkNY1RUlKqqqrqSxdeJpvNOl9WrjZFRadlGE3XHn3VfJqyr+in5kVfOQc+/5xHU/fVhVxdXRp08pXAEgAAAFcNDw8PDRkypNb022+/XcnJyTp79qy8vb1VWlpaq6a0tFQ+Pue//Hh7e6ukpOSSNQ1p58Kamtc1NZejOb9IoPkYBn3nLOgr50FfOQf6yXlYpa94hiUAAACuGseOHdNLL72ksrIyh+lnz55Vq1at5OHhoYCAABUWFqqiosKh5ttvv1XXrl0lnR+E59ixYw7zq6urlZ+fX29NSUmJ7HZ7vTU1r2tqAAAA4IjAEgAAAFeNkpIS/eEPf9Du3bvNaYZh6L/+67/Ur18/SedvEa+srNTevXvNmry8PB05ckSDBg0ya06cOOEwkveBAwdkt9s1ePBgSdKgQYN08OBBFRQUmDU7d+5UixYt1L9/f7Nm3759Ki8vd6jx8/NTYGBg0+8AAACAqwC3hAMAAOCq0atXL4WFhWnJkiUqKytTu3bt9Oqrr+rw4cN66aWXJEmdO3fW6NGjtWDBAp06dUo+Pj5KS0tTjx49FBERIel80NinTx/FxMQoLi5OlZWVSklJUWRkpIKCgiRJY8aM0erVqzV16lTNnj1bBQUFWrZsmcaNGyc/Pz9J0vjx47V582ZNmzZN0dHRys3N1bp16xQXFyc3Nw7FAQAALoajJAAAAFw1bDab0tPTtXLlSq1atUolJSXq0aOHNm7cqODgYLMuOTlZS5cuVWpqqgzDUFhYmBISEsyBcGw2mzIzM7VkyRIlJCTI3d1dI0eOVHx8vNlGzQA/S5Ys0dy5c+Xj46MJEyZozpw5Zo2/v782btyo5ORkxcbGqm3btpo7d66ioqJ+tn0CAADgbAgsAQAA4LRmzZqlWbNmOUxr3bq1Fi1apEWLFtW5nJeXl5KSkpSUlFRnTdu2bZWenl7v+gMCApSVlVVvTe/evfXyyy/XWwMAAID/4BmWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAAAAAAGAZBJYAAAAAAAAALIPAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDJ+UmC5a9cuDRgwwGGaYRjKyMhQeHi4+vTpoylTpujrr792qDl79qySkpI0ZMgQhYSEKDY2VoWFhQ41J0+eVFxcnEJDQzVgwAAlJCTIbrc71OTn5ysmJkb9+vVTWFiYUlNTVVlZ6VCTm5uryZMnKyQkRMOGDdP69et/ylsGAAAAAAAA0IzcLnfBzz77TPPnz5eLi2PmmZGRoeeee07z5s3TDTfcoNWrV2vKlCl6++235e3tLUlavHix9uzZo/j4eLVs2VJpaWmaPn26XnvtNbO9WbNm6fjx40pMTFR5eblSU1NVXFyszMxMSVJFRYWio6Pl5eWl1NRUnThxQsuXL1dlZaUWLlwoSSoqKlJ0dLSCgoK0cuVKHTp0SCtWrFCLFi0UFRV1uW8dAAAAAAAAQDNpdGBZUVGh559/Xunp6WrVqpWqq6vNeXa7XRs2bNDs2bM1adIkSVL//v01fPhwbdu2TZMnT9bRo0e1fft2paena9SoUZKkoKAgjR49Wnv27FFkZKSys7OVk5OjrVu3Kjg4WJLUvn17RUVFKTc3V0FBQdqxY4fy8/O1e/du+fv7S5I8PDyUmJioGTNmyM/PT1u2bJFhGMrMzJSnp6fCw8NVUVGhtWvXatKkSXJ1df3JOxAAAAAAAABA02n0LeHvv/++1q1bp7i4OE2cONFh3j/+8Q+VlZUpIiLCnHbNNddo4MCB+uCDDyRJ+/fvl4uLi8LDw82agIAAdevWzaHG39/fDCslKTQ0VN7e3mZNdna2goODzbBSkkaMGKHKykrt37/frAkLC5Onp6dDTXFxsQ4dOtTYtw4AAAAAAACgmTU6sOzVq5d27dqlyZMny2azOczLy8uTi4uLOnbs6DC9Y8eOysvLkyR98803ateunUOIeLGaLl26OG6oi4s6dOhg1uTl5dWq8fX1lbe3d701nTp1MtcBAAAAAAAAwFoafUt4u3bt6pxnt9vl6ekpNzfHZr28vMwBc0pLS+Xl5VVrWS8vL33//feXrKlpx263X1ZNzesLB/BpjAty2ibTXO3ivKbcv/RV86KvnENT71v6qvnwN+U82L8AAADATxh052IMw6hzXs1gOoZh1Loy83JqJDVZTWP4+tYOSeEc2rTxudKbgAair5wD/eQ86CvnQV8BAAAATRxY+vj46OzZs6qqqnIY0Ka0tNQcIdzb21ulpaW1li0tLZWPj49ZU1JScsmahrRzYU3N65qaxiopKVVVVfWlCy+DzcYXleZUVHRa9WTqjUJfNS/6yjk0ZT9J9FVz4m/KeTT139WPubq6cOIVAAAATuHyLjOsQ5cuXVRVVaXjx487TP/222/VtWtXSecH2CksLFRFRUW9NceOHXOYX11drfz8/HprSkpKZLfb662peV1TczkMo/l+0HzoK+dBXzkHPgOdB/3kPDjGAAAAAJo4sAwJCZGHh4d27txpTjt16pRycnI0ePBgSdLgwYNVWVmpvXv3mjV5eXk6cuSIBg0aZNacOHHCYSTvAwcOyG63m+0MGjRIBw8eVEFBgVmzc+dOtWjRQv379zdr9u3bp/LycocaPz8/BQYGNuVbBwAAAAAAANAEmvSWcC8vL02cOFFPP/20JKlz585as2aNWrdurXvvvdecNnr0aC1YsECnTp2Sj4+P0tLS1KNHD0VEREg6HzT26dNHMTExiouLU2VlpVJSUhQZGamgoCBJ0pgxY7R69WpNnTpVs2fPVkFBgZYtW6Zx48bJz89PkjR+/Hht3rxZ06ZNU3R0tHJzc7Vu3TrFxcXVGhgIAAAAAAAAwJXX5KndY489JpvNpvXr16u8vFy33nqrUlJSzGdYSlJycrKWLl2q1NRUGYahsLAwJSQkmAPh2Gw2ZWZmasmSJUpISJC7u7tGjhyp+Ph4s42WLVtqw4YNWrJkiebOnSsfHx9NmDBBc+bMMWv8/f21ceNGJScnKzY2Vm3bttXcuXMVFRXV1G8bAAAAAAAAQBP4SYHlrFmzNGvWLMcG3dw0f/58zZ8/v87lvLy8lJSUpKSkpDpr2rZtq/T09HrXHxAQoKysrHprevfurZdffrneGgAAAAAAAADW0KTPsAQAAAAAAACAn4LAEgAAAAAAAIBlEFgCAAAAAAAAsAwCSwAAAAAAAACWQWAJAAAAAAAAwDIILAEAAAAAAABYBoElAAAAAAAAAMsgsAQAAAAAAABgGQSWAAAAAAAAACyDwBIAAAAAAACAZRBYAgAAAAAAALAMAksAAAAAAAAAlkFgCQAAAAAAAMAyCCwBAAAAAAAAWAaBJQAAAAAAAADLILAEAAAAAAAAYBkElgAAAAAAAAAsg8ASAAAAAAAAgGUQWAIAAAAAAACwDAJLAAAAAAAAAJZBYAkAAAAAAADAMggsAQAAAAAAAFgGgSUAAAAAAAAAyyCwBAAAgNPatWuXBgwY4DDNMAxlZGQoPDxcffr00ZQpU/T111871Jw9e1ZJSUkaMmSIQkJCFBsbq8LCQoeakydPKi4uTqGhoRowYIASEhJkt9sdavLz8xUTE6N+/fopLCxMqampqqysdKjJzc3V5MmTFRISomHDhmn9+vVNuAcAAACuPm5XegMAAACAy/HZZ59p/vz5cnFxPAefkZGh5557TvPmzdMNN9yg1atXa8qUKXr77bfl7e0tSVq8eLH27Nmj+Ph4tWzZUmlpaZo+fbpee+01s71Zs2bp+PHjSkxMVHl5uVJTU1VcXKzMzExJUkVFhaKjo+Xl9f/au/O4Kur9j+NvQEQDTNTUrpbYAqiAG6JoSuB6WzU1fyqae+pVyUwyxbwuaZJLiuG+VZapqZV1NderuVG3zPLm0k1K0SvmluDCEb6/P3ww1yMgqBw52Ov5ePAoZj7zPd+ZjzPMfObMfD0VFxen48ePa9KkSbLZbBoxYoQk6dSpU+rRo4cCAgL09ttva9++fZo6darc3d3VrVu3O7exAAAAihAKlgAAAChS0tPTtXjxYk2bNk333HOPMjMzrXmpqalasGCBoqOj1aVLF0lSSEiIIiIitHLlSnXt2lW//fabVq9erWnTpqlly5aSpICAALVq1UqbN29W06ZNtXPnTiUmJurjjz9WYGCgJKlixYrq1q2b9u/fr4CAAH366adKTk7Wpk2bVL58eUmSh4eHRo8erX79+qlMmTJ6//33ZYxRQkKCSpQoofDwcKWnp2v27Nnq0qWL3Nzc7vDWAwAAcH48Eg4AAIAiZevWrZozZ45iYmIUFRVlN+/777/XhQsXFBkZaU279957FRoaqm3btkmSdu3aJVdXV4WHh1sxvr6+evTRR+1iypcvbxUrJal+/fry8vKyYnbu3KnAwECrWClJzZo1k81m065du6yYhg0bqkSJEnYxp0+f1r59+wpqkwAAANxVKFgCAACgSAkKCtLGjRvVtWtXubi42M1LSkqSq6urKleubDe9cuXKSkpKkiQdPnxYFSpUsCsi5hRTpUoVu/murq6qVKmSFZOUlJQtxsfHR15eXjeMeeCBB6zPAAAAQHY8Eg4AAIAipUKFCrnOS01NVYkSJVSsmP1prqenpzVgTlpamjw9PbMt6+npqZMnT+YZk9VOamrqLcVk/X79AD4347o6bYFyZNt/dgW9bcmV4xTktiVPjkWuigaOf0WHs2xbCpYAAAC4axhjcp2XNZiOMSbbNzNvJUZSgcXcDB+f7EVSFA1ly3oXdheQT+Sq6CBXRQN5KjqcJVcULAEAAHDX8Pb21uXLl5WRkWE3oE1aWpo1QriXl5fS0tKyLZuWliZvb28r5syZM3nG5Ked62Oyfs+KuVlnzqQpIyMz78Bb5OLiPBcrd5tTp87rBjX1m0auHKcgc0WeHItcFQ0c/4qOgs7V9dzcXPN185V3WAIAAOCuUaVKFWVkZOjYsWN2048ePaqqVatKujrATkpKitLT028Yc+TIEbv5mZmZSk5OvmHMmTNnlJqaesOYrN+zYm6FMY79gWOQq6KDPBUd5Kpo4PhXdDjLOQYFSwAAANw1ateuLQ8PD23YsMGadu7cOSUmJiosLEySFBYWJpvNpi1btlgxSUlJOnTokBo0aGDFHD9+3G4k7927dys1NdVqp0GDBtq7d69OnDhhxWzYsEHu7u4KCQmxYrZv366LFy/axZQpU0b+/v4FvwEAAADuAjwSDgAAgLuGp6enoqKiNHnyZEnSgw8+qFmzZqlUqVJq27atNa1Vq1YaPny4zp07J29vb02ZMkXVq1dXZGSkpKuFxpo1a6p///6KiYmRzWbTxIkT1bRpUwUEBEiSnnrqKc2cOVO9evVSdHS0Tpw4obfeeksdO3ZUmTJlJEmdOnXSe++9pz59+qhHjx7av3+/5syZo5iYmGwDAwEAAOAqzpIAAABwV3n55Zfl4uKiuXPn6uLFi6pTp44mTpxovcNSksaPH68JEyYoLi5Oxhg1bNhQsbGx1kA4Li4uSkhI0NixYxUbG6vixYurefPmGjZsmNVGyZIltWDBAo0dO1ZDhgyRt7e3OnfurMGDB1sx5cuX18KFCzV+/HgNGjRI5cqV05AhQ9StW7c7tj0AAACKGgqWAAAAKLIGDhyogQMH2k0rVqyYhg4dqqFDh+a6nKenp8aNG6dx48blGlOuXDlNmzbthp/v6+ur+fPn3zAmODhYS5cuvWEMAAAA/od3WAIAAAAAAABwGhQsAQAAAAAAADgNCpYAAAAAAAAAnAYFSwAAAAAAAABOg4IlAAAAAAAAAKdBwRIAAAAAAACA06BgCQAAAAAAAMBpULAEAAAAAAAA4DQoWAIAAAAAAABwGhQsAQAAAAAAADgNCpYAAAAAAAAAnAYFSwAAAAAAAABOg4IlAAAAAAAAAKdBwRIAAAAAAACA06BgCQAAAAAAAMBpULAEAAAAAAAA4DQoWAIAAAAAAABwGhQsAQAAAAAAADgNCpYAAAAAAAAAnAYFSwAAAAAAAABOg4IlAAAAAAAAAKdBwRIAAAAAAACA06BgCQAAAAAAAMBpULAEAAAAAAAA4DQoWAIAAAAAAABwGhQsAQAAAAAAADgNCpYAAAAAAAAAnAYFSwAAAAAAAABOg4IlAAAAAAAAAKdBwRIAAAAAAACA06BgCQAAAAAAAMBpULAEAAAAAAAA4DQoWAIAAAAAAABwGhQsAQAAAAAAADgNCpYAAAAAAAAAnAYFSwAAAAAAAABOg4IlAAAAAAAAAKdBwRIAAAAAAACA06BgCQAAAAAAAMBpULAEAAAAAAAA4DQcUrBMS0tTQECA/P397X4GDRokSTLGaMaMGQoPD1fNmjXVvXt3/fLLL3ZtXL58WePGjVOjRo1Uu3ZtDRo0SCkpKXYxZ8+eVUxMjOrXr6969eopNjZWqampdjHJycnq37+/6tatq4YNGyouLk42m80Rqw0AAAAAAADgNhVzRKMHDhyQMUZz5szRvffea00vXbq0JGnGjBmaN2+eXnnlFf3lL3/RzJkz1b17d33++efy8vKSJI0aNUqbN2/WsGHDVLJkSU2ZMkV9+/bVihUr5Op6tc46cOBAHTt2TKNHj9bFixcVFxen06dPKyEhQZKUnp6uHj16yNPTU3FxcTp+/LgmTZokm82mESNGOGLVAQAAAAAAANwGhxUsS5curfDw8GzzUlNTtWDBAkVHR6tLly6SpJCQEEVERGjlypXq2rWrfvvtN61evVrTpk1Ty5YtJUkBAQFq1aqVNm/erKZNm2rnzp1KTEzUxx9/rMDAQElSxYoV1a1bN+3fv18BAQH69NNPlZycrE2bNql8+fKSJA8PD40ePVr9+vVTmTJlHLH6AAAAAAAAAG6RQx4JP3DggPz8/HKc9/333+vChQuKjIy0pt17770KDQ3Vtm3bJEm7du2Sq6urXcHT19dXjz76qF1M+fLlrWKlJNWvX19eXl5WzM6dOxUYGGgVKyWpWbNmstls2rVrV8GtMAAAAAAAAIAC4bCCZXp6ujp16qSgoCA1adJEc+fOlTFGSUlJcnV1VeXKle2WqVy5spKSkiRJhw8fVoUKFVSiRIkbxlSpUsV+ZVxdValSJSsmKSkpW4yPj4+8vLysGAAAAAAAAADOwyGPhB88eFBubm6KiYlRdHS0tmzZoilTpshms8nNzU0lSpRQsWL2H+3p6WkNmJOWliZPT89s7Xp6eurkyZN5xmS1k5qammfMrXBxueVFC6VdXFWQ25dcORa5KhoKetuSK8dhnyo62L4AAACAAwqWmZmZeuedd1ShQgVVrVpV0tVHtS9cuKC5c+eqZ8+euS6bNZiOMUYuuZyx30yMpHzF3Awfn+wFUBQNZct6F3YXkE/kqmggT0UHuSo6yBUAAADggIKlq6urGjRokG1648aNtXTpUvn4+Ojy5cvKyMiQm5ubNT8tLc0aIdzLy0tpaWnZ2khLS5O3t7cVc+bMmTxj8mrnZp05k6aMjMxbWjYvLi5cqDjSqVPnZUzBtEWuHItcFQ0FmSeJXDkS+1TRUdD71bXc3Fy58QoAAIAiocDfYXnq1CktW7ZMKSkpdtMvX74s6eo7JDMyMnTs2DG7+UePHrW+kenr66uUlBSlp6ffMObIkSN28zMzM5WcnHzDmDNnzig1NdWKuRXGOO4HjkOuig5yVTRwDCw6yFPRwTkGAAAA4KBBd0aOHKlVq1bZTVu3bp0eeughhYeHy8PDQxs2bLDmnTt3TomJiQoLC5MkhYWFyWazacuWLVZMUlKSDh06ZH17MywsTMePH9e+ffusmN27dys1NdVqp0GDBtq7d69OnDhhxWzYsEHu7u4KCQkp8PUGAAAAAAAAcHsK/JHwsmXLql27dkpISJC7u7v8/Py0bt06ffnll0pISJCnp6eioqI0efJkSdKDDz6oWbNmqVSpUmrbtq01rVWrVho+fLjOnTsnb29vTZkyRdWrV1dkZKSkq8XImjVrqn///oqJiZHNZtPEiRPVtGlTBQQESJKeeuopzZw5U7169VJ0dLROnDiht956Sx07dlSZMmUKetUBAAAAAAAA3CaHjBL++uuvq3z58lqyZIlSUlL08MMPKz4+3io2vvzyy3JxcdHcuXN18eJF1alTRxMnTrTeYSlJ48eP14QJExQXFydjjBo2bKjY2FhrsBwXFxclJCRo7Nixio2NVfHixdW8eXMNGzbMaqNkyZJasGCBxo4dqyFDhsjb21udO3fW4MGDHbHaAAAAAAAAAG6TQwqWHh4eio6OVnR0dM4fWqyYhg4dqqFDh+bahqenp8aNG6dx48blGlOuXDlNmzbthn3x9fXV/Pnz89dxAAAAAAAAAIXKIe+wBAAAAAAAAIBbQcESAAAAAAAAgNOgYAkAAAAAAADAaVCwBAAAAAAAAOA0KFgCAAAAAAAAcBoULAEAAHDXSUtLU0BAgPz9/e1+Bg0aJEkyxmjGjBkKDw9XzZo11b17d/3yyy92bVy+fFnjxo1To0aNVLt2bQ0aNEgpKSl2MWfPnlVMTIzq16+vevXqKTY2VqmpqXYxycnJ6t+/v+rWrauGDRsqLi5ONpvNsRsAAACgCCtW2B0AAAAACtqBAwdkjNGcOXN07733WtNLly4tSZoxY4bmzZunV155RX/5y180c+ZMde/eXZ9//rm8vLwkSaNGjdLmzZs1bNgwlSxZUlOmTFHfvn21YsUKubpeve8/cOBAHTt2TKNHj9bFixcVFxen06dPKyEhQZKUnp6uHj16yNPTU3FxcTp+/LgmTZokm82mESNG3NmNAgAAUERQsAQAAMBd58CBAypdurTCw8OzzUtNTdWCBQsUHR2tLl26SJJCQkIUERGhlStXqmvXrvrtt9+0evVqTZs2TS1btpQkBQQEqFWrVtq8ebOaNm2qnTt3KjExUR9//LECAwMlSRUrVlS3bt20f/9+BQQE6NNPP1VycrI2bdqk8uXLS5I8PDw0evRo9evXT2XKlLlDWwQAAKDo4JFwAAAA3HUOHDggPz+/HOd9//33unDhgiIjI61p9957r0JDQ7Vt2zZJ0q5du+Tq6mpX8PT19dWjjz5qF1O+fHmrWClJ9evXl5eXlxWzc+dOBQYGWsVKSWrWrJlsNpt27dpVcCsMAABwF6FgCQAAgLvOgQMHlJ6erk6dOikoKEhNmjTR3LlzZYxRUlKSXF1dVblyZbtlKleurKSkJEnS4cOHVaFCBZUoUeKGMVWqVLGb7+rqqkqVKlkxSUlJ2WJ8fHzk5eVlxQAAAMAej4QDAADgrnPw4EG5ubkpJiZG0dHR2rJli6ZMmSKbzSY3NzeVKFFCxYrZnwp7enpaA+akpaXJ09MzW7uenp46efJknjFZ7aSmpuYZcytcXG550UJt+8+uoLctuXKcgty25MmxyFXRwPGv6HCWbUvBEgAAAHeVzMxMvfPOO6pQoYKqVq0q6eqj2hcuXNDcuXPVs2fPXJfNGkzHGCOXXM7YbyZGUr5iboaPT/YCKIqGsmW9C7sLyCdyVXSQq6KBPBUdzpIrCpYAAAC4q7i6uqpBgwbZpjdu3FhLly6Vj4+PLl++rIyMDLm5uVnz09LSrBHCvby8lJaWlq2NtLQ0eXt7WzFnzpzJMyavdm7WmTNpysjIvKVl88PFxXkuVu42p06dlzEF1x65cpyCzBV5cixyVTRw/Cs6CjpX13Nzc83XzVfeYQkAAIC7yqlTp7Rs2TKlpKTYTb98+bKkq++QzMjI0LFjx+zmHz161PpGpq+vr1JSUpSenn7DmCNHjtjNz8zMVHJy8g1jzpw5o9TUVCvmVhjj2B84BrkqOshT0UGuigaOf0WHs5xjULAEAADAXWfkyJFatWqV3bR169bpoYceUnh4uDw8PLRhwwZr3rlz55SYmKiwsDBJUlhYmGw2m7Zs2WLFJCUl6dChQ9a3N8PCwnT8+HHt27fPitm9e7dSU1Otdho0aKC9e/fqxIkTVsyGDRvk7u6ukJCQAl9vAACAuwGPhAMAAOCuUrZsWbVr104JCQlyd3eXn5+f1q1bpy+//FIJCQny9PRUVFSUJk+eLEl68MEHNWvWLJUqVUpt27a1prVq1UrDhw/XuXPn5O3trSlTpqh69eqKjIyUdLUYWbNmTfXv318xMTGy2WyaOHGimjZtqoCAAEnSU089pZkzZ6pXr16Kjo7WiRMn9NZbb6ljx44qU6ZM4WwgAAAAJ0fBEgAAAHed119/XeXLl9eSJUuUkpKihx9+WPHx8Vax8eWXX5aLi4vmzp2rixcvqk6dOpo4caL1DktJGj9+vCZMmKC4uDgZY9SwYUPFxsZag+W4uLgoISFBY8eOVWxsrIoXL67mzZtr2LBhVhslS5bUggULNHbsWA0ZMkTe3t7q3LmzBg8efGc3CAAAQBFCwRIAAAB3HQ8PD0VHRys6OjrH+cWKFdPQoUM1dOjQXNvw9PTUuHHjNG7cuFxjypUrp2nTpt2wL76+vpo/f37+Og4AAADeYQkAAAAAAADAeVCwBAAAAAAAAOA0KFgCAAAAAAAAcBoULAEAAAAAAAA4DQqWAAAAAAAAAJwGBUsAAAAAAAAAToOCJQAAAAAAAACnQcESAAAAAAAAgNOgYAkAAAAAAADAaVCwBAAAAAAAAOA0KFgCAAAAAAAAcBoULAEAAAAAAAA4DQqWAAAAAAAAAJwGBUsAAAAAAAAAToOCJQAAAAAAAACnQcESAAAAAAAAgNOgYAkAAAAAAADAaVCwBAAAAAAAAOA0KFgCAAAAAAAAcBoULAEAAAAAAAA4DQqWAAAAAAAAAJwGBUsAAAAAAAAAToOCJQAAAAAAAACnQcESAAAAAAAAgNOgYAkAAAAAAADAaVCwBAAAAAAAAOA0KFgCAAAAAAAAcBoULAEAAAAAAAA4DQqWAAAAAAAAAJwGBUsAAAAAAAAAToOCJQAAAAAAAACnQcESAAAAAAAAgNOgYAkAAAAAAADAaVCwBAAAAAAAAOA0KFgCAAAAAAAAcBoULAEAAAAAAAA4DQqWAAAAAAAAAJwGBUsAAAAAAAAAToOCJQAAAAAAAACnQcESAAAAAAAAgNOgYAkAAAAAAADAaVCwBAAAAAAAAOA0KFgCAAAAAAAAcBoULAEAAAAAAAA4DQqWAAAAAAAAAJwGBUsAAAAAAAAAToOCJQAAAAAAAACnQcESAAAAAAAAgNOgYAkAAAAAAADAaVCwBAAAAAAAAOA0KFgCAAAAAAAAcBoULAEAAAAAAAA4DQqWAAAAAAAAAJwGBUsAAAAAAAAAToOCJQAAAAAAAACnQcESAAAAAAAAgNOgYAkAAAAAAADAafwpCpYffvihmjdvruDgYHXo0EF79uwp7C4BAADgT4TzUQAAgPy76wuWK1eu1JgxY/Tss88qPj5e3t7e6tmzp44dO1bYXQMAAMCfAOejAAAAN+euLlgaYzRjxgx16tRJAwYMUHh4uGbOnKnSpUtr8eLFhd09AAAA3OU4HwUAALh5d3XB8tdff1VycrIiIyOtae7u7nr88ce1bdu2QuwZAAAA/gw4HwUAALh5d3XBMikpSZL04IMP2k1/4IEH9Ouvv8oYUwi9AgAAwJ8F56MAAAA3r1hhd8CRUlNTJUmenp520z09PXXlyhVdunRJJUuWvKk23dwcV+N1cbn632q+PrqUnuGwz/mzKVHcTZJUrJirCuqagFw5BrkqGhyRJ4lcOQL7VNHhqP3qWo48h0Huitr5qMR+7gj87Sw6+NtZdJCrooHjX9FxJ85Hpfyfx7iYu/i27meffaZXXnlFu3btko+PjzV9+fLlio2N1d69e+Xh4VGIPQQAAMDdjPNRAACAm3dX32r39vaWJKWlpdlNT0tLk7u7OyeHAAAAcCjORwEAAG7eXV2wrFKliiTpyJEjdtOPHDmiqlWrFkaXAAAA8CfC+SgAAMDNu6sLlr6+vrr//vu1ceNGa5rNZtOWLVsUFhZWiD0DAADAnwHnowAAADfvrh50x8XFRb1799bYsWPl5eWl2rVr6/3339e5c+f0wgsvFHb3AAAAcJfjfBQAAODm3dWD7mSZP3++3nvvPZ05c0bVqlXTa6+9ppo1axZ2twAAAPAnwfkoAABA/v0pCpYAAAAAAAAAioa7+h2WAAAAAAAAAIoWCpYAAAAAAAAAnAYFSwAAAAAAAABOg4IlAAAAAAAAAKdBwRIAAABAgWNsT+dFbvLmTNvImfqCnJGjoo8c5s+d3E4ULJ3IF198oa5du6p+/foKCQlRhw4d9Pnnn1vzV69eLX9/fyUmJubaRvPmzTV48OBc5588eVKjRo3S448/rsDAQDVq1EiDBw/Wzz//XKDrcquOHj0qf39/bdiw4bbbSk5OVv/+/VW3bl01bNhQcXFxstlsBdBLciUVbK6yXLlyRe3atdOiRYsKpD3yVLB5+vbbb9WlSxeFhIToscceU0xMjH7//fcC6CW5kgo2Vz/99JO6du2q2rVrKzw8XPHx8Rz/CpAjjn+StGrVKvn7++vo0aMF2i6QXytXrpS/v3+uPx07dsx3Wx999JHi4+Md2NubExkZqTfeeCNfsVn7+I1+IiMjb7tPx48fV48ePfTHH3/kGdulS5cb9mf58uX5+sw//vhDQ4YM0YEDB263+wVi9+7d8vf3108//ZSv+Pj4+DxzUxD/7jZs2KC///3vt7w8+9JVzrgvZSFHVzlzjvIjr77/+uuv+Wrn0KFD6tGjR4H27XbEx8crJCQk3/F5/Y3w9/fX7t27b7tfM2bM0NKlS2+7nfwqdsc+CTc0fPhwrVmzRp06dVKPHj3k4uKijRs36uWXX9bBgwc1ePBgtWjRQqNHj9Y//vEPhYaGZmtjz549+u233xQbG5vjZ6SlpalTp07y9PTU4MGDdf/99yslJUWLFi1Shw4dtGzZMj388MOOXtU7Ij09XT169JCnp6fi4uJ0/PhxTZo0STabTSNGjLittsmVY9hsNg0bNkw//PCDnnrqqdtujzwVrP/85z/q1q2bGjZsqMmTJ+uPP/7QtGnT1KtXL61YsULFit36nxNyVbD++9//qlu3bgoKClJ8fLySk5MVFxen1NRUvfbaa7fVNrlynJMnT2rChAmF3Q1AkrRw4ULdc8892aZ7eXnlu43Zs2eradOmBdmtO6Z8+fL66KOPrN+3bNmimTNn2m2X4sWL3/bn7Ny5U9u3b893fL169fTKK6/kOO/BBx/MVxs//fST1qxZo169euX7c51J+/bt1bhxY+v30aNHy9PT0267VKxY8bY/Z/HixfL29r7tdtiXnHNfuhY5cv4c5eWFF17QE088keO8+++/P19trF27Vj/88ENBduuOGjVqlFJTU63fO3TokG27PPLII7f9OfHx8bd9PXEzKFg6geXLl2vlypWaP3++GjVqZE0PDw+Xj4+PZs2apSeeeEL+/v5q3ry51q1bp9jYWLm5udm1s2bNGt1333167LHHcvycL7/8UkePHtX27dtVpkwZa/rjjz+u5s2ba9GiRRo7dqxjVvIO+/TTT5WcnKxNmzapfPnykiQPDw+NHj1a/fr1s1v/m0GuHGP//v0aNWqUDh8+XCDtkaeCt2TJEt13332Kj4+Xu7u7JKlKlSpq3769du7caXfxcDPIVcFbtmyZjDGKj49XyZIlJV0ths2dO1evvvqqXF1v7eEKcuVYY8aMUYkSJXTu3LnC7gqgwMBAlSpVqrC7UWiKFy+uWrVqWb//8ssvkgp/u5QqVcquX39GFStWtCtIenl5ydvb22m3S2H/mylszrovXcuZ+lIYikKO8vKXv/zFaY8Bd0pOxci7YbvwSLgTWLRokSIiIuwuALP06tVLnTt3VkZGhiSpdevWOnXqVLZH7TIyMvTFF1/o6aefznZxmOXUqVOSpMzMTLvpXl5eGjFihF3B4fz58xozZoz1OF7Dhg01cuRIXbhwQdL/vjq+ceNGde3aVcHBwWrZsqW2bt2qH3/8Ue3atVPNmjXVvn17HTx40Go3MjJSs2bN0quvvqpatWopPDxcs2fPvuH22bt3r7p06aLg4GA1bNhQEyZMUHp6+g2X2blzpwIDA61ipSQ1a9ZMNptNu3btuuGyN0KuCj5XkvTqq6+qZMmSWrFiRZ6x+UGeCj5PjzzyiHr06GEVKyXpoYceknT19Qu3ilwVfK6ioqK0aNEiq1gpSe7u7srIyMi2/jeDXDnm+Cddvav/9ddfa+DAgfmKBwrb3Llz5e/vr507d1rTpk6dqsDAQB08eFCRkZFKTk7Wu+++K39/fysmr/2kS5cuio2NVffu3RUcHKyJEycqPj5ezz33nD799FO1aNFCQUFB6tChg/bt22ctZ4zRwoUL9eSTTyooKEh16tRR7969lZSU5NDtcPjwYb344ouqXbu26tWrp9dee83upsOFCxc0YsQIPfbYYwoODlabNm305ZdfSrr6OGrWt1Tq1atXII+TXrlyRc8884yaN29ubddLly6pZcuW6tSpk3bu3KmuXbtKunqcHjZsmLXswoUL1axZMwUGBurpp5+2e+VF1rE06+9ASEiI9u7dq8jISM2dO1cjR45UvXr1FBISotjYWF26dMla9sSJE3r11VfVqFEj1ahRQ02aNNGkSZN05cqV217fG1m9erWefPJJBQYGqkWLFnbfIJOk77//Xp07d1bt2rUVGhqqQYMGWeczXbp0UWJiojZu3Ojw13SwL13lbPvStcjRVc6co7wcOXJEtWrV0tChQ61pP//8swIDAzVlyhTFx8drxowZOn/+vPz9/bVy5UpJUmpqqkaNGqWwsDAFBwerW7dudueLK1euVP369TVnzhyFhoYqMjJSv/zyi3Xu2aNHD9WsWVPh4eFauHChXZ/27Nmjnj17qm7dugoMDNQTTzyh1atXO3Q72Gw2TZkyRU2aNFFQUJDat2+vb775xi5m1apV1r+tJk2aaPz48bp8+bIkWf++J0yYUCCvCcgXg0L13//+1/j5+ZkPP/wwX/EZGRmmcePGZuTIkXbTt27davz8/MyBAwdyXXbfvn0mICDANGvWzMyfP9/s37/fZGZm5hjbp08fExkZadasWWN27txpZsyYYQICAsyMGTOMMcYcOXLE+Pn5mdDQULNw4ULz1VdfmTZt2pjQ0FDTvHlzs2zZMrN582bTuHFj065dO6vdiIgIU7duXdOzZ0+zZcsWM3XqVOPv72/mzJlj1+769euNMcYcOHDABAcHm549e5rNmzebpUuXmnr16pmXXnrphtvpueeeMzExMdmm16lTx7zzzjs3XDY35MoxucpaNoufn59ZuHBhnsvkhjw5Lk/X++STT4yfn5/ZvXv3TS9rDLm6E7lKTU01mzZtMqGhodm2280gV47L1ZkzZ0zDhg3NJ598YtavX2/8/PzMkSNH8lwOcISPP/7Y+Pn5mdOnTxubzZbtJ2tfvHLlimnTpo154oknjM1mM//+979N9erVzcyZM40xV/fjRo0amZdeesl89913xpj87SdRUVGmevXqZvz48Wbr1q3mxx9/NNOnTze1a9c2LVu2NJ9//rnZuHGjadGihWnRooW13Lx580xQUJB59913ze7du82yZctMgwYNTNeuXa2YiIgIM27cuNvaLufOnbOmpaSkmAYNGpi2bdua9evXm08++cQ8/vjjpkOHDiYjI8MYY8zw4cNNZGSk+eKLL8zOnTvNkCFDTEBAgPn555/NqVOnzNSpU42fn5/Zvn27OX78+A37EBUVZfr27ZtjXq5cuWLF7d2711SrVs0kJCQYY4x58803Tc2aNU1SUpI5f/68ef/9942fn59ZtWqV+fXXX40xxrz99tumRo0aJj4+3mzdutW8/vrrJiAgwGzZssUY879jXv369c0XX3xhVq1aZWw2m4mIiDB16tQxQ4cONV999ZVZsGCBCQgIMLNmzTLGXP1b8PTTT5vWrVub9evXmx07dpixY8dan2+MMbt27TJ+fn7m3//+9y3lJioqyvTr189u2vLly42/v78ZN26c2bZtm5kyZYoJCAgwH3zwgTHGmD/++MOEhoaawYMHmx07dpi1a9eaZs2ameeff94YY8yhQ4dM69atTefOnc13331nLl++fNP9Yl+68XYpzH2JHBWdHOWHn5+fWbBgQY45zOqbMcYsXLjQ+Pn5mW+++cZcuXLFtG/f3jz11FPm8uXL5vjx42b48OGmVq1a5rvvvjOnTp0yGRkZJioqyjRs2NAsW7bMbNy40URFRZnQ0FDz3//+19pW1apVM61btzbbtm0z69atsztezpgxw+zYscMMGzbM+Pn5mW+//dYYY0xycrKpWbOmeemll8z27dvN5s2bTffu3U21atWsc8Dp06ebunXr3tZ2uf6aeujQoaZWrVpm0aJFZsuWLWbgwIEmKCjIOv4mJiaagIAAk5CQYHbv3m2WLFligoKCzKRJk4wxxnz33XfGz8/PvPHGG2bfvn233LebQcGykH3//ffGz8/P/POf/8z3MnFxcaZ+/frGZrNZ02JiYkybNm3yXPbTTz81oaGhxs/Pz7qIGzp0qPnpp5+smEuXLpnu3bubr776ym7Zzp07mx49ehhj/nfiMmbMGGv+559/bvz8/MzixYutafPnzzfVqlWz+hoREWEiIiJMenq6FTNixAhTv359k5GRke0iMDo62rRo0cJuXbds2WL8/Pzs+ny9Fi1amNGjR2eb3rhxYzNx4sQ8t1NOyJVjcnW92y1Ykqc7k6fjx4+bRo0ameeffz7XYlJeyJVjc5WZmWlq1Khh/Pz8TGRkpDl69Giey+SGXDkuV0OHDjU9e/Y0xhgKlih0WRequf2sWbPGit23b5+pXr26mT9/vmnTpo1p27atXeHs+gvm/OwnUVFR1n6WZfr06dkKWqtXrzZ+fn5WwW3s2LFm9uzZdusybdo0U6NGjVz7cyvb5doL+Li4OBMaGmo37eDBg8bf3986NrRs2dLuxk16erqZMGGC2b9/f67t5iYqKirXvAQGBtrFTpgwwdSsWdNs2LDBVKtWze54d32B8OzZsyYoKMjEx8fbtREdHW2effZZY8z/jqUTJkywi4mIiDDPPPOM3bQXXnjBdOzY0RhjzLFjx0xUVJQ5ePCgXczjjz9ubZeCLlhmZGSYRo0amWHDhtnFxcXFmQYNGpj09HTrojureGCMMV9//bWZNm2a9W8vp0LozWBfuvF2Kcx96fq+kKOct4sz5Cg/bpTDrPNBY64eG9q2bWtat25tFixYYKpXr25+/PFHa/71BcKsfCUmJlrTLl++bMLDw80bb7xht04bN260YrKOl9du//T0dBMcHGymTp1qtd29e3e7fx+//fab8fPzM5999lmO/bmV7XLtNfXPP/9sd7PImKvXCu3btzf9+/c3xhgze/ZsU7t2bbubNCtWrDArV67MtV1H4x2WhSzrkThzE0PDt27dWvPmzbPeG3fp0iWtX79eL730Up7LPv3002rRooW2bdumbdu2aefOnfrkk0+0Zs0avfXWW3ryySfl4eGhBQsWyBijI0eO6PDhwzp48KCOHj2qBx54wK69oKAg6//Lli0r6er7LrKULl1aGRkZunDhgvUOjJYtW9o9Vtq0aVMtX75chw8floeHh137X3/9tVq1aiVJ1qMjDRo0kLu7u3bt2iV/f3/rEcQsWYN/uLi45LgNbvX9beTKcbkqSOTJ8Xk6ceKEunXrJkmaNGlSrvtaXsiVY3N15coVzZ49WxcvXlRCQoKef/55rVy5UhUqVMhzW12PXDkmV1u3btX69eu1Zs2aPLcJcCe9++67OQ5Cce3ALtWrV1f37t311ltvqVixYlq9enWur3qQ8t5PAgICJEm+vr7ZztWKFy9uzZdkvfIn6/UPWYN4nTp1Sv/5z3/0yy+/aMeOHbLZbDe97vn19ddfq3bt2rrnnnus9alataoqVaqkXbt2qVmzZgoJCdGyZcuUkpKiiIgIPf7443aPYd+s0NBQxcTEZJt+/faKjo7W+vXrNWDAAIWEhKhLly65tvn999/r8uXLatKkid1j2k2aNNE//vEPnT171ppWtWrVbMvXrFnT7vfy5cvr0KFDkq4OdvHee+8pIyNDhw8f1uHDh/XTTz8pNTXVYbk5fPiwTp48qfDw8GzrM2/ePB06dEiPPPKISpcurb59++rJJ59UeHi4wsLCbmpE3vxiX8pbYexL1yJHeSvsHOWle/fuevLJJ7NNv3bgLFdXV73xxhtq27at4uLi1LdvX9WoUSPXNr/++mt5enqqdu3a1jq7uroqLCws2yvm8jo2uru7y8fHRxcvXpR09f3v4eHhunTpkg4dOqTDhw/r22+/lSSH5THrNU05HeuzHlevU6eOLly4oGeeeUZ//etfFRERoeeee+6Wr/UKAgXLQpY1atWxY8dyjTlx4oTdBeajjz6q6tWr6x//+IcaN26sTZs2KT09Pd8jK3t4eKhZs2Zq1qyZJGnfvn0aPHiwxo0bp7/+9a9ydXXVhg0bNH78eCUnJ6tMmTKqWbOmSpQoka2tnEZPu/a9aTm577777H7PGlTh3Llzdu+clKSzZ8/q/fff1/vvv5+tnZSUFCUmJlrv4sly4MABeXl5KS0tLdsyaWlptzziH7lyTK4KGnlybJ5+/vln9erVSzabTQsXLsxWGLoZ5MqxuXJ3d7feN1mnTh09/vjjWr58uQYMGHDDPuaEXBV8rv71r39p1KhRGjRokCpUqKArV65Y7+3MzMxUZmbmLd9gA25XtWrV8jXYwlNPPaW5c+fqwQcflK+v7w1j89pPsuQ0MKKHh4fdBVPWvpF1E+Xnn39WbGysvvvuO91zzz2qVq1agYxqeyNnz57V999/n+MF78mTJyVdLSxUqFBBn3zyiTZv3ixXV1eFh4dr/PjxtzQApLe3t90NmNyULFlSzZo106JFi9S4ceMbXmxmFSTbt2+f4/zff//dOq5m3fC51vU3cFxdXe3eQfzRRx/p7bff1unTp1WhQgXVqlVLHh4eN3UD7GZkrU90dHSO80+ePKnq1avr/fff1zvvvKNVq1ZpyZIlKlWqlPr06aPevXsXaH/Yl/JWGPvStchR3go7R3mpWLFivo6N/v7+8vPz0759+xQeHn7D2LNnzyotLS3Hdb5+fXI6Nl5/PnrtsfHKlSuaMGGCli1bpitXrqhKlSrW4DiOPjaGhYXlOP/ixYsKCQlRQkKCFi5cqDlz5ighIUGVK1fW3//+91seYPV2UbAsZGXKlFFAQIC2bdumjh07ZpuflpamFi1a6P/+7//sho9/9tlnlZCQoNGjR2vNmjVq0qRJngeC559/XrVq1dLw4cPtpteoUUP9+vXTsGHDdObMGZ0/f14vvfSS2rVrp379+lkXoD179sz3AAI3cu2dWul/AyzktKN7eXmpZcuWOZ5ElStXTt7e3jkO1OLr66sjR47YTTtz5oxSU1NzvAOSH+TKMbkqaOTJcXnau3evevXqJS8vLy1ZsiTPk7W8kCvH5GrXrl3KyMiwGxynTJkyqlChgt1J8s0gVwWfq3379unYsWN688039eabb9rNa968udq0aZNtOuBMjDF644039NBDD+nXX3/V4sWL1aNHj1zj89pPblVmZqb69euncuXK6fPPP9fDDz8sFxcXzZ49W7t3777ldvPi5eWliIgI/e1vf8s2795775V09YJ14MCBGjhwoH755Rd9+eWXeueddzRt2jSNHj3aYX37z3/+ow8++ED+/v6aOXOmnnzySVWqVCnH2Kwb+TNnzsx2o0aSKleurN9///2W+pGYmGjdmOnYsaN8fHwkXf0Gu6Nkrc+YMWNUvXr1bPOrVKki6epNtbffflvp6en617/+pffee0+TJk1SaGhotm+NOhr7kvPuS1nIkfPnKD8+/vhj/fTTT3r00Uc1evRoLV++PNcn/ry9vXXfffdp5syZ2ebd7lOCs2bN0sqVKzVlyhQ99thjKlmypFJSUrRq1arbavdGvL295ebmpqVLl+Z4Eyur6B0ZGanIyEidP39e27Zt08yZMzV48GDt2LHD4YXxnHDr3gl06dJFmzZtsht5LMusWbN06dKlbF9xfvrpp5WWlqatW7fqq6++Ups2bfL8nEqVKunTTz/N8aQjKSlJ5cqVk4+Pj/7973/LZrOpT58+1gXgH3/8oR9++KFAKv5btmyxa2fDhg2qWLGidQJxrTp16ujw4cMKCgqyfsqUKaPJkycrKSlJXl5edvOy7qw0aNBAe/fu1YkTJ+w+x93d/bYe9yBXBZ8rRyBPBZ+no0ePqnfv3ipbtqw+/PDD2y5WZiFXBZ+r1atXa8SIEXZFu19//VXJycl2o1feLHJVsLmqUaOGVqxYYffz6quvSrpaOLiVb8ICd9Ly5cv1zTffaOLEierRo4emT59ud7P4+m8I57Wf3KrTp0/rt99+U4cOHfTII49YF2Lbt2+X5Lhvq2StT0BAgLU+VatW1dtvv60ff/xRmZmZevrpp7Vo0SJJ0kMPPaS+ffuqVq1aOn78uKRbf03RjRhjNHLkSD300EP68MMPVbZsWY0aNcqaf/1jrMHBwSpWrJjOnj1rl5sffvhBc+bMua0+7tmzR25ubnrxxRetYuWRI0d05MgRh+XloYceUunSpZWSkmK3PidOnFB8fLzS09O1fft2hYWF6fTp0ypevLjCwsI0YsQISf97kuBOfsOdfck596VrkSPnz1Fefv/9d8XFxaljx46aOnWqDh48qAULFljzc8rh6dOnde+999rlcfny5Vq7du1t9WXPnj0KCgpS8+bNrSd+duzYIcmxOczIyNDFixft1mfz5s1aunSp3NzcrFdISVcLnE888YR69Oih8+fPKzU1VdKdzyPfsHQCzz33nLZs2aIXX3xRXbp0UVhYmC5duqS1a9fqs88+09/+9jcFBwfbLVO2bFk1atRIcXFxKlmyZJ5faZauPhqxY8cOtW3bVt27d1e1atWUnp6uf/7zn/rggw80fvx4ubq6KiAgQG5ubnrrrbfUoUMHnTp1SnPmzNEff/xhvXfhdhw8eFCvvPKKWrdurW+++UarVq3SmDFjcozt16+fOnXqpCFDhujZZ5/VhQsXNGPGDJ07d87u3R7Xe+qppzRz5kz16tVL0dHROnHihN566y117Njxtr6STq4KPleOQJ4KPk9vvvmmzp8/r5EjR+r48ePWyYd0tcCU07cy8oNcFXyuunfvri+++EIDBw5UVFSUTp8+rfj4eFWpUkXPPffcLfedXBVsrrKKmNfKusnm5+enypUr3/Y6ALfqxx9/zPGdbtLV93KdPHlScXFxat++vYKDg/Xoo4/qs88+0+uvv269C6tUqVL64YcflJiYqHr16jnsPKFs2bK6//77tXDhQpUuXVouLi5avny59b6uixcv5rout6N79+5avXq1+vbtq86dO8vFxUVz5szRgQMHFBsbK1dXV9WqVUvvvPOOPDw89PDDD2vPnj3617/+ZX3bKOsx1LVr16phw4Z57vd//PGH9uzZk+M8Hx8fValSRR988IG+/fZbffDBB/L09NSIESPUt29fffLJJ3r22WetbyBu3LhRxYsX18MPP6xOnTrpjTfe0JkzZ1SjRg398MMPmjZtmp577rnb+kZNUFCQ9ehj8+bNdfToUb3zzjvKzMwskON0TooVK6Z+/fpp0qRJyszMVGhoqJKSkjR58mTVrFlT5cqVs9ZpwIAB6t27t9zd3fXuu++qVKlSql+/vqSrudm/f792796d6+tG8oN9KW+FsS9dixzlrbBzlJdjx47lemx84IEHVLZsWY0dO1bFihXTSy+9pFKlSqlr166aMWOGWrRoIV9fX5UqVUppaWnauHGjgoKCFBERoWrVqql3797Wkzxr1qzRihUrNHny5Nvqb2BgoObNm6clS5bokUce0Z49ezRz5ky5uLjo0qVLt9V2bqpXr66mTZtqyJAh+tvf/qaqVavqq6++0rx58/Tyyy9Luvqe5Pj4eMXGxurJJ5/UuXPnNGvWLNWtW9eqoZQqVUrffPONateufUe+jU7B0gm4urpq2rRp+vDDD7Vy5Up99NFHcnFx0SOPPKLp06fn+thE69atNXjwYEVFReXrZMLX11crV67UrFmz9N577yklJUXFixdXjRo1NGvWLDVp0kTS1Tsi48ePV0JCgvr06aP77rtPTZs21TPPPKPp06db1fVb1a5dO124cEEDBgxQhQoVNHbsWLVr1y7H2ODgYC1atEhTp07VgAEDVLJkSdWrV0+vvPKKdac2JyVLltSCBQs0duxYDRkyRN7e3urcubMGDx58W30nVwWfK0cgTwWbpytXrmjLli3KyMjQkCFDss1/7bXXrEF4bha5Kvh9yt/fX++++64mT56s6Ohoubu7KzIyUkOHDs3zvY03Qq6KxvEPKAjdu3fPdd7evXs1ZswYFStWzLrIKVmypIYPH64BAwbo448/Vtu2bfXCCy9owoQJ6t27t9atW+ew/cTFxUXTp0/XuHHjFB0dLW9vb9WuXVuzZ89Wnz59tGfPHjVs2PCW289NpUqVtGTJEk2aNElDhgyRm5ubgoODtXjxYuv1Q6+99po8PDw0a9YsnTp1SpUqVdKrr75qPSZav359hYaGasyYMXr++ef1+uuv3/Azv/76a3Xo0CHHeU888YSGDRumKVOm6LnnnlOdOnUkSREREYqMjNT48ePVuHFjPfroo2rVqpVmz56tH3/8UbNmzdJrr72mcuXK6YMPPrDeR/ziiy+qX79+t7WNwsLCFBMTo/fee0/Lly9XxYoV1bZtW50/f15r16512DeJunXrpnvuuUeLFi3S3LlzVbZsWetvkXT1gnvevHmaNGmSYmJiZLPZFBwcrIULF1oX5Z06ddKrr76qXr16afHixdb2vFnsS3krjH3pWuQob4Wdo7wsXrxYixcvznHe3//+d1WoUEFr167VxIkTrcLpgAED9Pnnn2vkyJF699131aJFC61cuVLR0dGKjo5W7969NX/+fE2aNElvvvmmLl68qKpVq2rKlCk5DvBzM/r06aMTJ05o+vTpstlsqlq1qiZMmKAFCxbou+++U+fOnW+r/dxMnTpVb7/9thISEnT27FlVrlxZI0aMsAZmCwkJ0eTJkzVnzhytWbNGHh4eatKkid3gSb169dKsWbOUmJioHTt2OGQQ3Wu5GEf9pQByEBkZqaZNm1qPXcB5kauigTwVHeSq6CBXAAAAQOHiG5YAAAAA/hQyMzPtRrHOiaura6G/b+3P6MqVK3nGuLm53XDUc9w57EvOjxwVfcYYZWRk5Bnn6G86Fpa7c60AAAAA4DrDhw/PcyTWNm3a6M0337xDPUKWGjVq5Bnz7rvvWu+ZROFiX3J+5KjoS0xMVNeuXfOMO3DgwB3ozZ3HI+EAAAAA/hSOHj2qM2fO3DDGx8eHga8KwQ8//JBnTNWqVeXl5XUHeoO8sC85P3JU9KWmpurw4cN5xl0/kOPdgoIlAAAAAAAAAKfBywoAAAAAAAAAOA0KlgAAAAAAAACcBgVLAAAAAAAAAE6DgiUAAAAAAAAAp0HBEgAAAAAAAIDToGAJAAAAAAAAwGlQsAQAAAAAAADgNChYAgAAAAAAAHAa/w94bqB7AAXF+AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'forward')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 124 , total number of selected features: 1\n",
      "Combined cost on test and validation data is 348203.73468571866\n",
      "Cost on external test data is 446593.8192818435\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'backward')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 124 , total number of selected features: 1\n",
      "Combined cost on test and validation data is 348203.73468571866\n",
      "Cost on external test data is 446593.8192818435\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'step')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 124 , total number of selected features: 6\n",
      "Combined cost on test and validation data is 521168.4357531353\n",
      "Cost on external test data is 282654.28401208844\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'recursive')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 124 , total number of selected features: 42\n",
      "Combined cost on test and validation data is 415339.17034445604\n",
      "Cost on external test data is 225627.7208027888\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = XGBRegressor(n_estimators=200,random_state=1,n_jobs=-1,tree_method = 'gpu_hist')\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'filter')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 124 , total number of selected features: 0\n",
      "Combined cost on test and validation data is 298761.3986472537\n",
      "Cost on external test data is 374254.7820061209\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'forward')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'backward')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'step')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 124 , total number of selected features: 5\n",
      "Combined cost on test and validation data is 443267.7681393625\n",
      "Cost on external test data is 269789.3740908789\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'recursive')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 4369 , total number of selected features: 596\n",
      "Combined cost on test and validation data is 103646728299.10315\n",
      "Cost on external test data is 113188526634.01526\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "patch_sklearn()\n",
    "\n",
    "#initialize model\n",
    "model_use = LinearRegression(n_jobs=-1)\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'filter')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 4369 , total number of selected features: 0\n",
      "Combined cost on test and validation data is 654857.9984719114\n",
      "Cost on external test data is 577396.1717633444\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'forward')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'backward')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'step')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           cutoff = 0.5,\n",
    "                                                                           sequence = 'recursive')\n",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unpatch_sklearn()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}