data_pre.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import pickle as pkl\n",
    "import numpy as np\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, RidgeClassifier\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.preprocessing import Normalizer\n",
    "from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score, confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Collection and Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#reading dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"Train.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#data preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#handling categorical values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_map = {}\n",
    "for i in data.columns:\n",
    "    if str(data[i].dtype) == 'object':\n",
    "        temp = {}\n",
    "        cats = data[i].unique()\n",
    "        for index in range(len(cats)):\n",
    "            temp[cats[index]] = index\n",
    "        label_map[i] = temp\n",
    "        data[i] = data[i].map(temp)\n",
    "label_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#handling outlliers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=0\n",
    "plt.figure(figsize=(18, 10))\n",
    "for i in data.drop(columns=['Warehouse_block', 'Mode_of_Shipment', 'Product_importance', 'Gender', 'Reached.on.Time_Y.N', 'ID']).columns:\n",
    "    if str(data[i].dtype)=='object':\n",
    "        continue\n",
    "    plt.subplot(2, 3, c+1)\n",
    "    plt.boxplot(data[i])\n",
    "    plt.title(i)\n",
    "    c+=1\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_outliers(arr):\n",
    "    Q1 = np.percentile(arr, 25, interpolation='midpoint')\n",
    "    Q3 = np.percentile(arr, 75, interpolation='midpoint')\n",
    "    IQR = Q3 - Q1\n",
    "    \n",
    "    #Above upper bound\n",
    "    upper = Q3 + 1.5*IQR\n",
    "    upper_array = np.array(arr >= upper)\n",
    "    print(' '*3, len(upper_array[upper_array == True]), 'are over the upper bound', upper)\n",
    "    \n",
    "    #Below lower bound\n",
    "    lower = Q1 - 1.5*IQR\n",
    "    lower_array = np.array(arr <= lower)\n",
    "    print(' '*3, len(lower_array[lower_array == True]), 'are less than the lower bound', lower)\n",
    "    \n",
    "for i in data.drop(columns=['Warehouse_block', 'Mode_of_Shipment', 'Product_importance', 'Gender', 'Reached.on.Time_Y.N', 'ID']).columns:\n",
    "    if str(data[i].dtype)=='object':\n",
    "        continue  \n",
    "    print(i)\n",
    "    check_outliers(data[i])   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exploratory Data Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#descriptive statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.describe(include='all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#visual analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#splitting data into train and test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, x_test, y_train, y_test = train_test_split(data.drop(columns=['ID', 'Reached.on.Time_Y.N']),data['Reached.on.Time_Y.N'], random_state=1234, test_size=0.20, shuffle= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x_train.shape)\n",
    "print(x_test.shape)\n",
    "print(y_train.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the necessary module\n",
    "from sklearn.preprocessing import Normalizer\n",
    "\n",
    "# Initialize the L1 normalizer\n",
    "l1_normalizer = Normalizer(norm='l1')\n",
    "\n",
    "# Normalize x_train and x_test\n",
    "x_train_normalized = l1_normalizer.fit_transform(x_train)\n",
    "x_test_normalized = l1_normalizer.transform(x_test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model Building"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training model in multiple algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def models_eval_mm(x_train,y_train, x_test,y_test):\n",
    "# Logistic Regression\n",
    "    lg = LogisticRegression (random_state=1234)\n",
    "    lg.fit(x_train,y_train)\n",
    "\n",
    "    print('--Logistic Regression')\n",
    "    print('Train Score:', lg.score(x_train,y_train))\n",
    "    print('Test Score:',lg.score(x_test,y_test))\n",
    "\n",
    "    print()\n",
    "\n",
    "    lcv = LogisticRegressionCV (random_state=1234)\n",
    "    lcv.fit(x_train,y_train)\n",
    "\n",
    "    print('--Logistic Regression CV')\n",
    "    print('Train Score:',lcv.score(x_train,y_train))\n",
    "\n",
    "    print('Test Score:',lcv.score(x_test,y_test))\n",
    "    print()\n",
    "\n",
    "    print('--XGBoost')\n",
    "    xgb = XGBClassifier(random_state=1234)\n",
    "    xgb.fit(x_train,y_train)\n",
    "\n",
    "    print('Train Score:', xgb.score(x_train,y_train))\n",
    "    print('Test Score:',xgb.score(x_test,y_test))\n",
    "\n",
    "    print()\n",
    "\n",
    "    print('--Ridge Classifier')\n",
    "    rg = RidgeClassifier(random_state=1234)\n",
    "    rg.fit(x_train,y_train)\n",
    "\n",
    "    print('Train Score:', rg.score(x_train,y_train))\n",
    "    print('Test Score:',rg.score(x_test,y_test))\n",
    "\n",
    "    print()\n",
    "\n",
    "    print('--KNN')\n",
    "    knn = KNeighborsClassifier()\n",
    "    knn.fit(x_train,y_train)\n",
    "\n",
    "    print('Train Score:',knn.score(x_train,y_train))\n",
    "    print('Test Score:',knn.score(x_test,y_test))\n",
    "\n",
    "    print()\n",
    "\n",
    "    print('--Random Forest')\n",
    "    rf = RandomForestClassifier(random_state=1234)\n",
    "    rf.fit(x_train,y_train)\n",
    "\n",
    "    print('Train Score:',rf.score(x_train,y_train))\n",
    "    print('Test Score:',rf.score(x_test,y_test))\n",
    "\n",
    "    print()\n",
    "\n",
    "    print('--SVM classifier')\n",
    "    svc = svm.SVC(random_state=1234)\n",
    "\n",
    "    svc.fit(x_train,y_train)\n",
    "    print('Train Score:',svc.score(x_train,y_train))\n",
    "\n",
    "    print('Test Score:',svc.score(x_test,y_test))\n",
    "    print()\n",
    "\n",
    "    return lg, lcv, xgb, rg, knn, rf, svc\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lg, lcv, xgb, rg, knn, rf, svc = models_eval_mm(x_train_normalized, y_train, x_test_normalized, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#testng the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#model.predict(x_test_normalized[0].reshape(1,-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Performance Testing and Hyperparameter Tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval(name, model):\n",
    "    y_pred = model.predict(x_test_normalized)\n",
    "\n",
    "    result = []\n",
    "    result.append(name)\n",
    "\n",
    "    result.append(\"{:.2f}\".format(accuracy_score(y_test, y_pred) * 100))\n",
    "    result.append(\"{:.2f}\".format(f1_score(y_test, y_pred) * 100))\n",
    "    result.append(\"{:.2f}\".format(recall_score(y_test, y_pred) * 100))\n",
    "    result.append(\"{:.2f}\".format(precision_score(y_test, y_pred) * 100))\n",
    "\n",
    "    return result\n",
    "\n",
    "model_list = {\n",
    "    'logistic regression': lg,\n",
    "    'logistic regression CV': lcv,\n",
    "    'XGBoost': xgb,\n",
    "    'Ridge classifiering': rg,\n",
    "    'KNN': knn,\n",
    "    'Random Forest': rf,\n",
    "    'Support Vector Classifier': svc\n",
    "}\n",
    "\n",
    "model_eval_info = []\n",
    "\n",
    "for i in model_list.keys():\n",
    "    model_eval_info.append(eval(i, model_list[i]))\n",
    "\n",
    "model_eval_df = pd.DataFrame(model_eval_info, columns=['Name', \"Accuracy\", \"F1-score\", \"Recall\", 'Precision'])\n",
    "model_eval_df.to_csv('model_eval.csv')\n",
    "\n",
    "print(model_eval_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hyperparameter optimisation for SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "svc = svm.SVC(random_state=1234)\n",
    "params = {\n",
    "    'kernel': ['poly', 'rbf'],\n",
    "    'C': [10, 13],\n",
    "    'tol': [1e-1, 1e-2, 1e-3],\n",
    "    'gamma': [4, 5],\n",
    "}\n",
    "\n",
    "grid_search = GridSearchCV(svc, param_grid=params, cv=5, refit=True, scoring=\"accuracy\", n_jobs=-1, verbose=3)\n",
    "grid_search.fit(x_train_normalized, y_train)\n",
    "\n",
    "print(grid_search.best_estimator_, grid_search.best_params_, grid_search.best_score_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hyperparameter optimisation for XGBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    'min_child_weight' : [10,20],\n",
    "    'gamma':[1.5, 2.0, 2.5],\n",
    "    'colsample_bytree' : [0.6, 0.8, 0.9],\n",
    "    'max_depth' : [4,5,6]\n",
    "}\n",
    "\n",
    "xgb = XGBClassifier(learning_rate = 0.5, n_estimators = 100, objective = 'binary:logistic', nthread = 3)\n",
    "fitmodel = GridSearchCV(xgb, param_grid=params, cv=5, refit=True, scoring=\"accuracy\", n_jobs=-1, verbose=3)\n",
    "fitmodel.fit(x_train_normalized, y_train)\n",
    "\n",
    "print(fitmodel.best_estimator_, fitmodel.best_params_, fitmodel.best_score_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#logistic regression hyperparameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Yash Singh\\AppData\\Local\\Temp\\ipykernel_3200\\2491883471.py:23: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n",
      "  data = data.fillna(method='ffill')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Logistic Regression\n",
      "Train Score: 0.6973333333333334\n",
      "Test Score: 0.6907844630616908\n",
      "\n",
      "--Logistic Regression CV\n",
      "Train Score: 0.7006666666666667\n",
      "Test Score: 0.7037319116527038\n",
      "\n",
      "--XGBoost\n",
      "Train Score: 0.92\n",
      "Test Score: 0.7254379284082254\n",
      "\n",
      "--Ridge Classifier\n",
      "Train Score: 0.7083809523809523\n",
      "Test Score: 0.7121096725057121\n",
      "\n",
      "--KNN\n",
      "Train Score: 0.8043809523809524\n",
      "Test Score: 0.7132520944402132\n",
      "\n",
      "--Random Forest\n",
      "Train Score: 1.0\n",
      "Test Score: 0.7399086062452399\n",
      "\n",
      "--SVM classifier\n",
      "Train Score: 0.7246666666666667\n",
      "Test Score: 0.7353389185072353\n",
      "\n",
      "                     Name Accuracy F1-score Recall Precision\n",
      "0     Logistic Regression    69.08    64.20  55.79     75.60\n",
      "1  Logistic Regression CV    70.37    63.95  52.87     80.89\n",
      "2                 XGBoost    72.54    70.19  65.06     76.21\n",
      "3        Ridge Classifier    71.21    65.73  55.56     80.47\n",
      "4                     KNN    71.33    67.61  60.23     77.06\n",
      "5           Random Forest    73.99    69.55  59.77     83.16\n",
      "6          SVM classifier    73.53    64.52  48.43     96.64\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split, RandomizedSearchCV, cross_val_score\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score, classification_report\n",
    "from xgboost import XGBClassifier\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, RidgeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn import svm\n",
    "import pickle\n",
    "\n",
    "# Load dataset\n",
    "data = pd.read_csv('Train.csv')\n",
    "\n",
    "# Feature engineering\n",
    "data['Total_Interaction'] = data['Customer_care_calls'] * data['Customer_rating']\n",
    "data['Cost_per_Weight'] = data['Cost_of_the_Product'] / data['Weight_in_gms']\n",
    "\n",
    "# Data preprocessing\n",
    "data = data.fillna(method='ffill')\n",
    "\n",
    "# Define features and target\n",
    "X = data.drop(columns=['ID', 'Reached.on.Time_Y.N'])\n",
    "y = data['Reached.on.Time_Y.N']\n",
    "\n",
    "# Define numerical and categorical features\n",
    "numerical_features = ['Customer_care_calls', 'Customer_rating', 'Cost_of_the_Product', 'Prior_purchases', 'Discount_offered', 'Weight_in_gms', 'Total_Interaction', 'Cost_per_Weight']\n",
    "categorical_features = ['Warehouse_block', 'Mode_of_Shipment', 'Product_importance', 'Gender']\n",
    "\n",
    "numerical_transformer = StandardScaler()\n",
    "categorical_transformer = OneHotEncoder(handle_unknown='ignore', drop='first')\n",
    "\n",
    "preprocessor = ColumnTransformer(\n",
    "    transformers=[\n",
    "        ('num', numerical_transformer, numerical_features),\n",
    "        ('cat', categorical_transformer, categorical_features)\n",
    "    ])\n",
    "\n",
    "# Preprocess data before applying SMOTE\n",
    "X_preprocessed = preprocessor.fit_transform(X)\n",
    "\n",
    "# Apply SMOTE to the preprocessed training data\n",
    "smote = SMOTE(random_state=42)\n",
    "X_resampled, y_resampled = smote.fit_resample(X_preprocessed, y)\n",
    "\n",
    "# Split resampled data into training and test sets\n",
    "X_train_res, X_test_res, y_train_res, y_test_res = train_test_split(X_resampled, y_resampled, test_size=0.2, random_state=42)\n",
    "\n",
    "# Model evaluation function\n",
    "def models_eval_mm(x_train, y_train, x_test, y_test):\n",
    "    models = {\n",
    "        'Logistic Regression': LogisticRegression(random_state=1234),\n",
    "        'Logistic Regression CV': LogisticRegressionCV(random_state=1234),\n",
    "        'XGBoost': XGBClassifier(random_state=1234),\n",
    "        'Ridge Classifier': RidgeClassifier(random_state=1234),\n",
    "        'KNN': KNeighborsClassifier(),\n",
    "        'Random Forest': RandomForestClassifier(random_state=1234),\n",
    "        'SVM classifier': svm.SVC(random_state=1234)\n",
    "    }\n",
    "\n",
    "    for name, model in models.items():\n",
    "        model.fit(x_train, y_train)\n",
    "        print(f'--{name}')\n",
    "        print('Train Score:', model.score(x_train, y_train))\n",
    "        print('Test Score:', model.score(x_test, y_test))\n",
    "        print()\n",
    "    \n",
    "    return models\n",
    "\n",
    "# Evaluate models\n",
    "models = models_eval_mm(X_train_res, y_train_res, X_test_res, y_test_res)\n",
    "\n",
    "# Evaluation function\n",
    "def eval(name, model, x_test, y_test):\n",
    "    y_pred = model.predict(x_test)\n",
    "    result = [\n",
    "        name,\n",
    "        f\"{accuracy_score(y_test, y_pred) * 100:.2f}\",\n",
    "        f\"{f1_score(y_test, y_pred) * 100:.2f}\",\n",
    "        f\"{recall_score(y_test, y_pred) * 100:.2f}\",\n",
    "        f\"{precision_score(y_test, y_pred) * 100:.2f}\"\n",
    "    ]\n",
    "    return result\n",
    "\n",
    "# Collect evaluation results\n",
    "model_eval_info = []\n",
    "for name, model in models.items():\n",
    "    model_eval_info.append(eval(name, model, X_test_res, y_test_res))\n",
    "\n",
    "# Create a DataFrame for evaluation results\n",
    "model_eval_df = pd.DataFrame(model_eval_info, columns=['Name', 'Accuracy', 'F1-score', 'Recall', 'Precision'])\n",
    "model_eval_df.to_csv('model_eval.csv', index=False)\n",
    "\n",
    "print(model_eval_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Yash Singh\\AppData\\Local\\Temp\\ipykernel_3200\\1454650401.py:25: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n",
      "  data = data.fillna(method='ffill')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Logistic Regression\n",
      "Train Score: 0.6973333333333334\n",
      "Test Score: 0.6907844630616908\n",
      "\n",
      "--Logistic Regression CV\n",
      "Train Score: 0.7006666666666667\n",
      "Test Score: 0.7037319116527038\n",
      "\n",
      "--XGBoost\n",
      "Train Score: 0.92\n",
      "Test Score: 0.7254379284082254\n",
      "\n",
      "--Ridge Classifier\n",
      "Train Score: 0.7083809523809523\n",
      "Test Score: 0.7121096725057121\n",
      "\n",
      "--KNN\n",
      "Train Score: 0.8043809523809524\n",
      "Test Score: 0.7132520944402132\n",
      "\n",
      "--Random Forest\n",
      "Train Score: 1.0\n",
      "Test Score: 0.7399086062452399\n",
      "\n",
      "--SVM classifier\n",
      "Train Score: 0.7246666666666667\n",
      "Test Score: 0.7353389185072353\n",
      "\n",
      "--Logistic Regression Classification Report--\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.65      0.82      0.73      1321\n",
      "           1       0.76      0.56      0.64      1305\n",
      "\n",
      "    accuracy                           0.69      2626\n",
      "   macro avg       0.70      0.69      0.68      2626\n",
      "weighted avg       0.70      0.69      0.69      2626\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Logistic Regression CV Classification Report--\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.65      0.88      0.75      1321\n",
      "           1       0.81      0.53      0.64      1305\n",
      "\n",
      "    accuracy                           0.70      2626\n",
      "   macro avg       0.73      0.70      0.69      2626\n",
      "weighted avg       0.73      0.70      0.69      2626\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--XGBoost Classification Report--\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.70      0.80      0.75      1321\n",
      "           1       0.76      0.65      0.70      1305\n",
      "\n",
      "    accuracy                           0.73      2626\n",
      "   macro avg       0.73      0.72      0.72      2626\n",
      "weighted avg       0.73      0.73      0.72      2626\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg4AAAIjCAYAAABriZPRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAByqklEQVR4nO3dd1gU1/s28HtpSxMQlWYB7KDYE8VuINbYTdQQRcUSo6KoqHyNRrEQid1ESdSIvZcYjQV7I3bsImLBQlEUEVTqef/wZX6ugNlV1kH2/uSaK3LmzMwzA7oPz5wzoxBCCBARERGpQU/uAIiIiOjTwcSBiIiI1MbEgYiIiNTGxIGIiIjUxsSBiIiI1MbEgYiIiNTGxIGIiIjUxsSBiIiI1MbEgYiIiNTGxIG0JioqCi1btoSlpSUUCgW2bdtWoPu/c+cOFAoFQkNDC3S/n7LmzZujefPmBba/lJQU9O/fH3Z2dlAoFBgxYkSB7ZuIPk1MHIq46OhoDBo0COXLl4exsTEsLCzQqFEjzJs3Dy9fvtTqsb29vXHp0iVMmzYNK1euRL169bR6vI+pT58+UCgUsLCwyPM6RkVFQaFQQKFQYObMmRrv/+HDh5g0aRIiIiIKINr3N336dISGhmLw4MFYuXIlevXqpbVjXb16FUZGRujbt2+udUlJSbC3t0f9+vWRnZ2tsu7ixYvo27cvnJ2dYWxsDHNzc9SqVQtjxozBrVu3VPrmfN9yFgMDA5QtWxY9evTA1atXtXZu6rp69SomTZqEO3fuyB0KUb4M5A6AtGfnzp34+uuvoVQq0bt3b1SvXh3p6ek4duwY/P39ceXKFfzxxx9aOfbLly8RHh6O8ePHY+jQoVo5hqOjI16+fAlDQ0Ot7P+/GBgY4MWLF/j777/xzTffqKxbvXo1jI2N8erVq/fa98OHDzF58mQ4OTmhVq1aam+3d+/e9zpefg4cOIAGDRrgp59+KtD95sXV1RX+/v6YPn06+vTpg2bNmknrxo0bh0ePHmHXrl3Q0/u/33cWL16MwYMHo2TJkvDy8kLVqlWRmZmJy5cvY8WKFZg7dy5evnwJfX19aRulUoklS5YAADIzMxEdHY2QkBDs3r0bV69ehYODg9bPNT9Xr17F5MmT0bx5czg5OckWB9G7MHEoom7fvo0ePXrA0dERBw4cgL29vbRuyJAhuHnzJnbu3Km14z969AgAYGVlpbVjKBQKGBsba23//0WpVKJRo0ZYu3ZtrsRhzZo1aNeuHTZv3vxRYnnx4gVMTU1hZGRUoPtNSEiAq6trge0vMzMT2dnZ+cY5YcIErF+/HoMGDcLFixdhZGSE8PBw/PHHH/Dz81NJok6cOIHBgwejUaNG2LFjB4oVK6ayr1mzZmHatGm5jmFgYIDvvvtOpa1Bgwb46quvsHPnTgwYMODDT5SoKBNUJH3//fcCgDh+/Lha/TMyMkRgYKAoX768MDIyEo6OjiIgIEC8evVKpZ+jo6No166dOHr0qPjss8+EUqkUzs7OYvny5VKfn376SQBQWRwdHYUQQnh7e0t/flPONm/au3evaNSokbC0tBRmZmaicuXKIiAgQFp/+/ZtAUAsW7ZMZbv9+/eLxo0bC1NTU2FpaSk6dOggrl69mufxoqKihLe3t7C0tBQWFhaiT58+IjU19T+vl7e3tzAzMxOhoaFCqVSKp0+fSutOnTolAIjNmzcLAOKXX36R1iUmJopRo0aJ6tWrCzMzM1GsWDHRunVrERERIfU5ePBgruv35nk2a9ZMVKtWTZw5c0Y0adJEmJiYiOHDh0vrmjVrJu2rd+/eQqlU5jr/li1bCisrK/HgwYM8zy+/GG7fvi2EECI+Pl7069dP2NjYCKVSKWrUqCFCQ0NV9pHz/fnll1/EnDlzRPny5YWenp44f/78O6/t3r17BQAxadIkkZ6eLqpXry7KlSsnUlJScp2DgYGBuHfv3jv396ac79vbzpw5IwCIP//8U6U9OjpadOvWTRQvXlyYmJiI+vXrix07duTaXp3rIYQQa9euFXXq1BHm5uaiWLFionr16mLu3LlCCCGWLVuW5zU/ePCg2udH9DEwcSiiSpcuLcqXL692f29vbwFAdOvWTfz222+id+/eAoDo1KmTSj9HR0dRpUoVYWtrK/73v/+JX3/9VdSpU0coFApx+fJlIYQQFy5cEHPmzBEARM+ePcXKlSvF1q1bpeOokzhcvnxZGBkZiXr16ol58+aJkJAQMXr0aNG0aVOpT16JQ1hYmDAwMBCVK1cWwcHBYvLkyaJkyZKiePHi0ofem8erXbu26NKli1i4cKHo37+/ACDGjBmj1vUyMzMTycnJwtjYWCxdulRaN2LECFG1alWVD84cp0+fFhUqVBDjxo0Tv//+uwgMDBSlS5cWlpaW0od4XFycCAwMFADEwIEDxcqVK8XKlStFdHS0EOJ1cmBnZydKlSolhg0bJn7//Xexbds2ad2bicPTp09FmTJlxGeffSYyMzOFEEKEhIQIAGLlypX5nl9cXJxYuXKlKFmypKhVq5YUQ0pKinjx4oVwcXERhoaGws/PT8yfP180adJEAJA+BN/8/ri6uory5cuLn3/+WcyZM0fcvXv3P69vz549hVKpFAMHDhQAxF9//aWyPjU1VRgYGAhPT8//3Nebcr5vjx49Eo8ePRJxcXHixIkTokmTJqJEiRIiISFB5RrY2tqKYsWKifHjx4vZs2eLmjVrCj09PbFlyxapn7rXIych8vDwEL/99pv47bffxNChQ8XXX38thHidpPj6+goA4n//+590zePi4jQ6RyJtY+JQBD179kwAEB07dlSrf0REhAAg+vfvr9I+evRoAUAcOHBAanN0dBQAxJEjR6S2hIQEoVQqxahRo6S2vD40hVA/cchJPB49epRv3HklDrVq1RI2NjYiMTFRartw4YLQ09MTvXv3znW8fv36qeyzc+fOokSJEvke883zyPnNtVu3bsLDw0MIIURWVpaws7MTkydPzvMavHr1SmRlZeU6D6VSKQIDA6W206dP51lNEeJ1cgBAhISE5LnuzcRBCCH27NkjAIipU6eKW7duCXNz81wJYX5yKkxvmjt3rgAgVq1aJbWlp6cLd3d3YW5uLpKTk6XzAiAsLCxUPpDVERcXJ4oXL55n8irE6+8pADFixIhc6xITE6XE4NGjRyItLU1al5Mgv72ULl1anD17VmU/I0aMEADE0aNHpbbnz58LZ2dn4eTkJH0f1b0ew4cPFxYWFlICl5eNGzeyykCFHmdVFEHJyckAkOueb37++ecfAMDIkSNV2keNGgUAucZCuLq6okmTJtLXpUqVQpUqVXKNYP8QOWMj/vrrr1yj6PMTGxuLiIgI9OnTB9bW1lJ7jRo18OWXX0rn+abvv/9e5esmTZogMTFRuobq+Pbbb3Ho0CHExcXhwIEDiIuLw7fffptnX6VSKQ3uy8rKQmJiIszNzVGlShWcO3dO7WMqlco8Zx/kpWXLlhg0aBACAwPRpUsXGBsb4/fff1f7WG/7559/YGdnh549e0pthoaG8PX1RUpKCg4fPqzSv2vXrihVqpRGxzA1NYWpqakU/9tyvj/m5ua51pUvXx6lSpWSlu3bt6usNzY2RlhYGMLCwrBnzx78/vvvMDc3R9u2bXHjxg2V8/z888/RuHFjqc3c3BwDBw7EnTt3pFkY6l4PKysrpKamIiwsTKNrQVTYMHEogiwsLAAAz58/V6v/3bt3oaenh4oVK6q029nZwcrKCnfv3lVpL1euXK59FC9eHE+fPn3PiHPr3r07GjVqhP79+8PW1hY9evTAhg0b3plE5MRZpUqVXOtcXFzw+PFjpKamqrS/fS7FixcHAI3OpW3btihWrBjWr1+P1atX47PPPst1LXNkZ2djzpw5qFSpEpRKJUqWLIlSpUrh4sWLePbsmdrHLF26tEYDIWfOnAlra2tERERg/vz5sLGxUXvbt929exeVKlVSmd0AvL7GOevf5OzsrPExxo8fj7i4OLi4uOCnn37K9f3ISYpTUlJybfvXX38hLCws32mw+vr68PT0hKenJ1q2bImBAwdi3759ePbsGQICAlTOM7+fpZz1Of9X53r88MMPqFy5Mtq0aYMyZcqgX79+2L17t1rXg6gwYeJQBFlYWMDBwQGXL1/WaDuFQqFWvzentr1JCPHex8jKylL52sTEBEeOHMG+ffvQq1cvXLx4Ed27d8eXX36Zq++H+JBzyaFUKtGlSxcsX74cW7duzbfaALx+LsLIkSPRtGlTrFq1Cnv27EFYWBiqVaumdmUFeH19NHH+/HkkJCQAAC5duqTRth9K01jPnDmD3377DcOGDcO6devw9OlTjB07VqVPxYoVYWBgkOfPeLNmzeDp6Ym6deuqfcwyZcqgSpUqOHLkiEaxasLGxgYRERHYvn07OnTogIMHD6JNmzbw9vbW2jGJtIGJQxH11VdfITo6GuHh4f/Z19HREdnZ2YiKilJpj4+PR1JSEhwdHQssruLFiyMpKSlX+9u/pQKAnp4ePDw8MHv2bFy9ehXTpk3DgQMHcPDgwTz3nRNnZGRkrnXXr19HyZIlYWZm9mEnkI9vv/0W58+fx/Pnz9GjR498+23atAktWrTA0qVL0aNHD7Rs2RKenp65rom6SZw6UlNT0bdvX7i6umLgwIEIDg7G6dOn33t/jo6OiIqKypXoXL9+XVr/vrKysjBw4EA4ODggMDAQNWrUwPDhw7FkyRKVn2UzMzM0b94chw8fxoMHD977eG/KzMxUqWA4Ojrm+7OUsz7n/+peDyMjI7Rv3x4LFy6UHs62YsUK3Lx5E0DBft+JtIWJQxE1ZswYmJmZoX///oiPj8+1Pjo6GvPmzQPwutQOAHPnzlXpM3v2bABAu3btCiyuChUq4NmzZ7h48aLUFhsbi61bt6r0e/LkSa5tc+bwp6Wl5blve3t71KpVC8uXL1f5IL58+TL27t0rnac2tGjRAlOmTMGvv/4KOzu7fPvp6+vnqmZs3Lgx14dfToKTV5KlqbFjxyImJgbLly/H7Nmz4eTkBG9v73yv439p27Yt4uLisH79eqktMzMTCxYsgLm5ucqDmzQ1f/58nD9/HvPnz5duR0yePBllypTB999/j8zMTKnvxIkTkZWVhe+++y7PWxaaVI1u3LiByMhI1KxZU2pr27YtTp06pZKwpKam4o8//oCTk5P0fAt1r0diYqLKMfX09FCjRg0A//czXZDfdyJt4QOgiqgKFSpgzZo16N69O1xcXFSeHHnixAls3LgRffr0AQDUrFkT3t7e+OOPP5CUlIRmzZrh1KlTWL58OTp16oQWLVoUWFw9evTA2LFj0blzZ/j6+uLFixdYtGgRKleurDI4MDAwEEeOHEG7du3g6OiIhIQELFy4EGXKlFEZrPa2X375BW3atIG7uzt8fHzw8uVLLFiwAJaWlpg0aVKBncfb9PT08OOPP/5nv6+++gqBgYHo27cvGjZsiEuXLmH16tUoX768Sr8KFSrAysoKISEhKFasGMzMzFC/fn2NxwscOHAACxcuxE8//YQ6deoAAJYtW4bmzZtjwoQJCA4O1mh/ADBw4ED8/vvv6NOnD86ePQsnJyds2rQJx48fx9y5c9UelPu2e/fuYeLEiWjfvj06d+4stZuZmWHevHno0qUL5s2bJw3abdKkCX799VcMGzYMlSpVkp4cmZ6ejhs3bmD16tUwMjLKlchlZmZi1apVAF6POblz5w5CQkKQnZ2t8oTMcePGYe3atWjTpg18fX1hbW2N5cuX4/bt29i8ebM0pkHd69G/f388efIEX3zxBcqUKYO7d+9iwYIFqFWrljQeolatWtDX18eMGTPw7NkzKJVKfPHFFx80JoWowMk7qYO07caNG2LAgAHCyclJGBkZiWLFiolGjRqJBQsWqDzcKSMjQ0yePFk4OzsLQ0NDUbZs2Xc+AOptb08DzG86phCv57NXr15dGBkZiSpVqohVq1blmo65f/9+0bFjR+Hg4CCMjIyEg4OD6Nmzp7hx40auY7w9ZXHfvn2iUaNGwsTERFhYWIj27dvn+wCot6d75jyE581nPuQlvwcJvSm/6ZijRo0S9vb2wsTERDRq1EiEh4fnOY3yr7/+Eq6ursLAwCDPB0Dl5c39JCcnC0dHR1GnTh2RkZGh0s/Pz0/o6emJ8PDwd55Dft/v+Ph40bdvX1GyZElhZGQk3Nzccn0f3vUzkJeOHTsKMzOzfJ/z8NVXXwlzc3MRExOj0n7+/HnRu3dvUa5cOWFkZCTMzMxEjRo1xKhRo8TNmzdV+uY1HdPCwkJ4eHiIffv25TpmzgOgrKyshLGxsfj888/zfQDUf12PTZs2iZYtWwobGxthZGQkypUrJwYNGiRiY2NV+i1evFiUL19e6Ovrc2omFUoKITSo5xEREZFO4xgHIiIiUhsTByIiIlIbEwciIiJSGxMHIiIiUhsTByIiIlIbEwciIiJSGxMHIiIiUluRfHKkSe2hcodApHVPT/8qdwhEWmes5U8pbX5evDxfNP+OsuJAREREaiuSFQciIiK1KPj7s6aYOBARke7iq8w1xlSLiIiI1MaKAxER6S7eqtAYrxgRERGpjRUHIiLSXRzjoDFWHIiIiEhtrDgQEZHu4hgHjfGKERERkdpYcSAiIt3FMQ4aY+JARES6i7cqNMYrRkRERGpjxYGIiHQXb1VojBUHIiIiUhsrDkREpLs4xkFjvGJERESkNlYciIhId3GMg8ZYcSAiIiK1seJARES6i2McNMbEgYiIdBdvVWiMqRYRERGpjRUHIiLSXbxVoTFeMSIiIlIbKw5ERKS7WHHQGK8YERERqY0VByIi0l16nFWhKVYciIiISG1MHIiISHcp9LS3aODIkSNo3749HBwcoFAosG3bNpX1QghMnDgR9vb2MDExgaenJ6KiolT6PHnyBF5eXrCwsICVlRV8fHyQkpKi0ufixYto0qQJjI2NUbZsWQQHB2t8yZg4EBGR7lIotLdoIDU1FTVr1sRvv/2W5/rg4GDMnz8fISEhOHnyJMzMzNCqVSu8evVK6uPl5YUrV64gLCwMO3bswJEjRzBw4EBpfXJyMlq2bAlHR0ecPXsWv/zyCyZNmoQ//vhDs0smhBAabfEJMKk9VO4QiLTu6elf5Q6BSOuMtTwSz8Rjutb2nfTPKKSlpam0KZVKKJXKd26nUCiwdetWdOrUCcDraoODgwNGjRqF0aNHAwCePXsGW1tbhIaGokePHrh27RpcXV1x+vRp1KtXDwCwe/dutG3bFvfv34eDgwMWLVqE8ePHIy4uDkZGRgCAcePGYdu2bbh+/bra58WKAxER6S4t3qoICgqCpaWlyhIUFKRxiLdv30ZcXBw8PT2lNktLS9SvXx/h4eEAgPDwcFhZWUlJAwB4enpCT08PJ0+elPo0bdpUShoAoFWrVoiMjMTTp0/VjoezKoiIiLQgICAAI0eOVGn7r2pDXuLi4gAAtra2Ku22trbSuri4ONjY2KisNzAwgLW1tUofZ2fnXPvIWVe8eHG14mHiQEREukuLL7lS57bEp4i3KoiIiAoxOzs7AEB8fLxKe3x8vLTOzs4OCQkJKuszMzPx5MkTlT557ePNY6iDiQMREemuQjId812cnZ1hZ2eH/fv3S23Jyck4efIk3N3dAQDu7u5ISkrC2bNnpT4HDhxAdnY26tevL/U5cuQIMjIypD5hYWGoUqWK2rcpACYOREREsktJSUFERAQiIiIAvB4QGRERgZiYGCgUCowYMQJTp07F9u3bcenSJfTu3RsODg7SzAsXFxe0bt0aAwYMwKlTp3D8+HEMHToUPXr0gIODAwDg22+/hZGREXx8fHDlyhWsX78e8+bNyzUO479wjAMREekuLY5x0MSZM2fQokUL6eucD3Nvb2+EhoZizJgxSE1NxcCBA5GUlITGjRtj9+7dMDY2lrZZvXo1hg4dCg8PD+jp6aFr166YP3++tN7S0hJ79+7FkCFDULduXZQsWRITJ05UedaDOvgcB6JPFJ/jQLpA689xaD1ba/t+uVuz3+Q/FbxVQURERGrjrQoiItJdheRWxaeEFQciIiJSW6FIHFauXIlGjRrBwcEBd+/eBQDMnTsXf/31l8yRERFRkfYJTMcsbGQ/s0WLFmHkyJFo27YtkpKSkJWVBQCwsrLC3Llz5Q2OiIiIVMieOCxYsACLFy/G+PHjoa+vL7XXq1cPly5dkjEyIiIq8grJa7U/JbInDrdv30bt2rVztSuVSqSmpsoQEREREeVH9sTB2dlZelLWm3bv3g0XF5ePHxAREekOjnHQmOzTMUeOHIkhQ4bg1atXEELg1KlTWLt2LYKCgrBkyRK5wyMioqKsCH/Aa4vsiUP//v1hYmKCH3/8ES9evMC3334LBwcHzJs3Dz169JA7PCIiInqD7IkDAHh5ecHLywsvXrxASkoKbGxs5A6JiIh0QREexKgthSJxyGFqagpTU1O5wyAiIqJ8yJ44JCYmYuLEiTh48CASEhKQnZ2tsv7JkycyRUZEREUexzhoTPbEoVevXrh58yZ8fHxga2sLBctGREREhZbsicPRo0dx7Ngx1KxZU+5QiIhI1/CXVY3JXqOpWrUqXr58KXcYREREpAbZE4eFCxdi/PjxOHz4MBITE5GcnKyyEBERaQ0fAKUx2W9VWFlZITk5GV988YVKuxACCoVCeukVERFRgeOtCo3Jnjh4eXnB0NAQa9as4eBIIiKiQk72xOHy5cs4f/48qlSpIncoRESkY/jLquZkvwlTr1493Lt3T+4wiIiISA2yVxyGDRuG4cOHw9/fH25ubjA0NFRZX6NGDZkiIyKioo4VB83Jnjh0794dANCvXz+pTaFQcHAkERFRISR74nD79m25QyAiIl3FgoPGZE8cHB0d5Q6BiIiI1CRL4rB9+3a0adMGhoaG2L59+zv7dujQ4SNFRUREuoZjHDQnS+LQqVMnxMXFwcbGBp06dcq3H8c4EBGRNjFx0Jws0zGzs7Px6tUrCCGQnZ2d78KkgYiIqHCR7TkOzs7OePTokVyHJyIigkKh0NpSVMmWOAgh5Do0ERERvSdZZ1UU5YyMiIgKP34OaU7WxGHChAkwNTV9Z5/Zs2d/pGiIiIjov8iaOFy6dAlGRkb5rmcmSEREWsWPGY3Jmjhs3boVNjY2coZAREREGpAtcWA1gYiI5MbPIs1xVgURERGpTbaKw7Jly2BpaSnX4YmIiFhxeA+yJQ7e3t5yHZqIiAgAE4f3IdutCiIiIvr0yP5abSIiIrmw4qA5VhyIiIhIbYWm4pCeno6EhARkZ2ertJcrV06miIiIqMhjwUFjsicOUVFR6NevH06cOKHSLoSAQqHgq7WJiIgKEdkThz59+sDAwAA7duyAvb097zcREdFHw88czcmeOERERODs2bOoWrWq3KEQERHRf5A9cXB1dcXjx4/lDoOIiHQQKw6ak31WxYwZMzBmzBgcOnQIiYmJSE5OVlmIiIi0RaFQaG0pqmRPHDw9PfHvv//Cw8MDNjY2KF68OIoXLw4rKysUL15c7vCIiIi07vnz5xgxYgQcHR1hYmKChg0b4vTp09J6IQQmTpwIe3t7mJiYwNPTE1FRUSr7ePLkCby8vGBhYQErKyv4+PggJSWlwGOV/VbFwYMH5Q6BiIh0VSEpDPTv3x+XL1/GypUr4eDggFWrVsHT0xNXr15F6dKlERwcjPnz52P58uVwdnbGhAkT0KpVK1y9ehXGxsYAAC8vL8TGxiIsLAwZGRno27cvBg4ciDVr1hRorApRBF9TaVJ7qNwhEGnd09O/yh0CkdYZa/nXWxufDVrbd8LSb9Tq9/LlSxQrVgx//fUX2rVrJ7XXrVsXbdq0wZQpU+Dg4IBRo0Zh9OjRAIBnz57B1tYWoaGh6NGjB65duwZXV1ecPn0a9erVAwDs3r0bbdu2xf379+Hg4FBg5yV7xQEAkpKSsHTpUly7dg0AUK1aNfTr149vzyQiIq3S5liEtLQ0pKWlqbQplUoolUqVtszMTGRlZUmVgxwmJiY4duwYbt++jbi4OHh6ekrrLC0tUb9+fYSHh6NHjx4IDw+HlZWVlDQAr4cC6Onp4eTJk+jcuXOBnZfsYxzOnDmDChUqYM6cOXjy5AmePHmC2bNno0KFCjh37pzc4REREb2XoKAgWFpaqixBQUG5+hUrVgzu7u6YMmUKHj58iKysLKxatQrh4eGIjY1FXFwcAMDW1lZlO1tbW2ldXFwcbGxsVNYbGBjA2tpa6lNQZK84+Pn5oUOHDli8eDEMDF6Hk5mZif79+2PEiBE4cuSIzBESEVFRpc2KQ0BAAEaOHKnS9na1IcfKlSvRr18/lC5dGvr6+qhTpw569uyJs2fPai2+91UoKg5jx46VkgbgdZY0ZswYnDlzRsbIiIiI3p9SqYSFhYXKkl/iUKFCBRw+fBgpKSm4d+8eTp06hYyMDJQvXx52dnYAgPj4eJVt4uPjpXV2dnZISEhQWZ+ZmYknT55IfQqK7ImDhYUFYmJicrXfu3cPxYoVkyEiIiLSFYXtOQ5mZmawt7fH06dPsWfPHnTs2BHOzs6ws7PD/v37pX7Jyck4efIk3N3dAQDu7u5ISkpSqVAcOHAA2dnZqF+//oddpLfIfquie/fu8PHxwcyZM9GwYUMAwPHjx+Hv74+ePXvKHB0RERVlheVBTXv27IEQAlWqVMHNmzfh7++PqlWrom/fvlAoFBgxYgSmTp2KSpUqSdMxHRwc0KlTJwCAi4sLWrdujQEDBiAkJAQZGRkYOnQoevToUaAzKoBCkDjMnDkTCoUCvXv3RmZmJgDA0NAQgwcPxs8//yxzdERERNr37NkzBAQE4P79+7C2tkbXrl0xbdo0GBoaAgDGjBmD1NRUDBw4EElJSWjcuDF2796tMhNj9erVGDp0KDw8PKCnp4euXbti/vz5BR5roXmOw4sXLxAdHQ3g9b0eU1PT994Xn+NAuoDPcSBdoO3nODh8v0Vr+34Y0kVr+5aT7BWHHKampnBzc5M7DCIiInqHQpM4EBERfWyFZYzDp0T2WRVERET06WDFgYiIdBYrDppjxYGIiIjUJkvFYfv27Wr37dChgxYjISIiXcaKg+ZkSRxyHliRQ6FQ4M1ZoW9+I7Oysj5WWEREpGuYN2hMllsV2dnZ0rJ3717UqlULu3btQlJSEpKSkvDPP/+gTp062L17txzhERERUT5kHxw5YsQIhISEoHHjxlJbq1atYGpqioEDB+LatWsyRkdEREUZb1VoTvbBkdHR0bCyssrVbmlpiTt37nz0eIiIiCh/sicOn332GUaOHKnyutD4+Hj4+/vj888/lzEyIiIq6grb2zE/BbInDn/++SdiY2NRrlw5VKxYERUrVkS5cuXw4MEDLF26VO7wiIiI6A2yj3GoWLEiLl68iLCwMFy/fh3A69eDenp6FumMrbBpVKcC/Hp7oo5rOdiXssQ3fn/g70MXVfpMGNwOfTs3hFUxE4RfuAXf6esRHfNIWn9952Q4OpRQ3Wb+X5i5LEylbUQvD/Tr2gjl7IsjMSkVv284iuCle7R3ckT5WLr4d+wP24vbt29BaWyMWrVqY8TI0XByLq/S70LEeSyYNweXLl2Evp4eqlR1waI/lkpvJmzz5Rd4+PCByja+I0bBZ8DAj3Yu9H74OaM52RMH4PU3rmXLlmjatCmUSiW/kTIwM1Hi0o0HWPFXONbPzv2P3ag+nvihZzMMmLgSdx4kYuIPX+Hv34agdtepSEvPlPpNXrgDy7Ycl75+npqmsp9ZY7rBo0FVBMzZistRD2FtaYriFmbaOzGidzhz+hS69/RCNTc3ZGVmYcG82fh+gA+2bN8pvaH3QsR5/DCoP/r1H4Rx4yfAQF8fkZHXoaenWrD9Yagvunb7Rvra1Iw/11Q0yZ44ZGdnY9q0aQgJCUF8fDxu3LiB8uXLY8KECXBycoKPj4/cIeqEvcevYu/xq/muH/JtC8xYvAc7Dl0CAPSfsAJ39wWhQ4ua2LjnrNQvJfUV4hOf57mPKs62GNCtCep+PQ1RdxMAAHcfJhbgWRBpZtEfqrdDA6f9jBZN3HHt6hXUrfcZAOCXGUHo6dVLpXrwdkUCAMzMzFCyVCntBkwFjr+oak72MQ5Tp05FaGgogoODYWRkJLVXr14dS5YskTEyyuFUugTsS1niwMnrUltyyiucvnwH9Ws4qfQd1bcl7h+cgfC1Y+HX2wP6+v/3I9auqRtuP3iMtk2r49qOSbi+czIWTvwWxS1MP9apEL1TyvPXSa+FpSUAIDExEZcuXoB1iRLo7dUDLZo2RD/v73Du7Jlc2/65ZDGaNqyPb7p2QuifS5CZmZmrDxVCCi0uRZTsFYcVK1bgjz/+gIeHB77//nupvWbNmtKYh3dJS0tDWppqOVxkZ0Ghp1/gseoqu5IWAICEJ6qVhITE57AtYSF9vXDtYZy/dg9Pk1PRoGZ5BA7rALtSlhg7awsAwKlMSZSzt0YXz9roP2El9PT0EDy6C9b84oM2gxZ8vBMiykN2djaCZ0xHrdp1UKlSZQDAg/v3AAAhv/2Kkf5jUKWqC3b8tQ0Dffpg81874OjoBADo6dULLq6usLS0RETEecyfOxuPHj2C/9gAuU6HSGtkTxwePHiAihUr5mrPzs5GRkbGf24fFBSEyZMnq7Tp234GQ3tO5fzY5q86IP35ctRDpGdk4tfxPTFh/nakZ2RCT6GAsdIQPhNW4mbM61sVgyevRvjacajkaCPdviCSw/SpkxEdFYXQlWuktuzsbABAt2+6o1PnrgAAFxdXnDwZjm1bNmO43ygAQO8+faVtKlepCkNDQ0yd/BOG+41SqaRS4cNbFZqT/VaFq6srjh49mqt906ZNqF279n9uHxAQgGfPnqksBrZ1tRGqzop7nAwAsLEuptJuU6IY4hOT893u9KU7MDTUh6OD9f/fzzNkZGRJSQMAXL/9+vkdZe2sCzpsIrVNnxqII4cPYfGy5bC1s5Pac8YslK9QQaW/c/kKiIt9mO/+3GrURGZmJh4+uK+dgIlkJHvFYeLEifD29saDBw+QnZ2NLVu2IDIyEitWrMCOHTv+c3ulUgmlUqnSxtsUBevOg0TEPnqGFvWr4OKN11POipkZ47PqTli88Vi+29WsUgZZWdl49P9vcYRH3IKhoT6cy5TE7fuPAQCVHG0AADGxT7R8FkS5CSEQNG0KDuwPw9LQlShTpqzK+tKly6CUjQ3u3L6t0n73zh00btI03/1GXr8GPT09WFuXyLcPFQ6sOGhO9sShY8eO+PvvvxEYGAgzMzNMnDgRderUwd9//40vv/xS7vB0hpmJESqU/b8R4U6lS6BG5dJ4mvwC9+Ke4rc1BzG2f2vcjHmEOw8S8dMP7RD76Bm2H7wAAKhfwxmfVXfE4TNReJ76Cg1qOGPG6K5Y+89pJD1/CQA4cDIS567G4PdJXvD/ZTP09BSYO+4b7Au/plKFIPpYpk+ZjF3/7MDcBQthZmqGx49eP5fEvFgxGBsbQ6FQoE9fHyz6bQGqVKmKKlVdsP2vrbhz+xZmzZkP4PV0zUsXL+CzzxvAzMwMFy6cxy8zgtDuqw7SIEuiokQh3nyfdRFhUnuo3CF8cprUrYS9S4bnal+5/V8M/GkVgNcPgOrXpRGsipngREQ0hk/fIH3g16paBvMCuqOysy2Uhga48zARa3aexvyVB5Ce8X+jy+1LWWL22K/h0aAqUl+mY+/xqxg3ewueJr/4OCdahDw9/avcIXzyalarkmd74NQgdOzcRfp66eI/sH7dajx79gxVqlTFiJGjUaduPQDAtatXMG3KZNy5fQvp6ekoXboMvurQEb28+3J8QwEw1vKvtxVH79Lavm/ObKO1fcup0CQO6enpSEhIkAYj5ShXrpzG+2LiQLqAiQPpAiYOhY/styqioqLQr18/nDhxQqVdCAGFQoGsrCyZIiMioqKOYxw0J3vi0KdPHxgYGGDHjh2wt7fnN5GIiD4afuRoTvbEISIiAmfPnkXVqlXlDoWIiIj+g+yJg6urKx4/fix3GEREpINY5dacLA+ASk5OlpYZM2ZgzJgxOHToEBITE1XWJSfn/3AhIiIi+vhkqThYWVmpZHlCCHh4eKj04eBIIiLSNhYcNCdL4nDw4EE5DktEREQfSJbEoVmzZnIcloiISIWeHksOmpL9JVfLli3Dxo0bc7Vv3LgRy5cvlyEiIiIiyo/siUNQUBBKliyZq93GxgbTp0+XISIiItIVCoX2lqJK9umYMTExcHZ2ztXu6OiImJgYGSIiIiJdwemYmpO94mBjY4OLFy/mar9w4QJKlOAraYmIiAoT2SsOPXv2hK+vL4oVK4amTV+/3/7w4cMYPnw4evToIXN0RERUlLHgoDnZE4cpU6bgzp078PDwgIHB63Cys7PRu3dvjnEgIiIqZGRPHIyMjLB+/XpMmTIFFy5cgImJCdzc3ODo6Ch3aEREVMRxjIPmZE8cclSuXBmVK1eWOwwiIiJ6h0KRONy/fx/bt29HTEwM0tPTVdbNnj1bpqiIiKioY8VBc7InDvv370eHDh1Qvnx5XL9+HdWrV8edO3cghECdOnXkDo+IiIjeIPt0zICAAIwePRqXLl2CsbExNm/ejHv37qFZs2b4+uuv5Q6PiIiKMD4ASnOyJw7Xrl1D7969AQAGBgZ4+fIlzM3NERgYiBkzZsgcHRERFWUKhUJrS1Ele+JgZmYmjWuwt7dHdHS0tO7x48dyhUVERER5kH2MQ4MGDXDs2DG4uLigbdu2GDVqFC5duoQtW7agQYMGcodHRERFWBEuDGiN7InD7NmzkZKSAgCYPHkyUlJSsH79elSqVIkzKoiIiAoZ2ROH8uXLS382MzNDSEiIjNEQEZEuKcpjEbRF9jEOAJCUlIQlS5YgICAAT548AQCcO3cODx48kDkyIiIi7crKysKECRPg7OwMExMTVKhQAVOmTIEQQuojhMDEiRNhb28PExMTeHp6IioqSmU/T548gZeXFywsLGBlZQUfHx+pol+QZE8cLl68iMqVK2PGjBmYOXMmkpKSAABbtmxBQECAvMEREVGRVhimY86YMQOLFi3Cr7/+imvXrmHGjBkIDg7GggULpD7BwcGYP38+QkJCcPLkSZiZmaFVq1Z49eqV1MfLywtXrlxBWFgYduzYgSNHjmDgwIEFebkAFILEYeTIkejTpw+ioqJgbGwstbdt2xZHjhyRMTIiIiLtO3HiBDp27Ih27drByckJ3bp1Q8uWLXHq1CkAr6sNc+fOxY8//oiOHTuiRo0aWLFiBR4+fIht27YBeP1og927d2PJkiWoX78+GjdujAULFmDdunV4+PBhgcYre+Jw+vRpDBo0KFd76dKlERcXJ0NERESkK7T5HIe0tDQkJyerLGlpabliaNiwIfbv348bN24AAC5cuIBjx46hTZs2AIDbt28jLi4Onp6e0jaWlpaoX78+wsPDAQDh4eGwsrJCvXr1pD6enp7Q09PDyZMnC/SayZ44KJVKJCcn52q/ceMGSpUqJUNEREREHy4oKAiWlpYqS1BQUK5+48aNQ48ePVC1alUYGhqidu3aGDFiBLy8vABA+iXa1tZWZTtbW1tpXVxcHGxsbFTWGxgYwNrausB/CZd9VkWHDh0QGBiIDRs2AHid/cXExGDs2LHo2rWrzNEREVFRps1JFQEBARg5cqRKm1KpzNVvw4YNWL16NdasWYNq1aohIiICI0aMgIODA7y9vbUX4HuSPXGYNWsWunXrBhsbG7x8+RLNmjVDXFwcGjRogGnTpskdHhERFWHanI6pVCrzTBTe5u/vL1UdAMDNzQ13795FUFAQvL29YWdnBwCIj4+Hvb29tF18fDxq1aoFALCzs0NCQoLKfjMzM/HkyRNp+4Iie+JgaWmJsLAwHDt2DBcvXkRKSgrq1Kmjci+HiIioqHrx4gX09FRHDujr6yM7OxsA4OzsDDs7O+zfv19KFJKTk3Hy5EkMHjwYAODu7o6kpCScPXsWdevWBQAcOHAA2dnZqF+/foHGK3vikKNx48Zo3Lix9PW5c+cwceJE7NixQ8aoiIioKCsMz39q3749pk2bhnLlyqFatWo4f/48Zs+ejX79+gF4XRUZMWIEpk6dikqVKsHZ2RkTJkyAg4MDOnXqBABwcXFB69atMWDAAISEhCAjIwNDhw5Fjx494ODgUKDxypo47NmzB2FhYTAyMkL//v1Rvnx5XL9+HePGjcPff/+NVq1ayRkeERGR1i1YsAATJkzADz/8gISEBDg4OGDQoEGYOHGi1GfMmDFITU3FwIEDkZSUhMaNG2P37t0qjzFYvXo1hg4dCg8PD+jp6aFr166YP39+gcerEG8+muojWrp0KQYMGABra2s8ffoUJUqUwOzZszFs2DB0794dw4cPh4uLy3vt26T20AKOlqjweXr6V7lDINI6Yy3/eus+Q3vPCwof21Rr+5aTbNMx582bhxkzZuDx48fYsGEDHj9+jIULF+LSpUsICQl576SBiIiItEe2WxXR0dH4+uuvAQBdunSBgYEBfvnlF5QpU0aukIiISMcUhjEOnxrZKg4vX76EqakpgNcDP5RKpco0EyIiIip8ZB0cuWTJEpibmwN4Pd80NDQUJUuWVOnj6+srR2hERKQD+Fptzck2ONLJyek/v2EKhQK3bt3SeN8cHEm6gIMjSRdoe3Bk45lHtbbvY6ObaG3fcpKt4nDnzh25Dk1ERETvqdA8AIqIiOhj460Kzcn+dkwiIiL6dLDiQEREOosVB82x4kBERERqY8WBiIh0FgsOmpO94qCvr5/rHeIAkJiYCH19fRkiIiIiovzIXnHI7zESaWlpMDIy+sjREBGRLuEYB83JljjkvOpToVCoPEESALKysnDkyBFUrVpVrvCIiEgHMG/QnGyJw5w5cwC8rjiEhISo3JYwMjKCk5MTQkJC5AqPiIiI8iBb4nD79m0AQIsWLbBlyxYUL15crlCIiEhH8VaF5mQf43Dw4EHpzznjHfiNJCIiKpxkn1UBACtWrICbmxtMTExgYmKCGjVqYOXKlXKHRURERZxCob2lqJK94jB79mxMmDABQ4cORaNGjQAAx44dw/fff4/Hjx/Dz89P5giJiIgoh+yJw4IFC7Bo0SL07t1bauvQoQOqVauGSZMmMXEgIiKt0SvKpQEtkf1WRWxsLBo2bJirvWHDhoiNjZUhIiIiIsqP7IlDxYoVsWHDhlzt69evR6VKlWSIiIiIdAXHOGhO9lsVkydPRvfu3XHkyBFpjMPx48exf//+PBMKIiKigsJZfJqTveLQtWtXnDx5EiVLlsS2bduwbds2lCxZEqdOnULnzp3lDo+IiIjeIHvFAQDq1q2LVatWyR0GERHpGD0WHDQme8WBiIiIPh2yVRz09PT+896SQqFAZmbmR4qIiIh0Dcc4aE62xGHr1q35rgsPD8f8+fORnZ39ESMiIiKi/yJb4tCxY8dcbZGRkRg3bhz+/vtveHl5ITAwUIbIiIhIV7DgoLlCMcbh4cOHGDBgANzc3JCZmYmIiAgsX74cjo6OcodGREREb5A1cXj27BnGjh2LihUr4sqVK9i/fz/+/vtvVK9eXc6wiIhIRyi0+F9RJdutiuDgYMyYMQN2dnZYu3ZtnrcuiIiItInTMTUnW+Iwbtw4mJiYoGLFili+fDmWL1+eZ78tW7Z85MiIiIgoP7IlDr179+Y0GCIikhU/hzQnW+IQGhoq16GJiIjoPRWKR04TERHJgQUHzRWK6ZhERET0aWDFgYiIdJYeSw4aY8WBiIiI1MaKAxER6SwWHDTHxIGIiHQWp2NqjrcqiIiISG2sOBARkc5iwUFzrDgQERGR2lhxICIincXpmJpjxYGIiIjUxooDERHpLNYbNMeKAxEREamNiQMREekshUKhtUVdTk5OeW4/ZMgQAMCrV68wZMgQlChRAubm5ujatSvi4+NV9hETE4N27drB1NQUNjY28Pf3R2ZmZoFeqxy8VUFERDpLrxDcqzh9+jSysrKkry9fvowvv/wSX3/9NQDAz88PO3fuxMaNG2FpaYmhQ4eiS5cuOH78OAAgKysL7dq1g52dHU6cOIHY2Fj07t0bhoaGmD59eoHHqxBCiALfq8xMag+VOwQirXt6+le5QyDSOmMt/3rrtTJCa/te3avWe203YsQI7NixA1FRUUhOTkapUqWwZs0adOvWDQBw/fp1uLi4IDw8HA0aNMCuXbvw1Vdf4eHDh7C1tQUAhISEYOzYsXj06BGMjIwK6pQA8FYFERHpMG3eqkhLS0NycrLKkpaW9s540tPTsWrVKvTr1w8KhQJnz55FRkYGPD09pT5Vq1ZFuXLlEB4eDgAIDw+Hm5ublDQAQKtWrZCcnIwrV64U+DVj4kBERKQFQUFBsLS0VFmCgoLeuc22bduQlJSEPn36AADi4uJgZGQEKysrlX62traIi4uT+ryZNOSsz1lX0DjGgYiIdJY2n/8UEBCAkSNHqrQplcp3brN06VK0adMGDg4O2gvsAzFxICIi0gKlUvmficKb7t69i3379mHLli1Sm52dHdLT05GUlKRSdYiPj4ednZ3U59SpUyr7ypl1kdOnIPFWBRER6azCMB0zx7Jly2BjY4N27dpJbXXr1oWhoSH2798vtUVGRiImJgbu7u4AAHd3d1y6dAkJCQlSn7CwMFhYWMDV1fUDrk7e1Ko4bN++Xe0ddujQ4b2DISIi0kXZ2dlYtmwZvL29YWDwfx/NlpaW8PHxwciRI2FtbQ0LCwsMGzYM7u7uaNCgAQCgZcuWcHV1Ra9evRAcHIy4uDj8+OOPGDJkiEYVD3WplTh06tRJrZ0pFAqVuahERESFWWF4jgMA7Nu3DzExMejXr1+udXPmzIGenh66du2KtLQ0tGrVCgsXLpTW6+vrY8eOHRg8eDDc3d1hZmYGb29vBAYGaiVWPseB6BPF5ziQLtD2cxz6rruktX0v6+GmtX3LiWMciIiISG3vlculpqbi8OHDiImJQXp6uso6X1/fAgmMiIhI2wrJnYpPisaJw/nz59G2bVu8ePECqampsLa2xuPHj6UXazBxICIiKro0vlXh5+eH9u3b4+nTpzAxMcG///6Lu3fvom7dupg5c6Y2YiQiItIKPYVCa0tRpXHiEBERgVGjRkFPTw/6+vpIS0tD2bJlERwcjP/973/aiJGIiIgKCY0TB0NDQ+jpvd7MxsYGMTExAF7PNb13717BRkdERKRFCoX2lqJK4zEOtWvXxunTp1GpUiU0a9YMEydOxOPHj7Fy5UpUr15dGzESERFRIaFxxWH69Omwt7cHAEybNg3FixfH4MGD8ejRI/zxxx8FHiAREZG2FKZHTn8qNK441KtXT/qzjY0Ndu/eXaABERERUeHFt2MSEZHOKsKFAa3ROHFwdnZ+Zwnm1q1bHxQQERHRx1KUp01qi8aJw4gRI1S+zsjIwPnz57F79274+/sXVFxERERUCGmcOAwfPjzP9t9++w1nzpz54ICIiIg+FhYcNFdgL7lq06YNNm/eXFC7IyIiokKowAZHbtq0CdbW1gW1OyIiIq0rytMmteW9HgD15oUWQiAuLg6PHj3CwoULCzQ4IiIiKlw0Thw6duyokjjo6emhVKlSaN68OapWrVqgwb2vQ5umyR0CkdZVH7dL7hCItO7mzDZa3X+B3a/XIRonDpMmTdJCGERERPQp0DjZ0tfXR0JCQq72xMRE6OvrF0hQREREHwMfOa05jSsOQog829PS0mBkZPTBAREREX0sekX3811r1E4c5s+fD+B1drZkyRKYm5tL67KysnDkyJFCM8aBiIiItEPtxGHOnDkAXlccQkJCVG5LGBkZwcnJCSEhIQUfIRERkZaw4qA5tROH27dvAwBatGiBLVu2oHjx4loLioiIiAonjcc4HDx4UBtxEBERfXRFeRCjtmg8q6Jr166YMWNGrvbg4GB8/fXXBRIUERERFU4aJw5HjhxB27Ztc7W3adMGR44cKZCgiIiIPgY9hfaWokrjxCElJSXPaZeGhoZITk4ukKCIiIiocNI4cXBzc8P69etzta9btw6urq4FEhQREdHHoFBobymqNB4cOWHCBHTp0gXR0dH44osvAAD79+/HmjVrsGnTpgIPkIiISFv0ivInvJZonDi0b98e27Ztw/Tp07Fp0yaYmJigZs2aOHDgAF+rTUREVMRpnDgAQLt27dCuXTsAQHJyMtauXYvRo0fj7NmzyMrKKtAAiYiItIVvx9Tce1+zI0eOwNvbGw4ODpg1axa++OIL/PvvvwUZGxERERUyGlUc4uLiEBoaiqVLlyI5ORnffPMN0tLSsG3bNg6MJCKiTw6HOGhO7YpD+/btUaVKFVy8eBFz587Fw4cPsWDBAm3GRkRERIWM2hWHXbt2wdfXF4MHD0alSpW0GRMREdFHwVkVmlO74nDs2DE8f/4cdevWRf369fHrr7/i8ePH2oyNiIiIChm1E4cGDRpg8eLFiI2NxaBBg7Bu3To4ODggOzsbYWFheP78uTbjJCIiKnB8AJTmNJ5VYWZmhn79+uHYsWO4dOkSRo0ahZ9//hk2Njbo0KGDNmIkIiLSCr6rQnMfNIW1SpUqCA4Oxv3797F27dqCiomIiIgKqfd6ANTb9PX10alTJ3Tq1KkgdkdERPRRcHCk5vjQLCIiIlJbgVQciIiIPkUsOGiOFQciIiJSGysORESks4ry7AdtYcWBiIiI1MaKAxER6SwFWHLQFBMHIiLSWbxVoTneqiAiIpLZgwcP8N1336FEiRIwMTGBm5sbzpw5I60XQmDixImwt7eHiYkJPD09ERUVpbKPJ0+ewMvLCxYWFrCysoKPjw9SUlIKPFYmDkREpLMKwyOnnz59ikaNGsHQ0BC7du3C1atXMWvWLBQvXlzqExwcjPnz5yMkJAQnT56EmZkZWrVqhVevXkl9vLy8cOXKFYSFhWHHjh04cuQIBg4cWJCXCwBvVRAREclqxowZKFu2LJYtWya1OTs7S38WQmDu3Ln48ccf0bFjRwDAihUrYGtri23btqFHjx64du0adu/ejdOnT6NevXoAgAULFqBt27aYOXMmHBwcCixeVhyIiEhnKRQKrS1paWlITk5WWdLS0nLFsH37dtSrVw9ff/01bGxsULt2bSxevFhaf/v2bcTFxcHT01Nqs7S0RP369REeHg4ACA8Ph5WVlZQ0AICnpyf09PRw8uTJAr1mTByIiIi0ICgoCJaWlipLUFBQrn63bt3CokWLUKlSJezZsweDBw+Gr68vli9fDgCIi4sDANja2qpsZ2trK62Li4uDjY2NynoDAwNYW1tLfQoKb1UQEZHO0uasioCAAIwcOVKlTalU5uqXnZ2NevXqYfr06QCA2rVr4/LlywgJCYG3t7f2AnxPrDgQERFpgVKphIWFhcqSV+Jgb28PV1dXlTYXFxfExMQAAOzs7AAA8fHxKn3i4+OldXZ2dkhISFBZn5mZiSdPnkh9CgoTByIi0lkKhfYWdTVq1AiRkZEqbTdu3ICjoyOA1wMl7ezssH//fml9cnIyTp48CXd3dwCAu7s7kpKScPbsWanPgQMHkJ2djfr163/AFcqNtyqIiEhn6RWC12P6+fmhYcOGmD59Or755hucOnUKf/zxB/744w8ArwdwjhgxAlOnTkWlSpXg7OyMCRMmwMHBAZ06dQLwukLRunVrDBgwACEhIcjIyMDQoUPRo0ePAp1RATBxICIiktVnn32GrVu3IiAgAIGBgXB2dsbcuXPh5eUl9RkzZgxSU1MxcOBAJCUloXHjxti9ezeMjY2lPqtXr8bQoUPh4eEBPT09dO3aFfPnzy/weBVCCFHge5XZyehncodApHVei07IHQKR1t2c2Uar+59/7LbW9u3b2Pm/O32COMaBiIiI1MZbFUREpLMKwRCHTw4rDkRERKQ2VhyIiEhn6YElB02x4kBERERqY8WBiIh0Fsc4aI6JAxER6SxtvquiqOKtCiIiIlIbKw5ERKSzCsMjpz81rDgQERGR2lhxICIincWCg+ZYcSAiIiK1seJAREQ6i2McNMeKAxEREamNFQciItJZLDhortBUHNLT0xEZGYnMzEy5QyEiIh2hp8WlqJL93F68eAEfHx+YmpqiWrVqiImJAQAMGzYMP//8s8zRERER0ZtkTxwCAgJw4cIFHDp0CMbGxlK7p6cn1q9fL2NkRERU1CkUCq0tRZXsYxy2bduG9evXo0GDBioXulq1aoiOjpYxMiIiInqb7InDo0ePYGNjk6s9NTW1SGdsREQkP37KaE72WxX16tXDzp07pa9zkoUlS5bA3d1drrCIiIgoD7JXHKZPn442bdrg6tWryMzMxLx583D16lWcOHEChw8fljs8IiIqwvgAKM3JXnFo3LgxIiIikJmZCTc3N+zduxc2NjYIDw9H3bp15Q6PiIiI3iB7xQEAKlSogMWLF8sdBhER6RjWGzRXKBIHAEhISEBCQgKys7NV2mvUqCFTREREVNTxToXmZE8czp49C29vb1y7dg1CCJV1CoUCWVlZMkVGREREb5M9cejXrx8qV66MpUuXwtbWllMwiYjoo+FnjuZkTxxu3bqFzZs3o2LFinKHQkRERP9B9lkVHh4euHDhgtxhEBGRDuJLrjQne8VhyZIl8Pb2xuXLl1G9enUYGhqqrO/QoYNMkREREdHbZE8cwsPDcfz4cezatSvXOg6OJCIibeIYB83JXk0ZNmwYvvvuO8TGxiI7O1tlYdJARERUuMhecUhMTISfnx9sbW3lDoWIiHQM6w2ak73i0KVLFxw8eFDuMIiIiEgNslccKleujICAABw7dgxubm65Bkf6+vrKFBkRERV1HOOgOdkThyVLlsDc3ByHDx/O9TZMhULBxIGIiLRG9rL7J0j2xOH27dtyh0BERERqkj1xICIikgtvVWhOlsRh5MiRmDJlCszMzDBy5Mh39p09e/ZHioqIiIj+iyyJw/nz55GRkSH9OT/MBImISJv4KaM5WRKHgwcPYsWKFejevTunYhIREX1CZBtQ2rdvXzx79kyuwxMREUGh0N5SVMmWOAgh5Do0ERERvSdZZ1VwDAMREclJj6McNCZr4uDh4QEDg3eHcO7cuY8UDRER6Rr+/qo5WROHVq1awdzcXM4QiIiISAOyJg7+/v6wsbGRMwQiItJhCt6q0JhsgyM5voGIiOjTw1kVRESkswrDdMxJkyZBoVCoLFWrVpXWv3r1CkOGDEGJEiVgbm6Orl27Ij4+XmUfMTExaNeuHUxNTWFjYwN/f39kZmYW1GVSIdutitu3b6NUqVJyHZ6IiKjQqFatGvbt2yd9/ebEAT8/P+zcuRMbN26EpaUlhg4dii5duuD48eMAgKysLLRr1w52dnY4ceIEYmNj0bt3bxgaGmL69OkFHqtsiYOjo6NchyYiIgKg3emYaWlpSEtLU2lTKpVQKpW5+hoYGMDOzi5X+7Nnz7B06VKsWbMGX3zxBQBg2bJlcHFxwb///osGDRpg7969uHr1Kvbt2wdbW1vUqlULU6ZMwdixYzFp0iQYGRkV6HnxVeRERERaEBQUBEtLS5UlKCgoz75RUVFwcHBA+fLl4eXlhZiYGADA2bNnkZGRAU9PT6lv1apVUa5cOYSHhwMAwsPD4ebmBltbW6lPq1atkJycjCtXrhT4efG12kREpLO0OU4/ICAg1xug86o21K9fH6GhoahSpQpiY2MxefJkNGnSBJcvX0ZcXByMjIxgZWWlso2trS3i4uIAAHFxcSpJQ876nHUFjYkDERHpLG0mDvndlnhbmzZtpD/XqFED9evXh6OjIzZs2AATExPtBfieCkXikJSUhFOnTiEhIQHZ2dkq63r37i1TVERERB+flZUVKleujJs3b+LLL79Eeno6kpKSVKoO8fHx0pgIOzs7nDp1SmUfObMu8ho38aFkTxz+/vtveHl5ISUlBRYWFirPd1AoFEwciIhIawrjA6BSUlIQHR2NXr16oW7dujA0NMT+/fvRtWtXAEBkZCRiYmLg7u4OAHB3d8e0adOQkJAgPVQxLCwMFhYWcHV1LfD4ZB8cOWrUKPTr1w8pKSlISkrC06dPpeXJkydyh0dERKRVo0ePxuHDh3Hnzh2cOHECnTt3hr6+Pnr27AlLS0v4+Phg5MiROHjwIM6ePYu+ffvC3d0dDRo0AAC0bNkSrq6u6NWrFy5cuIA9e/bgxx9/xJAhQ9S6VaIp2SsODx48gK+vL0xNTeUOhYiIdIxeISg43L9/Hz179kRiYiJKlSqFxo0b499//5WedTRnzhzo6emha9euSEtLQ6tWrbBw4UJpe319fezYsQODBw+Gu7s7zMzM4O3tjcDAQK3EqxAyP8KxS5cu6NGjB7755psC2+fJ6GcFti+iwspr0Qm5QyDSupsz2/x3pw+w//pjre3bo2pJre1bTrJXHNq1awd/f39cvXoVbm5uMDQ0VFnfoUMHmSIjIqKirjCOcSjsZE8cBgwYAAB5llQUCgWysrI+dkhERESUD9kTh7enXxIREX0sfFGz5mRPHIiIiOTCWxWak306JgAcPnwY7du3R8WKFVGxYkV06NABR48elTssIiIieovsicOqVavg6ekJU1NT+Pr6wtfXFyYmJvDw8MCaNWvkDo+IiIowPYX2lqJK9umYLi4uGDhwIPz8/FTaZ8+ejcWLF+PatWsa75PTMUkXcDom6QJtT8c8ckN7DxpsWtlaa/uWk+wVh1u3bqF9+/a52jt06IDbt2/LEBEREekKhRb/K6pkTxzKli2L/fv352rft28fypYtK0NERERElB/ZZ1WMGjUKvr6+iIiIQMOGDQEAx48fR2hoKObNmydzdJTj7w3LsTH0N7Ts2APfDXr9fvnpY7/H9UvnVPq1aNMZfYcFqLQdDduB3VvXIO5BDIxNzfB5Yw94Dxnz0WInyo+eAvBtWQkd6zqgVDElEp6lYfOZ+/htX3Se/QO7VsO37uUw9a9rCD16R2qvVtoC/u2qoEZZS2RlC+y5FIfp26/jRTqfQ1PYcTqm5mRPHAYPHgw7OzvMmjULGzZsAPB63MP69evRsWNHmaMjALh14yoO7tqCss4Vc61r3roTunw3UPpaaWyssn7XltXYvXUNuvcbhgpVqyPt1Us8jo/VesxE6hjUojy+bVgOY9ZdRFRcCtzKWuLnb9zw/FUmVhy7q9L3y+q2qFXOCnHPXqm021gosXzQZ9gZEYfJW6/C3NgAP3ZwQXCPGhi64vzHPB2ij0L2xAEAOnfujM6dO8sdBuXh1csXWBQ8Af18x2P7uj9zrTdSGsPKOu/nsac+T8bmlSHw+2kWqtX6XGov51xJa/ESaaK2U3HsvxyPQ9ceAQAePH2Jr2rZo2ZZS5V+thZK/NTJFX0Xn8Zin7oq61q42CAzS2DS1ivIGWo+YfNl/DO6CRxLmOJu4ouPci70flhw0JzsYxyocFu+MBi1Pm+E6rU/z3N9+MHd+KHHlwgY3AMblv2GtFf/99vY5fMnIbIFniY+wthB32B4r6/w6/QAJD6K/1jhE73T+TtP4V6pBJxKvn47b1X7YqjnXByH33jxkUIBzPy2JhYfuoWo+JRc+zAy0ENGVjbenJ+WlvH6ibh1nYtr9wTog+kpFFpbiqpCUXH4EGlpaUhLS1NpS09Lg5EW3kGua/49vBd3b0Zi0rzQPNe7N2+FEjZ2KG5dCvfu3MT6P39F7IO7GP5jMAAgIe4hskU2/l4fCq9BI2FqZo5NK0IQPH4opv22BgZvvdCM6GMLOXgL5sYG2DumKbKEgL5Cgdm7b2D7+YdSn0EtyiMrS2D5W7cucvx7MxH/61AV/Zs7Y/nROzAx0od/uyoAXt/GICpqPvmKQ1BQECwtLVWW5SGz5Q7rk5f4KB6rfp+N78cEwsgo73/8WrTpjBp13VHWuSIatmiNQaN+wtkThxAfex8AIEQ2sjIz8d33o1CjrjsqVnXDD2OnIu7hPVy9eOZjng5RntrWtEeHOg7wW3MBHeccx5h1F+HTzBmd65UG8HrQo3djJ4xZfzHffUTFp7zerqkzLk1viX9/8sC9Jy/wKDkN2bI+JYfUodDiUlR98hWHgIAAjBw5UqXtwv1X+fQmdd2JuobkpCeYOKy31JadnYXIy+ex7++N+POvY9DT11fZpkLV6gCA+If3YGtfBlbFX499KF3OWepjYVkcxSyseLuCCoVxX1XB7wduYWfE6wG7N+JS4FDcBN9/UR5bzzzAZ+WtUcLcCEfGN5e2MdDXQ0D7qujTxBHNpx8GAPx9PhZ/n49FCXMjvEzPggDQr6kz7nF8AxVBn3zioFQqoXzrtoSRkmn+h3Kt9RmmL1yr0rZ4TiDsyzjhq69750oaAOBu9A0AkAZLVnKtAQCIvX8X1iVtAQApz5/heXISStrYaTN8IrUYG+rnqgpkCyHdn9529gGORz1WWb9swGf46+wDbDr9INf+ElPSAQDdPiuDtMwsHLvxOFcfKmSKcmlAS2RJHN6uELzL7Nm87SAHE1MzlHGqoNKmNDaBuYUlyjhVQHzsfYQf3IOanzWEuYUl7t2+iTV/zEGV6rWlWRP2ZRxRp0FTrPp9NvoN+x9MTM2wIfQ3OJRxhEuNenKcFpGKA1cT8INHBTxMeomouBS4lrZAv6bO2Hj69e22pBcZSHqRobJNZlY2Hj1Px+1HqVJbr0blcO5OElLTMtG4ckmM/aoqfvknEs9fZX7U8yH6GGRJHM6fV53bfO7cOWRmZqJKldcDim7cuAF9fX3UrVs3r82pEDAwMMSViFPY89dapL96BetStqjXqAU69uyn0m/Q6ElY/ccczJrkB4VCgapudTB6ynwYGHzyxS4qAgK3XcWIVpUxuUs1lDA3QsKzNKz9Nwa/ht3UaD81ylrBt2UlmCkNEJ2QggmbLmPbuYf/vSHJrig/GlpbZH/J1ezZs3Ho0CEsX74cxYu/nrr09OlT9O3bF02aNMGoUaM03idfckW6gC+5Il2g7ZdcafPzon4Fy//u9AmSfVbFrFmzEBQUJCUNAFC8eHFMnToVs2bNkjEyIiIq6hQK7S1Flez14uTkZDx69ChX+6NHj/D8+XMZIiIiIl1RhD/ftUb2ikPnzp3Rt29fbNmyBffv38f9+/exefNm+Pj4oEuXLnKHR0RERG+QveIQEhKC0aNH49tvv0VGxuvRywYGBvDx8cEvv/wic3RERFSkseSgMdkTB1NTUyxcuBC//PILoqNfv8q2QoUKMDMzkzkyIiIiepvstypyxMbGIjY2FpUqVYKZmRlknuxBREQ6QKHF/4oq2ROHxMREeHh4oHLlymjbti1iY18/+tXHx+e9pmISERGR9sieOPj5+cHQ0BAxMTEwNTWV2rt3747du3fLGBkRERV1nI6pOdnHOOzduxd79uxBmTJlVNorVaqEu3fzfo0tERERyUP2xCE1NVWl0pDjyZMnuV5eRUREVJCKcGFAa2S/VdGkSROsWLFC+lqhUCA7OxvBwcFo0aKFjJEREVGRp9DiUkTJXnEIDg6Gh4cHzpw5g/T0dIwZMwZXrlzBkydPcPz4cbnDIyIiojfIXnGoXr06bty4gcaNG6Njx45ITU1Fly5dcP78eVSoUOG/d0BERPSeOB1Tc7JXHADA0tIS48ePlzsMIiIi+g+FInFISkrCqVOnkJCQgOzsbJV1vXv3likqIiIq6orytEltkT1x+Pvvv+Hl5YWUlBRYWFhA8cZ3UaFQMHEgIiIqRGQf4zBq1Cj069cPKSkpSEpKwtOnT6XlyZMncodHRERFGCdVaE72xOHBgwfw9fXN81kOREREVLjInji0atUKZ86ckTsMIiLSRSw5aEyWMQ7bt2+X/tyuXTv4+/vj6tWrcHNzg6GhoUrfDh06fOzwiIhIRxTlaZPaIkvi0KlTp1xtgYGBudoUCgWysrI+QkRERESkDlkSh7enXBIREcmB0zE1J/sYByIiIvp0yJ44+Pr6Yv78+bnaf/31V4wYMeLjB0RERDqDYyM1J3visHnzZjRq1ChXe8OGDbFp0yYZIiIiIqL8yP7kyMTERFhaWuZqt7CwwOPHj2WIiIiIdEZRLg1oiewVh4oVK2L37t252nft2oXy5cvLEBERERHlR/bEYeTIkRgzZgx++uknHD58GIcPH8bEiRMxbtw4+Pn5yR0eEREVYYXxtdo///wzFAqFyji/V69eYciQIShRogTMzc3RtWtXxMfHq2wXExODdu3awdTUFDY2NvD390dmZuZ7x5Ef2W9V9OvXD2lpaZg2bRqmTJkCAHBycsKiRYv4gisiItIpp0+fxu+//44aNWqotPv5+WHnzp3YuHEjLC0tMXToUHTp0gXHjx8HAGRlZaFdu3aws7PDiRMnEBsbi969e8PQ0BDTp08v0BgVQghRoHv8AI8ePYKJiQnMzc0/aD8no58VUEREhZfXohNyh0CkdTdnttHq/q8+TNXavl0dzDTqn5KSgjp16mDhwoWYOnUqatWqhblz5+LZs2coVaoU1qxZg27dugEArl+/DhcXF4SHh6NBgwbYtWsXvvrqKzx8+BC2trYAgJCQEIwdOxaPHj2CkZFRgZ2X7Lcq3lSqVKkPThqIiIjUpc3pmGlpaUhOTlZZ0tLS8o1lyJAhaNeuHTw9PVXaz549i4yMDJX2qlWroly5cggPDwcAhIeHw83NTUoagNfvgkpOTsaVK1fe9/LkSfZbFQCwadMmbNiwATExMUhPT1dZd+7cOZmiIiIien9BQUGYPHmySttPP/2ESZMm5eq7bt06nDt3DqdPn861Li4uDkZGRrCyslJpt7W1RVxcnNTnzaQhZ33OuoIke8Vh/vz56Nu3L2xtbXH+/Hl8/vnnKFGiBG7duoU2bbRboiIiIh2nxZJDQEAAnj17prIEBATkCuHevXsYPnw4Vq9eDWNjY62ebkGQPXFYuHAh/vjjDyxYsABGRkYYM2YMwsLC4Ovri2fPOFaBiIg+TUqlEhYWFiqLUqnM1e/s2bNISEhAnTp1YGBgAAMDAxw+fBjz58+HgYEBbG1tkZ6ejqSkJJXt4uPjYWdnBwCws7PLNcsi5+ucPgVF9sQhJiYGDRs2BACYmJjg+fPnAIBevXph7dq1coZGRERFXGGYjunh4YFLly4hIiJCWurVqwcvLy/pz4aGhti/f7+0TWRkJGJiYuDu7g4AcHd3x6VLl5CQkCD1CQsLg4WFBVxdXQvugqEQjHGws7PDkydP4OjoiHLlyuHff/9FzZo1cfv2bRSiCR9ERERaUaxYMVSvXl2lzczMDCVKlJDafXx8MHLkSFhbW8PCwgLDhg2Du7s7GjRoAABo2bIlXF1d0atXLwQHByMuLg4//vgjhgwZkmeV40PInjh88cUX2L59O2rXro2+ffvCz88PmzZtwpkzZ9ClSxe5wyMioiLsU3mt9pw5c6Cnp4euXbsiLS0NrVq1wsKFC6X1+vr62LFjBwYPHgx3d3eYmZnB29sbgYGBBR6L7M9xyM7ORnZ2NgwMXucw69atw4kTJ1CpUiUMGjToveae8jkOpAv4HAfSBdp+jkNk3Aut7buKnanW9i0n2SsOenp60NP7v6EWPXr0QI8ePWSMiIiIdMUnUnAoVGQfHAkAR48exXfffQd3d3c8ePAAALBy5UocO3ZM5siIiKhI0+YToIoo2ROHzZs3o1WrVjAxMcH58+elp2o9e/aswJ+vTURERB9G9sRh6tSpCAkJweLFi2FoaCi1N2rUiE+NJCIirSoM0zE/NbInDpGRkWjatGmudktLy1wPuyAiIiJ5yZ442NnZ4ebNm7najx07hvLly8sQERER6QqFQntLUSV74jBgwAAMHz4cJ0+ehEKhwMOHD7F69WqMHj0agwcPljs8IiIieoPs0zHHjRuH7OxseHh44MWLF2jatCmUSiVGjx6NYcOGyR0eEREVYUW4MKA1sicOCoUC48ePh7+/P27evImUlBS4urrC3NwcL1++hImJidwhEhER0f8n+62KHEZGRnB1dcXnn38OQ0NDzJ49G87OznKHRURERRmf46Ax2RKHtLQ0BAQEoF69emjYsCG2bdsGAFi2bBmcnZ0xZ84c+Pn5yRUeERHpAE7H1JxstyomTpyI33//HZ6enjhx4gS+/vpr9O3bF//++y9mz56Nr7/+Gvr6+nKFR0RERHmQLXHYuHEjVqxYgQ4dOuDy5cuoUaMGMjMzceHCBSiK8jwWIiIqNPhxoznZblXcv38fdevWBQBUr14dSqUSfn5+TBqIiIgKMdkqDllZWSqvzDYwMIC5ublc4RARkQ7ir6qaky1xEEKgT58+UCqVAIBXr17h+++/h5mZmUq/LVu2yBEeERER5UG2xMHb21vl6++++06mSIiISGex5KAx2RKHZcuWyXVoIiIiek+yPzmSiIhILkX5eQvawsSBiIh0Fifyaa7QPHKaiIiICj9WHIiISGex4KA5VhyIiIhIbaw4EBGRzuIYB82x4kBERERqY8WBiIh0GEsOmmLFgYiIiNTGigMREeksjnHQHBMHIiLSWcwbNMdbFURERKQ2VhyIiEhn8VaF5lhxICIiIrWx4kBERDqLb8fUHCsOREREpDZWHIiISHex4KAxVhyIiIhIbaw4EBGRzmLBQXNMHIiISGdxOqbmeKuCiIiI1MaKAxER6SxOx9QcKw5ERESkNlYciIhId7HgoDFWHIiIiEhtrDgQEZHOYsFBc6w4EBERkdpYcSAiIp3F5zhojokDERHpLE7H1BxvVRAREclo0aJFqFGjBiwsLGBhYQF3d3fs2rVLWv/q1SsMGTIEJUqUgLm5Obp27Yr4+HiVfcTExKBdu3YwNTWFjY0N/P39kZmZqZV4mTgQEZHOUii0t6irTJky+Pnnn3H27FmcOXMGX3zxBTp27IgrV64AAPz8/PD3339j48aNOHz4MB4+fIguXbpI22dlZaFdu3ZIT0/HiRMnsHz5coSGhmLixIkFfbkAAAohhNDKnmV0MvqZ3CEQaZ3XohNyh0CkdTdnttHq/p++yNLavoub6r/3ttbW1vjll1/QrVs3lCpVCmvWrEG3bt0AANevX4eLiwvCw8PRoEED7Nq1C1999RUePnwIW1tbAEBISAjGjh2LR48ewcjIqEDOJwcrDkRERFqQlpaG5ORklSUtLe2d22RlZWHdunVITU2Fu7s7zp49i4yMDHh6ekp9qlatinLlyiE8PBwAEB4eDjc3NylpAIBWrVohOTlZqloUJCYOREREWhAUFARLS0uVJSgoKM++ly5dgrm5OZRKJb7//nts3boVrq6uiIuLg5GREaysrFT629raIi4uDgAQFxenkjTkrM9ZV9A4q4KIiHSWNqdjBgQEYOTIkSptSqUyz75VqlRBREQEnj17hk2bNsHb2xuHDx/WXnAfgIkDERGRFiiVynwThbcZGRmhYsWKAIC6devi9OnTmDdvHrp374709HQkJSWpVB3i4+NhZ2cHALCzs8OpU6dU9pcz6yKnT0HirQoiItJZCi3+9yGys7ORlpaGunXrwtDQEPv375fWRUZGIiYmBu7u7gAAd3d3XLp0CQkJCVKfsLAwWFhYwNXV9YPiyAsrDkREpLMKw5MjAwIC0KZNG5QrVw7Pnz/HmjVrcOjQIezZsweWlpbw8fHByJEjYW1tDQsLCwwbNgzu7u5o0KABAKBly5ZwdXVFr169EBwcjLi4OPz4448YMmSI2hUPTTBxICIiklFCQgJ69+6N2NhYWFpaokaNGtizZw++/PJLAMCcOXOgp6eHrl27Ii0tDa1atcLChQul7fX19bFjxw4MHjwY7u7uMDMzg7e3NwIDA7USL5/jQPSJ4nMcSBdo+zkOz19la23fxYyL5miAonlWREREpBW8VUFERLqrEIxx+NSw4kBERERqY8WBiIh0Fl+rrTlWHIiIiEhtrDgQEZHOKgzPcfjUsOJAREREamPFgYiIdBYLDppj4kBERLqLmYPGeKuCiIiI1MaKAxER6SxOx9QcKw5ERESkNlYciIhIZ3E6puZYcSAiIiK1FcnXatPHlZaWhqCgIAQEBECpVModDpFW8Oec6DUmDvTBkpOTYWlpiWfPnsHCwkLucIi0gj/nRK/xVgURERGpjYkDERERqY2JAxEREamNiQN9MKVSiZ9++okDxqhI48850WscHElERERqY8WBiIiI1MbEgYiIiNTGxIGIiIjUxsSB8nXo0CEoFAokJSUV+L4VCgW2bdtW4Pv9UIU1Lvpv2vreNW/eHCNGjCjw/X6owhoXFX1MHNTQp08fKBQK/Pzzzyrt27Ztg0LDN6Q4OTlh7ty5avVTKBRQKBQwNTWFm5sblixZotGx6P+EhoZK1zO/5c6dO4iNjUWbNm3kDveTkvP3Q6FQwNDQEM7OzhgzZgxevXold2ifpDt37vznz2poaCi2bNmCKVOmyB0u6SC+HVNNxsbGmDFjBgYNGoTixYt/lGMGBgZiwIABePHiBTZu3IgBAwagdOnS/GB7D927d0fr1q2lr7t06YLq1asjMDBQaitVqhT09fXlCO+T17p1ayxbtgwZGRk4e/YsvL29oVAoMGPGDLlD++SULVsWsbGx0tczZ87E7t27sW/fPqnN0tISJiYmcoRHxIqDujw9PWFnZ4egoKB39tu8eTOqVasGpVIJJycnzJo1S1rXvHlz3L17F35+ftJvDu9SrFgx2NnZoXz58hg7diysra0RFhYmrU9KSkL//v1RqlQpWFhY4IsvvsCFCxek9dHR0ejYsSNsbW1hbm6Ozz77TOUfH+D1i3vGjh2LsmXLQqlUomLFili6dKlKn7Nnz6JevXowNTVFw4YNERkZqbL+r7/+Qp06dWBsbIzy5ctj8uTJyMzMlNZHRUWhadOmMDY2hqurq8o55CctLQ2+vr6wsbGBsbExGjdujNOnT0vrc26j7N+//52x5TAxMYGdnZ20GBkZwdTUVKVNX19fpdyd85vfhg0b0KRJE5iYmOCzzz7DjRs3cPr0adSrVw/m5uZo06YNHj16pHK8JUuWwMXFBcbGxqhatSoWLlz4n+f8KVMqlbCzs0PZsmXRqVMneHp6qnyfs7OzERQUBGdnZ5iYmKBmzZrYtGmTtD4rKws+Pj7S+ipVqmDevHm5jvPnn39Kf7/s7e0xdOhQlfWPHz9G586dYWpqikqVKmH79u0q6y9fvow2bdrA3Nwctra26NWrFx4/fiytT01NRe/evWFubg57e3uVv7/vsmjRIlSoUAFGRkaoUqUKVq5cqbJeoVBgyZIl74wth76+vsrPpbm5OQwMDFTaTExMct2qcHJywtSpU6X4HR0dsX37djx69AgdO3aEubk5atSogTNnzqgc79ixY9LPd9myZeHr64vU1FS1zpt0lKD/5O3tLTp27Ci2bNkijI2Nxb1794QQQmzdulW8eQnPnDkj9PT0RGBgoIiMjBTLli0TJiYmYtmyZUIIIRITE0WZMmVEYGCgiI2NFbGxsfke09HRUcyZM0cIIURWVpbYtGmTUCgUYuzYsVIfT09P0b59e3H69Glx48YNMWrUKFGiRAmRmJgohBAiIiJChISEiEuXLokbN26IH3/8URgbG4u7d+9K+/jmm29E2bJlxZYtW0R0dLTYt2+fWLdunRBCiIMHDwoAon79+uLQoUPiypUrokmTJqJhw4bS9keOHBEWFhYiNDRUREdHi7179wonJycxadIkKfbq1asLDw8PERERIQ4fPixq164tAIitW7fme/6+vr7CwcFB/PPPP+LKlSvC29tbFC9eXDo3dWJ7l2bNmonhw4fnan8zrtu3bwsAomrVqmL37t3i6tWrokGDBqJu3bqiefPm4tixY+LcuXOiYsWK4vvvv5f2sWrVKmFvby82b94sbt26JTZv3iysra1FaGioWrF9anL+fuS4dOmSsLOzE/Xr15fapk6dKl3H6OhosWzZMqFUKsWhQ4eEEEKkp6eLiRMnitOnT4tbt26JVatWCVNTU7F+/XppHwsXLhTGxsZi7ty5IjIyUpw6dUr6OyLE6+9dmTJlxJo1a0RUVJTw9fUV5ubm0s/M06dPRalSpURAQIC4du2aOHfunPjyyy9FixYtpH0MHjxYlCtXTuzbt09cvHhRfPXVV6JYsWJ5/qzk2LJlizA0NBS//fabiIyMFLNmzRL6+vriwIEDasf2Lj/99JOoWbNmrva3f4YdHR2FtbW1CAkJETdu3BCDBw8WFhYWonXr1mLDhg0iMjJSdOrUSbi4uIjs7GwhhBA3b94UZmZmYs6cOeLGjRvi+PHjonbt2qJPnz7/GRfpLiYOanjzH8YGDRqIfv36CSFyJw7ffvut+PLLL1W29ff3F66urtLXbyYE7+Lo6CiMjIyEmZmZMDAwEACEtbW1iIqKEkIIcfToUWFhYSFevXqlsl2FChXE77//nu9+q1WrJhYsWCCEECIyMlIAEGFhYXn2zflw3rdvn9S2c+dOAUC8fPlSCCGEh4eHmD59usp2K1euFPb29kIIIfbs2SMMDAzEgwcPpPW7du16Z+KQkpIiDA0NxerVq6W29PR04eDgIIKDg9WO7V00SRyWLFkirV+7dq0AIPbv3y+1BQUFiSpVqkhfV6hQQaxZs0Zlv1OmTBHu7u7/GdenyNvbW+jr6wszMzOhVCoFAKGnpyc2bdokhBDi1atXwtTUVJw4cUJlOx8fH9GzZ8989ztkyBDRtWtX6WsHBwcxfvz4fPsDED/++KP0dUpKigAgdu3aJYR4/T1o2bKlyjb37t0TAERkZKR4/vy5MDIyEhs2bJDWJyYmChMTk3cmDg0bNhQDBgxQafv6669F27Zt1Y7tXTRJHL777jvp69jYWAFATJgwQWoLDw8XAKRfWnx8fMTAgQNV9nv06FGhp6en1t8j0k0c46ChGTNm4IsvvsDo0aNzrbt27Ro6duyo0taoUSPMnTsXWVlZGt8/9/f3R58+fRAbGwt/f3/88MMPqFixIgDgwoULSElJQYkSJVS2efnyJaKjowEAKSkpmDRpEnbu3InY2FhkZmbi5cuXiImJAQBERERAX18fzZo1e2ccNWrUkP5sb28PAEhISEC5cuVw4cIFHD9+HNOmTZP6ZGVl4dWrV3jx4gWuXbuGsmXLwsHBQVrv7u7+zuNFR0cjIyMDjRo1ktoMDQ3x+eef49q1a2rHVlDePIatrS0AwM3NTaUtISEBwOtSd3R0NHx8fDBgwACpT2ZmJiwtLQsspsKmRYsWWLRoEVJTUzFnzhwYGBiga9euAICbN2/ixYsX+PLLL1W2SU9PR+3ataWvf/vtN/z555+IiYnBy5cvkZ6ejlq1agF4/T19+PAhPDw83hnHm98rMzMzWFhYSN+bCxcu4ODBgzA3N8+1XXR0tHTM+vXrS+3W1taoUqXKO4957do1DBw4UKWtUaNGuW61vCu2gqLOzyrw+nra2dnhwoULuHjxIlavXi31EUIgOzsbt2/fhouLS4HGR0UDEwcNNW3aFK1atUJAQAD69Omj1WOVLFkSFStWRMWKFbFx40a4ubmhXr16cHV1RUpKCuzt7XHo0KFc21lZWQEARo8ejbCwMMycORMVK1aEiYkJunXrhvT0dABQe3CVoaGh9OeccRnZ2dkAXicnkydPRpcuXXJtZ2xsrMnpvpd3xabNY7zd9ub1AIDFixerfAABKNIDL83MzKSk9s8//0TNmjWxdOlS+Pj4SNdk586dKF26tMp2Oe99WLduHUaPHo1Zs2bB3d0dxYoVwy+//IKTJ08CeL+fVSD396Z9+/Z5Dti0t7fHzZs3NThjzb0rNm0cI7+fVUD17++gQYPg6+uba18FmXxT0cLE4T38/PPPqFWrVq7fRFxcXHD8+HGVtuPHj6Ny5crSh4aRkRGysrI0PmbZsmXRvXt3BAQESIMR4+LiYGBgACcnpzy3OX78OPr06YPOnTsDeP2PxJ07d6T1bm5uyM7OxuHDh+Hp6alxTABQp04dREZGSh8ab3NxccG9e/cQGxsrVQT+/fffd+4zZ5DZ8ePH4ejoCADIyMjA6dOnC/28dVtbWzg4OODWrVvw8vKSOxxZ6Onp4X//+x9GjhyJb7/9Fq6urlAqlYiJicm3unX8+HE0bNgQP/zwg9SWUzkDXg8UdnJywv79+9GiRYv3iqtOnTrYvHkznJycYGCQ+5++ChUqwNDQECdPnpQ+NJ8+fYobN268syqX8/fe29tb5XxcXV3fK86PqU6dOrh69Wq+f3+J8sJZFe/Bzc0NXl5emD9/vkr7qFGjsH//fkyZMgU3btzA8uXL8euvv6rc1nBycsKRI0fw4MEDldHc6hg+fDj+/vtvnDlzBp6ennB3d0enTp2wd+9e3LlzBydOnMD48eOlUdOVKlXCli1bEBERgQsXLuDbb79V+Q3HyckJ3t7e6NevH7Zt24bbt2/j0KFD2LBhg9oxTZw4EStWrMDkyZNx5coVXLt2DevWrcOPP/4I4PVslMqVK8Pb2xsXLlzA0aNHMX78+Hfu08zMDIMHD4a/vz92796Nq1evStNSfXx8NLpmcpg8eTKCgoIwf/583LhxA5cuXcKyZcswe/ZsuUP7aL7++mvo6+vjt99+Q7FixTB69Gj4+flh+fLliI6Oxrlz57BgwQIsX74cwOuf1TNnzmDPnj24ceMGJkyYoDKLBgAmTZqEWbNmYf78+YiKipL2oa4hQ4bgyZMn6NmzJ06fPo3o6Gjs2bMHffv2RVZWFszNzeHj4wN/f38cOHAAly9fRp8+faCn9+5/Jv39/REaGopFixYhKioKs2fPxpYtW/K8nVnYjB07FidOnMDQoUMRERGBqKgo/PXXX7lmqxC9iYnDewoMDMxVZqxTpw42bNiAdevWoXr16pg4cSICAwNVbmkEBgbizp07qFChAkqVKqXRMV1dXdGyZUtMnDgRCoUC//zzD5o2bYq+ffuicuXK6NGjB+7evSvdx5w9ezaKFy+Ohg0bon379mjVqhXq1Kmjss9FixahW7du+OGHH1C1alUMGDBAo6lYrVq1wo4dO7B371589tlnaNCgAebMmSNVCvT09LB161a8fPkSn3/+Ofr3768yHiI/P//8M7p27YpevXqhTp06uHnzJvbs2fPRnqHxIfr3748lS5Zg2bJlcHNzQ7NmzRAaGgpnZ2e5Q/toDAwMMHToUAQHByM1NRVTpkzBhAkTEBQUBBcXF7Ru3Ro7d+6UrsmgQYPQpUsXdO/eHfXr10diYqJK9QEAvL29MXfuXCxcuBDVqlXDV199haioKLVjcnBwwPHjx5GVlYWWLVvCzc0NI0aMgJWVlZQc/PLLL2jSpAnat28PT09PNG7cGHXr1n3nfjt16oR58+Zh5syZqFatGn7//XcsW7YMzZs31+yiyaBGjRo4fPgwbty4gSZNmqB27dqYOHGiypgkorfxtdpERESkNlYciIiISG1MHIiIiEhtTByIiIhIbUwciIiISG1MHIiIiEhtTByIiIhIbUwciIiISG1MHIiIiEhtTByIPgF9+vRBp06dpK+bN28uy3s7Dh06BIVCgaSkpI9+bCIqHJg4EH2APn36QKFQQKFQwMjICBUrVkRgYCAyMzO1etwtW7ZgypQpavXlhz0RFSS+HZPoA7Vu3RrLli1DWloa/vnnHwwZMgSGhoYICAhQ6Zeeng4jI6MCOaa1tXWB7IeISFOsOBB9IKVSCTs7Ozg6OmLw4MHw9PTE9u3bpdsL06ZNg4ODg/Qa9nv37uGbb76BlZUVrK2t0bFjR5XXnWdlZWHkyJGwsrJCiRIlMGbMGLz9Spm3b1WkpaVh7NixKFu2LJRKJSpWrIilS5fizp070muoixcvDoVCIb10LTs7G0FBQXB2doaJiQlq1qyJTZs2qRznn3/+QeXKlWFiYoIWLVqoxElEuomJA1EBMzExQXp6OgBg//79iIyMRFhYGHbs2IGMjAy0atUKxYoVw9GjR3H8+HGYm5ujdevW0jazZs1CaGgo/vzzTxw7dgxPnjzB1q1b33nM3r17Y+3atZg/fz6uXbuG33//Hebm5ihbtiw2b94MAIiMjERsbCzmzZsHAAgKCsKKFSsQEhKCK1euwM/PD9999x0OHz4M4HWC06VLF7Rv3x4RERHo378/xo0bp63LRkSfCkFE783b21t07NhRCCFEdna2CAsLE0qlUowePVp4e3sLW1tbkZaWJvVfuXKlqFKlisjOzpba0tLShImJidizZ48QQgh7e3sRHBwsrc/IyBBlypSRjiOEEM2aNRPDhw8XQggRGRkpAIiwsLA8Yzx48KAAIJ4+fSq1vXr1SpiamooTJ06o9PXx8RE9e/YUQggREBAgXF1dVdaPHTs2176ISLdwjAPRB9qxYwfMzc2RkZGB7OxsfPvtt5g0aRKGDBkCNzc3lXENFy5cwM2bN1GsWDGVfbx69QrR0dF49uwZYmNjUb9+fWmdgYEB6tWrl+t2RY6IiAjo6+ujWbNmasd88+ZNvHjxAl9++aVKe3p6OmrXrg0AuHbtmkocAODu7q72MYioaGLiQPSBWrRogUWLFsHIyAgODg4wMPi/v1ZmZmYqfVNSUlC3bl2sXr06135KlSr1Xsc3MTHReJuUlBQAwM6dO1G6dGmVdUql8r3iICLdwMSB6AOZmZmhYsWKavWtU6cO1q9fDxsbG1hYWOTZx97eHidPnkTTpk0BAJmZmTh79izq1KmTZ383NzdkZ2fj8OHD8PT0zLU+p+KRlZUltbm6ukKpVCImJibfSoWLiwu2b9+u0vbvv//+90kSUZHGwZFEH5GXlxdKliyJjh074ujRo7h9+zYOHToEX19f3L9/HwAwfPhw/Pzzz9i2bRuuX7+OH3744Z3PYHBycoK3tzf69euHbdu2SfvcsGEDAMDR0REKhQI7duzAo0ePkJKSgmLFimH06NHw8/PD8uXLER0djXPnzmHBggVYvnw5AOD7779HVFQU/P39ERkZiTVr1iA0NFTbl4iICjkmDkQfkampKY4cOYJy5cqhS5cucHFxgY+PD169eiVVIEaNGoVevXrB29sb7u7uKFasGDp37vzO/S5atAjdunXDDz/8gKpVq2LAgAFITU0FAJQuXRqTJ0/GuHHjYGtri6FDhwIApkyZggkTJiAoKAguLi5o3bo1du7cCWdnZwBAuXLlsHnzZmzbtg01a9ZESEgIpk+frsWrQ0SfAoXIb8QVERER0VtYcSAiIiK1MXEgIiIitTFxICIiIrUxcSAiIiK1MXEgIiIitTFxICIiIrUxcSAiIiK1MXEgIiIitTFxICIiIrUxcSAiIiK1MXEgIiIitf0/1g0fB9Zy4rEAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ridge Classifier Classification Report--\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.66      0.87      0.75      1321\n",
      "           1       0.80      0.56      0.66      1305\n",
      "\n",
      "    accuracy                           0.71      2626\n",
      "   macro avg       0.73      0.71      0.70      2626\n",
      "weighted avg       0.73      0.71      0.70      2626\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--KNN Classification Report--\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.68      0.82      0.74      1321\n",
      "           1       0.77      0.60      0.68      1305\n",
      "\n",
      "    accuracy                           0.71      2626\n",
      "   macro avg       0.72      0.71      0.71      2626\n",
      "weighted avg       0.72      0.71      0.71      2626\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Random Forest Classification Report--\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.69      0.88      0.77      1321\n",
      "           1       0.83      0.60      0.70      1305\n",
      "\n",
      "    accuracy                           0.74      2626\n",
      "   macro avg       0.76      0.74      0.73      2626\n",
      "weighted avg       0.76      0.74      0.73      2626\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg4AAAIjCAYAAABriZPRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABq/0lEQVR4nO3dd1gUV9sG8HtpSxMQpUYFBAsodqPYFaJRY4/RaBQUSwyKoqLxNRpFI/aaV7FF0WhijbFEI/YaY8MeUCzYEAURQal7vj/8mNcVy65hGWTvn9dcl3vm7Myzw8I++8w5MwohhAARERGRBgzkDoCIiIg+HEwciIiISGNMHIiIiEhjTByIiIhIY0wciIiISGNMHIiIiEhjTByIiIhIY0wciIiISGNMHIiIiEhjTBz0zNWrV9GyZUtYW1tDoVBgy5YtBbr9mzdvQqFQYOXKlQW63Q9Zs2bN0KxZswLbXlpaGvr16wdHR0coFAoMGzaswLb9oeD7jEg+TBxkEBcXh4EDB6J8+fIwNTWFlZUVGjZsiHnz5uH58+c63be/vz8uXLiAH374AatXr0adOnV0ur/CFBAQAIVCASsrq9cex6tXr0KhUEChUGDmzJlab//evXuYMGECoqOjCyDa9zdlyhSsXLkSgwYNwurVq9GrVy+d7s/V1VU6bgqFAhYWFvj444+xatUqne73Q/PqcXp5ycjIkDu8fI4dO4YJEyYgJSVF7lDoA2MkdwD6ZseOHejatSuUSiV69+6NqlWrIisrC0eOHEFoaCguXbqEJUuW6GTfz58/x/HjxzF27FgMHjxYJ/twcXHB8+fPYWxsrJPtv4uRkRGePXuGbdu24YsvvlBbt2bNGpiamr73H/F79+5h4sSJcHV1RY0aNTR+3u7du99rf2+yb98+1K9fH99//32BbvdtatSogREjRgAA7t+/j2XLlsHf3x+ZmZno379/ocVR1L18nF5mYmIiQzRvd+zYMUycOBEBAQGwsbGROxz6gDBxKEQ3btxA9+7d4eLign379sHJyUlaFxQUhGvXrmHHjh062//Dhw8BQKd/JBQKBUxNTXW2/XdRKpVo2LAhfvnll3yJw9q1a9G2bVts2rSpUGJ59uwZzM3NC/xDIzExEV5eXgW2vZycHKhUqrfG+dFHH+Grr76SHgcEBKB8+fKYM2cOE4eXvHqcCopKpUJWVpasv1tEeXiqohBNnz4daWlpWL58uVrSkMfDwwNDhw6VHufk5GDSpElwd3eHUqmEq6sr/vOf/yAzM1Ptea6urvjss89w5MgRfPzxxzA1NUX58uXVSskTJkyAi4sLACA0NBQKhQKurq4AXnwI5P3/ZRMmTIBCoVBri4qKQqNGjWBjYwNLS0tUqlQJ//nPf6T1bzr3vG/fPjRu3BgWFhawsbFBhw4dcOXKldfu79q1a9K3IGtra/Tp0wfPnj1784F9RY8ePbBz5061EuzJkydx9epV9OjRI1//5ORkjBw5Et7e3rC0tISVlRVat26Nc+fOSX0OHDiAunXrAgD69OkjlaDzXmezZs1QtWpVnD59Gk2aNIG5ubl0XF4d4+Dv7w9TU9N8r79Vq1YoWbIk7t2799rXdeDAASgUCty4cQM7duyQYrh58yaAFwlFYGAgHBwcYGpqiurVqyMyMlJtG3k/n5kzZ2Lu3LnSe+vy5csaHds8dnZ2qFy5MuLi4tTaDx8+jK5du6JcuXJQKpUoW7YsQkJC8p06CggIgKWlJe7evYuOHTvC0tISdnZ2GDlyJHJzc9X6pqSkICAgANbW1rCxsYG/v/8by+vavM9iY2Px1VdfwdraGnZ2dhg3bhyEELh9+zY6dOgAKysrODo6YtasWVodm7dJT0/HiBEjULZsWSiVSlSqVAkzZ87EqzcpVigUGDx4MNasWYMqVapAqVRi165dAIC7d++ib9++cHBwgFKpRJUqVfDTTz/l29eCBQtQpUoVmJubo2TJkqhTpw7Wrl0rHYPQ0FAAgJubW773EtHbsOJQiLZt24by5cujQYMGGvXv168fIiMj8fnnn2PEiBE4ceIEwsPDceXKFfz2229qfa9du4bPP/8cgYGB8Pf3x08//YSAgADUrl0bVapUQefOnWFjY4OQkBB8+eWXaNOmDSwtLbWK/9KlS/jss89QrVo1hIWFQalU4tq1azh69Ohbn7dnzx60bt0a5cuXx4QJE/D8+XMsWLAADRs2xJkzZ/IlLV988QXc3NwQHh6OM2fOYNmyZbC3t8e0adM0irNz5874+uuvsXnzZvTt2xfAi2pD5cqVUatWrXz9r1+/ji1btqBr165wc3PDgwcPsHjxYjRt2hSXL1+Gs7MzPD09ERYWhvHjx2PAgAFo3LgxAKj9LJOSktC6dWt0794dX331FRwcHF4b37x587Bv3z74+/vj+PHjMDQ0xOLFi7F7926sXr0azs7Or32ep6cnVq9ejZCQEJQpU0YqidvZ2eH58+do1qwZrl27hsGDB8PNzQ0bNmxAQEAAUlJS1BJSAFixYgUyMjIwYMAAKJVK2NraanRs8+Tk5ODOnTsoWbKkWvuGDRvw7NkzDBo0CKVKlcLff/+NBQsW4M6dO9iwYYNa39zcXLRq1Qr16tXDzJkzsWfPHsyaNQvu7u4YNGgQAEAIgQ4dOuDIkSP4+uuv4enpid9++w3+/v75YtL2fdatWzd4enpi6tSp2LFjByZPngxbW1ssXrwYLVq0wLRp07BmzRqMHDkSdevWRZMmTd55XLKzs/Ho0SO1NnNzc5ibm0MIgfbt22P//v0IDAxEjRo18OeffyI0NBR3797FnDlz1J63b98+rF+/HoMHD0bp0qXh6uqKBw8eoH79+lJiYWdnh507dyIwMBCpqanSQNmlS5ciODgYn3/+OYYOHYqMjAycP38eJ06cQI8ePdC5c2fExsbil19+wZw5c1C6dGkAL95LRO8kqFA8efJEABAdOnTQqH90dLQAIPr166fWPnLkSAFA7Nu3T2pzcXERAMShQ4ektsTERKFUKsWIESOkths3bggAYsaMGWrb9Pf3Fy4uLvli+P7778XLb5E5c+YIAOLhw4dvjDtvHytWrJDaatSoIezt7UVSUpLUdu7cOWFgYCB69+6db399+/ZV22anTp1EqVKl3rjPl1+HhYWFEEKIzz//XPj6+gohhMjNzRWOjo5i4sSJrz0GGRkZIjc3N9/rUCqVIiwsTGo7efJkvteWp2nTpgKAiIiIeO26pk2bqrX9+eefAoCYPHmyuH79urC0tBQdO3Z852sU4sXPu23btmptc+fOFQDEzz//LLVlZWUJHx8fYWlpKVJTU6XXBUBYWVmJxMREjffXsmVL8fDhQ/Hw4UNx4cIF0atXLwFABAUFqfV99uxZvueHh4cLhUIhbt26JbX5+/sLAGrHVwghatasKWrXri093rJliwAgpk+fLrXl5OSIxo0b/+v32YABA9S2WaZMGaFQKMTUqVOl9sePHwszMzPh7++v0XECkG/5/vvv1V7L5MmT1Z73+eefC4VCIa5duya1ARAGBgbi0qVLan0DAwOFk5OTePTokVp79+7dhbW1tXT8O3ToIKpUqfLWeGfMmCEAiBs3brzztRG9jKcqCklqaioAoESJEhr1/+OPPwAAw4cPV2vP+5b56lgILy8v6Vsw8OKbQ6VKlXD9+vX3jvlVeWMjfv/9d6hUKo2ec//+fURHRyMgIEDtW221atXwySefSK/zZV9//bXa48aNGyMpKUk6hpro0aMHDhw4gISEBOzbtw8JCQmvPU0BvBgXYWDw4lchNzcXSUlJ0mmYM2fOaLxPpVKJPn36aNS3ZcuWGDhwIMLCwtC5c2eYmppi8eLFGu/rVX/88QccHR3x5ZdfSm3GxsYIDg5GWloaDh48qNa/S5cuWn273L17N+zs7GBnZwdvb2+sXr0affr0wYwZM9T6mZmZSf9PT0/Ho0eP0KBBAwghcPbs2Xzbfd3P+uX37B9//AEjIyOpAgEAhoaGGDJkiNrz3ud91q9fP7Vt1qlTB0IIBAYGSu02NjZa/R7Vq1cPUVFRakvv3r2l12JoaIjg4GC154wYMQJCCOzcuVOtvWnTpmpjWYQQ2LRpE9q1awchBB49eiQtrVq1wpMnT6T3q42NDe7cuYOTJ09qFDeRNpg4FBIrKysAwNOnTzXqf+vWLRgYGMDDw0Ot3dHRETY2Nrh165Zae7ly5fJto2TJknj8+PF7Rpxft27d0LBhQ/Tr1w8ODg7o3r071q9f/9YkIi/OSpUq5Vvn6emJR48eIT09Xa391deSVw7X5rW0adMGJUqUwLp167BmzRrUrVs337HMo1KpMGfOHFSoUAFKpRKlS5eGnZ0dzp8/jydPnmi8z48++kirgZAzZ86Era0toqOjMX/+fNjb22v83FfdunULFSpUkBKgPJ6entL6l7m5uWm1/bwPxF27dmHmzJmwsbHB48eP873e+Ph46cM7b9xC06ZNASDfsTQ1Nc2XvLz6nr116xacnJzynVZ79f1UEO8za2trmJqaSmX7l9s1fe+VLl0afn5+akv58uWlGJ2dnfN9edD0Z/Tw4UOkpKRgyZIlUhKXt+QlrImJiQCA0aNHw9LSEh9//DEqVKiAoKCgd55SJNIUxzgUEisrKzg7O+PixYtaPe/VwYlvYmho+Np28cqgK2328eogNTMzMxw6dAj79+/Hjh07sGvXLqxbtw4tWrTA7t273xiDtv7Na8mjVCrRuXNnREZG4vr165gwYcIb+06ZMgXjxo1D3759MWnSJNja2sLAwADDhg3TuLICqH/b1sTZs2elP/QXLlxQqxbomrax5n0gAi8GcVauXBmfffYZ5s2bJ1XFcnNz8cknnyA5ORmjR49G5cqVYWFhgbt37yIgICDfsSyo98v7et3+C+K9V1Be/RnlHb+vvvrqtWM8gBcVFuBFMhITE4Pt27dj165d2LRpExYuXIjx48dj4sSJug2cij0mDoXos88+w5IlS3D8+HH4+Pi8ta+LiwtUKhWuXr0qfSMBgAcPHiAlJUWaIVEQSpYs+dpR6q9+AwIAAwMD+Pr6wtfXF7Nnz8aUKVMwduxY7N+/X/pgefV1AEBMTEy+df/88w9Kly4NCwuLf/8iXqNHjx746aefYGBggO7du7+x38aNG9G8eXMsX75crT0lJUXt26emSZwm0tPT0adPH3h5eaFBgwaYPn06OnXqJM3c0JaLiwvOnz8PlUqlVnX4559/pPUFqW3btmjatCmmTJmCgQMHwsLCAhcuXEBsbCwiIyOl8jzwYibO+3JxccHevXuRlpamVnV49f0k5/tMUy4uLtizZw+ePn2qVnXQ9GdkZ2eHEiVKIDc397W/a6+ysLBAt27d0K1bN2RlZaFz58744YcfMGbMGJiamhbo+5n0C09VFKJRo0bBwsIC/fr1w4MHD/Ktj4uLw7x58wC8KLUDwNy5c9X6zJ49G8CLP9wFxd3dHU+ePMH58+eltvv37+ebuZGcnJzvuXkXQnp1imgeJycn1KhRA5GRkWrJycWLF7F7927pdepC8+bNMWnSJPz4449wdHR8Yz9DQ8N83yg3bNiAu3fvqrXlffAUxJX2Ro8ejfj4eERGRmL27NlwdXWVLqj0Ptq0aYOEhASsW7dOasvJycGCBQtgaWkpnS4oSKNHj0ZSUhKWLl0K4H/f1l8+lkII6T39Ptq0aYOcnBwsWrRIasvNzcWCBQvU+sn5PtNUmzZtkJubix9//FGtfc6cOVAoFGjduvVbn29oaIguXbpg06ZNr61c5l2nBXgxw+dlJiYm8PLyghAC2dnZAAr2/Uz6hRWHQuTu7o61a9dK08BevnLksWPHpOlzAFC9enX4+/tjyZIlSElJQdOmTfH3338jMjISHTt2RPPmzQssru7du2P06NHo1KkTgoOD8ezZMyxatAgVK1ZUGxwYFhaGQ4cOoW3btnBxcUFiYiIWLlyIMmXKoFGjRm/c/owZM9C6dWv4+PggMDBQmiZnbW391lMI/5aBgQG+++67d/b77LPPEBYWhj59+qBBgwa4cOEC1qxZI52bzuPu7g4bGxtERESgRIkSsLCwQL169bQeL7Bv3z4sXLgQ33//vTQ9dMWKFWjWrBnGjRuH6dOna7U9ABgwYAAWL16MgIAAnD59Gq6urti4cSOOHj2KuXPnajwoVxutW7dG1apVMXv2bAQFBaFy5cpwd3fHyJEjcffuXVhZWWHTpk3/apxNu3bt0LBhQ3z77be4efMmvLy8sHnz5teOPZHrfaapdu3aoXnz5hg7dixu3ryJ6tWrY/fu3fj9998xbNgwuLu7v3MbU6dOxf79+1GvXj30798fXl5eSE5OxpkzZ7Bnzx4puW/ZsiUcHR3RsGFDODg44MqVK/jxxx/Rtm1b6b1Qu3ZtAMDYsWPRvXt3GBsbo127drJXZugDIM9kDv0WGxsr+vfvL1xdXYWJiYkoUaKEaNiwoViwYIHIyMiQ+mVnZ4uJEycKNzc3YWxsLMqWLSvGjBmj1keI10/PEyL/NMA3TccUQojdu3eLqlWrChMTE1GpUiXx888/55uOuXfvXtGhQwfh7OwsTExMhLOzs/jyyy9FbGxsvn28OmVxz549omHDhsLMzExYWVmJdu3aicuXL6v1ydvfq9M9V6xYodG0sZenY77Jm6ZjjhgxQjg5OQkzMzPRsGFDcfz48ddOo/z999+Fl5eXMDIyUnudTZs2feP0t5e3k5qaKlxcXEStWrVEdna2Wr+QkBBhYGAgjh8//tbX8Kaf94MHD0SfPn1E6dKlhYmJifD29s73c3jbe0Db/QkhxMqVK9WOw+XLl4Wfn5+wtLQUpUuXFv379xfnzp3L955408/q1fecEEIkJSWJXr16CSsrK2FtbS169eolzp49W+DvszfF9Laf7cvedpzyPH36VISEhAhnZ2dhbGwsKlSoIGbMmCFUKpVaP7xmqmueBw8eiKCgIFG2bFlhbGwsHB0dha+vr1iyZInUZ/HixaJJkyaiVKlSQqlUCnd3dxEaGiqePHmitq1JkyaJjz76SBgYGHBqJmlMIYQMo36IiIjog8QxDkRERKQxJg5ERESkMSYOREREpDEmDkRERKQxJg5ERESkMSYOREREpDEmDkRERKSxYnnlSLOag+UOgUjnHp/88d2diD5wpjr+lNLl58Xzs8Xzd5QVByIiItJYsaw4EBERaUTB78/aYuJARET6i7cX1xpTLSIiItIYKw5ERKS/eKpCazxiREREpDFWHIiISH9xjIPWWHEgIiIijbHiQERE+otjHLTGI0ZEREQaY8WBiIj0F8c4aI2JAxER6S+eqtAajxgRERFpjBUHIiLSXzxVoTVWHIiIiEhjrDgQEZH+4hgHrfGIERERkcZYcSAiIv3FMQ5aY8WBiIiINMaKAxER6S+OcdAaEwciItJfPFWhNaZaREREpDFWHIiISH/xVIXWeMSIiIhIY6w4EBGR/mLFQWs8YkRERKQxVhyIiEh/GXBWhbZYcSAiIiKNseJARET6i2MctMbEgYiI9BcvAKU1plpERESkMVYciIhIf/FUhdZ4xIiIiEhjrDgQEZH+4hgHrbHiQERERBpjxYGIiPQXxzhojUeMiIiINMaKAxER6S+OcdAaEwciItJfPFWhNR4xIiIi0hgrDkREpL94qkJrrDgQERGRxopE4rB69Wo0bNgQzs7OuHXrFgBg7ty5+P3332WOjIiIijWFge6WYkr2V7Zo0SIMHz4cbdq0QUpKCnJzcwEANjY2mDt3rrzBERERkRrZE4cFCxZg6dKlGDt2LAwNDaX2OnXq4MKFCzJGRkRExZ5CobulmJI9cbhx4wZq1qyZr12pVCI9PV2GiIiIiOhNZE8c3NzcEB0dna99165d8PT0LPyAiIhIf3CMg9Zkn445fPhwBAUFISMjA0II/P333/jll18QHh6OZcuWyR0eEREVZ8X4A15XZE8c+vXrBzMzM3z33Xd49uwZevToAWdnZ8ybNw/du3eXOzwiIiJ6ieyJAwD07NkTPXv2xLNnz5CWlgZ7e3u5QyIiIn1QjAcx6kqRSBzymJubw9zcXO4wiIiI6A1kTxySkpIwfvx47N+/H4mJiVCpVGrrk5OTZYqMiIiKPY5x0JrsiUOvXr1w7do1BAYGwsHBAQqWjYiIiIos2ROHw4cP48iRI6hevbrcoRARkb7hl1WtyV6jqVy5Mp4/fy53GERERKQB2ROHhQsXYuzYsTh48CCSkpKQmpqqthAREekMLwClNdlPVdjY2CA1NRUtWrRQaxdCQKFQSDe9IiIiKnA8VaE12ROHnj17wtjYGGvXruXgSCIioiJO9sTh4sWLOHv2LCpVqiR3KEREpGf4ZVV7sp+EqVOnDm7fvi13GERERKQB2SsOQ4YMwdChQxEaGgpvb28YGxurra9WrZpMkRERUXHHioP2ZE8cunXrBgDo27ev1KZQKDg4koiIqAiSPXG4ceOG3CEQEZG+YsFBa7InDi4uLnKHQERERBqSJXHYunUrWrduDWNjY2zduvWtfdu3b19IURERkb7hGAftyZI4dOzYEQkJCbC3t0fHjh3f2I9jHIiISJeYOGhPlumYKpUKGRkZEEJApVK9cWHSQEREVLTIdh0HNzc3PHz4UK7dExERQaFQ6GwprmRLHIQQcu2aiIiI3pOssyqKc0ZGRERFHz+HtCdr4jBu3DiYm5u/tc/s2bMLKRoiIiJ5HDp0CDNmzMDp06dx//59/Pbbb2qTB4QQ+P7777F06VKkpKSgYcOGWLRoESpUqCD1SU5OxpAhQ7Bt2zYYGBigS5cumDdvHiwtLaU+58+fR1BQEE6ePAk7OzsMGTIEo0aN0ipWWROHCxcuwMTE5I3rmQkSEZFOFZGPmfT0dFSvXh19+/ZF586d862fPn065s+fj8jISLi5uWHcuHFo1aoVLl++DFNTUwAv7jZ9//59REVFITs7G3369MGAAQOwdu1aAEBqaipatmwJPz8/RERE4MKFC+jbty9sbGwwYMAAjWNVCJkGGxgYGEhTMguaWc3BBb5NoqLm8ckf5Q6BSOdMdfz11rrHap1t+8naXu/1PIVCoVZxEELA2dkZI0aMwMiRI19s+8kTODg4YOXKlejevTuuXLkCLy8vnDx5EnXq1AEA7Nq1C23atMGdO3fg7OyMRYsWYezYsUhISJC+tH/77bfYsmUL/vnnH43jk21wJKsJREQkN13OqsjMzERqaqrakpmZqXWMN27cQEJCAvz8/KQ2a2tr1KtXD8ePHwcAHD9+HDY2NlLSAAB+fn4wMDDAiRMnpD5NmjRRq/S3atUKMTExePz4scbxcFYFERGRDoSHh8Pa2lptCQ8P13o7CQkJAAAHBwe1dgcHB2nd6yr4RkZGsLW1Vevzum28vA9NyDbGYcWKFbC2tpZr90RERDqtfo8ZMwbDhw9Xa1MqlTrbX2GRLXHw9/eXa9dEREQAdJs4KJXKAkkUHB0dAQAPHjyAk5OT1P7gwQPUqFFD6pOYmKj2vJycHCQnJ0vPd3R0xIMHD9T65D3O66MJ2U5VEBER0bu5ubnB0dERe/fuldpSU1Nx4sQJ+Pj4AAB8fHyQkpKC06dPS3327dsHlUqFevXqSX0OHTqE7OxsqU9UVBQqVaqEkiVLahwPEwciItJbReWS02lpaYiOjkZ0dDSAFwMio6OjER8fD4VCgWHDhmHy5MnYunUrLly4gN69e8PZ2VmaeeHp6YlPP/0U/fv3x99//42jR49i8ODB6N69O5ydnQEAPXr0gImJCQIDA3Hp0iWsW7cO8+bNy3c65V1kvY4DERERAadOnULz5s2lx3kf5v7+/li5ciVGjRqF9PR0DBgwACkpKWjUqBF27dolXcMBANasWYPBgwfD19dXugDU/PnzpfXW1tbYvXs3goKCULt2bZQuXRrjx4/X6hoOgIzXcXhVVlYWEhMToVKp1NrLlSun9bZ4HQfSB7yOA+kDXV/HoZT/LzrbdlLklzrbtpxkrzhcvXoVffv2xbFjx9TahRBQKBS8tTYREVERInviEBAQACMjI2zfvh1OTk68MBQRERUafuZoT/bEITo6GqdPn0blypXlDoWIiIjeQfbEwcvLC48ePZI7DCIi0kOsOGhP9umY06ZNw6hRo3DgwAEkJSXlu643ERGRrhSV6ZgfEtkrDnk37fD19VVr5+BIIiKiokf2xGH//v1yh0BERPqq+BYGdEb2xKFp06Zyh0BEREQakj1xAICUlBQsX74cV65cAQBUqVIFffv25d0ziYhIp4rzWARdkX1w5KlTp+Du7o45c+YgOTkZycnJmD17Ntzd3XHmzBm5wyMiIqKXyF5xCAkJQfv27bF06VIYGb0IJycnB/369cOwYcNw6NAhmSMkIqLiihUH7cmeOJw6dUotaQAAIyMjjBo1CnXq1JExMiIiInqV7KcqrKysEB8fn6/99u3bKFGihAwRERGRvuB1HLQne8WhW7duCAwMxMyZM9GgQQMAwNGjRxEaGoovvyyedxYjIqKioTh/wOuK7InDzJkzoVAo0Lt3b+Tk5AAAjI2NMWjQIEydOlXm6IiIiOhlsicOJiYmmDdvHsLDwxEXFwcAcHd3h7m5ucyRERFRsceCg9ZkTxzymJubw9vbW+4wiIiI6C2KTOJARERU2DjGQXuyz6ogIiKiDwcrDkREpLdYcdAeKw5ERESkMVkqDlu3btW4b/v27XUYCRER6TNWHLQnS+LQsWNHtccKhQJCCLXHeXJzcwsrLCIi0jfMG7Qmy6kKlUolLbt370aNGjWwc+dOpKSkICUlBX/88Qdq1aqFXbt2yREeERERvYHsgyOHDRuGiIgINGrUSGpr1aoVzM3NMWDAAFy5ckXG6IiIqDjjqQrtyT44Mi4uDjY2Nvnara2tcfPmzUKPh4iIiN5M9sShbt26GD58OB48eCC1PXjwAKGhofj4449ljIyIiIo73h1Te7InDj/99BPu37+PcuXKwcPDAx4eHihXrhzu3r2L5cuXyx0eERERvUT2MQ4eHh44f/48oqKi8M8//wAAPD094efnV6wztqKmYS13hPT2Qy2vcnCys8YXIUuw7cB5aX2HFtXR7/NGqOlZDqVsLFCvWzjOx97Nt5161dwwIegz1PV2RW6uCudj76LdN/9FRmY2AGDD3IGoXvEj2NmWwOPUZ9h/Igbfzf8d9x8+KbTXSvSy06dOYuVPy3Hl8kU8fPgQc+b/Fy18/aT14/7zLbb+/pvacxo0bIRFS/73xebmzRuYM3M6os+eQXZ2NipUrISgIUPxcb36hfY66P3wc0Z7sicOwIsfXMuWLdGkSRMolUr+IGVgYabEhdi7WPX7caybPSDfenMzExyLjsOmqDNYNL7na7dRr5obfv/xG8xcsRvDp21ATq4K1Sp+BJXqf1NtD52MxYzlfyLh0RM429sgPKQT1s4IRPOA2Tp7bURv8/z5M1SqVAkdO3fB8KGDX9unYaPGCJscLj02MTFRWz/km6/h4uKCpT9FQmlqijWrIjEk6Gvs2BmF0nZ2Oo2fqLDJnjioVCr88MMPiIiIwIMHDxAbG4vy5ctj3LhxcHV1RWBgoNwh6oXdRy9j99HLb1z/y46TAIByTrZv7DN9RGcs/PUAZq6Iktqu3kpU67NgzX7p//H3H2Pmiiisn90fRkYGyMlRvW/4RO+tUeOmaNS46Vv7mJiYvDEBePw4GfG3bmLipB9QsVJlAMDQ4SOw7te1uHbtKhOHIo5fVLUn+xiHyZMnY+XKlZg+fbpaFl+1alUsW7ZMxshIG3YlLfFxNTc8TE7D/pXDcXPPFOxeNhQNapR/43NKWpmje+s6+OvcDSYNVKSdOvk3mjX2Qfu2rTA57HukpDyW1tnYlISrmxu2/b4Fz549Q05ODjauXwfbUqXg5VVFxqhJIwodLsWU7BWHVatWYcmSJfD19cXXX38ttVevXl0a8/A2mZmZyMzMVGsTqlwoDAwLPFZ6M7cypQEAYwe2wZg5v+F8zB30/Oxj/LF4CGp3nYK4+IdS38nBHfB19yawMFPixPkb6BwcIVfYRO/UoFFj+Pp9go/KlMHt27exYO5sfDOwP1avXQdDQ0MoFAosWbYSw4K/QYOPa8HAwAC2trZYuHgZrKyt5Q6fqMDJXnG4e/cuPDw88rWrVCpkZ2e/8/nh4eGwtrZWW3IenNZFqPQWBgYv0uvlm45g9da/cC7mDkbN2ozYm4nw7+Cj1nfOqj2o330a2n79I3JzVVg2qZccIRNppHWbtmjWwhcVKlZCC18/LFi4GJcuXsCpk38DAIQQmDJ5ImxtS2HFqjVY8+sGNG/hh+Cgr/HwYeI7tk5y43RM7cmeOHh5eeHw4cP52jdu3IiaNWu+8/ljxozBkydP1BYjh9q6CJXe4v7DVADAlesJau0xNxJQ1rGkWltSSjquxSdi34l/0PvbFWjduCrqVXMrtFiJ/o0yZcuiZMmSiI+/BQD4+8RfOHTwAKbNnIOatWrD06sKxo6fAFOlKbZu2SJvsEQ6IPupivHjx8Pf3x93796FSqXC5s2bERMTg1WrVmH79u3vfL5SqYRSqVRr42mKwnfrXhLuJaagoqu9WruHi/1bB13mVSpMjGV/KxJp5EFCAlJSUmBX+sWgx+fPnwMADF75hqkwUEAIjt0p6opzZUBXZP9r3aFDB2zbtg1hYWGwsLDA+PHjUatWLWzbtg2ffPKJ3OHpDQszE7iX/d/ob9ePSqFaxY/wOPUZbic8Rkkrc5R1LAkn+xfnbCu6OgAAHiSl4kHSUwDAnMg9+O7rtrgQexfnYu7gq3b1UMnVAT1CX8x3r1vVBbWruODY2TikPH0GtzJ2+P6btoiLf4gT528U8ismeuFZejri4+Olx3fv3ME/V65Ipz4jFv0Iv09aoVTp0rhz+zbmzJqBsuVc0KBRYwBA9Ro1YGVlhe/+8y0GDgqC0lSJzRvX4+6du2jcpJlMr4pIdxTi5ftZFxNmNV8/F5verHHtCti9bGi+9tVb/8KA73/GV+3qYWlY/rEIkyP+wA+L/5Aej+zzCQZ+0QQlrc1xIfYuxs7dgmPR1wEAVTycMTO0C7wrloGFmQkSHj3B7mNXMG3pLtzjBaC09vjkj3KHUCyc/PsE+vXpna+9fYdOGDt+AoYNCcI//1zG09SnsLe3h0+DhggaMhSlSpeW+l66eAEL5s3F5UsXkZOTDXePChg46Jt3TvOkdzPV8ddbj5E7dbbtazNb62zbcioyiUNWVhYSExOhUqmX9sqVK6f1tpg4kD5g4kD6gIlD0SP7qYqrV6+ib9++OHbsmFq7EAIKhQK5ubkyRUZERMUdxzhoT/bEISAgAEZGRti+fTucnJz4QyQiokLDjxztyZ44REdH4/Tp06hcubLcoRAREdE7yJ44eHl54dGjR3KHQUREeohVbu3JcgGo1NRUaZk2bRpGjRqFAwcOICkpSW1damqqHOERERHRG8hScbCxsVHL8oQQ8PX1VevDwZFERKRrLDhoT5bEYf/+/e/uREREREWOLIlD06a8KAoREckv77L3pDnZb3K1YsUKbNiwIV/7hg0bEBkZKUNERERE9CayJw7h4eEo/dKlW/PY29tjypQpMkRERET6QqHQ3VJcyT4dMz4+Hm5u+W+p7OLionbjGSIiooLG6Zjak73iYG9vj/Pnz+drP3fuHEqVKiVDRERERPQmslccvvzySwQHB6NEiRJo0qQJAODgwYMYOnQounfvLnN0RERUnLHgoD3ZE4dJkybh5s2b8PX1hZHRi3BUKhV69+7NMQ5ERERFjOyJg4mJCdatW4dJkybh3LlzMDMzg7e3N1xcXOQOjYiIijmOcdCe7IlDnooVK6JixYpyh0FERERvUSQShzt37mDr1q2Ij49HVlaW2rrZs2fLFBURERV3rDhoT/bEYe/evWjfvj3Kly+Pf/75B1WrVsXNmzchhECtWrXkDo+IiIheIvt0zDFjxmDkyJG4cOECTE1NsWnTJty+fRtNmzZF165d5Q6PiIiKMV4ASnuyJw5XrlxB7969AQBGRkZ4/vw5LC0tERYWhmnTpskcHRERFWcKhUJnS3Ele+JgYWEhjWtwcnJCXFyctO7Ro0dyhUVERESvIfsYh/r16+PIkSPw9PREmzZtMGLECFy4cAGbN29G/fr15Q6PiIiKsWJcGNAZ2ROH2bNnIy0tDQAwceJEpKWlYd26dahQoQJnVBARERUxsicO5cuXl/5vYWGBiIgIGaMhIiJ9UpzHIuiK7GMcACAlJQXLli3DmDFjkJycDAA4c+YM7t69K3NkRERE9DLZKw7nz5+Hn58frK2tcfPmTfTv3x+2trbYvHkz4uPjsWrVKrlDJCKiYooFB+3JXnEYPnw4AgICcPXqVZiamkrtbdq0waFDh2SMjIiIiF4le8Xh5MmTWLx4cb72jz76CAkJCTJERERE+oJjHLQne8VBqVQiNTU1X3tsbCzs7OxkiIiIiIjeRPbEoX379ggLC0N2djaAF9lffHw8Ro8ejS5dusgcHRERFWe85LT2ZE8cZs2ahbS0NNjb2+P58+do2rQpPDw8YGlpiR9++EHu8IiIqBjjJae1J/sYB2tra0RFReHIkSM4f/480tLSUKtWLfj5+ckdGhEREb1C9sQhT6NGjdCoUSPp8ZkzZzB+/Hhs375dxqiIiKg4K8aFAZ2R9VTFn3/+iZEjR+I///kPrl+/DgD4559/0LFjR9StWxcqlUrO8IiIiOgVslUcli9fLl3s6fHjx1i2bBlmz56NIUOGoFu3brh48SI8PT3lCo+IiPRAcR6LoCuyVRzmzZuHadOm4dGjR1i/fj0ePXqEhQsX4sKFC4iIiGDSQEREVATJVnGIi4tD165dAQCdO3eGkZERZsyYgTJlysgVEhER6RkWHLQnW8Xh+fPnMDc3B/CiVKRUKuHk5CRXOERERKQBWWdVLFu2DJaWlgCAnJwcrFy5EqVLl1brExwcLEdoRESkBzjGQXsKIYSQY8eurq7v/IEpFApptoU2zGoOft+wiD4Yj0/+KHcIRDpnquOvt41mHtbZto+MbKyzbctJtorDzZs35do1ERERvacicwEoIiKiwsZTFdqT/V4VRERE+iw3Nxfjxo2Dm5sbzMzM4O7ujkmTJuHlkQRCCIwfPx5OTk4wMzODn58frl69qrad5ORk9OzZE1ZWVrCxsUFgYCDS0tIKPF4mDkREpLeKwk2upk2bhkWLFuHHH3/ElStXMG3aNEyfPh0LFiyQ+kyfPh3z589HREQETpw4AQsLC7Rq1QoZGRlSn549e+LSpUuIiorC9u3bcejQIQwYMKBAjxcg4+BIXeLgSNIHHBxJ+kDXgyObzD6qs20fGt5Qo36fffYZHBwcsHz5cqmtS5cuMDMzw88//wwhBJydnTFixAiMHDkSAPDkyRM4ODhg5cqV6N69O65cuQIvLy+cPHkSderUAQDs2rULbdq0wZ07d+Ds7Fxgr4sVByIi0lsKhe6WzMxMpKamqi2ZmZn5YmjQoAH27t2L2NhYAMC5c+dw5MgRtG7dGgBw48YNJCQkqN012traGvXq1cPx48cBAMePH4eNjY2UNACAn58fDAwMcOLEiQI9ZrInDoaGhkhMTMzXnpSUBENDQxkiIiIi+vfCw8NhbW2ttoSHh+fr9+2336J79+6oXLkyjI2NUbNmTQwbNgw9e/YEACQkJAAAHBwc1J7n4OAgrUtISIC9vb3aeiMjI9ja2kp9CorssyredKYkMzMTJiYmhRwNERHpE13OqhgzZgyGDx+u1qZUKvP1W79+PdasWYO1a9eiSpUqiI6OxrBhw+Ds7Ax/f3+dxfe+ZEsc5s+fD+DFD+3lK0gCL0aYHjp0CJUrV5YrPCIi0gO6nI2pVCpfmyi8KjQ0VKo6AIC3tzdu3bqF8PBw+Pv7w9HREQDw4MEDtVszPHjwADVq1AAAODo65qve5+TkIDk5WXp+QZEtcZgzZw6AFxWHiIgItdMSJiYmcHV1RUREhFzhERERFYpnz57BwEB95IChoSFUKhUAwM3NDY6Ojti7d6+UKKSmpuLEiRMYNGgQAMDHxwcpKSk4ffo0ateuDQDYt28fVCoV6tWrV6DxypY43LhxAwDQvHlzbN68GSVLlpQrFCIi0lNF4QJQ7dq1ww8//IBy5cqhSpUqOHv2LGbPno2+ffsCeBHjsGHDMHnyZFSoUAFubm4YN24cnJ2d0bFjRwCAp6cnPv30U/Tv3x8RERHIzs7G4MGD0b179wKdUQEUgTEO+/fvl/6fN96hKPwgiYiICsOCBQswbtw4fPPNN0hMTISzszMGDhyI8ePHS31GjRqF9PR0DBgwACkpKWjUqBF27doFU1NTqc+aNWswePBg+Pr6wsDAAF26dJGGBRSkInEdh1WrVmHGjBnSVbAqVqyI0NBQ9OrV6722x+s4kD7gdRxIH+j6Og6+C47rbNt7h/jobNtykr3iMHv2bIwbNw6DBw9Gw4YvLpZx5MgRfP3113j06BFCQkJkjpCIiIjyyJ44LFiwAIsWLULv3r2ltvbt26NKlSqYMGECEwciItIZA54a15rsF4C6f/8+GjRokK+9QYMGuH//vgwRERER0ZvInjh4eHhg/fr1+drXrVuHChUqyBARERHpC11ecrq4kv1UxcSJE9GtWzccOnRIGuNw9OhR7N2797UJBRERUUHhLD7tyV5x6NKlC06cOIHSpUtjy5Yt2LJlC0qXLo2///4bnTp1kjs8IiIieonsFQcAqF27Nn7++We5wyAiIj1jwIKD1mSvOBAREdGHQ7aKg4GBwTvPLSkUCuTk5BRSREREpG84xkF7siUOv/322xvXHT9+HPPnz5du8EFERERFg2yJQ4cOHfK1xcTE4Ntvv8W2bdvQs2dPhIWFyRAZERHpCxYctFckxjjcu3cP/fv3h7e3N3JychAdHY3IyEi4uLjIHRoRERG9RNbE4cmTJxg9ejQ8PDxw6dIl7N27F9u2bUPVqlXlDIuIiPSEQof/iivZTlVMnz4d06ZNg6OjI3755ZfXnrogIiLSJU7H1J5sicO3334LMzMzeHh4IDIyEpGRka/tt3nz5kKOjIiIiN5EtsShd+/enAZDRESy4ueQ9mRLHFauXCnXromIiOg9FYlLThMREcmBBQftFYnpmERERPRhYMWBiIj0lgFLDlpjxYGIiIg0xooDERHpLRYctMfEgYiI9BanY2qPpyqIiIhIY6w4EBGR3mLBQXusOBAREZHGWHEgIiK9xemY2mPFgYiIiDTGigMREekt1hu0x4oDERERaYwVByIi0lu8joP2mDgQEZHeMmDeoDWeqiAiIiKNseJARER6i6cqtMeKAxEREWmMFQciItJbLDhojxUHIiIi0hgrDkREpLc4xkF7GiUOW7du1XiD7du3f+9giIiIqGjTKHHo2LGjRhtTKBTIzc39N/EQEREVGl7HQXsaJQ4qlUrXcRARERU6nqrQHgdHEhERkcbea3Bkeno6Dh48iPj4eGRlZamtCw4OLpDAiIiIdI31Bu1pnTicPXsWbdq0wbNnz5Ceng5bW1s8evQI5ubmsLe3Z+JARERUjGl9qiIkJATt2rXD48ePYWZmhr/++gu3bt1C7dq1MXPmTF3ESEREpBMGCoXOluJK68QhOjoaI0aMgIGBAQwNDZGZmYmyZcti+vTp+M9//qOLGImIiKiI0DpxMDY2hoHBi6fZ29sjPj4eAGBtbY3bt28XbHREREQ6pFDobimutB7jULNmTZw8eRIVKlRA06ZNMX78eDx69AirV69G1apVdREjERERFRFaVxymTJkCJycnAMAPP/yAkiVLYtCgQXj48CGWLFlS4AESERHpikKh0NlSXGldcahTp470f3t7e+zatatAAyIiIqKiize5IiIivVWMCwM6o3Xi4Obm9tYSzPXr1/9VQERERIWlOE+b1BWtE4dhw4apPc7OzsbZs2exa9cuhIaGFlRcREREVARpnTgMHTr0te3//e9/cerUqX8dEBERUWFhwUF7BXaTq9atW2PTpk0FtTkiIiIqggpscOTGjRtha2tbUJsjIiLSueI8bVJX3usCUC8faCEEEhIS8PDhQyxcuLBAgyMiIqKiRevEoUOHDmqJg4GBAezs7NCsWTNUrly5QIN7X4uXjpY7BCKdaxfxl9whEOlc1OD6Ot1+gZ2v1yNaJw4TJkzQQRhERET0IdA62TI0NERiYmK+9qSkJBgaGhZIUERERIWBl5zWntYVByHEa9szMzNhYmLyrwMiIiIqLAbF9/NdZzROHObPnw/gRXa2bNkyWFpaSutyc3Nx6NChIjPGgYiIiHRD48Rhzpw5AF5UHCIiItROS5iYmMDV1RUREREFHyEREZGOsOKgPY0Thxs3bgAAmjdvjs2bN6NkyZI6C4qIiIiKJq3HOOzfv18XcRARERW64jyIUVe0nlXRpUsXTJs2LV/79OnT0bVr1wIJioiIiIomrROHQ4cOoU2bNvnaW7dujUOHDhVIUERERIXBQKG7pbjSOnFIS0t77bRLY2NjpKamFkhQREREVDRpnTh4e3tj3bp1+dp//fVXeHl5FUhQREREhUGh0N1SXGk9OHLcuHHo3Lkz4uLi0KJFCwDA3r17sXbtWmzcuLHAAyQiItIVg+L8Ca8jWicO7dq1w5YtWzBlyhRs3LgRZmZmqF69Ovbt28fbahMRERVzWicOANC2bVu0bdsWAJCamopffvkFI0eOxOnTp5Gbm1ugARIREekK746pvfc+ZocOHYK/vz+cnZ0xa9YstGjRAn/9xdv8EhERFWdaVRwSEhKwcuVKLF++HKmpqfjiiy+QmZmJLVu2cGAkERF9cDjEQXsaVxzatWuHSpUq4fz585g7dy7u3buHBQsW6DI2IiIiKmI0rjjs3LkTwcHBGDRoECpUqKDLmIiIiAoFZ1VoT+OKw5EjR/D06VPUrl0b9erVw48//ohHjx7pMjYiIiIqYjROHOrXr4+lS5fi/v37GDhwIH799Vc4OztDpVIhKioKT58+1WWcREREBY4XgNKe1rMqLCws0LdvXxw5cgQXLlzAiBEjMHXqVNjb26N9+/a6iJGIiEgneK8K7f2rKayVKlXC9OnTcefOHfzyyy8FFRMREREVUe91AahXGRoaomPHjujYsWNBbI6IiKhQcHCk9njRLCIiIpndvXsXX331FUqVKgUzMzN4e3vj1KlT0nohBMaPHw8nJyeYmZnBz88PV69eVdtGcnIyevbsCSsrK9jY2CAwMBBpaWkFHisTByIi0ltFYXDk48eP0bBhQxgbG2Pnzp24fPkyZs2ahZIlS0p9pk+fjvnz5yMiIgInTpyAhYUFWrVqhYyMDKlPz549cenSJURFRWH79u04dOgQBgwYUJCHC0ABnaogIiKi9zNt2jSULVsWK1askNrc3Nyk/wshMHfuXHz33Xfo0KEDAGDVqlVwcHDAli1b0L17d1y5cgW7du3CyZMnUadOHQDAggUL0KZNG8ycORPOzs4FFi8rDkREpLd0OasiMzMTqampaktmZma+GLZu3Yo6deqga9eusLe3R82aNbF06VJp/Y0bN5CQkAA/Pz+pzdraGvXq1cPx48cBAMePH4eNjY2UNACAn58fDAwMcOLEiYI9ZgW6NSIiIgIAhIeHw9raWm0JDw/P1+/69etYtGgRKlSogD///BODBg1CcHAwIiMjAby4TxQAODg4qD3PwcFBWpeQkAB7e3u19UZGRrC1tZX6FBSeqiAiIr2lgO5mVYwZMwbDhw9Xa1Mqlfn6qVQq1KlTB1OmTAEA1KxZExcvXkRERAT8/f11Ft/7YsWBiIj0li5PVSiVSlhZWaktr0scnJyc8t1h2tPTE/Hx8QAAR0dHAMCDBw/U+jx48EBa5+joiMTERLX1OTk5SE5OlvoUFCYOREREMmrYsCFiYmLU2mJjY+Hi4gLgxUBJR0dH7N27V1qfmpqKEydOwMfHBwDg4+ODlJQUnD59Wuqzb98+qFQq1KtXr0Dj5akKIiLSW0Xh0tAhISFo0KABpkyZgi+++AJ///03lixZgiVLlgAAFAoFhg0bhsmTJ6NChQpwc3PDuHHj4OzsLF140dPTE59++in69++PiIgIZGdnY/DgwejevXuBzqgAmDgQERHJqm7duvjtt98wZswYhIWFwc3NDXPnzkXPnj2lPqNGjUJ6ejoGDBiAlJQUNGrUCLt27YKpqanUZ82aNRg8eDB8fX1hYGCALl26YP78+QUer0IIIQp8qzJbdeq23CEQ6dzqv+7KHQKRzkUNrq/T7c84cF1n2w5tVl5n25YTxzgQERGRxniqgoiI9FZRGOPwoWHFgYiIiDTGigMREekt3lVbe0wciIhIbxkwc9AaT1UQERGRxlhxICIivcXBkdpjxYGIiIg0xooDERHpLQ5x0B4rDkRERKQxVhyIiEhvGYAlB22x4kBEREQaY8WBiIj0Fsc4aI+JAxER6S1Ox9QeT1UQERGRxlhxICIivcVLTmuPFQciIiLSGCsORESkt1hw0B4rDkRERKQxVhyIiEhvcYyD9lhxICIiIo2x4kBERHqLBQftFZmKQ1ZWFmJiYpCTkyN3KEREpCcMdLgUV7K/tmfPniEwMBDm5uaoUqUK4uPjAQBDhgzB1KlTZY6OiIiIXiZ74jBmzBicO3cOBw4cgKmpqdTu5+eHdevWyRgZEREVdwqFQmdLcSX7GIctW7Zg3bp1qF+/vtqBrlKlCuLi4mSMjIiIiF4le+Lw8OFD2Nvb52tPT08v1hkbERHJj58y2pP9VEWdOnWwY8cO6XFesrBs2TL4+PjIFRYRERG9huwVhylTpqB169a4fPkycnJyMG/ePFy+fBnHjh3DwYMH5Q6PiIiKMV4ASnuyVxwaNWqE6Oho5OTkwNvbG7t374a9vT2OHz+O2rVryx0eERERvUT2igMAuLu7Y+nSpXKHQUREeob1Bu0VicQBABITE5GYmAiVSqXWXq1aNZkiIiKi4o5nKrQne+Jw+vRp+Pv748qVKxBCqK1TKBTIzc2VKTIiIiJ6leyJQ9++fVGxYkUsX74cDg4OnIJJRESFhp852pM9cbh+/To2bdoEDw8PuUMhIiKid5B9VoWvry/OnTsndxhERKSHeJMr7clecVi2bBn8/f1x8eJFVK1aFcbGxmrr27dvL1NkRERE9CrZE4fjx4/j6NGj2LlzZ751HBxJRES6xDEO2pO9mjJkyBB89dVXuH//PlQqldrCpIGIiKhokb3ikJSUhJCQEDg4OMgdChER6RnWG7Qne8Whc+fO2L9/v9xhEBERkQZkrzhUrFgRY8aMwZEjR+Dt7Z1vcGRwcLBMkRERUXHHMQ7akz1xWLZsGSwtLXHw4MF8d8NUKBRMHIiISGdkL7t/gGRPHG7cuCF3CERERKQh2RMHIiIiufBUhfZkSRyGDx+OSZMmwcLCAsOHD39r39mzZxdSVERERPQusiQOZ8+eRXZ2tvT/N2EmSEREusRPGe3Jkjjs378fq1atQrdu3TgVk4iI6AMi24DSPn364MmTJ3LtnoiICAqF7pbiSrbEQQgh166JiIjoPck6q4JjGIiISE4GHOWgNVkTB19fXxgZvT2EM2fOFFI0RESkb/j9VXuyJg6tWrWCpaWlnCEQERGRFmRNHEJDQ2Fvby9nCEREpMcUPFWhNdkGR3J8AxER0YdHtooDZ1UQEZHc+B1We7JVHG7cuAE7Ozu5dk9ERETvQbaKg4uLi1y7JiIiAsDpmO+DtyInIiIijfG22kREpLc4xkF7TByIiEhvMXHQXpFIHFJSUvD3338jMTERKpVKbV3v3r1lioqIiIheJXvisG3bNvTs2RNpaWmwsrJSu76DQqFg4kBERDrDC0BpT/bBkSNGjEDfvn2RlpaGlJQUPH78WFqSk5PlDo+IiIheInvF4e7duwgODoa5ubncoRARkZ4xYMFBa7JXHFq1aoVTp07JHQYRERFpQPaKQ9u2bREaGorLly/D29sbxsbGauvbt28vU2RERFTccYyD9mRPHPr37w8ACAsLy7dOoVAgNze3sEMiIiKiN5A9cXh1+iUREVFh4XUctCd74kBERCQXnqrQnuyDIwHg4MGDaNeuHTw8PODh4YH27dvj8OHDcodFREREr5A9cfj555/h5+cHc3NzBAcHIzg4GGZmZvD19cXatWvlDo+IiIoxA4XuluJKIYQQcgbg6emJAQMGICQkRK199uzZWLp0Ka5cuaL1Nledul1Q4REVWav/uit3CEQ6FzW4vk63fyhWdxcabFLRVmfblpPsFYfr16+jXbt2+drbt2+PGzduyBARERHpC4UO/xVXsicOZcuWxd69e/O179mzB2XLlpUhIiIiInoT2WdVjBgxAsHBwYiOjkaDBg0AAEePHsXKlSsxb948maPTX4c2ReLw5tVqbaWcyuLrmSvwPC0VhzZF4vqF00h9lAhzK2tUrN0QTbsGwNTcUur/Q0+/fNvtOHgsqvg013n8RJpY3bsmHK2U+dq3nk/AgkM3UdLcGAMalEOtstYwMzHEnccZWHv6Lo7E/a+8XUJpiKAmbqjvZgMhgMNxyVh4+CYysjnV/EPA6Zjakz1xGDRoEBwdHTFr1iysX78ewItxD+vWrUOHDh1kjk6/2ZVxRY8x06XHBoaGAICnj5Pw9HESfHsMhN1HLnjy6AF2/jQXaY+T0GXY92rb+GxAKNyr15Uev5xYEMlt8PoLMHhpFJurrRmmd/TCwf9PDEb7ucNCaYTxO2LwJCMHLSqWxnetKiBo/QXEPXoGAPi2ZQWUMjfGt7//A0MDBUJ9yyOkeXmE774my2si0jXZEwcA6NSpEzp16iR3GPQKhYEhLG3yD+6xL+uGz4dNkB6XdHBGsy/64veFU6HKzZUSDAAwtbB87TaIioInGTlqj7vXcsbdlAycv5sKAPByLIH5B28gJjEdALD21F10qeGIivYWiHv0DOVKmuJjFxsErb+A2P/v8+Ohm/ihXWUsOXoLSenZhfuCSGssOGivSCQOVDQ9fnAX84K6wcjYGB9V8ELzboGwLu3w2r4Zz9KhNDNXSxoAYNfK+dixdBZs7J1Qy/czVG/6KRSsDVIRZGSggG+l0tgUfV9qu5zwFE0rlMKJm4+RlpmLphVKwdjQAOf+P7HwdCyBpxk5UtIAAGduP4EQQGUHSxy9/rjQXwdpx4B/j7T2wScOmZmZyMzMVGvLzsqEsUn+85akOWd3T7QbGApbp7JIS0nC4c2rsSosBAOmLYPSTP0W6M+ePsGR335GjRZt1dqbfB4AV68aMFYqcf3CaexaOR/ZGRmo+ymrS1T0NChfEpZKI+z+56HUNmnXVXz3aQVs7l8XObkqZOaoMPGPWNx78uJvjq25MVKeq1cVVAJIzchBSXOTQo2fqLDIPqvi3woPD4e1tbXasn3lf+UO64PnUeNjeNZrCody5eFerS66h05B5rM0XDlxUK1f5rN0rJsxFqU/ckGTzr3V1jXu9BXKVqoKR9cKaNCuO3w+64bjO9YX5ssg0lhrL3v8fStF7fRCQP2ysDAxwqgtlxG0/iI2Rt/Hd59WgGspMxkjpYKk0OFSXH3wicOYMWPw5MkTteWzgCC5wyp2TC0sYetUBo8T/nfRocznz/DL9DEwMTVD15CJMDR6ewHL2b0yniY/RE52lq7DJdKKfQkT1CxjjZ2XE6U2JyslOlZzxKx9cTh7JxXXk57h55N3EZuYjg7ejgCA5GfZsDEzVtuWgQKwMjXC42d8n9P7mTp1KhQKBYYNGya1ZWRkICgoCKVKlYKlpSW6dOmCBw8eqD0vPj4ebdu2hbm5Oezt7REaGoqcnBwUtA8+cVAqlbCyslJbeJqi4GVlPMfjB/dhaVMKwItKwy9TR8PQyAhfjJgEI5N3l2Uf3IqDqUUJGBmzhEtFSytPe6Q8z8aJm/8bk6A0fvHn8dWL66qEkKbwXUl4ihKmRqhgZyGtr1nGGgoF8M+DNN0HTv9eESs5nDx5EosXL0a1atXU2kNCQrBt2zZs2LABBw8exL1799C5c2dpfW5uLtq2bYusrCwcO3YMkZGRWLlyJcaPH/9+gbyFLGMchg8frnHf2bNn6zASepM9axajQq36sC7tgLTHSTi0KRIGBgbwatAcmc/SsXbqaORkZaLDN2OQ+fwZMp+/mJpmbmUNAwNDxJ45jvQnj/GRhyeMjE1w4+JpHNv6C+q16SrzKyNSpwDQqrIdov55CNVLOcLtxxm4m/IcQ5uVx5Kjt5CakYOG5W1Rq6w1xm2PAQDEP87A37dSENK8POYduA4jAwUGN3XFgatJnFFBrx2Dp1QqoVS+/sttWloaevbsiaVLl2Ly5MlS+5MnT7B8+XKsXbsWLVq0AACsWLECnp6e+Ouvv1C/fn3s3r0bly9fxp49e+Dg4IAaNWpg0qRJGD16NCZMmAATDb7caUqWxOHs2bNqj8+cOYOcnBxUqlQJABAbGwtDQ0PUrl1bjvAIwNPkh9jy4xQ8T0uFeQlrlK1UFQETF8DCyga3LkfjXtw/AICFw9XHNQTN/Rk2do4wNDTE6ajfsefnRRBCoKTDR/Dr+TVqNm8jx8sheqNaZa3hYKXErisP1dpzVQJjt8UgsEFZTPqsEkyNDXHvSQZm7InD37dSpH5Td1/F4KZumN7RC0IIHI5Lxn8P3yzcF0HvTZeXhg4PD8fEiRPV2r7//ntMmDDhtf2DgoLQtm1b+Pn5qSUOp0+fRnZ2Nvz8/ndRvcqVK6NcuXI4fvw46tevj+PHj8Pb2xsODv+b+daqVSsMGjQIly5dQs2aNQvsdcmSOOzfv1/6/+zZs1GiRAlERkaiZMmSAIDHjx+jT58+aNy4sRzhEYBOQ7574zoXrxoYu2bPW5/vXv1juFf/uKDDIipwp28/wSc//vXadXefZCBs59W3Pv9pZi4v9kSvNWbMmHwV9jdVG3799VecOXMGJ0+ezLcuISEBJiYmsLGxUWt3cHBAQkKC1OflpCFvfd66giT7dMxZs2Zh9+7dUtIAACVLlsTkyZPRsmVLjBgxQsboiIioONPlZRzedlriZbdv38bQoUMRFRUFU1NT3QVUQGQfHJmamoqHDx/ma3/48CGePn0qQ0RERKQvisLYyNOnTyMxMRG1atWCkZERjIyMcPDgQcyfPx9GRkZwcHBAVlYWUlJS1J734MEDODq+mOHj6OiYb5ZF3uO8PgVF9sShU6dO6NOnDzZv3ow7d+7gzp072LRpEwIDA9VGjBIRERVHvr6+uHDhAqKjo6WlTp066Nmzp/R/Y2NjtTtJx8TEID4+Hj4+PgAAHx8fXLhwAYmJ/5tSHBUVBSsrK3h5eRVovLKfqoiIiMDIkSPRo0cPZGe/GIVsZGSEwMBAzJgxQ+boiIioWCsCV2oqUaIEqlatqtZmYWGBUqVKSe2BgYEYPnw4bG1tYWVlhSFDhsDHxwf169cHALRs2RJeXl7o1asXpk+fjoSEBHz33XcICgrS6HSJNmRPHMzNzbFw4ULMmDEDcXFxAAB3d3dYWFi845lERET6Yc6cOTAwMECXLl2QmZmJVq1aYeHChdJ6Q0NDbN++HYMGDYKPjw8sLCzg7++PsLCwAo9FIV69uolMrl27hri4ODRp0gRmZmYQQrz3zZBWnbpdwNERFT2r/7r77k5EH7iowfV1uv1TN1J1tu06blY627acZB/jkJSUBF9fX1SsWBFt2rTB/fsv7kwXGBjIGRVERERFjOyJQ0hICIyNjREfHw9z8//ddbFbt27YtWuXjJEREVFxp1DobimuZB/jsHv3bvz5558oU6aMWnuFChVw69YtmaIiIiKi15E9cUhPT1erNORJTk4u8JGgRERELyvGhQGdkf1URePGjbFq1SrpsUKhgEqlwvTp09G8eXMZIyMiomKvKFwB6gMje8Vh+vTp8PX1xalTp5CVlYVRo0bh0qVLSE5OxtGjR+UOj4iIiF4ie8WhatWqiI2NRaNGjdChQwekp6ejc+fOOHv2LNzd3eUOj4iIijGFDv8VV7JXHADA2toaY8eOlTsMIiIieocikTikpKTg77//RmJiIlQqldq63r17yxQVEREVd8V52qSuyJ44bNu2DT179kRaWhqsrKzUrhapUCiYOBARERUhso9xGDFiBPr27Yu0tDSkpKTg8ePH0pKcnCx3eEREVIxxUoX2ZE8c7t69i+Dg4Ndey4GIiIiKFtkTh1atWuHUqVNyh0FERPqIJQetyTLGYevWrdL/27Zti9DQUFy+fBne3t4wNjZW69u+ffvCDo+IiPREcZ42qSuyJA4dO3bM1/a6e4YrFArk5uYWQkRERESkCVkSh1enXBIREcmB0zG1J/sYByIiIvpwyJ44BAcHY/78+fnaf/zxRwwbNqzwAyIiIr3BsZHakz1x2LRpExo2bJivvUGDBti4caMMEREREdGbyH7lyKSkJFhbW+drt7KywqNHj2SIiIiI9EZxLg3oiOwVBw8PD+zatStf+86dO1G+fHkZIiIiIqI3kb3iMHz4cAwePBgPHz5EixYtAAB79+7FrFmzMHfuXHmDIyKiYo3XcdCe7IlD3759kZmZiR9++AGTJk0CALi6umLRokW8wRUREVERI3viAACDBg3CoEGD8PDhQ5iZmcHS0lLukIiISA/wOg7aKxKJQx47Ozu5QyAiIj3CvEF7RSJx2LhxI9avX4/4+HhkZWWprTtz5oxMUREREdGrZJ9VMX/+fPTp0wcODg44e/YsPv74Y5QqVQrXr19H69at5Q6PiIiKM14BSmuyJw4LFy7EkiVLsGDBApiYmGDUqFGIiopCcHAwnjx5Ind4RERE9BLZE4f4+Hg0aNAAAGBmZoanT58CAHr16oVffvlFztCIiKiYU+jwX3Ele+Lg6OiI5ORkAEC5cuXw119/AQBu3LgBIYScoREREdErZE8cWrRoga1btwIA+vTpg5CQEHzyySfo1q0bOnXqJHN0RERUnCkUuluKK9lnVSxZsgQqlQoAEBQUhFKlSuHYsWNo3749Bg4cKHN0RERE9DLZEwcDAwMYGPyv8NG9e3d0795dxoiIiEhfFOPCgM7IfqoCAA4fPoyvvvoKPj4+uHv3LgBg9erVOHLkiMyRERFRscbpmFqTPXHYtGkTWrVqBTMzM5w9exaZmZkAgCdPnmDKlCkyR0dEREQvkz1xmDx5MiIiIrB06VIYGxtL7Q0bNuRVI4mISKc4HVN7sicOMTExaNKkSb52a2trpKSkFH5ARERE9EayJw6Ojo64du1avvYjR46gfPnyMkRERET6gtMxtSd74tC/f38MHToUJ06cgEKhwL1797BmzRqMHDkSgwYNkjs8IiIieons0zG//fZbqFQq+Pr64tmzZ2jSpAmUSiVGjhyJIUOGyB0eEREVY8W4MKAzsicOCoUCY8eORWhoKK5du4a0tDR4eXnB0tISz58/h5mZmdwhEhER0f+T/VRFHhMTE3h5eeHjjz+GsbExZs+eDTc3N7nDIiKi4ozXcdCabIlDZmYmxowZgzp16qBBgwbYsmULAGDFihVwc3PDnDlzEBISIld4RESkBzgdU3uynaoYP348Fi9eDD8/Pxw7dgxdu3ZFnz598Ndff2H27Nno2rUrDA0N5QqPiIiIXkO2xGHDhg1YtWoV2rdvj4sXL6JatWrIycnBuXPnoCjO81iIiKjI4MeN9mQ7VXHnzh3Url0bAFC1alUolUqEhIQwaSAiIirCZKs45ObmwsTE5H+BGBnB0tJSrnCIiEgP8auq9mRLHIQQCAgIgFKpBABkZGTg66+/hoWFhVq/zZs3yxEeERERvYZsiYO/v7/a46+++kqmSIiISG+x5KA12RKHFStWyLVrIiIiek+yXzmSiIhILsX5egu6wsSBiIj0Fifyaa/IXHKaiIiIij5WHIiISG+x4KA9VhyIiIhIY6w4EBGR3uIYB+2x4kBEREQaY8WBiIj0GEsO2mLFgYiIiDTGigMREektjnHQHhMHIiLSW8wbtMdTFURERKQxVhyIiEhv8VSF9lhxICIiIo2x4kBERHqLd8fUHisOREREpDFWHIiISH+x4KA1VhyIiIhIY6w4EBGR3mLBQXtMHIiISG9xOqb2eKqCiIiINMaKAxER6S1Ox9QeKw5ERESkMVYciIhIf7HgoDVWHIiIiEhjrDgQEZHeYsFBe6w4EBERkcZYcSAiIr3F6zhoj4kDERHpLU7H1B5PVRAREZHGWHEgIiK9xVMV2mPFgYiISEbh4eGoW7cuSpQoAXt7e3Ts2BExMTFqfTIyMhAUFIRSpUrB0tISXbp0wYMHD9T6xMfHo23btjA3N4e9vT1CQ0ORk5NT4PEycSAiIpLRwYMHERQUhL/++gtRUVHIzs5Gy5YtkZ6eLvUJCQnBtm3bsGHDBhw8eBD37t1D586dpfW5ublo27YtsrKycOzYMURGRmLlypUYP358gcerEEKIAt+qzFadui13CEQ6t/qvu3KHQKRzUYPr63T7j5/l6mzb5oY5yMzMVGtTKpVQKpVvfd7Dhw9hb2+PgwcPokmTJnjy5Ans7Oywdu1afP755wCAf/75B56enjh+/Djq16+PnTt34rPPPsO9e/fg4OAAAIiIiMDo0aPx8OFDmJiYFNjrYsWBiIj0lkKhuyU8PBzW1tZqS3h4+DtjevLkCQDA1tYWAHD69GlkZ2fDz89P6lO5cmWUK1cOx48fBwAcP34c3t7eUtIAAK1atUJqaiouXbpUkIeMgyOJiIh0YcyYMRg+fLha27uqDSqVCsOGDUPDhg1RtWpVAEBCQgJMTExgY2Oj1tfBwQEJCQlSn5eThrz1eesKEhMHIiLSW7q8joMmpyVeFRQUhIsXL+LIkSM6iurf46kKIiLSW7o8VaGtwYMHY/v27di/fz/KlCkjtTs6OiIrKwspKSlq/R88eABHR0epz6uzLPIe5/UpKEwciIiIZCSEwODBg/Hbb79h3759cHNzU1tfu3ZtGBsbY+/evVJbTEwM4uPj4ePjAwDw8fHBhQsXkJiYKPWJioqClZUVvLy8CjRenqogIiK9VRSu/xQUFIS1a9fi999/R4kSJaQxCdbW1jAzM4O1tTUCAwMxfPhw2NrawsrKCkOGDIGPjw/q138x66Rly5bw8vJCr169MH36dCQkJOC7775DUFCQ1qdL3oWJAxERkYwWLVoEAGjWrJla+4oVKxAQEAAAmDNnDgwMDNClSxdkZmaiVatWWLhwodTX0NAQ27dvx6BBg+Dj4wMLCwv4+/sjLCyswOPldRyIPlC8jgPpA11fx+Fppkpn2y6hLJ6jAYrnqyIiIiKd4KkKIiLSW7yttvZYcSAiIiKNseJARER6i7fV1h4rDkRERKQxVhyIiEhvseCgPSYORESkv5g5aI2nKoiIiEhjrDgQEZHe4nRM7bHiQERERBpjxYGIiPQWp2NqjxUHIiIi0lixvMkVFa7MzEyEh4djzJgxBX77VqKigu9zoheYONC/lpqaCmtrazx58gRWVlZyh0OkE3yfE73AUxVERESkMSYOREREpDEmDkRERKQxJg70rymVSnz//fccMEbFGt/nRC9wcCQRERFpjBUHIiIi0hgTByIiItIYEwciIiLSGBMHeqMDBw5AoVAgJSWlwLetUCiwZcuWAt/uv1VU46J309XPrlmzZhg2bFiBb/ffKqpxUfHHxEEDAQEBUCgUmDp1qlr7li1boNDyDimurq6YO3euRv0UCgUUCgXMzc3h7e2NZcuWabUv+p+VK1dKx/NNy82bN3H//n20bt1a7nA/KHm/HwqFAsbGxnBzc8OoUaOQkZEhd2gfpJs3b77zvbpy5Ups3rwZkyZNkjtc0kO8O6aGTE1NMW3aNAwcOBAlS5YslH2GhYWhf//+ePbsGTZs2ID+/fvjo48+4gfbe+jWrRs+/fRT6XHnzp1RtWpVhIWFSW12dnYwNDSUI7wP3qeffooVK1YgOzsbp0+fhr+/PxQKBaZNmyZ3aB+csmXL4v79+9LjmTNnYteuXdizZ4/UZm1tDTMzMznCI2LFQVN+fn5wdHREeHj4W/tt2rQJVapUgVKphKurK2bNmiWta9asGW7duoWQkBDpm8PblChRAo6OjihfvjxGjx4NW1tbREVFSetTUlLQr18/2NnZwcrKCi1atMC5c+ek9XFxcejQoQMcHBxgaWmJunXrqv3xAV7cuGf06NEoW7YslEolPDw8sHz5crU+p0+fRp06dWBubo4GDRogJiZGbf3vv/+OWrVqwdTUFOXLl8fEiRORk5Mjrb969SqaNGkCU1NTeHl5qb2GN8nMzERwcDDs7e1hamqKRo0a4eTJk9L6vNMoe/fufWtseczMzODo6CgtJiYmMDc3V2szNDRUK3fnffNbv349GjduDDMzM9StWxexsbE4efIk6tSpA0tLS7Ru3RoPHz5U29+yZcvg6ekJU1NTVK5cGQsXLnzna/6QKZVKODo6omzZsujYsSP8/PzUfs4qlQrh4eFwc3ODmZkZqlevjo0bN0rrc3NzERgYKK2vVKkS5s2bl28/P/30k/T75eTkhMGDB6utf/ToETp16gRzc3NUqFABW7duVVt/8eJFtG7dGpaWlnBwcECvXr3w6NEjaX16ejp69+4NS0tLODk5qf3+vs2iRYvg7u4OExMTVKpUCatXr1Zbr1AosGzZsrfGlsfQ0FDtfWlpaQkjIyO1NjMzs3ynKlxdXTF58mQpfhcXF2zduhUPHz5Ehw4dYGlpiWrVquHUqVNq+zty5Ij0/i5btiyCg4ORnp6u0esmPSXonfz9/UWHDh3E5s2bhampqbh9+7YQQojffvtNvHwIT506JQwMDERYWJiIiYkRK1asEGZmZmLFihVCCCGSkpJEmTJlRFhYmLh//764f//+G/fp4uIi5syZI4QQIjc3V2zcuFEoFAoxevRoqY+fn59o166dOHnypIiNjRUjRowQpUqVEklJSUIIIaKjo0VERIS4cOGCiI2NFd99950wNTUVt27dkrbxxRdfiLJly4rNmzeLuLg4sWfPHvHrr78KIYTYv3+/ACDq1asnDhw4IC5duiQaN24sGjRoID3/0KFDwsrKSqxcuVLExcWJ3bt3C1dXVzFhwgQp9qpVqwpfX18RHR0tDh48KGrWrCkAiN9+++2Nrz84OFg4OzuLP/74Q1y6dEn4+/uLkiVLSq9Nk9jepmnTpmLo0KH52l+O68aNGwKAqFy5sti1a5e4fPmyqF+/vqhdu7Zo1qyZOHLkiDhz5ozw8PAQX3/9tbSNn3/+WTg5OYlNmzaJ69evi02bNglbW1uxcuVKjWL70OT9fuS5cOGCcHR0FPXq1ZPaJk+eLB3HuLg4sWLFCqFUKsWBAweEEEJkZWWJ8ePHi5MnT4rr16+Ln3/+WZibm4t169ZJ21i4cKEwNTUVc+fOFTExMeLvv/+WfkeEePGzK1OmjFi7dq24evWqCA4OFpaWltJ75vHjx8LOzk6MGTNGXLlyRZw5c0Z88sknonnz5tI2Bg0aJMqVKyf27Nkjzp8/Lz777DNRokSJ175X8mzevFkYGxuL//73vyImJkbMmjVLGBoain379mkc29t8//33onr16vnaX30Pu7i4CFtbWxERESFiY2PFoEGDhJWVlfj000/F+vXrRUxMjOjYsaPw9PQUKpVKCCHEtWvXhIWFhZgzZ46IjY0VR48eFTVr1hQBAQHvjIv0FxMHDbz8h7F+/fqib9++Qoj8iUOPHj3EJ598ovbc0NBQ4eXlJT1+OSF4GxcXF2FiYiIsLCyEkZGRACBsbW3F1atXhRBCHD58WFhZWYmMjAy157m7u4vFixe/cbtVqlQRCxYsEEIIERMTIwCIqKio1/bN+3Des2eP1LZjxw4BQDx//lwIIYSvr6+YMmWK2vNWr14tnJychBBC/Pnnn8LIyEjcvXtXWr9z5863Jg5paWnC2NhYrFmzRmrLysoSzs7OYvr06RrH9jbaJA7Lli2T1v/yyy8CgNi7d6/UFh4eLipVqiQ9dnd3F2vXrlXb7qRJk4SPj8874/oQ+fv7C0NDQ2FhYSGUSqUAIAwMDMTGjRuFEEJkZGQIc3NzcezYMbXnBQYGii+//PKN2w0KChJdunSRHjs7O4uxY8e+sT8A8d1330mP09LSBACxc+dOIcSLn0HLli3VnnP79m0BQMTExIinT58KExMTsX79eml9UlKSMDMze2vi0KBBA9G/f3+1tq5du4o2bdpoHNvbaJM4fPXVV9Lj+/fvCwBi3LhxUtvx48cFAOlLS2BgoBgwYIDadg8fPiwMDAw0+j0i/cQxDlqaNm0aWrRogZEjR+Zbd+XKFXTo0EGtrWHDhpg7dy5yc3O1Pn8eGhqKgIAA3L9/H6Ghofjmm2/g4eEBADh37hzS0tJQqlQptec8f/4ccXFxAIC0tDRMmDABO3bswP3795GTk4Pnz58jPj4eABAdHQ1DQ0M0bdr0rXFUq1ZN+r+TkxMAIDExEeXKlcO5c+dw9OhR/PDDD1Kf3NxcZGRk4NmzZ7hy5QrKli0LZ2dnab2Pj89b9xcXF4fs7Gw0bNhQajM2NsbHH3+MK1euaBxbQXl5Hw4ODgAAb29vtbbExEQAL0rdcXFxCAwMRP/+/aU+OTk5sLa2LrCYiprmzZtj0aJFSE9Px5w5c2BkZIQuXboAAK5du4Znz57hk08+UXtOVlYWatasKT3+73//i59++gnx8fF4/vw5srKyUKNGDQAvfqb37t2Dr6/vW+N4+WdlYWEBKysr6Wdz7tw57N+/H5aWlvmeFxcXJ+2zXr16UrutrS0qVar01n1euXIFAwYMUGtr2LBhvlMtb4utoGjyXgVeHE9HR0ecO3cO58+fx5o1a6Q+QgioVCrcuHEDnp6eBRofFQ9MHLTUpEkTtGrVCmPGjEFAQIBO91W6dGl4eHjAw8MDGzZsgLe3N+rUqQMvLy+kpaXByckJBw4cyPc8GxsbAMDIkSMRFRWFmTNnwsPDA2ZmZvj888+RlZUFABoPrjI2Npb+nzcuQ6VSAXiRnEycOBGdO3fO9zxTU1NtXu57eVtsutzHq20vHw8AWLp0qdoHEIBiPfDSwsJCSmp/+uknVK9eHcuXL0dgYKB0THbs2IGPPvpI7Xl593349ddfMXLkSMyaNQs+Pj4oUaIEZsyYgRMnTgB4v/cqkP9n065du9cO2HRycsK1a9e0eMXae1tsutjHm96rgPrv78CBAxEcHJxvWwWZfFPxwsThPUydOhU1atTI903E09MTR48eVWs7evQoKlasKH1omJiYIDc3V+t9li1bFt26dcOYMWOkwYgJCQkwMjKCq6vra59z9OhRBAQEoFOnTgBe/JG4efOmtN7b2xsqlQoHDx6En5+f1jEBQK1atRATEyN9aLzK09MTt2/fxv3796WKwF9//fXWbeYNMjt69ChcXFwAANnZ2Th58mSRn7fu4OAAZ2dnXL9+HT179pQ7HFkYGBjgP//5D4YPH44ePXrAy8sLSqUS8fHxb6xuHT16FA0aNMA333wjteVVzoAXA4VdXV2xd+9eNG/e/L3iqlWrFjZt2gRXV1cYGeX/0+fu7g5jY2OcOHFC+tB8/PgxYmNj31qVy/u99/f3V3s9Xl5e7xVnYapVqxYuX778xt9fotfhrIr34O3tjZ49e2L+/Plq7SNGjMDevXsxadIkxMbGIjIyEj/++KPaaQ1XV1ccOnQId+/eVRvNrYmhQ4di27ZtOHXqFPz8/ODj44OOHTti9+7duHnzJo4dO4axY8dKo6YrVKiAzZs3Izo6GufOnUOPHj3UvuG4urrC398fffv2xZYtW3Djxg0cOHAA69ev1zim8ePHY9WqVZg4cSIuXbqEK1eu4Ndff8V3330H4MVslIoVK8Lf3x/nzp3D4cOHMXbs2Ldu08LCAoMGDUJoaCh27dqFy5cvS9NSAwMDtTpmcpg4cSLCw8Mxf/58xMbG4sKFC1ixYgVmz54td2iFpmvXrjA0NMR///tflChRAiNHjkRISAgiIyMRFxeHM2fOYMGCBYiMjATw4r166tQp/Pnnn4iNjcW4cePUZtEAwIQJEzBr1izMnz8fV69elbahqaCgICQnJ+PLL7/EyZMnERcXhz///BN9+vRBbm4uLC0tERgYiNDQUOzbtw8XL15EQEAADAze/mcyNDQUK1euxKJFi3D16lXMnj0bmzdvfu3pzKJm9OjROHbsGAYPHozo6GhcvXoVv//+e77ZKkQvY+LwnsLCwvKVGWvVqoX169fj119/RdWqVTF+/HiEhYWpndIICwvDzZs34e7uDjs7O6326eXlhZYtW2L8+PFQKBT4448/0KRJE/Tp0wcVK1ZE9+7dcevWLek85uzZs1GyZEk0aNAA7dq1Q6tWrVCrVi21bS5atAiff/45vvnmG1SuXBn9+/fXaipWq1atsH37duzevRt169ZF/fr1MWfOHKlSYGBggN9++w3Pnz/Hxx9/jH79+qmNh3iTqVOnokuXLujVqxdq1aqFa9eu4c8//yy0a2j8G/369cOyZcuwYsUKeHt7o2nTpli5ciXc3NzkDq3QGBkZYfDgwZg+fTrS09MxadIkjBs3DuHh4fD09MSnn36KHTt2SMdk4MCB6Ny5M7p164Z69eohKSlJrfoAAP7+/pg7dy4WLlyIKlWq4LPPPsPVq1c1jsnZ2RlHjx5Fbm4uWrZsCW9vbwwbNgw2NjZScjBjxgw0btwY7dq1g5+fHxo1aoTatWu/dbsdO3bEvHnzMHPmTFSpUgWLFy/GihUr0KxZM+0OmgyqVauGgwcPIjY2Fo0bN0bNmjUxfvx4tTFJRK/ibbWJiIhIY6w4EBERkcaYOBAREZHGmDgQERGRxpg4EBERkcaYOBAREZHGmDgQERGRxpg4EBERkcaYOBAREZHGmDgQfQACAgLQsWNH6XGzZs1kuW/HgQMHoFAokJKSUuj7JqKigYkD0b8QEBAAhUIBhUIBExMTeHh4ICwsDDk5OTrd7+bNmzFp0iSN+vLDnogKEu+OSfQvffrpp1ixYgUyMzPxxx9/ICgoCMbGxhgzZoxav6ysLJiYmBTIPm1tbQtkO0RE2mLFgehfUiqVcHR0hIuLCwYNGgQ/Pz9s3bpVOr3www8/wNnZWboN++3bt/HFF1/AxsYGtra26NChg9rtznNzczF8+HDY2NigVKlSGDVqFF69pcyrpyoyMzMxevRolC1bFkqlEh4eHli+fDlu3rwp3Ya6ZMmSUCgU0k3XVCoVwsPD4ebmBjMzM1SvXh0bN25U288ff/yBihUrwszMDM2bN1eLk4j0ExMHogJmZmaGrKwsAMDevXsRExODqKgobN++HdnZ2WjVqhVKlCiBw4cP4+jRo7C0tMSnn34qPWfWrFlYuXIlfvrpJxw5cgTJycn47bff3rrP3r1745dffsH8+fNx5coVLF68GJaWlihbtiw2bdoEAIiJicH9+/cxb948AEB4eDhWrVqFiIgIXLp0CSEhIfjqq69w8OBBAC8SnM6dO6Ndu3aIjo5Gv3798O233+rqsBHRh0IQ0Xvz9/cXHTp0EEIIoVKpRFRUlFAqlWLkyJHC399fODg4iMzMTKn/6tWrRaVKlYRKpZLaMjMzhZmZmfjzzz+FEEI4OTmJ6dOnS+uzs7NFmTJlpP0IIUTTpk3F0KFDhRBCxMTECAAiKirqtTHu379fABCPHz+W2jIyMoS5ubk4duyYWt/AwEDx5ZdfCiGEGDNmjPDy8lJbP3r06HzbIiL9wjEORP/S9u3bYWlpiezsbKhUKvTo0QMTJkxAUFAQvL291cY1nDt3DteuXUOJEiXUtpGRkYG4uDg8efIE9+/fR7169aR1RkZGqFOnTr7TFXmio6NhaGiIpk2bahzztWvX8OzZM3zyySdq7VlZWahZsyYA4MqVK2pxAICPj4/G+yCi4omJA9G/1Lx5cyxatAgmJiZwdnaGkdH/fq0sLCzU+qalpaF27dpYs2ZNvu3Y2dm91/7NzMy0fk5aWhoAYMeOHfjoo4/U1imVyveKg4j0AxMHon/JwsICHh4eGvWtVasW1q1bB3t7e1hZWb22j5OTE06cOIEmTZoAAHJycnD69GnUqlXrtf29vb2hUqlw8OBB+Pn55VufV/HIzc2V2ry8vKBUKhEfH//GSoWnpye2bt2q1vbXX3+9+0USUbHGwZFEhahnz54oXbo0OnTogMOHD+PGjRs4cOAAgoODcefOHQDA0KFDMXXqVGzZsgX//PMPvvnmm7deg8HV1RX+/v7o27cvtmzZIm1z/fr1AAAXFxcoFAps374dDx8+RFpaGkqUKIGRI0ciJCQEkZGRiIuLw5kzZ7BgwQJERkYCAL7++mtcvXoVoaGhiImJwdq1a7Fy5UpdHyIiKuKYOBAVInNzcxw6dAjlypVD586d4enpicDAQGRkZEgViBEjRqBXr17w9/eHj48PSpQogU6dOr11u4sWLcLnn3+Ob775BpUrV0b//v2Rnp4OAPjoo48wceJEfPvtt3BwcMDgwYMBAJMmTcK4ceMQHh4OT09PfPrpp9ixYwfc3NwAAOXKlcOmTZuwZcsWVK9eHREREZgyZYoOjw4RfQgU4k0jroiIiIhewYoDERERaYyJAxEREWmMiQMRERFpjIkDERERaYyJAxEREWmMiQMRERFpjIkDERERaYyJAxEREWmMiQMRERFpjIkDERERaYyJAxEREWns/wDiMh99ky35owAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--SVM classifier Classification Report--\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.66      0.98      0.79      1321\n",
      "           1       0.97      0.48      0.65      1305\n",
      "\n",
      "    accuracy                           0.74      2626\n",
      "   macro avg       0.81      0.73      0.72      2626\n",
      "weighted avg       0.81      0.74      0.72      2626\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                     Name Accuracy F1-score Recall Precision\n",
      "0     Logistic Regression    69.08    64.20  55.79     75.60\n",
      "1  Logistic Regression CV    70.37    63.95  52.87     80.89\n",
      "2                 XGBoost    72.54    70.19  65.06     76.21\n",
      "3        Ridge Classifier    71.21    65.73  55.56     80.47\n",
      "4                     KNN    71.33    67.61  60.23     77.06\n",
      "5           Random Forest    73.99    69.55  59.77     83.16\n",
      "6          SVM classifier    73.53    64.52  48.43     96.64\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split, RandomizedSearchCV, cross_val_score\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score, classification_report, confusion_matrix\n",
    "from xgboost import XGBClassifier\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, RidgeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn import svm\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load dataset\n",
    "data = pd.read_csv('Train.csv')\n",
    "\n",
    "# Feature engineering\n",
    "data['Total_Interaction'] = data['Customer_care_calls'] * data['Customer_rating']\n",
    "data['Cost_per_Weight'] = data['Cost_of_the_Product'] / data['Weight_in_gms']\n",
    "\n",
    "# Data preprocessing\n",
    "data = data.fillna(method='ffill')\n",
    "\n",
    "# Define features and target\n",
    "X = data.drop(columns=['ID', 'Reached.on.Time_Y.N'])\n",
    "y = data['Reached.on.Time_Y.N']\n",
    "\n",
    "# Define numerical and categorical features\n",
    "numerical_features = ['Customer_care_calls', 'Customer_rating', 'Cost_of_the_Product', 'Prior_purchases', 'Discount_offered', 'Weight_in_gms', 'Total_Interaction', 'Cost_per_Weight']\n",
    "categorical_features = ['Warehouse_block', 'Mode_of_Shipment', 'Product_importance', 'Gender']\n",
    "\n",
    "numerical_transformer = StandardScaler()\n",
    "categorical_transformer = OneHotEncoder(handle_unknown='ignore', drop='first')\n",
    "\n",
    "preprocessor = ColumnTransformer(\n",
    "    transformers=[\n",
    "        ('num', numerical_transformer, numerical_features),\n",
    "        ('cat', categorical_transformer, categorical_features)\n",
    "    ])\n",
    "\n",
    "# Preprocess data before applying SMOTE\n",
    "X_preprocessed = preprocessor.fit_transform(X)\n",
    "\n",
    "# Apply SMOTE to the preprocessed training data\n",
    "smote = SMOTE(random_state=42)\n",
    "X_resampled, y_resampled = smote.fit_resample(X_preprocessed, y)\n",
    "\n",
    "# Split resampled data into training and test sets\n",
    "X_train_res, X_test_res, y_train_res, y_test_res = train_test_split(X_resampled, y_resampled, test_size=0.2, random_state=42)\n",
    "\n",
    "# Model evaluation function\n",
    "def models_eval_mm(x_train, y_train, x_test, y_test):\n",
    "    models = {\n",
    "        'Logistic Regression': LogisticRegression(random_state=1234),\n",
    "        'Logistic Regression CV': LogisticRegressionCV(random_state=1234),\n",
    "        'XGBoost': XGBClassifier(random_state=1234),\n",
    "        'Ridge Classifier': RidgeClassifier(random_state=1234),\n",
    "        'KNN': KNeighborsClassifier(),\n",
    "        'Random Forest': RandomForestClassifier(random_state=1234),\n",
    "        'SVM classifier': svm.SVC(random_state=1234)\n",
    "    }\n",
    "\n",
    "    trained_models = {}\n",
    "    for name, model in models.items():\n",
    "        model.fit(x_train, y_train)\n",
    "        print(f'--{name}')\n",
    "        print('Train Score:', model.score(x_train, y_train))\n",
    "        print('Test Score:', model.score(x_test, y_test))\n",
    "        print()\n",
    "        trained_models[name] = model\n",
    "    \n",
    "    return trained_models\n",
    "\n",
    "# Evaluate models\n",
    "models = models_eval_mm(X_train_res, y_train_res, X_test_res, y_test_res)\n",
    "\n",
    "# Evaluation function\n",
    "def eval(name, model, x_test, y_test):\n",
    "    y_pred = model.predict(x_test)\n",
    "    result = [\n",
    "        name,\n",
    "        f\"{accuracy_score(y_test, y_pred) * 100:.2f}\",\n",
    "        f\"{f1_score(y_test, y_pred) * 100:.2f}\",\n",
    "        f\"{recall_score(y_test, y_pred) * 100:.2f}\",\n",
    "        f\"{precision_score(y_test, y_pred) * 100:.2f}\"\n",
    "    ]\n",
    "\n",
    "    # Print classification report\n",
    "    class_report = classification_report(y_test, y_pred, output_dict=True)\n",
    "    print(f'--{name} Classification Report--')\n",
    "    print(classification_report(y_test, y_pred))\n",
    "    \n",
    "    # Compute confusion matrix\n",
    "    cm = confusion_matrix(y_test, y_pred)\n",
    "    plt.figure(figsize=(6,6))\n",
    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['Not Reached on Time', 'Reached on Time'], yticklabels=['Not Reached on Time', 'Reached on Time'])\n",
    "    plt.ylabel('Actual')\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.title(f'Confusion Matrix for {name}')\n",
    "    plt.show()\n",
    "    \n",
    "    return result, class_report\n",
    "\n",
    "# Collect evaluation results\n",
    "model_eval_info = []\n",
    "classification_reports = {}\n",
    "\n",
    "for name, model in models.items():\n",
    "    results, class_report = eval(name, model, X_test_res, y_test_res)\n",
    "    model_eval_info.append(results)\n",
    "    classification_reports[name] = class_report\n",
    "\n",
    "# Create a DataFrame for evaluation results\n",
    "model_eval_df = pd.DataFrame(model_eval_info, columns=['Name', 'Accuracy', 'F1-score', 'Recall', 'Precision'])\n",
    "model_eval_df.to_csv('model_eval.csv', index=False)\n",
    "\n",
    "# Save classification reports\n",
    "for name, report in classification_reports.items():\n",
    "    report_df = pd.DataFrame(report).transpose()\n",
    "    report_df.to_csv(f'classification_report_{name}.csv', index=True)\n",
    "\n",
    "print(model_eval_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 50 candidates, totalling 150 fits\n",
      "Fitting 3 folds for each of 50 candidates, totalling 150 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Yash Singh\\Lib\\site-packages\\sklearn\\model_selection\\_search.py:320: UserWarning: The total space of parameters 15 is smaller than n_iter=50. Running 15 iterations. For exhaustive searches, use GridSearchCV.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 15 candidates, totalling 45 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Yash Singh\\Lib\\site-packages\\sklearn\\model_selection\\_search.py:320: UserWarning: The total space of parameters 24 is smaller than n_iter=50. Running 24 iterations. For exhaustive searches, use GridSearchCV.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 24 candidates, totalling 72 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Yash Singh\\Lib\\site-packages\\sklearn\\model_selection\\_search.py:320: UserWarning: The total space of parameters 24 is smaller than n_iter=50. Running 24 iterations. For exhaustive searches, use GridSearchCV.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 24 candidates, totalling 72 fits\n",
      "--Logistic Regression CV--\n",
      "Accuracy: 0.7037319116527038\n",
      "F1-score: 0.6394810009267841\n",
      "Confusion Matrix:\n",
      " [[1158  163]\n",
      " [ 615  690]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.65      0.88      0.75      1321\n",
      "           1       0.81      0.53      0.64      1305\n",
      "\n",
      "    accuracy                           0.70      2626\n",
      "   macro avg       0.73      0.70      0.69      2626\n",
      "weighted avg       0.73      0.70      0.69      2626\n",
      "\n",
      "--XGBoost--\n",
      "Accuracy: 0.7467631378522468\n",
      "F1-score: 0.6673336668334167\n",
      "Confusion Matrix:\n",
      " [[1294   27]\n",
      " [ 638  667]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.67      0.98      0.80      1321\n",
      "           1       0.96      0.51      0.67      1305\n",
      "\n",
      "    accuracy                           0.75      2626\n",
      "   macro avg       0.82      0.75      0.73      2626\n",
      "weighted avg       0.81      0.75      0.73      2626\n",
      "\n",
      "--Random Forest--\n",
      "Accuracy: 0.7429550647372429\n",
      "F1-score: 0.6676514032496307\n",
      "Confusion Matrix:\n",
      " [[1273   48]\n",
      " [ 627  678]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.67      0.96      0.79      1321\n",
      "           1       0.93      0.52      0.67      1305\n",
      "\n",
      "    accuracy                           0.74      2626\n",
      "   macro avg       0.80      0.74      0.73      2626\n",
      "weighted avg       0.80      0.74      0.73      2626\n",
      "\n",
      "--Ridge Classifier--\n",
      "Accuracy: 0.7121096725057121\n",
      "F1-score: 0.657298277425204\n",
      "Confusion Matrix:\n",
      " [[1145  176]\n",
      " [ 580  725]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.66      0.87      0.75      1321\n",
      "           1       0.80      0.56      0.66      1305\n",
      "\n",
      "    accuracy                           0.71      2626\n",
      "   macro avg       0.73      0.71      0.70      2626\n",
      "weighted avg       0.73      0.71      0.70      2626\n",
      "\n",
      "--KNN--\n",
      "Accuracy: 0.7357197258187357\n",
      "F1-score: 0.6915555555555556\n",
      "Confusion Matrix:\n",
      " [[1154  167]\n",
      " [ 527  778]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.69      0.87      0.77      1321\n",
      "           1       0.82      0.60      0.69      1305\n",
      "\n",
      "    accuracy                           0.74      2626\n",
      "   macro avg       0.75      0.73      0.73      2626\n",
      "weighted avg       0.75      0.74      0.73      2626\n",
      "\n",
      "--SVM--\n",
      "Accuracy: 0.7387661843107388\n",
      "F1-score: 0.676109537299339\n",
      "Confusion Matrix:\n",
      " [[1224   97]\n",
      " [ 589  716]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.68      0.93      0.78      1321\n",
      "           1       0.88      0.55      0.68      1305\n",
      "\n",
      "    accuracy                           0.74      2626\n",
      "   macro avg       0.78      0.74      0.73      2626\n",
      "weighted avg       0.78      0.74      0.73      2626\n",
      "\n",
      "                    Model Accuracy F1-score Recall Precision\n",
      "0  Logistic Regression CV    70.37    63.95  52.87     80.89\n",
      "1                 XGBoost    74.68    66.73  51.11     96.11\n",
      "2           Random Forest    74.30    66.77  51.95     93.39\n",
      "3        Ridge Classifier    71.21    65.73  55.56     80.47\n",
      "4                     KNN    73.57    69.16  59.62     82.33\n",
      "5                     SVM    73.88    67.61  54.87     88.07\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegressionCV, RidgeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn import svm\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, f1_score, recall_score, precision_score\n",
    "\n",
    "# Hyperparameter tuning for XGBoost\n",
    "param_dist_xgb = {\n",
    "    'n_estimators': [100, 200, 300],\n",
    "    'learning_rate': [0.01, 0.1, 0.2],\n",
    "    'max_depth': [3, 5, 7],\n",
    "    'subsample': [0.8, 0.9, 1.0]\n",
    "}\n",
    "\n",
    "random_search_xgb = RandomizedSearchCV(estimator=XGBClassifier(random_state=42), param_distributions=param_dist_xgb, n_iter=50, cv=3, verbose=2, random_state=42, n_jobs=-1)\n",
    "random_search_xgb.fit(X_train_res, y_train_res)\n",
    "best_xgb = random_search_xgb.best_estimator_\n",
    "\n",
    "# Hyperparameter tuning for Random Forest\n",
    "param_dist_rf = {\n",
    "    'n_estimators': [100, 200, 300],\n",
    "    'max_depth': [None, 10, 20],\n",
    "    'min_samples_split': [2, 5, 10],\n",
    "    'min_samples_leaf': [1, 2, 4]\n",
    "}\n",
    "\n",
    "random_search_rf = RandomizedSearchCV(estimator=RandomForestClassifier(random_state=42), param_distributions=param_dist_rf, n_iter=50, cv=3, verbose=2, random_state=42, n_jobs=-1)\n",
    "random_search_rf.fit(X_train_res, y_train_res)\n",
    "best_rf = random_search_rf.best_estimator_\n",
    "\n",
    "# Hyperparameter tuning for Logistic Regression CV\n",
    "best_lcv = LogisticRegressionCV(cv=5, random_state=42, solver='lbfgs', max_iter=1000).fit(X_train_res, y_train_res)\n",
    "\n",
    "# Hyperparameter tuning for Ridge Classifier\n",
    "param_dist_rg = {\n",
    "    'alpha': [0.1, 1.0, 10.0],\n",
    "    'solver': ['auto', 'svd', 'cholesky', 'lsqr', 'sag']\n",
    "}\n",
    "\n",
    "random_search_rg = RandomizedSearchCV(estimator=RidgeClassifier(random_state=42), param_distributions=param_dist_rg, n_iter=50, cv=3, verbose=2, random_state=42, n_jobs=-1)\n",
    "random_search_rg.fit(X_train_res, y_train_res)\n",
    "best_rg = random_search_rg.best_estimator_\n",
    "\n",
    "# Hyperparameter tuning for KNN\n",
    "param_dist_knn = {\n",
    "    'n_neighbors': [3, 5, 7],\n",
    "    'weights': ['uniform', 'distance'],\n",
    "    'algorithm': ['auto', 'ball_tree', 'kd_tree', 'brute']\n",
    "}\n",
    "\n",
    "random_search_knn = RandomizedSearchCV(estimator=KNeighborsClassifier(), param_distributions=param_dist_knn, n_iter=50, cv=3, verbose=2, random_state=42, n_jobs=-1)\n",
    "random_search_knn.fit(X_train_res, y_train_res)\n",
    "best_knn = random_search_knn.best_estimator_\n",
    "\n",
    "# Hyperparameter tuning for SVM\n",
    "param_dist_svm = {\n",
    "    'C': [0.1, 1.0, 10.0],\n",
    "    'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],\n",
    "    'gamma': ['scale', 'auto']\n",
    "}\n",
    "\n",
    "random_search_svm = RandomizedSearchCV(estimator=svm.SVC(probability=True, random_state=42), param_distributions=param_dist_svm, n_iter=50, cv=3, verbose=2, random_state=42, n_jobs=-1)\n",
    "random_search_svm.fit(X_train_res, y_train_res)\n",
    "best_svm = random_search_svm.best_estimator_\n",
    "\n",
    "# Evaluate tuned models\n",
    "models_tuned = {\n",
    "    'Logistic Regression CV': best_lcv,\n",
    "    'XGBoost': best_xgb,\n",
    "    'Random Forest': best_rf,\n",
    "    'Ridge Classifier': best_rg,\n",
    "    'KNN': best_knn,\n",
    "    'SVM': best_svm\n",
    "}\n",
    "\n",
    "# Function to evaluate models\n",
    "def evaluate_models(models, x_test, y_test):\n",
    "    results = []\n",
    "    for name, model in models.items():\n",
    "        y_pred = model.predict(x_test)\n",
    "        accuracy = accuracy_score(y_test, y_pred)\n",
    "        f1 = f1_score(y_test, y_pred)\n",
    "        results.append({\n",
    "            'Model': name,\n",
    "            'Accuracy': accuracy,\n",
    "            'F1-score': f1,\n",
    "            'Recall': recall_score(y_test, y_pred),\n",
    "            'Precision': precision_score(y_test, y_pred),\n",
    "            'Confusion Matrix': confusion_matrix(y_test, y_pred),\n",
    "            'Classification Report': classification_report(y_test, y_pred, output_dict=True)\n",
    "        })\n",
    "        print(f'--{name}--')\n",
    "        print('Accuracy:', accuracy)\n",
    "        print('F1-score:', f1)\n",
    "        print('Confusion Matrix:\\n', confusion_matrix(y_test, y_pred))\n",
    "        print('Classification Report:\\n', classification_report(y_test, y_pred))\n",
    "    return results\n",
    "\n",
    "# Get evaluation results\n",
    "evaluation_results = evaluate_models(models_tuned, X_test_res, y_test_res)\n",
    "\n",
    "# Save evaluation results\n",
    "for result in evaluation_results:\n",
    "    model_name = result['Model']\n",
    "    classification_report_df = pd.DataFrame(result['Classification Report']).transpose()\n",
    "    classification_report_df.to_csv(f'classification_report_{model_name}.csv', index=True)\n",
    "\n",
    "# Display evaluation results summary\n",
    "eval_summary_df = pd.DataFrame([\n",
    "    {\n",
    "        'Model': res['Model'],\n",
    "        'Accuracy': f\"{res['Accuracy'] * 100:.2f}\",\n",
    "        'F1-score': f\"{res['F1-score'] * 100:.2f}\",\n",
    "        'Recall': f\"{res['Recall'] * 100:.2f}\",\n",
    "        'Precision': f\"{res['Precision'] * 100:.2f}\"\n",
    "    }\n",
    "    for res in evaluation_results\n",
    "])\n",
    "print(eval_summary_df)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}