Chapter 5 - Putting Everything Together - Coupon Recommendation.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 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 precision_score(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):\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",
    "        model.fit(x_train,y_train)\n",
    "        \n",
    "        ### - obtain + filtered features + cost for test + cost for validation\n",
    "        \n",
    "        #filtered features\n",
    "        selected_features[i] = current_at_feature_subset\n",
    "        \n",
    "        #predict for test and validation\n",
    "        y_test_predict=model.predict(x_test)\n",
    "        y_validation_predict=model.predict(x_validation[current_at_feature_subset])\n",
    "        \n",
    "        #predict for external test\n",
    "        y_external_predict=model.predict(x_external[current_at_feature_subset])\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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coupon Recommendation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#'HotelCancellations', 'CouponRecommendation', 'PredictRoomBooking','CarSales'\n",
    "problem = 'CouponRecommendation'\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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 141 , total number of selected features: 141\n",
      "Combined precision on test and validation data is 0.6992499562767346 combined recall on test and validation data is 0.7244791817149933\n",
      "Precision on external test data is 0.7449131020882135 recall on external test data is 0.7790697674418605\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 = LGBMClassifier(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 = 'classification',\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",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'Precision',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 141 , total number of selected features: 141\n",
      "Combined precision on test and validation data is 0.7094701943466979 combined recall on test and validation data is 0.7098880146527706\n",
      "Precision on external test data is 0.7572848609420056 recall on external test data is 0.7399709302325581\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 = XGBClassifier(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 = 'classification',\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",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'Precision',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 198 , total number of selected features: 198\n",
      "Combined precision on test and validation data is 0.6015635691930095 combined recall on test and validation data is 0.7677954287483232\n",
      "Precision on external test data is 0.6327293522181333 recall on external test data is 0.8123546511627907\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABQ0AAAKrCAYAAABbZqvkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABu8ElEQVR4nO3debyWc/4/8PdplRYSg7EV5px2J1IqpCjGvoesJTSy72F81SA7lRZbpWyDYjAYWyP7MvYla4sYRpGKtH1+f/Trni6d6pw6p7rN8/l49OBc97V87s/7vu77c7/uaylIKaUAAAAAAPj/Kq3uBgAAAAAAaxahIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNgTJLKeXlutekbVKy31otfmvPBwBYvfJ9bOF7BOQXoSFrrPPPPz+Kiooy/xo1ahTbb799HH300fH888+vsrZ8+eWXUVRUFLfddluplzn//POjRYsWFdiqJd18882x4447RrNmzaJ3794Vso0HHnggLrroojVu3UcddVTsvffeq3Sbq0PHjh3jxBNPXCXb+vVruDR9vCL7SkTEjz/+GBdeeGE89dRTZdreqrCifX7zzTfH9ddfXwEtAoAlGTuX3aoYO5eXTz/9NI466qj4/vvvV3dTlvDKK69EUVFRPP7440udp6SxXnlZmXWX59gVfouqrO4GwLKstdZaMWLEiNzf8+fPj2+//TYGDRoUPXr0iNtvvz3atGlT4e343e9+F/fee2/8/ve/L/Uyf/rTn+KII46owFZl/fvf/45rr702dtlllzj++ONj/fXXr5Dt3HTTTfGHP/wh79a9Jm0zX11yySUxb968Cln3hx9+GPfff3/stNNOq2R7q8K1114bXbt2Xd3NAOB/iLFz6a2qsXN5eeyxx+LVV19d3c1YYSWN9fJh3WvSNmF1EBqyRqtUqVIUFxcvMb1p06bRuXPnVTbwqVatWontWJbNN988Nt9884ppUAl++OGHiIjo3LlzbL/99qtsu/zv2HrrrX/T2wOAfGfsXHrGzgDL5/Rk8tJmm20WdevWjUmTJkXEfw+Jv/POO2P33XeP5s2b5w4xnzp1alx00UXRrl27aNq0aeyzzz7x4IMPLrHOp556Kg477LBo0aJFtG3bNs4888yYMmVKRJR82Ppdd90V++yzT2yzzTbRqlWrOOmkk+Kjjz7KPV7SKRZvvPFGdOvWLVq3bh0tWrSIY445Jl5//fXMPEVFRXH77bdHv379cqdLHHbYYfGvf/1rqf0xYMCA2G+//SIionfv3lFUVBRffvllRER8/PHH0atXr9hxxx2jefPmceihhy5xGH3Hjh3jz3/+c/Ts2TOKi4vjwAMPLPH6HEVFRTFlypQYO3ZsZhul6eOvvvoqTj755GjXrl00a9Ys9thjjxg8eHDMnz9/mesuydtvvx1HH310tGjRInbaaae4+eabl5gnpRR33HFHHHDAAVFcXBxNmzaNP/7xjzF8+PDlPp+33norTjrppNhhhx2iSZMm0bZt2zjnnHNi6tSpS21TRMScOXNi4MCBsddee0Xz5s2jefPmsf/++8fDDz+cm2fRa/W5556LU089NbbddtvYdttt49RTT41vvvkms75//vOfccghh8Q222wTu+22W9x///3L3H5ExPHHHx8dO3Zcon733XdfFBUVxSeffBIREZ999lmceeaZseOOO0aTJk2idevWcfLJJ8eECROWuu5fny6cUorhw4dH586do1mzZnHwwQfH22+/vcRy33zzTVx88cXRoUOHaNq0aWy33XZx3HHHxTvvvBMREaNHj46jjz46IiJOO+20OOqoo0rcXkTEM888E4cffni0bNkyWrZsGT179ozx48fnHl+0rz744IPRu3fvaN26dWyzzTbRvXv3+Oyzz5bbf6Xp8+XVeVEbIiLuvPPO3P8vWv+xxx4b22+/fTRp0iTat28fffr0iVmzZi23bQCwooyds1bV2DkiYt68eTFo0KDo3LlzNG3aNDp06BDXX399zJkzJyIifvrpp9h9992jXbt2uSAzImLw4MFRVFQUjz32WJx//vkxcODAiIho06ZNDBgwINOve++9dzRr1ix23HHH6NOnT8ycOTP3+OjRo6OoqCgeeOCB2GWXXaJFixbx6KOPxoABA6J169bx+uuvR5cuXaJ58+bRrl27uPLKK2Pu3Lm55Uszvl2epY31IiJeeumlOOqoo6K4uDi23Xbb6NmzZ3z++eeZ5Z944ok48MADo0WLFrHtttvGMcccE6+88spy1/1rFT12Lc33D8g7CdZQ5513XiouLi7xsalTp6aGDRumY489NqWU0ssvv5wKCwtTy5Yt0wMPPJCefPLJ9MUXX6Tp06enTp06pXbt2qW77747Pffcc+niiy9OhYWFadiwYbn1jR49OhUWFqaTTz45PfPMM+nRRx9Nu+22W9ptt93STz/9lCZPnpwKCwvTrbfemlJK6dFHH02FhYXp+uuvTy+//HJ6/PHH05577plat26dZs2aVWL7H3300VRUVJS6deuWnnzyyfT444+nww47LDVu3DiNHTs2N9+i53HiiSemsWPHpsceeyx16NAhtWrVKs2ePbvE/vj666/TmDFjcm1688030y+//JJef/311LRp03TAAQekRx99ND3zzDPppJNOSoWFhenee+/NLd+hQ4fUuHHj1Lt37/Tiiy+mZ555psTtvPnmm6ldu3bpsMMOy22jNH08f/78tOeee6a99947PfHEE+nll19O11xzTSosLExDhw5d6rpLMn78+NSsWbN00EEHpSeffDI98sgjqXPnzqlx48Zpr732ys133XXXpcaNG6dBgwall19+OT311FOpW7duqbCwMP3zn/9c6jY//vjj1KRJk3T88cenZ599Nr344otpwIABqVGjRun0008vsU2LnHnmmam4uDiNHDkyvfLKK+mxxx5LBx54YCoqKkqffPJJSum/r9VWrVqlfv36pRdffDGNHDkyNWvWLPXo0SO3rueeey41bNgwde/ePT377LPpvvvuS+3atUuNGjVKJ5xwwlLbsOi1+eqrr2amH3HEEemggw5KKaX03Xffpe233z4dcsgh6R//+Ed6+eWX07Bhw1JxcXE65JBDcsv8+jV85JFHLtHHRUVF6bLLLkvjxo1LAwYMSM2bN8/sK7Nnz0677bZb2n333dPDDz+cXnnllXTPPfektm3bpvbt26c5c+akqVOnplGjRqXCwsI0ZMiQXF/9enu33nprKiwsTGeeeWZ69tln09/+9re05557puLi4vTBBx+klFJuX23ZsmU6//zz07hx49Lo0aNTq1atMusqSWn7fHl1/uWXX9Kbb76ZCgsL0ymnnJLefPPNlFJK48aNS0VFRemcc85J48aNS88//3z6y1/+kgoLC9PVV1+9zLYBwPIYO695Y+eUUjrllFNSkyZN0o033pief/75NHTo0NSsWbP0pz/9KTfP22+/nRo3bpzOOuuszN8XX3xxSimliRMnpt69e6fCwsL03HPPpa+//jqllFK/fv1SUVFR6tu3bxo3blwaNWpUatWqVTr44INzY+kHHnggFRYWpp133jk9/vjj6W9/+1uaOnVq6t+/f2rSpEnaaaed0vDhw9NLL72U+vTpkwoLC9Mtt9ySa1tZxrePPfbYUl9/JY31nnrqqdSwYcPUrVu39NRTT6VHHnkk7bvvvqlVq1Zp0qRJKaWUXn/99dSoUaN08cUXpxdffDE9++yz6bDDDktNmjRJU6ZMWeq6S1LRY9fSfP+AfCM0ZI21aOAwd+7c3L8ZM2akt99+Ox199NGpsLAwPfXUUyml/35Q9e3bN7OO/v37p4YNG6b3338/M/3iiy9OxcXFafr06WnBggVpp512Soceemhmnrfffjt16NAhvfLKK0sMfP785z+n4uLizEDkgw8+SNdcc0365ptvMu1PKeW2sd9++6X58+fnlvnll19Sp06dUufOnXPTCgsL0+67756Zb9HA7Pnnn19qf33wwQepsLAwPfDAA7lpXbp0Se3atcsNxhbp2rVr2m677dJPP/2UUkq5gdXcuXOXuv5FOnTokAlQStPH//nPf1JhYWG66aabMvMMGTIkPfzww0tdd0nOOOOMtN1226UffvghN+3LL79MTZo0yYRCZ511Vrrxxhszy06bNi0VFhamfv36LXWbDz74YDryyCPTzz//nFn2xBNPTK1atVpqu3755Zd0/PHHp7vuuisz/d13302FhYVp5MiRKaX/vlYvvPDCzHznn39+Kioqyg3wDj300LTrrrtmavLGG2+kwsLCZfbRL7/8klq1apUuuuii3LRJkyaloqKidOedd6aUUnr++efTYYcdlv79739nll00UJw5c2ZKadmh4YwZM1KTJk3SOeeck1nH4MGDM/vKhx9+mLp27ZreeeedzHy33XZbKiwsTOPHj8/0y+KDzcW3N3369NS8efN00kknZdYzbdq0tP3226fjjjsupfTf0HDRl6JFBgwYkAoLC9MXX3yx1L4rTZ+Xts4pLdyXL7300sxz7tmz5xLb3XvvvdMBBxyw1HYBQGkYO695Y+dF/Tx8+PDM9IcffniJ9i0aqzz22GOpU6dOae+99870V//+/VNhYWGaOnVqSmnh+K5hw4bpsssuy6z7X//6VybkXBQaLh76Lr6+hx56KDO9Y8eOqUuXLimlso9vlxYaljTPggULUocOHdIBBxyQqd2MGTNS69at05lnnplSSmno0KGpsLAwF5SmlNJXX32V+vXrlz799NNSb39VjF1L+/0D8olrGrJG++mnn6JJkyZLTN94443jL3/5S+y6666Z6Y0bN878/cILL8Smm24ahYWFmRsq7LrrrnHvvffGa6+9FltuuWV88803cdxxx2WWbd68eTzzzDMREUucKtumTZu45557Yq+99opOnTpF27Zto3Xr1nHWWWeV+Dw+//zz+Oabb+Loo4+OSpX+e1WAatWqxd577x033XRTfPXVV7mLRbdo0SIz30YbbRQRUaZTGH/++ed466234vDDD4+1114789gBBxwQvXv3jvfeey93DZfCwsKoUqXsbwml6eOOHTtGYWFhDBw4MN5///1o27Zt7Lzzzit0R9pXX301WrVqFeuss05u2iabbBLFxcWZUzquueaaiIiYPn16TJgwISZPnhzvvfdeRETudJCS7LfffrHffvvFnDlz4rPPPotJkybFp59+Gp999tkyl6tWrVrccsstEbHwtJ5F21x06sSvl91uu+0yf2+00UaRUoqffvopFixYEG+//XYcddRRmZpsu+22y72geLVq1WKfffaJhx56KC6++OKoVq1aPPTQQ7nXWkREu3btol27djF//vyYMGFCTJo0KT7//PPcaTxz5syJmjVrLnM7b775ZsydOzc6d+6cmb7XXntl7hjcsGHDGDVqVKSU4ssvv4xJkybFhAkT4tlnny2xX5a1vdmzZ8e+++6bmV63bt3o0KFDPProo7lT3SNK7t+Ipe9Ds2fPLlWfl7XOi+vWrVt069YtZs+enVvu448/jqlTp0a9evVK0w0AsEzGzgutKWPnF154ISIidtttt0x/7rLLLlGpUqV47rnnol27dhER0bNnz3j++efjjDPOiOrVq8cDDzwQ1atXX+q6X3zxxViwYMES627WrFlssMEG8dxzz8Whhx6am96oUaMS11PSmOnHH3+MiJUb9yzPhAkTYsqUKXHggQfGggULYsGCBRGx8GY+bdq0iXHjxkVEROvWraNy5cpx8MEHR+fOnaNt27bRpk2bOO+888q0vVUxdl3R7x+wJhMaskZba621YtSoUbm/q1atGnXr1o0NN9ywxPl//QE/bdq0mDRpUomDp4iFd02rW7duRESZvrTvscceMXDgwLjzzjtj5MiRcfvtt0fNmjXjwAMPjHPPPTeqVauWmX9RmLXBBhsssa5F02bMmJGbVqNGjcw8iwZBiz5MS+PHH3+MlFKpt/nrviut0vRxQUFBDB8+PIYOHRpPPvlk7rowTZo0id69e0fLli1Lvb0ffvgh1ltvvSWmb7DBBpnQ8KOPPoq//OUv8dprr0XVqlWjfv36se2220ZELPWaMxELP9CvvPLKeOCBB+Lnn3+ODTfcMBo3blyq/nnllVfiiiuuiA8//DCqV68eW221VRQWFpa4zWXVePr06ZFSWurzXJ6DDjooRo4cGc8++2zsvvvu8be//S122223qFOnTq4tAwcOjJEjR8b06dNjvfXWi0aNGuXatKz+WWRRXy/afxb53e9+t8S8d955ZwwZMiS+/fbbqFOnThQVFZVpWxELB18RS9+H5s6dGz///HNuWln3obL0eVnqvLgff/wxLr300njiiSdi3rx58fvf/z6aNWsWa621Vqn7AQCWxdh5oTVl7Dxt2rSIWHgNxJL8+9//zv1/5cqV44ADDog333wzttpqq2jQoEGp1r20a/gtvu5ltbekvlt8XLKi457lWdT+AQMGZK7RuLiff/45ttlmmxg+fHgMGzYsRo8eHXfeeWdUr1499thjj7j44oujdu3apdreqhi7ruj3D1iTCQ1Zo1WqVCmaNWu2wssvepO/7LLLSnz897//fXz//fcR8d8PrsWNHTs296H4a506dYpOnTrF7Nmz41//+leMHj06Ro4cGRtvvHF07949M++6664bERH/+c9/lljPoptf/PoDbGXVrl07KlWqVOHbLE0fRywcWPbu3Tt69+4dkyZNinHjxsXQoUPj5JNPjnHjxi0xWFyaunXrxnfffbfE9EV1jIiYOXNmdOvWLTbaaKN44IEHoqioKKpWrRo//fRT3Hvvvctc/2WXXRZjxoyJPn36xK677pobiJx66qm5i4eXZPLkyXHiiSdGy5Yt49FHH40tt9wyKlWqFJ988kmJFw9f3nOsVKnSUp/n8urWqFGjaNSoUTzyyCOx4YYbxsSJE+PPf/5z7vFbbrklBg4cGL1794599tknF5RdeeWV8cYbb5SqjYuW+XUbF69DRMTf//736NOnT/To0SOOOuqo3JeWO++8M5577rlSbSsickeWLu31XK1atahVq1YmOC6L0vb5ytT5zDPPjPfeey934fFFg/eDDjoofvnllxVqNwAszth5xVXE2LlOnTpRUFAQd911V1StWnWJxxc/c+abb76J6667Lho3bhzvv/9+3HrrrXHCCScsc90REQMHDswdWbm4X4eBK6I8x7e/tui5n3TSSbHbbruVOM+i7wetWrWKVq1axdy5c+Ptt9+Oxx9/PEaNGhW1atXKjHGXpaLHrivz/QPWZO6ezG9a69atY/LkyfG73/0umjVrlvs3ceLE6N+/f0yfPj223HLLWH/99ePJJ5/MLPvhhx/GiSeemDv8fnG9e/eOQw45JFJKsdZaa0Xbtm2jX79+Ubly5fjqq6+WmL9Bgwax4YYbxiOPPJL5xXPu3Lnx6KOPRoMGDUr8lWtlrL322rHNNtvEk08+GT/99FPmsYceeihq16691F+Rl2XxUz8iStfHH330Uey0007xj3/8IyIiNt988+jatWscfPDB8cMPP+ROHfn1ukvSrl27eOWVVzIf+FOnTs3c+ezzzz+PqVOnxuGHHx5NmzbNDdIWnVaweA1+vc3XXnstmjZtGvvvv38uMJwxY0a88cYby/y1+t13342ff/45unfvHltvvXVuvSVtc3mqVasWLVu2jKeeeioTJo0fP36Zd5Ve3EEHHRTjxo2L0aNHx0YbbRRt27bNPMeNNtoojjnmmNwAau7cufH8889HROl+CW3RokXUqFEjHn300cz0p59+OvP3q6++GpUqVYpTTz01c5TDon5ZtK3KlSsvd3trrbVW/O1vf8tM/+GHH2Ls2LHRqlWr5bZ5WUrb52Wpc0mvrZ122ik6dOiQCwynTJkS48ePL9PrAwAqirFz+Y6dW7duHSml+OGHHzL9WbNmzbjmmmtyd49OKcX5558fEQt/3D3ssMOif//+8f777+fWVdIYPGLhEYWLr3vTTTeN6667Ll577bUy98Gvlef49tdjvS233DI22GCD+PzzzzPtb9asWdx5553xwAMPROXKlWPAgAHRsWPHmDNnTlStWjVatmwZF110UWy88ca5187yxpERFT92Lcv3D8gnjjTkN61bt27x8MMPxzHHHBMnnHBCbLLJJvHOO+/EwIEDo3HjxlG/fv2oVKlSnHnmmdG7d+8488wzY7/99ouZM2fGjTfeGH/4wx9i9913X+KX1B133DEeeOCBOOecc2K//faLgoKCuP/++yMi4o9//OMS7ahUqVKcd955cdZZZ0WPHj3i8MMPj5RSDB8+PL788ssYNGhQhTz/s88+O4499tg46qijonv37rH22mvHfffdF6+99lr8+c9/LvXRfYurU6dOfPbZZ/HKK69E8+bNS9XHKaVYZ511ok+fPvHDDz9E/fr1Y8KECXHXXXfFjjvumPvV9tfrLukX0pNPPjmeeuqpOPbYY6NXr15RUFAQgwcPznwQb7nlllGnTp0YPnx4rLvuulGrVq147bXX4rbbbouCgoLMaay/3mZxcXE89NBDMWzYsGjSpElMmTIlbr/99pg6dWpERMyfP7/EgcmiwUH//v1jzpw5UaVKlRg7dmzcddddERGZbZbGWWedFUceeWR069YtunfvHjNnzowbbrih1DXbZ5994qqrror7778/evTokRloFhcXx3PPPRfXX399tGvXLr777rsYOXJkfPLJJxGx8HpIyzvlaO21147TTz89rrjiirjoootijz32iPHjx+eue7P4tu6+++7o06dP7L333jFz5sy4//77cwHlokH5ol/LX3zxxdhiiy2WuO5OnTp14uSTT45rr702zjrrrNh3331jxowZMWTIkPjll1/ijDPOKFW/LEtp+rwsda5Tp068//778dprr8V2220XxcXF8fTTT8d9990XW2yxRXz22Wdx8803x7x588r8+gCAimDsXL5j55133jl23HHHOO+88+KEE06IZs2axddffx0DBgyI2bNn544KHTFiRLz44otx9dVXx/rrrx/nnHNOPPfcc3H22WfHmDFjYq211sodmffkk09G27ZtY+utt45DDz00rr766vjuu++idevW8cMPP8TQoUNj0qRJcfbZZ690f5Tn+Laksd65554b55xzTpx11lmx9957R+XKleO+++6Lf/zjH3HppZdGRETbtm1j8ODB0bNnzzjyyCNjrbXWiieffDK++uqr3DUxlzeOjKj4sWtZvn9APhEa8ptWr169+Otf/xo33nhjXHvttTF9+vTYcMMNo2vXrnHyySfngpSDDjooatWqFTfffHP06tUr1llnndhpp53izDPPjLXXXnuJgc+ee+4Zc+bMiTvuuCNOO+20WLBgQTRq1CiGDBmy1Ovz7bXXXlGrVq0YOnRonHXWWVGlSpUoLi6OkSNHlumafmXRsmXLuPPOO6N///5x0UUXRUopGjZsGDfddNNSTwNYnuOPPz4uu+yyOP7442PYsGHRsmXLUvXxrbfeGjfccEMMHDgwpk2bFuutt17svffecdpppy1z3b+22Wabxd133x1XXXVVXHDBBbHWWmvFoYceGltttVWMHz8+IiJq1aoVQ4YMiauvvjp3nZz69evHZZddFo888ki8/vrrkVKKgoKCJbZ5/vnnR0opbrnllpg1a1ZstNFG0aFDhzj22GOjd+/e8frrr+d+2V3c5ptvHjfeeGP0798/Tj311KhZs2ZsvfXWcfPNN0e/fv3K/GtvcXFxDB8+PK6//vo444wzYt11143u3bvHY489Vqrl11133dh1113jscceiwMPPDDzWI8ePWLGjBkxZsyYGDZsWGywwQbRpk2bOPHEE+PEE0+M1157LTbbbLPlbuPYY4+NmjVrxrBhw+Khhx6K+vXrx7XXXhvdunXLzbP//vvHN998E/fee2889NBDUa9evSguLo677rorjjjiiHjttddihx12iK233jr23nvvePDBB+P111+Pv//970ts74QTTogNN9wwRowYEb169Yq11147tt9++7j22mujqKioVP2yLKXp87LUuWfPnjFo0KDo0aNHPPLII3HllVfGZZddFtdcc03MmTMnfv/738chhxwSlSpVihtuuCEmT55cqn4HgIpi7Fy+Y+dFP24PHjw416/rrrtutG7dOk499dTYeOONY/z48XHttddGx44dczd8q1mzZvTt2ze6desWV155ZVxyySXRuXPnePDBB6Nv375x4IEHRp8+feLSSy+NrbbaKu6777647bbbolatWlFcXByXXXbZCp1R9GvlOb4taay37777xjrrrBM333xznHHGGVGpUqXYeuut44YbbsiFydttt10MHjw4hg4dGueee2788ssvsdVWW8VVV12Vu8lfacaRERU/di3t9w/IJwXJFTkBAAAAgMW4piEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACAjCqruwEr4scff4758xes7masEerWrRnffz9rdTeDUlCr/KFW+UGd8oda/VflypWiTp0aq7sZlAPj0f+yj+cPtcofapU/1Co/qFNWacekeRkazp+/IObNM0grKFj43/nzF0RKq7ctLJta5Q+1yg/qlD/Uit8q49GF7OP5Q63yh1rlD7XKD+q04pyeDAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgIwqq7sBAAAA+a6gYHW3YNkWtW9Nb+ciKa3uFgAgNAQAAFgJ66yzdlSrVnl1N6NU6tWrvbqbUCpz5syP6dN/Wt3NAPifJjQEAABYQQUFEdWqVY5j+zwRP82et7qb85uw9lpVYvifd4+CAkcc/i/Lh6Ni8+kIXvsSK0JoCAAAsJJ+mj0vfv5FaAjlIZ+O3o3IjyN4Hb3LihAaAgAAAGsER++WP0fvsqKEhgAAsIZa0095y6dT8yJ8WSY/Xqv2q4UcvZs/1vTXqn1qxQkNAQBgDZRPp+flw6l5EU7P+1+XT/tUhP2K/JBP+5V9quyEhgAAsIZxel75c3re/zb7VMWwX/1vs1+VvzVtnxIaAgDAGsrpeVC+7FNQ/uxXv12VVncDAAAAAIA1i9AQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGRUWd0NWFMVFKzuFizfojbmQ1sjIlJa3S0AAAAAoDSEhiVYZ521o1q1yqu7GaVWr17t1d2EUpkzZ35Mn/7T6m4GAAAAAMshNPyVgoKIatUqx7F9noifZs9b3c35zVh7rSox/M+7R0GBIw4BAAAA1nRCw6X4afa8+PkXoSEAAAAA/3vcCAUAAAAAyBAaAgAAAAAZKxQa3n333dGpU6do3rx5dOnSJd56661lzv/dd9/F2WefHdtvv320atUqTj311Pj3v/+9IpsGAAAAACpYmUPD0aNHR58+fWK//faLAQMGRO3ataN79+7x1VdflTj/nDlz4rjjjosPPvggLr/88ujTp0989NFH0bNnz0juiAEAAAAAa5wy3QglpRQDBw6MI444Inr16hUREW3bto099tgjRowYERdccMESyzz44IPx5ZdfxmOPPRYbbbRRRETUq1cvzjrrrJgwYUI0aNCgHJ4GAAAAAFBeynSk4cSJE2PKlCnRsWPH3LSqVavGLrvsEuPGjStxmaeeeip23nnnXGAYEbH99tvHc889JzCE/zEFBfnxL1/aCgAAABWlTEcaTpgwISIiNt9888z0zTbbLO65555IKUXBr77Jfvzxx7H//vvHjTfeGPfee2/MmDEjdt5557j00ktj/fXXX7nWA3ljnXXWjmrVKq/uZpRavXq1V3cTlmvOnPkxffpPFbLuNT2UXDzczQeuxgEAAOSbMoWGM2fOjIiImjVrZqbXrFkz5s2bF7Nnz44aNWpkHps2bVrcf//9sdlmm8UVV1wRP/74Y1x11VXRq1evuPvuu5cIGUuror4o5ssX0HxVEf2bDzVb1MZKlfIjPCjvNhYURFSrVjmO7fNE/DR7Xvmu/H/U2mtVieF/3r1CXlN11lk7qlXNj4A3H8LdiIg5c+fHjxUU8K7p8i3ghbKoyNe1fabilHffqlXFKc++VaeKpVb5wftf/lhT+rbM1zSMiKUGfZUqLXm287x582LevHlxyy23RK1atSJi4TUNjzvuuHj55ZejTZs2ZW1z1K1bc/kzsUYq7y/4c+ctiKpVVugm4KvFeuvlR8BRUf360+x58fMvQsPyVFGhmYC3/CwKeNdfPz/2/4qSLwEvlJbxaP7yfpQ/1Cp/qFV+UKf8sabUqkyhYe3aCxs9a9asqFu3bm76rFmzomrVqlG9evUllll77bWjuLg4FxhGRLRq1SqqVKkSH3/88QqFht9/Pyvmz19Q5uVKo6BgzSnOb9HUqTPK7aioRbUSbpSvRQFHRdSK8leedYr4b60EvOWvvGuVLxa9pv5Xn/+vVa5cSdj0G1GR49EIn50VqaI+Oyl/xqP5Q63yg/e//FHRY+fSjknLFBpuscUWERExefLk2HTTTXPTJ0+evNSbmmy++eYxd+7czLQFCxbEggULVvjU5Ij8OMWTJaVU/rUTblSMiqgV5U+d8sf/eq3+158/v01e0/nJ+1H+UKv8oVb5QZ3yx5pSqzKdf1i/fv3YeOON4+mnn85Nmzt3bowdO3apRwy2a9cu3njjjfjuu+9y01544YVYsGBBtGjRYgWbDQAAAABUlDIdaVhQUBA9evSIvn37Rq1ataJFixYxatSomD59ehxzzDERETFp0qSYNm1aFBcXR0TEMcccEw888EAcf/zxccopp8SMGTPiqquuivbt20ezZs3K/QkBAAAAACunTKFhRETXrl1j9uzZMXLkyBg2bFg0atQobrvttthkk00iImLQoEExZsyYGD9+fERErL/++nHXXXdFv3794uyzz45q1arFHnvsEeedd175PhMAAAAAoFyUOTSMiOjevXt07969xMf69esX/fr1y0yrX79+DBkyZEU2BQAAAACsYisUGgIAq99K3E9slVnUxnxoa8SaccFpAABYEwgNASAPrbPO2lGtWuXV3YxSq1ev9upuQqnMmTM/pk//aXU3AwAAVjuhIQDkmYKCiGrVKsexfZ6In2bPW93N+c1Ye60qMfzPu0dBgSMOAQBAaAgAeeqn2fPi51+EhgAAQPmrtLobAAAAAACsWYSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZKxQa3n333dGpU6do3rx5dOnSJd56661lzn/qqadGUVHREv9mzZq1IpsHAAAAACpQlbIuMHr06OjTp0+cfPLJ0axZsxg5cmR07949Hn744fj9739f4jLjx4+Prl27xr777puZXqNGjRVrNQAAAABQYcoUGqaUYuDAgXHEEUdEr169IiKibdu2sccee8SIESPiggsuWGKZn3/+OSZNmhTnnXdeFBcXl0ujAQAAAICKU6bTkydOnBhTpkyJjh075qZVrVo1dtlllxg3blyJy3zyySexYMGCKCwsXLmWAgAAAACrRJmONJwwYUJERGy++eaZ6Ztttlncc889kVKKgoKCzGPjx4+PKlWqxODBg+Opp56K2bNnR/v27ePiiy+ODTbYYIUb/qvNlJuKWi8LlWf/qlXFUqv8UN59q1YVxz6VP/QvpVWRrxWvw4rjszN/+OzMH2qVH7z/5Y81pW/LFBrOnDkzIiJq1qyZmV6zZs2YN29ezJ49e4nrFI4fPz7mzZsXVatWjYEDB8bkyZPjhhtuiGOPPTbGjBkT1apVK3Oj69atufyZWCPVq1d7dTeBUlKr/KBO+UOt8odaURrGo/nLPp4/1Cp/qFV+UKf8sabUqszXNIyIJY4mXKRSpSXPdu7atWvsuuuu0aZNm4iI2H777WOrrbaKQw89NJ544onYZ599ytrm+P77WTF//oIyL1caBQVrTnF+i6ZOnRH//2W00tSqYqlVfijPOkWoVUWyT+WP8t6vFle5ciVh029ERY5HI+znFclnZ/7w2Zk/1Co/eP/LHxU5Ho0o/Zi0TKFh7doLXwyzZs2KunXr5qbPmjUrqlatGtWrV19imQYNGkSDBg0y07bZZpuoU6dOjB8/foVCw4io0M6j4qSkdvlCrfKDOuUPtcofakVpeZ3kJ/t4/lCr/KFW+UGd8seaUqsy3Qhliy22iIiIyZMnZ6ZPnjx5iWBwkSeeeCJefvnlzLSUUsyZMyfWXXfdsmweAAAAAFgFyhQa1q9fPzbeeON4+umnc9Pmzp0bY8eOzZ1+/Gv3339/9O3bN+bPn5+b9s9//jNmz54d22+//Qo2GwAAAACoKGU6PbmgoCB69OgRffv2jVq1akWLFi1i1KhRMX369DjmmGMiImLSpEkxbdq0KC4ujoiIHj16xDHHHBNnnHFGdOnSJSZMmBA33nhj7L777rHNNtuU+xMCAAAAAFZOmULDiIU3Npk9e3aMHDkyhg0bFo0aNYrbbrstNtlkk4iIGDRoUIwZMybGjx8fERGtWrWKm2++OQYMGBC9evWKmjVrxkEHHRSnnXZa+T4TAAAAAKBclDk0jIjo3r17dO/evcTH+vXrF/369ctM22mnnWKnnXZakU0BAAAAAKtYma5pCAAAAAD89gkNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABkrFBrefffd0alTp2jevHl06dIl3nrrrVIvO3DgwCgqKlqRzQIAAAAAq0CZQ8PRo0dHnz59Yr/99osBAwZE7dq1o3v37vHVV18td9mPP/44hgwZskINBQAAAABWjTKFhimlGDhwYBxxxBHRq1evaN++fQwePDjWXXfdGDFixDKXnT9/fvTu3TvWW2+9lWowAAAAAFCxyhQaTpw4MaZMmRIdO3bMTatatWrssssuMW7cuGUuO3z48Jg1a1YceeSRK9ZSAAAAAGCVKFNoOGHChIiI2HzzzTPTN9tss5g4cWKklEpcbuLEiTFgwIDo27dvVKtWbcVaCgAAAACsElXKMvPMmTMjIqJmzZqZ6TVr1ox58+bF7Nmzo0aNGpnHUkpx0UUXxX777RctW7aM9957byWbvFBBQbmsZpWtl4XKs3/VqmKpVX4o775Vq4pjn8of+pfSqsjXitdhxfHZmT98duYPtcoP3v/yx5rSt2UKDRcdSViwlNZXqrTkgYv33HNPTJw4MQYPHrwCzStZ3bo1lz8Ta6R69Wqv7iZQSmqVH9Qpf6hV/lArSsN4NH/Zx/OHWuUPtcoP6pQ/1pRalSk0rF17YaNnzZoVdevWzU2fNWtWVK1aNapXr56Z/+uvv46rr746rrjiilhrrbVi3rx5ueBx3rx5UalSpRKDxuX5/vtZMX/+gjIvVxoFBWtOcX6Lpk6dEUs5i73M1KpiqVV+KM86RahVRbJP5Y/y3q8WV7lyJWHTb0RFjkcj7OcVyWdn/vDZmT/UKj94/8sfFTkejSj9mLRMoeEWW2wRERGTJ0+OTTfdNDd98uTJ0aBBgyXmf+mll2LWrFlx6qmnLvFYkyZNolevXnHKKaeUpQk5Fdl5VJyU1C5fqFV+UKf8oVb5Q60oLa+T/GQfzx9qlT/UKj+oU/5YU2pVptCwfv36sfHGG8fTTz8dbdq0iYiIuXPnxtixY2PXXXddYv4OHTrE/fffn5n26KOPxrBhw+L++++P3/3udyvRdAAAAACgIpQpNCwoKIgePXpE3759o1atWtGiRYsYNWpUTJ8+PY455piIiJg0aVJMmzYtiouLo27dupnTmCMi3njjjYiIaNasWTk9BQAAAACgPJUpNIyI6Nq1a8yePTtGjhwZw4YNi0aNGsVtt90Wm2yySUREDBo0KMaMGRPjx48v98YCAAAAABWvzKFhRET37t2je/fuJT7Wr1+/6Nev31KXPfbYY+PYY49dkc0CAAAAAKtA2W9dDAAAAAD8pgkNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABkrFBrefffd0alTp2jevHl06dIl3nrrrWXO//LLL8chhxwSxcXF0alTpxg5cuSKbBYAAAAAWAXKHBqOHj06+vTpE/vtt18MGDAgateuHd27d4+vvvqqxPk/+OCD6NGjRzRo0CAGDRoUhx12WPTr1y/uuOOOlW48AAAAAFD+yhQappRi4MCBccQRR0SvXr2iffv2MXjw4Fh33XVjxIgRJS4zYsSI2GyzzaJfv37Rtm3b6N69e+y7775x1113lcsTAAAAAADKV5lCw4kTJ8aUKVOiY8eOuWlVq1aNXXbZJcaNG1fiMmeeeWb0798/KlWqlFlmzpw5K9hkAAAAAKAilSk0nDBhQkREbL755pnpm222WUycODFSSksss+GGG8bWW28dEREzZsyIBx98MB588ME47LDDVrDJAAAAAEBFqlKWmWfOnBkRETVr1sxMr1mzZsybNy9mz54dNWrUKHHZb775JnbeeeeIiGjWrFkceuihK9LenIKClVp8la+Xhcqzf9WqYqlVfijvvlWrimOfyh/6l9KqyNeK12HF8dmZP3x25g+1yg/e//LHmtK3ZQoNFx1JWLCU1i9+CvKv1ahRI0aMGBFTp06NG264Ibp06RIPPvjgUkPGZalbt+byZ2KNVK9e7dXdBEpJrfKDOuUPtcofakVpGI/mL/t4/lCr/KFW+UGd8seaUqsyhYa1ay9s9KxZs6Ju3bq56bNmzYqqVatG9erVl7psnTp1YocddoiIiK233jr23XffeOKJJ2L//fcvc6O//35WzJ+/oMzLlUZBwZpTnN+iqVNnRAlnsa8QtapYapUfyrNOEWpVkexT+aO896vFVa5cSdj0G1GR49EI+3lF8tmZP3x25g+1yg/e//JHRY5HI0o/Ji1TaLjFFltERMTkyZNj0003zU2fPHlyNGjQoMRlnnnmmahbt260aNEiN62wsDCqVq0a3377bVk2n1GRnUfFSUnt8oVa5Qd1yh9qlT/UitLyOslP9vH8oVb5Q63ygzrljzWlVmW6EUr9+vVj4403jqeffjo3be7cuTF27Nho06ZNicsMGzYsrrjiisxNUl599dWYO3duFBYWrmCzAQAAAICKUqYjDQsKCqJHjx7Rt2/fqFWrVrRo0SJGjRoV06dPj2OOOSYiIiZNmhTTpk2L4uLiiIg48cQT4/jjj4/evXvHPvvsE5MmTYr+/ftHq1aton379uX+hAAAAACAlVOm0DAiomvXrjF79uwYOXJkDBs2LBo1ahS33XZbbLLJJhERMWjQoBgzZkyMHz8+IiJ23HHHGDp0aAwcODD+9Kc/Ra1atWKvvfaKM844Y6k3VAEAAAAAVp8yh4YREd27d4/u3buX+Fi/fv2iX79+mWnt27d3VCEAAAAA5IkyXdMQAAAAAPjtExoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMlYoNLz77rujU6dO0bx58+jSpUu89dZby5z/2WefjUMOOSRatGgRHTt2jL/85S8xc+bMFdk0AAAAAFDByhwajh49Ovr06RP77bdfDBgwIGrXrh3du3ePr776qsT5X3nllejZs2dsvfXWMWDAgOjZs2c8+uijcdZZZ6104wEAAACA8lelLDOnlGLgwIFxxBFHRK9evSIiom3btrHHHnvEiBEj4oILLlhimdtvvz223XbbuOKKK3LTatWqFaeffnp8/vnnseWWW67kUwAAAAAAylOZjjScOHFiTJkyJTp27JibVrVq1dhll11i3LhxJS7TvHnz6Nq1a2ZagwYNIiJiypQpZW0vAAAAAFDBynSk4YQJEyIiYvPNN89M32yzzeKee+6JlFIUFBRkHjv55JOXWM+zzz4bEf8NDwEAAACANUeZQsNFNy+pWbNmZnrNmjVj3rx5MXv27KhRo8Yy1/HRRx/FzTffHH/84x9j0003LWNz/+tX2WS5qaj1slB59q9aVSy1yg/l3bdqVXHsU/lD/1JaFfla8TqsOD4784fPzvyhVvnB+1/+WFP6tszXNIyIJY4mXKRSpWWf7fzJJ59E9+7dY6ONNopLL720LJvOqFu35vJnYo1Ur17t1d0ESkmt8oM65Q+1yh9qRWkYj+Yv+3j+UKv8oVb5QZ3yx5pSqzKFhrVrL2z0rFmzom7durnps2bNiqpVq0b16tWXuuzrr78ef/rTn2K99daLYcOGxTrrrLOCTY74/vtZMX/+ghVeflkKCtac4vwWTZ06I/5/9rzS1KpiqVV+KM86RahVRbJP5Y/y3q8WV7lyJWHTb0RFjkcj7OcVyWdn/vDZmT/UKj94/8sfFTkejSj9mLRMoeEWW2wRERGTJ0/OnFo8efLkZV6f8JlnnonTTz89ttxyy7jtttuiXr16ZdlsiSqy86g4KaldvlCr/KBO+UOt8odaUVpeJ/nJPp4/1Cp/qFV+UKf8sabUqkx3T65fv35svPHG8fTTT+emzZ07N8aOHRtt2rQpcZl33nknTjvttGjatGmMGjWqXAJDAAAAAKDilOlIw4KCgujRo0f07ds3atWqFS1atIhRo0bF9OnT45hjjomIiEmTJsW0adOiuLg4IiIuueSSqFKlSpx44onx6aefZtbXoEGDlTpNGQAAAAAof2UKDSMiunbtGrNnz46RI0fGsGHDolGjRnHbbbfFJptsEhERgwYNijFjxsT48ePjq6++ig8++CAiIk444YQl1nXTTTfFbrvttpJPAQAAAAAoT2UODSMiunfvHt27dy/xsX79+kW/fv0iIuL3v/99jB8/fsVbBwAAAACscmW6piEAAAAA8NsnNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkrFBoePfdd0enTp2iefPm0aVLl3jrrbdKtdzMmTOjQ4cO8dRTT63IZgEAAACAVaDMoeHo0aOjT58+sd9++8WAAQOidu3a0b179/jqq6+WudzMmTPjT3/603LnAwAAAABWrzKFhimlGDhwYBxxxBHRq1evaN++fQwePDjWXXfdGDFixFKXe/XVV+OQQw6Jjz76aKUbDAAAAABUrDKFhhMnTowpU6ZEx44dc9OqVq0au+yyS4wbN26py5188slRWFgYt95664q3FAAAAABYJaqUZeYJEyZERMTmm2+emb7ZZpvFPffcEymlKCgoWGK5O++8MwoLC+PLL79c8ZYCAAAAAKtEmULDmTNnRkREzZo1M9Nr1qwZ8+bNi9mzZ0eNGjWWWK6wsHAlmliyErLJNXq9LFSe/atWFUut8kN5961aVRz7VP7Qv5RWRb5WvA4rjs/O/OGzM3+oVX7w/pc/1pS+LVNomFKKiCjxaMKIiEqVVuhmzGVWt27N5c/EGqlevdqruwmUklrlB3XKH2qVP9SK0jAezV/28fyhVvlDrfKDOuWPNaVWZQoNa9de2OhZs2ZF3bp1c9NnzZoVVatWjerVq5dv65bi++9nxfz5Cypk3QUFa05xfoumTp0R/z97XmlqVbHUKj+UZ50i1Koi2afyR3nvV4urXLmSsOk3oiLHoxH284rkszN/+OzMH2qVH7z/5Y+KHI9GlH5MWqbQcIsttoiIiMmTJ8emm26amz558uRo0KBBGZu4ciqy86g4KaldvlCr/KBO+UOt8odaUVpeJ/nJPp4/1Cp/qFV+UKf8sabUqkznE9evXz823njjePrpp3PT5s6dG2PHjo02bdqUe+MAAAAAgFWvTEcaFhQURI8ePaJv375Rq1ataNGiRYwaNSqmT58exxxzTERETJo0KaZNmxbFxcUV0V4AAAAAoIKVKTSMiOjatWvMnj07Ro4cGcOGDYtGjRrFbbfdFptssklERAwaNCjGjBkT48ePL/fGAgAAAAAVr8yhYURE9+7do3v37iU+1q9fv+jXr1+Jj2266abCRAAAAABYw5XpmoYAAAAAwG+f0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAhtAQAAAAAMgQGgIAAAAAGUJDAAAAACBDaAgAAAAAZAgNAQAAAIAMoSEAAAAAkCE0BAAAAAAyhIYAAAAAQIbQEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAAAAGQIDQEAAACADKEhAAAAAJAhNAQAAAAAMoSGAAAAAECG0BAAAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQsUKh4d133x2dOnWK5s2bR5cuXeKtt95a5vwfffRRHH300dGiRYvYZZdd4pZbblmRzQIAAAAAq0CZQ8PRo0dHnz59Yr/99osBAwZE7dq1o3v37vHVV1+VOP/UqVOjW7duUaVKlbjhhhvi0EMPjeuvvz6GDx++sm0HAAAAACpAlbLMnFKKgQMHxhFHHBG9evWKiIi2bdvGHnvsESNGjIgLLrhgiWVGjRoVKaUYNGhQrLXWWtG+ffuYM2dODB06NI466qioXLly+TwTAAAAAKBclOlIw4kTJ8aUKVOiY8eOuWlVq1aNXXbZJcaNG1fiMi+99FK0bds21lprrdy03XbbLaZNmxbvv//+CjYbAAAAAKgoZQoNJ0yYEBERm2++eWb6ZpttFhMnToyUUonLbLHFFkvMHxHxxRdflGXzAAAAAMAqUKbTk2fOnBkRETVr1sxMr1mzZsybNy9mz54dNWrUWGKZkuZffH1lVblyxd30uaBg4X8b1a8bs+fMr7Dt/K9Zq9rC09CrVKkUJWTLK0StKoZa5YeKqFOEWlUE+1T+qKj9anEVOYZh1aroWtrPy5/PzvzhszN/qFV+8P6XP1bFeDSi9OOYglTS4YFL8fDDD8fZZ58dL7/8ctStWzc3/b777ouLLroo3nnnnahevXpmmaZNm8aZZ54Z3bp1y02bN29eNGnSJP7v//4vDj/88NJuHgAAAABYBcr0E2nt2rUjImLWrFmZ6bNmzYqqVasuERhGRNSqVavE+RdfHwAAAACw5ihTaLjo2oSTJ0/OTJ88eXI0aNCgxGXq169f4vwRsdRlAAAAAIDVp0yhYf369WPjjTeOp59+Ojdt7ty5MXbs2GjTpk2Jy+ywww7xwgsvxM8//5yb9tRTT8V6660XRUVFK9hsAAAAAKCilOlGKAUFBdGjR4/o27dv1KpVK1q0aBGjRo2K6dOnxzHHHBMREZMmTYpp06ZFcXFxREQcccQRMXLkyDjhhBOiW7du8dFHH8XNN98c5557blSpUqbNAwAAAACrQJluhLLIbbfdFiNHjozvv/8+GjVqFBdccEFss802ERFx/vnnx5gxY2L8+PG5+d955524/PLL4/3334/1118/jjzyyOjevXv5PQsAAAAAoNysUGgIAAAAAPx2lemahgAAAADAb5/QEAAAAADIEBoCAAAAABlCQwAAAAAgQ2gIAAC/Ue55uOZSm+Vbk/poTWoLJVOj/KeGpbMq+0lo+Ct///vf4+ijj47WrVtHy5Yto0uXLvHoo4/mHn/wwQejqKgoXn311aWuo1OnTnHGGWcs9fH//Oc/cckll8Quu+wSTZs2jXbt2sUZZ5wRn376abk+lxX15ZdfRlFRUTz11FMrva4pU6bEn/70p9huu+2ibdu2cdVVV8XcuXPLoZVqFVG+tVpk3rx5cfDBB8fw4cPLZX3qVL51+te//hVHHXVUtGzZMnbcccc499xz47vvviuHVqpVRPnW6sMPP4yjjz46WrRoEe3bt48BAwZ4/ytHFfH+FxExZsyYKCoqii+//LJc1wulNXr06CgqKlrqv8MPP7zU67r33ntjwIABFdjasunYsWNcdtllpZp30T6+rH8dO3Zc6TZ9/fXX0a1bt/jxxx+XO+9RRx21zPbcd999pdrmjz/+GGeddVaMHz9+ZZtfLl555ZUoKiqKDz/8sFTzDxgwYLm1KY/X3VNPPRX/93//t8LL25cWWhP3pUXUaKE1uUalsby2T5w4sVTr+eSTT6Jbt27l2raVMWDAgGjZsmWp51/eZ0RRUVG88sorK92ugQMHxj333LPS6ymtKqtsS3mgd+/e8cgjj8QRRxwR3bp1i4KCgnj66afjzDPPjI8//jjOOOOM6Ny5c1x66aXx2GOPRatWrZZYx1tvvRWTJk2Kiy66qMRtzJo1K4444oioWbNmnHHGGbHxxhvHt99+G8OHD48uXbrEX//619hqq60q+qmuEnPmzIlu3bpFzZo146qrroqvv/46rrnmmpg7d25ceOGFK7VutaoYc+fOjfPPPz/efffd2HvvvVd6fepUvj777LM49thjo23btnHttdfGjz/+GDfeeGMcf/zxcf/990eVKiv+lq5W5evf//53HHvssdGsWbMYMGBATJkyJa666qqYOXNmXHDBBSu1brWqOP/5z3/iiiuuWN3NgIiIGDZsWKy99tpLTK9Vq1ap1zF06NDYddddy7NZq8zvfve7uPfee3N/jx07NgYPHpzpl2rVqq30dl566aV44YUXSj3/9ttvH2effXaJj22++ealWseHH34YjzzySBx//PGl3u6a5JBDDomddtop9/ell14aNWvWzPTLRhtttNLbGTFiRNSuXXul12NfWjP3pcWp0Zpfo+U55phjYs899yzxsY033rhU63j88cfj3XffLc9mrVKXXHJJzJw5M/d3ly5dluiXrbfeeqW3M2DAgJX+PlEWQsP/77777ovRo0fHbbfdFu3atctNb9++fdStWzeGDBkSe+65ZxQVFUWnTp3iiSeeiIsuuigqV66cWc8jjzwSG2ywQey4444lbucf//hHfPnll/HCCy/Eeuutl5u+yy67RKdOnWL48OHRt2/finmSq9jf/va3mDJlSjzzzDPxu9/9LiIiqlevHpdeemn07Nkz8/zLQq0qxkcffRSXXHJJfPHFF+WyPnUqf3feeWdssMEGMWDAgKhatWpERGyxxRZxyCGHxEsvvZQZwJeFWpW/v/71r5FSigEDBkSNGjUiYmEgdcstt8R5550XlSqt2IH+alWx+vTpE2uttVZMnz59dTcFomnTplGnTp3V3YzVplq1alFcXJz7+/PPP4+I1d8vderUybTrf9FGG22UCQVr1aoVtWvXXmP7ZXW/Zla3NXVfWtya1JbVIR9qtDy///3v19j3gFWlpEDwt9AvTk/+/4YPHx4dOnTIfAlb5Pjjj4+uXbvG/PnzIyJi//33j6lTpy5x2tf8+fPj73//e+yzzz5LfEFbZOrUqRERsWDBgsz0WrVqxYUXXpj50j9jxozo06dP7tSwtm3bxsUXXxw//fRTRPz3MOann346jj766GjevHnsvvvu8dxzz8V7770XBx98cGyzzTZxyCGHxMcff5xbb8eOHWPIkCFx3nnnRXFxcbRv3z6GDh26zP5555134qijjormzZtH27Zt44orrog5c+Ysc5mXXnopmjZtmgsMIyJ22223mDt3brz88svLXHZZ1Kr8axURcd5550WNGjXi/vvvX+68paFO5V+nrbfeOrp165YLDCMittxyy4hYeCmAFaVW5V+rI488MoYPH54LDCMiqlatGvPnz1/i+ZeFWlXM+1/Ewl+3X3vttTjllFNKNT+sbrfccksUFRXFSy+9lJt2/fXXR9OmTePjjz+Ojh07xpQpU+KOO+6IoqKi3DzL20+OOuqouOiii+K4446L5s2bx5VXXhkDBgyIAw88MP72t79F586do1mzZtGlS5d4//33c8ullGLYsGGx1157RbNmzWLbbbeNHj16xIQJEyq0H7744os48cQTo0WLFrH99tvHBRdckAn+f/rpp7jwwgtjxx13jObNm8cBBxwQ//jHPyJi4amRi47W2H777cvl1MZ58+bFvvvuG506dcr16+zZs2P33XePI444Il566aU4+uijI2Lh+/T555+fW3bYsGGx2267RdOmTWOfffbJXH5h0Xvpos+Bli1bxjvvvBMdO3aMW265JS6++OLYfvvto2XLlnHRRRfF7Nmzc8t+8803cd5550W7du2iSZMmsfPOO8c111wT8+bNW+nnuywPPvhg7LXXXtG0adPo3Llz5kiqiIi33347unbtGi1atIhWrVrFqaeemhvPHHXUUfHqq6/G008/XeGXjLAvLbSm7UuLU6OF1uQaLc/kyZOjuLg4zjnnnNy0Tz/9NJo2bRrXXXddDBgwIAYOHBgzZsyIoqKiGD16dEREzJw5My655JJo06ZNNG/ePI499tjMeHH06NHRunXruPnmm6NVq1bRsWPH+Pzzz3Njz27dusU222wT7du3j2HDhmXa9NZbb0X37t1ju+22i6ZNm8aee+4ZDz74YIX2w9y5c+O6666LnXfeOZo1axaHHHJIvP7665l5xowZk3tt7bzzznH55ZfHL7/8EhGRe31fccUV5XLKeqkk0r///e9UWFiY7r777lLNP3/+/LTTTjuliy++ODP9ueeeS4WFhWn8+PFLXfb9999PDRs2TLvttlu67bbb0kcffZQWLFhQ4rwnnHBC6tixY3rkkUfSSy+9lAYOHJgaNmyYBg4cmFJKafLkyamwsDC1atUqDRs2LD3//PPpgAMOSK1atUqdOnVKf/3rX9Ozzz6bdtppp3TwwQfn1tuhQ4e03Xbbpe7du6exY8em66+/PhUVFaWbb745s94nn3wypZTS+PHjU/PmzVP37t3Ts88+m+655560/fbbp9NPP32Z/XTggQemc889d4np2267bbrpppuWuezSqFXF1GrRsosUFhamYcOGLXeZpVGniqvTrz300EOpsLAwvfLKK2VeNiW1WhW1mjlzZnrmmWdSq1atlui3slCriqvV999/n9q2bZseeuih9OSTT6bCwsI0efLk5S4HFeGBBx5IhYWFadq0aWnu3LlL/Fu0L86bNy8dcMABac8990xz585NH3zwQWrcuHEaPHhwSmnhftyuXbt0+umnpzfffDOlVLr95Mgjj0yNGzdOl19+eXruuefSe++9l/r3759atGiRdt999/Too4+mp59+OnXu3Dl17tw5t9ytt96amjVrlu644470yiuvpL/+9a9phx12SEcffXRung4dOqS//OUvK9Uv06dPz0379ttv0w477JAOOuig9OSTT6aHHnoo7bLLLqlLly5p/vz5KaWUevfunTp27Jj+/ve/p5deeimdddZZqWHDhunTTz9NU6dOTddff30qLCxML7zwQvr666+X2YYjjzwynXTSSSXWZd68ebn53nnnndSoUaM0aNCglFJK/fr1S9tss02aMGFCmjFjRho1alQqLCxMY8aMSRMnTkwppXTDDTekJk2apAEDBqTnnnsu/fnPf04NGzZMY8eOTSn99z2vdevW6e9//3saM2ZMmjt3burQoUPadttt0znnnJOef/75dPvtt6eGDRumIUOGpJQWfhbss88+af/9909PPvlkevHFF1Pfvn1z208ppZdffjkVFhamDz74YIVqc+SRR6aePXtmpt13332pqKgo/eUvf0njxo1L1113XWrYsGG66667Ukop/fjjj6lVq1bpjDPOSC+++GJ6/PHH02677ZYOPfTQlFJKn3zySdp///1T165d05tvvpl++eWXMrfLvrTsflmd+5Ia5U+NSqOwsDDdfvvtJdZwUdtSSmnYsGGpsLAwvf7662nevHnpkEMOSXvvvXf65Zdf0tdff5169+6diouL05tvvpmmTp2a5s+fn4488sjUtm3b9Ne//jU9/fTT6cgjj0ytWrVK//73v3N91ahRo7T//vuncePGpSeeeCLzfjlw4MD04osvpvPPPz8VFhamf/3rXymllKZMmZK22WabdPrpp6cXXnghPfvss+m4445LjRo1yo0B+/fvn7bbbruV6pdff6c+55xzUnFxcRo+fHgaO3ZsOuWUU1KzZs1y77+vvvpqatiwYRo0aFB65ZVX0p133pmaNWuWrrnmmpRSSm+++WYqLCxMl112WXr//fdXuG1lITRMKb399tupsLAw/fOf/yz1MldddVVq3bp1mjt3bm7aueeemw444IDlLvu3v/0ttWrVKhUWFua+SJ1zzjnpww8/zM0ze/bsdNxxx6Xnn38+s2zXrl1Tt27dUkr/HTz06dMn9/ijjz6aCgsL04gRI3LTbrvtttSoUaNcWzt06JA6dOiQ5syZk5vnwgsvTK1bt07z589f4ovYaaedljp37px5rmPHjk2FhYWZNv9a586d06WXXrrE9J122ildeeWVy+2nkqhVxdTq11Y2NFSnVVOnr7/+OrVr1y4deuihSw10lketKrZWCxYsSE2aNEmFhYWpY8eO6csvv1zuMkujVhVXq3POOSd17949pZSEhqx2i74sLu3fI488kpv3/fffT40bN0633XZbOuCAA9JBBx2UCa9+/aW1NPvJkUcemdvPFunfv/8SodKDDz6YCgsLc6FX375909ChQzPP5cYbb0xNmjRZantWpF8W/xJ91VVXpVatWmWmffzxx6moqCj33rD77rtnfjyZM2dOuuKKK9JHH3201PUuzZFHHrnUujRt2jQz7xVXXJG22Wab9NRTT6VGjRpl3u9+HdL98MMPqVmzZmnAgAGZdZx22mlpv/32Syn99730iiuuyMzToUOHtO+++2amHXPMMenwww9PKaX01VdfpSOPPDJ9/PHHmXl22WWXXL+Ud2g4f/781K5du3T++edn5rvqqqvSDjvskObMmZP74rvoC3xKKb322mvpxhtvzL32Sgojy8K+tOx+WZ370q/bokYl98uaUKPSWFYNF40HU1r43nDQQQel/fffP91+++2pcePG6b333ss9/uuQblG9Xn311dy0X375JbVv3z5ddtllmef09NNP5+ZZ9H65eP/PmTMnNW/ePF1//fW5dR933HGZ18ekSZNSYWFhevjhh0tsz4r0y+LfqT/99NPMDzYpLfyucMghh6Q//elPKaWUhg4dmlq0aJH5oeT+++9Po0ePXup6K5prGkbkTs9KZbht9f777x+33npr7jpis2fPjieffDJOP/305S67zz77ROfOnWPcuHExbty4eOmll+Khhx6KRx55JK6++urYa6+9onr16nH77bdHSikmT54cX3zxRXz88cfx5ZdfxmabbZZZX7NmzXL/X69evYhYeP2DRdZdd92YP39+/PTTT7lrIuy+++6ZUxx33XXXuO++++KLL76I6tWrZ9b/2muvxR577BERkTuNYYcddoiqVavGyy+/HEVFRbnT4RZZdEOGgoKCEvtgRa/npVYVV6vypE4VX6dvvvkmjj322IiIuOaaa5a6ry2PWlVsrebNmxdDhw6Nn3/+OQYNGhSHHnpojB49OjbccMPl9tWvqVXF1Oq5556LJ598Mh555JHl9gmsSnfccUeJNwZY/GYbjRs3juOOOy6uvvrqqFKlSjz44INLvexAxPL3k4YNG0ZERP369ZcYq1WrVi33eETkLj+z6FIEi26sNHXq1Pjss8/i888/jxdffLHc7hq/tOfTokWLWHvttXPPp0GDBrHJJpvEyy+/HLvttlu0bNky/vrXv8a3334bHTp0iF122SVzSnBZtWrVKs4999wlpv+6v0477bR48skno1evXtGyZcs46qijlrrOt99+O3755ZfYeeedM6cM77zzzvHYY4/FDz/8kJvWoEGDJZbfZpttMn//7ne/i08++SQiFt6AYOTIkTF//vz44osv4osvvogPP/wwZs6cWWG1+eKLL+I///lPtG/ffonnc+utt8Ynn3wSW2+9day77rpx0kknxV577RXt27ePNm3alOlOpaVlX1q+1bEvLU6Nlm9112h5jjvuuNhrr72WmL74zYwqVaoUl112WRx00EFx1VVXxUknnRRNmjRZ6jpfe+21qFmzZrRo0SL3nCtVqhRt2rRZ4nJny3tvrFq1atStWzd+/vnniFh4PfD27dvH7Nmz45NPPokvvvgi/vWvf0VEVFgdF10yqKT3+kWnTm+77bbx008/xb777ht//OMfo0OHDnHggQeu8He98iA0jP/ezeerr75a6jzffPNN5kveH/7wh2jcuHE89thjsdNOO8UzzzwTc+bMKfUdZ6tXrx677bZb7LbbbhER8f7778cZZ5wRf/nLX+KPf/xjVKpUKZ566qm4/PLLY8qUKbHeeuvFNttsE2uttdYS6yrprlKLX0erJBtssEHm70UXup8+fXrmGoQRET/88EOMGjUqRo0atcR6vv3223j11Vdz12ZZZPz48VGrVq2YNWvWEsvMmjVrhe+EplYVU6vypk4VW6dPP/00jj/++Jg7d24MGzZsiXCmLNSqYmtVtWrV3PUHt91229hll13ivvvui169ei2zjSVRq/Kv1RtvvBGXXHJJnHrqqbHhhhvGvHnzctdxXLBgQSxYsGCFf+SCldWoUaNSXQB/7733jltuuSU233zzqF+//jLnXd5+skhJN6urXr165kvLon1j0Q8Zn376aVx00UXx5ptvxtprrx2NGjUql7t9LssPP/wQb7/9dolfOv/zn/9ExMIv9xtuuGE89NBD8eyzz0alSpWiffv2cfnll6/QTflq166d+RFkaWrUqBG77bZbDB8+PHbaaadlfuFbFAoecsghJT7+3Xff5d5XF/3osrhf/4hSqVKlzDVp77333rjhhhti2rRpseGGG0ZxcXFUr169TD9ClcWi53PaaaeV+Ph//vOfaNy4cYwaNSpuuummGDNmTNx5551Rp06dOOGEE6JHjx7l2h770vKtjn1pcWq0fKu7Rsuz0UYbleq9saioKAoLC+P999+P9u3bL3PeH374IWbNmlXic/718ynpvfHX49HF3xvnzZsXV1xxRfz1r3+NefPmxRZbbJG7YUlFvze2adOmxMd//vnnaNmyZQwaNCiGDRsWN998cwwaNCg23XTT+L//+78VvunlyhIaxsIXXMOGDWPcuHFx+OGHL/H4rFmzonPnznHYYYdlbm293377xaBBg+LSSy+NRx55JHbeeefl7oyHHnpoFBcXR+/evTPTmzRpEj179ozzzz8/vv/++5gxY0acfvrpcfDBB0fPnj1zXwK7d+9e6ou6L8viv1hG/Pei9yXtbLVq1Yrdd9+9xIHM+uuvH7Vr1y7x5hn169ePyZMnZ6Z9//33MXPmzBJ/CSgNtaqYWpU3daq4Or3zzjtx/PHHR61ateLOO+9c7oBpedSqYmr18ssvx/z58zM3LFlvvfViww03zAxUy0Ktyr9W77//fnz11VfRr1+/6NevX+axTp06xQEHHLDEdFiTpJTisssuiy233DImTpwYI0aMiG7dui11/uXtJytqwYIF0bNnz1h//fXj0Ucfja222ioKCgpi6NCh8corr6zwepenVq1a0aFDhzj55JOXeGydddaJiIVfGk855ZQ45ZRT4vPPP49//OMfcdNNN8WNN94Yl156aYW17bPPPou77rorioqKYvDgwbHXXnvFJptsUuK8i35MHzx48BI/lkREbLrppvHdd9+tUDteffXV3I8jhx9+eNStWzciFh7JXVEWPZ8+ffpE48aNl3h8iy22iIiFP2zdcMMNMWfOnHjjjTdi5MiRcc0110SrVq2WOHqyotmX1tx9aRE1WvNrVBoPPPBAfPjhh/GHP/whLr300rjvvvuWeuZb7dq1Y4MNNojBgwcv8djKni03ZMiQGD16dFx33XWx4447Ro0aNeLbb7+NMWPGrNR6l6V27dpRuXLluOeee0r8IWlR8NyxY8fo2LFjzJgxI8aNGxeDBw+OM844I1588cUKD6dL4ufz/++oo46KZ555JnNHpkWGDBkSs2fPXuJw23322SdmzZoVzz33XDz//PNxwAEHLHc7m2yySfztb38r8YN/woQJsf7660fdunXjgw8+iLlz58YJJ5yQ+xL2448/xrvvvlsuyffYsWMz63nqqadio402yn2IL27bbbeNL774Ipo1a5b7t95668W1114bEyZMiFq1amUeW/QLww477BDvvPNOfPPNN5ntVK1adaVOPVCr8q9VRVCn8q/Tl19+GT169Ih69erF3XffvdKB4SJqVf61evDBB+PCCy/MBGcTJ06MKVOmZO7qV1ZqVb61atKkSdx///2Zf+edd15ELPzyviJHhMKqdN9998Xrr78eV155ZXTr1i369++f+cH210fKLm8/WVHTpk2LSZMmRZcuXWLrrbfOfRl64YUXIqLijtpY9HwaNmyYez4NGjSIG264Id57771YsGBB7LPPPjF8+PCIiNhyyy3jpJNOiuLi4vj6668jYsUvmbMsKaW4+OKLY8stt4y777476tWrF5dccknu8V+fUtm8efOoUqVK/PDDD5navPvuu3HzzTevVBvfeuutqFy5cpx44om5wHDy5MkxefLkCqvLlltuGeuuu258++23mefzzTffxIABA2LOnDnxwgsvRJs2bWLatGlRrVq1aNOmTVx44YUR8d8j6lflkd72pTVzX1qcGq35NVqe7777Lq666qo4/PDD4/rrr4+PP/44br/99tzjJdVw2rRpsc4662TqeN9998Xjjz++Um156623olmzZtGpU6fcmS8vvvhiRFRsDefPnx8///xz5vk8++yzcc8990TlypVzlzOKWBgy7rnnntGtW7eYMWNGzJw5MyJWfR0dafj/HXjggTF27Ng48cQT46ijjoo2bdrE7Nmz4/HHH4+HH344Tj755GjevHlmmXr16kW7du3iqquuiho1aiz38NqIhYfpv/jii3HQQQfFcccdF40aNYo5c+bEP//5z7jrrrvi8ssvj0qVKkXDhg2jcuXKcfXVV0eXLl1i6tSpcfPNN8ePP/6YOw9/ZXz88cdx9tlnx/777x+vv/56jBkzJvr06VPivD179owjjjgizjrrrNhvv/3ip59+ioEDB8b06dMz13r4tb333jsGDx4cxx9/fJx22mnxzTffxNVXXx2HH374Sh0erVblX6uKoE7lX6d+/frFjBkz4uKLL46vv/46NwCIWBjylHR0QmmoVfnX6rjjjou///3vccopp8SRRx4Z06ZNiwEDBsQWW2wRBx544Aq3Xa3Kt1aLgsTFLfqhq7CwMDbddNOVfg6wot57770Sr/EVsfA6Tf/5z3/iqquuikMOOSSaN28ef/jDH+Lhhx+OP//5z7lrI9WpUyfefffdePXVV2P77bevsHFCvXr1YuONN45hw4bFuuuuGwUFBXHfffflrt/0888/L/W5rIzjjjsuHnzwwTjppJOia9euUVBQEDfffHOMHz8+LrrooqhUqVIUFxfHTTfdFNWrV4+tttoq3nrrrXjjjTdyR90sOiXy8ccfj7Zt2y53v//xxx/jrbfeKvGxunXrxhZbbBF33XVX/Otf/4q77roratasGRdeeGGcdNJJ8dBDD8V+++2XOxLv6aefjmrVqsVWW20VRxxxRFx22WXx/fffR5MmTeLdd9+NG2+8MQ488MCVOrKkWbNmudPwOnXqFF9++WXcdNNNsWDBgnJ5ny5JlSpVomfPnnHNNdfEggULolWrVjFhwoS49tprY5ttton1118/95x69eoVPXr0iKpVq8Ydd9wRderUidatW0fEwtp89NFH8corryz10helYV9avtWxLy1OjZZvdddoeb766qulvjduttlmUa9evejbt29UqVIlTj/99KhTp04cffTRMXDgwOjcuXPUr18/6tSpE7NmzYqnn346mjVrFh06dIhGjRpFjx49cme0PPLII3H//ffHtddeu1Ltbdq0adx6661x5513xtZbbx1vvfVWDB48OAoKCmL27Nkrte6lady4cey6665x1llnxcknnxwNGjSI559/Pm699dY488wzI2LhdXMHDBgQF110Uey1114xffr0GDJkSGy33Xa5DKVOnTrx+uuvR4sWLVbJUdlCw/+vUqVKceONN8bdd98do0ePjnvvvTcKCgpi6623jv79+y/1EP79998/zjjjjDjyyCNL9YFev379GD16dAwZMiRGjhwZ3377bVSrVi2aNGkSQ4YMiZ133jkiFv4ycPnll8egQYPihBNOiA022CB23XXX2HfffaN///65lHlFHXzwwfHTTz9Fr169YsMNN4y+ffvGwQcfXOK8zZs3j+HDh8f1118fvXr1iho1asT2228fZ599du4Xy5LUqFEjbr/99ujbt2+cddZZUbt27ejatWucccYZK9V2tSr/WlUEdSrfOs2bNy/Gjh0b8+fPj7POOmuJxy+44ILcjVHKSq3Kf58qKiqKO+64I6699to47bTTomrVqtGxY8c455xzlnsdv2VRq/x4/4PycNxxxy31sXfeeSf69OkTVapUyX3RqFGjRvTu3Tt69eoVDzzwQBx00EFxzDHHxBVXXBE9evSIJ554osL2k4KCgujfv3/85S9/idNOOy1q164dLVq0iKFDh8YJJ5wQb731VrRt23aF1780m2yySdx5551xzTXXxFlnnRWVK1eO5s2bx4gRI3KXwrnggguievXqMWTIkJg6dWpssskmcd555+VOWWzdunW0atUq+vTpE4ceemj8+c9/XuY2X3vttejSpUuJj+25555x/vnnx3XXXRcHHnhgbLvtthER0aFDh+jYsWNcfvnlsdNOO8Uf/vCH2GOPPWLo0KHx3nvvxZAhQ+KCCy6I9ddfP+66667c9WlPPPHE6Nmz50r1UZs2beLcc8+NkSNHxn333RcbbbRRHHTQQTFjxox4/PHHK+yImmOPPTbWXnvtGD58eNxyyy1Rr1693GdRxMIvvbfeemtcc801ce6558bcuXOjefPmMWzYsNwX4yOOOCLOO++8OP7442PEiBG5/iwr+9LyrY59aXFqtHyru0bLM2LEiBgxYkSJj/3f//1fbLjhhvH444/HlVdemQsve/XqFY8++mhcfPHFcccdd0Tnzp1j9OjRcdppp8Vpp50WPXr0iNtuuy2uueaa6NevX/z888/RoEGDuO6660q86UpZnHDCCfHNN99E//79Y+7cudGgQYO44oor4vbbb48333wzunbtulLrX5rrr78+brjhhhg0aFD88MMPsemmm8aFF16Yu1lWy5Yt49prr42bb745HnnkkahevXrsvPPOmRvaHH/88TFkyJB49dVX48UXX6yQG5suriBV1CcFa6yOHTvGrrvumjsFgDWXWuUHdcofapU/1AoAAFYvRxoCAACrzKK7ky9LpUqVVvv1t/4XzZs3b7nzVK5ceZl3g2bVsS+t+dQo/6WUYv78+cudr6KP+FtdfpvPCgAAWCP17t17uXeodPfy1aNJkybLneeOO+7IXXeQ1cu+tOZTo/z36quvxtFHH73c+caPH78KWrPqOT0ZAABYZb788sv4/vvvlzlP3bp13YxoNXj33XeXO0+DBg2iVq1aq6A1LI99ac2nRvlv5syZ8cUXXyx3vl/fXO+3QmgIAAAAAGQ4cR4AAAAAyBAaAgAAAAAZQkMAAAAAIENoCAAAAABkCA0BAAAAgAyhIQAAAACQITQEAAAAADKEhgAAAABAxv8DRlF+p+bA+BMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = LogisticRegression(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 = 'classification',\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",
    "\n",
    "#make plot\n",
    "make_plot(metric = 'Precision',\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": []
  }
 ],
 "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
}