SK3_Model_Evaluation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SK Part 3: Model Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Objectives\n",
    "\n",
    "The objective of this tutorial is to illustrate evaluation of machine learning algorithms using various performance metrics. We shall use the following datasets as examples of binary classification, multinomial (a.k.a. multiclass) classification, and regression problems respectively:\n",
    "\n",
    "1. [Breast Cancer Wisconsin Data](https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Diagnostic%29). The target feature is binary, i.e., if a cancer diagnosis is \"malignant\" or \"benign\".\n",
    "2. [Wine Data](https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data). The target feature is multinomial. It consists of three classes of wines in a particular region in Italy.\n",
    "3. [California Housing Data](https://www.kaggle.com/datasets/camnugent/california-housing-prices). The target feature is continuous, which is the house prices in California."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "* [Why Evaluation?](#why)\n",
    "* [Evaluation Procedures](#procedures)\n",
    "* [Choosing the Right Metric(s)](#metrics)\n",
    "* [Evaluating Binary Classifiers](#classifiers)\n",
    "    - [Getting Started](#classifiers_started)\n",
    "    - [Confusion Matrix](#cmatrix)\n",
    "    - [Precision, Recall, and F1 Measures](#c_report)\n",
    "    - [Profit Matrix](#profit_matrix)\n",
    "    - [ROC Curves](#roc)\n",
    "* [Evaluating Multinomial Classifiers](#mn_classifiers)\n",
    "    - [Getting Started](#mn_classification_started)\n",
    "    - [Multinomial Evaluation Metrics](#mn_eval)\n",
    "* [Evaluating Regressors](#regression)\n",
    "    - [Getting Started](#regression_started)\n",
    "    - [Evaluating Multiple Regression Models](#regression_multiple_models)\n",
    "    - [MAE and R-Squared Metrics](#regression_metrics)\n",
    "    - [Residual Analysis](#regression_residuals)\n",
    "* [Beyond Evaluation](#beyond)\n",
    "* [Exercises](#exercises)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why Evaluation? <a class=\"anchor\" id=\"why\"></a> \n",
    "\n",
    "Model evaluation is a necessary step in machine learning in order to accomplish the following:\n",
    "\n",
    "* Determine the \"best\" model\n",
    "* Estimate how the models will perform when deployed\n",
    "* Convince the end-users that the deployed model meets their needs\n",
    "\n",
    "There are two major considerations in evaluation:\n",
    "\n",
    "1. How shall we split the data for evaluation?\n",
    "2. Which metric(s) should we use for evaluation?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation Procedures <a class=\"anchor\" id=\"procedures\"></a> \n",
    "\n",
    "With respect to the first consideration, we can split the dataset into a training set and a test set (also known as hold-out-sampling). Then we build a machine learning model on the training set and we evaluate how well the model performs on the test set. Data splitting is crucial to avoid or at least mitigate the issue of overfitting. \n",
    "\n",
    "A more robust and methodical approach to hold-out sampling is cross-validation. Also, another extension of cross-validation is repeated cross-validation (say 3 times) where data is partitioned into 5 (or sometimes 10) equal-sized chunks multiple times and the cross-validation procedure is repeated, each time with a different partitioning of data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choosing the Right Metric(s) <a class=\"anchor\" id=\"metrics\"></a> \n",
    "\n",
    "The second consideration is to choose the right metric(s), which is almost always problem-specific. Suppose the problem is a binary classification problem: either a patient is sick or healthy in a medical diagnosis setting. We want to predict a sick patient to be sick and, apparently we would never want to predict a sick patient to be healthy. However, there is no such thing as a perfect model and there is always some sort of trade-off involved. We can increase the cutoff threshold for scores to increase the chances of predicting a truly sick patient as sick, which would be increasing the true positive rate (TPR) (i.e., the recall). But there is no free lunch! Increasing TPR will probably lead to an increase in false positive rate (FPR) as well, i.e., predicting a healthy patient to be sick (a.k.a. false alarms). We discuss this issue of finding the \"sweet balance\" between TPR and FPR further below.\n",
    "\n",
    "Commonly used evaluation metrics for a binary classifier are as follows:\n",
    "\n",
    "* Simple classification accuracy,\n",
    "* Average class accuracy (using either arithmetic or harmonic mean),\n",
    "* Confusion matrix,\n",
    "* Area under ROC curve (AUC), and\n",
    "* Classification report.\n",
    "\n",
    "Some of the binary evaluation metrics can be extended to multinomial classification problems with some caveats. Meanwhile, evaluating a regressor is simpler. We do not need to adjust prediction score (in fact, we cannot). Popular metrics for regression are as follows:\n",
    "\n",
    "* Root mean squared error (RMSE),\n",
    "* R-squared ($R^2$), and \n",
    "* Mean absolute error (MAE).\n",
    "\n",
    "Please refer to `Scikit-Learn` documentation on [evaluation methods](https://scikit-learn.org/stable/modules/model_evaluation.html) for more details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluating Binary Classifiers  <a class=\"anchor\" id=\"classifiers\"></a> \n",
    "\n",
    "### Getting Started <a class=\"anchor\" id=\"classifiers_started\"></a> \n",
    "\n",
    "Let's load the Breast Cancer Wisconsin dataset and let's split the descriptive features and the target feature into a training set and a test set by a ratio of 70:30. That is, we use 70 % of the data to build a KNN classifier and evaluate its performance using the test set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn import preprocessing\n",
    "\n",
    "df = load_breast_cancer()\n",
    "Data, target = df.data, df.target\n",
    "\n",
    "Data = preprocessing.MinMaxScaler().fit_transform(Data)\n",
    "\n",
    "# target is already encoded, but we need to reverse the labels\n",
    "# so that malignant is the positive class\n",
    "target = np.where(target==0, 1, 0)\n",
    "\n",
    "D_train, D_test, t_train, t_test = train_test_split(Data, \n",
    "                                                    target, \n",
    "                                                    test_size = 0.3, \n",
    "                                                    random_state=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We shall utilize cross-validation to find the optimal KNN parameters (please refer to the **SK Part 4 tutorial** for more details on hyper-parameter tuning). Here, we use a 3-repeated 5-fold stratified cross-validation on the training set. We choose accuracy as our performance metric. In `Scikit-Learn`, a performance metric is called a \"score\". The accuracy rate is defined as\n",
    "\n",
    "$$\\text{Accuracy rate} = \\frac{\\text{Number of correct predictions}}{\\text{Total predictions}}$$\n",
    "\n",
    "Note that 1 - accuracy rate is called the misclassification rate, that is, \n",
    "\n",
    "$$\\text{Misclassification rate} = \\frac{\\text{Number of incorrect predictions}}{\\text{Total predictions}}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import RepeatedStratifiedKFold, GridSearchCV\n",
    "\n",
    "cv_method = RepeatedStratifiedKFold(n_splits=5, \n",
    "                                    n_repeats=3, \n",
    "                                    random_state=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the grid search, we determine the optimal KNN parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_KNN = KNeighborsClassifier()\n",
    "params_KNN = {'n_neighbors': [1, 2, 3, 4, 5, 6, 7], \n",
    "              'p': [1, 2, 5]}\n",
    "\n",
    "gs_KNN = GridSearchCV(estimator=model_KNN, \n",
    "                      param_grid=params_KNN, \n",
    "                      cv=cv_method,\n",
    "                      verbose=1, \n",
    "                      scoring='accuracy',\n",
    "                      return_train_score=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 15 folds for each of 21 candidates, totalling 315 fits\n"
     ]
    }
   ],
   "source": [
    "gs_KNN.fit(D_train, t_train);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's get the predictions for the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_pred = gs_KNN.predict(D_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scikit Learn has a module named `metrics` which contains different performance metrics for classifers and regressors. The example below shows how to calculate accuracy score on the test data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9649122807017544"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "metrics.accuracy_score(t_test, t_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, a score function has two arguments:\n",
    "\n",
    "* `y_true`: the actual values. In our example,  `y_true = t_test` (the actual target values from the test data).\n",
    "* `y_pred`: the predicted values. In our example, `y_pred = t_pred` (the predicted value from the test data)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix <a class=\"anchor\" id=\"cmatrix\"></a> \n",
    "\n",
    "A confusion matrix is a square matrix $M$ constructed such that $M_{i,j}$ is equal to the number of observations known to be in group $i$ but predicted to be in group $j$. For a binary classifier, \n",
    "\n",
    "* $M_{0,0}$ = True negatives (TN)\n",
    "* $M_{1,0}$ = False negative (FN)\n",
    "* $M_{1,1}$ = True positives (TP)\n",
    "* $M_{0,1}$ = False positives (FP)\n",
    "\n",
    "Above, we start the matrix index from 0 because Python indices start from 0. A confusion matrix for a binary classification problem can be shown as a table as below.\n",
    "\n",
    "| Target | Predicted Negative | Predicted Positive |\n",
    "|----|----|----|\n",
    "| Target Negative: | True Negative (TN) | False Positive (FP) |\n",
    "| Target Positive: | False Negative (FN) | True Positive (TP) |\n",
    "\n",
    "Let's calculate the confusion matrix for the KNN model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[104,   1],\n",
       "       [  5,  61]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.confusion_matrix(t_test, t_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**\n",
    "\n",
    "1. Calculate true positive rate (TPR), which is defined as TP/(TP + FN).\n",
    "2. Calculate false negative rate (FNR), which is defined as FN/(TP + FN)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Precision, Recall, and F1 Measures  <a class=\"anchor\" id=\"c_report\"></a> \n",
    "\n",
    "Precision, recall, and F1 measures are commonly used metrics for binary classification problems. There are two ways to obtain these measures. The first way is to use the functions from `metrics` below:\n",
    "\n",
    "* `metrics.precision_score(y_true, y_pred)`\n",
    "* `metrics.recall_score(y_true, y_pred)`\n",
    "* `metrics.f1_score(y_true, y_pred)`\n",
    "\n",
    "Another way is to use the `classification_report` which will report these measures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.95      0.99      0.97       105\n",
      "           1       0.98      0.92      0.95        66\n",
      "\n",
      "    accuracy                           0.96       171\n",
      "   macro avg       0.97      0.96      0.96       171\n",
      "weighted avg       0.97      0.96      0.96       171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(metrics.classification_report(t_test, t_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Refresher Questions**: \n",
    "\n",
    "1. Recall is equivalent to TPR. Does the value reported by `classification_report` match with the confusion matrix?\n",
    "2. Is the F1 score reported by `classification_report` correct? Hint: F1 $ = 2\\times\\frac{\\text{precision}\\times\\text{recall}}{\\text{precision}+\\text{recall}}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, is simple accuracy the correct measure in breast cancer classification? Most probably not. If you are a medical practitioner, you might want to increase **TPR** where malignant is the positive class and benign is the negative class. In `Scikit-Learn`, the positive class must be denoted by 1 and the negative class must be denoted by 0. However, in the original dataset, the target response is encoded as\n",
    "\n",
    "$$\\text{Target} = \\begin{cases}1 & \\text{ if benign }\\\\ 0 & \\text{ if malignant }\\end{cases}$$\n",
    "\n",
    "So, we need to be very careful how we define the positive and negative classes in a binary classification problem like this. For this reason, we used the `np.where()` function above to revert the labels so that the positive class is denoted by 1 and the negative class is denoted by 0. After reversing the labels, we now have\n",
    "\n",
    "$$\\text{Target} = \\begin{cases}0 & \\text{ if benign }\\\\ 1 & \\text{ if malignant }\\end{cases}$$\n",
    "\n",
    "Let's retrain a KNN model using recall (TPR) as the performance metric. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 15 folds for each of 21 candidates, totalling 315 fits\n"
     ]
    }
   ],
   "source": [
    "D_train, D_test, t_train, t_test = train_test_split(Data, target, test_size = 0.3, random_state=8)\n",
    "\n",
    "perf_metric = 'recall' # some other options are: accuracy, f1, roc_auc, etc.\n",
    "\n",
    "gs_KNN = GridSearchCV(estimator=model_KNN, \n",
    "                      param_grid=params_KNN, \n",
    "                      cv=cv_method,\n",
    "                      verbose=1, \n",
    "                      scoring=perf_metric,\n",
    "                      return_train_score=True)\n",
    "\n",
    "gs_KNN.fit(D_train, t_train);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.9242424242424242)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t_pred = gs_KNN.predict(D_test)\n",
    "metrics.recall_score(t_test, t_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[104,   1],\n",
       "       [  5,  61]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.confusion_matrix(t_test, t_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this specific problem, F1 or AUC metrics can be good alternatives to accuracy or TPR since there is a mild class imbalance problem here: we have more benign classes than malignant classes (357 vs. 212 counts)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Profit Matrix <a class=\"anchor\" id=\"profit_matrix\"></a> \n",
    "\n",
    "In many cases, it is incorrect to treat all outcomes equally. Sometimes we need to impose asymmetric gains for correct predictions and asymmetric costs for incorrect predictions. For instance, suppose the following is our profit matrix:\n",
    "\n",
    "|  Predicted Negative  |  Predicted Positive  |\n",
    "|----|----|\n",
    "| 0 for True Negative (TN)  | -10 False Positive (FP) |\n",
    "| -50 for False Negative (FN) | 100 True Positive (TP) |\n",
    "\n",
    "Notice that we allocate more cost to false negatives than to false positives. Next we shall calculate the **overall** profit using the profit and confusion matrices. Let's create the profit matrix using `NumPy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "profit_matrix = np.array([[0, -10], [-50, 100]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0, -10],\n",
       "       [-50, 100]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "profit_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[104,   1],\n",
       "       [  5,  61]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix = metrics.confusion_matrix(t_test, t_pred)\n",
    "confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The overall profit matrix is calculated as element-wise multiplication of the profit and confusion matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,  -10],\n",
       "       [-250, 6100]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "overall_profit_matrix = profit_matrix*confusion_matrix\n",
    "overall_profit_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The net profit (or loss) is given by the sum of the elements of the overall profit matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.int64(5840)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(overall_profit_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ROC Curves <a class=\"anchor\" id=\"roc\"></a> \n",
    "\n",
    "In the previous section, we saw how the TPR and TNR are calculated from a confusion matrix. As explained in Chapter 8 of our textbook, these measures are tied to the threshold used to convert probability scores to predictions. By default, `Scikit-Learn` models predict on the data based on a threshold value of 0.5. If we change the threshold, the confusion matrix will also change. For instance, as the threshold decreases, both TPR and FPR increase. The opposite holds when the threshold increases. To capture this trade-off, we use ROC (Receiver Operating Characteristic) curves. For instance, decreasing the score threshold would be moving to the right on the ROC curve. The area under the ROC curve (AUC) together with the F1 score are some of the most popular metrics for evaluating binary classifiers as they are robust to the class imbalance issue in general.\n",
    "\n",
    "In `Scikit-Learn`, a quick way to get AUC is to use `metric.roc_auc_score`. But first we will retrain the model with AUC as our performance metric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 15 folds for each of 21 candidates, totalling 315 fits\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "np.float64(0.9573593073593074)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perf_metric = 'roc_auc'\n",
    "\n",
    "gs_KNN = GridSearchCV(estimator=model_KNN, \n",
    "                      param_grid=params_KNN, \n",
    "                      cv=cv_method,\n",
    "                      verbose=1, \n",
    "                      scoring=perf_metric,\n",
    "                      return_train_score=True)\n",
    "\n",
    "gs_KNN.fit(D_train, t_train);\n",
    "\n",
    "metrics.roc_auc_score(t_test, t_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize an ROC curve by calculating prediction scores using the `predict_proba` method in `scikit-learn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.85714286, 0.14285714],\n",
       "       [0.14285714, 0.85714286],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t_prob = gs_KNN.predict_proba(D_test)\n",
    "t_prob[0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a side note, `_proba` stands for \"probability\", which is apparently between 0 and 1. Now let's visualize the ROC curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.9735930735930736)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fpr, tpr, _ = metrics.roc_curve(t_test, t_prob[:, 1])\n",
    "roc_auc = metrics.auc(fpr, tpr)\n",
    "roc_auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>fpr</th>\n",
       "      <th>tpr</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.727273</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.863636</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.009524</td>\n",
       "      <td>0.893939</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.038095</td>\n",
       "      <td>0.924242</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.076190</td>\n",
       "      <td>0.939394</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.133333</td>\n",
       "      <td>0.939394</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.247619</td>\n",
       "      <td>0.969697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        fpr       tpr\n",
       "0  0.000000  0.000000\n",
       "1  0.000000  0.727273\n",
       "2  0.000000  0.863636\n",
       "3  0.009524  0.893939\n",
       "4  0.038095  0.924242\n",
       "5  0.076190  0.939394\n",
       "6  0.133333  0.939394\n",
       "7  0.247619  0.969697\n",
       "8  1.000000  1.000000"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame({'fpr': fpr, 'tpr': tpr})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 459,
       "width": 569
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline \n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "plt.style.use(\"ggplot\")\n",
    "    \n",
    "ax = df.plot.line(x='fpr', y='tpr', title='ROC Curve', legend=False, marker = '.')\n",
    "plt.plot([0, 1], [0, 1], '--')\n",
    "ax.set_xlabel(\"False Postive Rate (FPR)\")\n",
    "ax.set_ylabel(\"True Positive Rate (TPR)\")\n",
    "plt.show();\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our ROC curve has an \"elbow\" around FNR = 0.1 with a very high corresponding TPR. This indicates the optimized KNN model has an outstanding predictive performance!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluating Multinomial Classifiers <a class=\"anchor\" id=\"mn_classifiers\"></a> \n",
    "\n",
    "Multinomial classification refers to prediction problems where the target feature is multinomial (a.k.a. multiclass). That is, the target feature is categorical with at least three different levels. For multinomial classification illustration, we use the [Wine Data](https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data). The target feature refers to three different classes of wines in a particular region in Italy. Although multinomial classification is a generalization of the binary case, we cannot use the following binary metrics to evaluate a multinomial classifier:\n",
    "\n",
    "* `metrics.roc_auc_score`.\n",
    "* `metrics.average_precision_score`\n",
    "\n",
    "Some other metrics can be applied to multinomial targets, but they require an \"average\" parameter as discussed below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting Started  <a class=\"anchor\" id=\"mn_classification_started\"></a> \n",
    "\n",
    "Let's load up the wine data and split it into 70% training and 30% test data. We shall use 3-repeated 5-fold cross-validation to determine optimal hyperparameters of a KNN model using the training set. Then we shall evaluate the model's performance on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_wine\n",
    "\n",
    "wine = load_wine()\n",
    "Data, target = wine.data, wine.target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check class counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2]), array([59, 71, 48]))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(wine.target, return_counts = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We shall optimize the KNN hyperparameters based on the simple accuracy score. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 15 folds for each of 18 candidates, totalling 270 fits\n"
     ]
    }
   ],
   "source": [
    "D_train, D_test, t_train, t_test = train_test_split(Data, \n",
    "                                                    target, \n",
    "                                                    test_size=0.3, \n",
    "                                                    stratify=target,\n",
    "                                                    random_state=8)\n",
    "\n",
    "model_KNN = KNeighborsClassifier()\n",
    "params_KNN = {'n_neighbors': [2, 3, 4, 5, 6, 7], \n",
    "              'p': [1, 2, 5]}\n",
    "\n",
    "gs_KNN = GridSearchCV(estimator=model_KNN, \n",
    "                      param_grid=params_KNN, \n",
    "                      cv=cv_method,\n",
    "                      verbose=1, \n",
    "                      scoring='accuracy', \n",
    "                      return_train_score=True)\n",
    "\n",
    "gs_KNN.fit(D_train, t_train);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multinomial Evaluation Metrics <a class=\"anchor\" id=\"mn_eval\"></a>  \n",
    "\n",
    "The accuracy of the KNN model on the test data can be calculated as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7222222222222222"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "\n",
    "t_pred = gs_KNN.predict(D_test)\n",
    "metrics.accuracy_score(t_test, t_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How about the confusion matrix? Clearly, it will be a 3 x 3 square matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[15,  1,  2],\n",
       "       [ 2, 16,  3],\n",
       "       [ 0,  7,  8]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.confusion_matrix(t_test, t_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in binary classification problems, we can also generate a classification report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.88      0.83      0.86        18\n",
      "           1       0.67      0.76      0.71        21\n",
      "           2       0.62      0.53      0.57        15\n",
      "\n",
      "    accuracy                           0.72        54\n",
      "   macro avg       0.72      0.71      0.71        54\n",
      "weighted avg       0.72      0.72      0.72        54\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(metrics.classification_report(t_test, t_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the classification report, \"micro\" averaging refers to calculating metrics globally by counting the total true positives, false negatives, and false positives. On the other hand, \"macro\" averaging refers to calculating metrics for each label, and find their unweighted mean. Macro averaging does not take label imbalance into account. Thus, micro averaging would be preferred to macro when there is a class imbalance. Likewise, if the class counts are somewhat balanced as in the wine data example, micro and macro averaging results will be similar. Also, the micro F1 score is the harmonic mean of micro recall and micro precision. To obtain micro scores, we set `average='micro'` as below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.7222222222222222)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.recall_score(t_test, t_pred, average='micro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.7222222222222222)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.precision_score(t_test, t_pred, average='micro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.7222222222222222)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.f1_score(t_test, t_pred, average='micro')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can calculate the \"average class accuracy using arithmetic mean\" by using the `balanced_accuracy_score` method. This metric can be used for both binary as well as multinomial classification problems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.7095238095238096)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.balanced_accuracy_score(t_test, t_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluating Regressors <a class=\"anchor\" id=\"regression\"></a>  \n",
    "\n",
    "### Getting Started <a class=\"anchor\" id=\"regression_started\"></a>  \n",
    "\n",
    "Let's load up the California housing data. Then we split the data into training and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import fetch_california_housing\n",
    "from sklearn import preprocessing\n",
    "\n",
    "housing_df = fetch_california_housing()\n",
    "\n",
    "Data, target = housing_df.data, housing_df.target\n",
    "\n",
    "# scale each descriptive feature to be between 0 and 1\n",
    "Data = preprocessing.MinMaxScaler().fit_transform(Data)\n",
    "\n",
    "D_train, D_test, t_train, t_test = train_test_split(Data, target, test_size = 0.3, random_state=999)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We choose mean squared error (MSE) for model performance evaluation and comparison. The MSE is defined as\n",
    "\n",
    "$$\\text{MSE} = \\frac{\\sum_{i=1}^{n}(t_{i} - \\mathbb{M}(d_{i})^2)}{n}$$\n",
    "\n",
    "where\n",
    "\n",
    "* $t_{1}, t_{2}, ..., t_{n}$ is the set of $n$ actual target values (in our case, housing prices) from the test data.\n",
    "* $\\mathbb{M}$ is the model we train and $\\mathbb{M}(d_{i})$ is the model's prediction for observation $d_i$ in the test data.\n",
    "\n",
    "As in classification problems, it is recommended to use the same performance metric for model evaluation and hyperparameter tuning. We determine the optimal parameters using a 3 repeated 5-folded cross validation. Keep in mind that stratification will not work with regression problems as there is nothing to stratify on as in classification problems!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import RepeatedKFold, GridSearchCV\n",
    "cv_method = RepeatedKFold(n_splits=5, n_repeats=3, random_state=999)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating Multiple Regression Models <a class=\"anchor\" id=\"regression_multiple_models\"></a> \n",
    "\n",
    "Unlike the previous classification problem, we shall illustrate how we can evaluate **two** models simultaneously within the same cross validation strategy. \n",
    "\n",
    "First, we need to import the modules required to build a KNN and a DT model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn import tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second, we create a dictionary called `models` as follows: each dictionary key corresponds to a different model and the dictionary values are the model objects. For example, the first key is `KNN` with a value of ` KNeighborsRegressor()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "models = {'KNN': KNeighborsRegressor(),\n",
    "          'DT': tree.DecisionTreeRegressor()}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Third, we create a dictionary named `models_parameters` which **must share the same keys** as in `models` dictionary. In `models_parameters`, each item contains its own dictionary of parameters we would like to optimize. For instance, `KNN` has a dictionary consisting of `n_neighbors` and `p` keys. Within this dictionary, each item has the range of parameter values that we would like to try."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "models_parameters = {'KNN': {'n_neighbors': [1, 2, 3, 4, 5], \n",
    "                             'p': [1, 2, 3]},\n",
    "                     'DT': {'max_depth': [2, 3, 4], \n",
    "                            'min_samples_split': [2, 3, 4, 5]}}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fourth, we need to create a `GridSearchCV` object where we specify `estimator=models` and `param_grid=models_parameters` to tell `GridSearchCV` the models and their corresponding parameters we wish to build and train. \n",
    "\n",
    "We define `scoring='neg_mean_squared_error'` as the regression performance metric we want to use. The convention in `scikit-learn` is that when it comes to scores, \"higher is always better\". Thus, whenever we would like to use a metric for which lower values are better (such as MSE), we need to use their negatives as the score so that we are compliant with the convention that \"higher score is better\". The reason is that maximizing the negative of MSE will actually minimize the MSE. For instance, in order to minimize MAE, we would define `scoring='neg_mean_absolute_error'`.\n",
    "\n",
    "\n",
    "For each model, we determine the optimal set of parameters that result in the lowest MSE as possible. Please remember to include `cv_method` (the cross-validation strategy we defined) in `GridSearchCV`.\n",
    "\n",
    "Finally, we run the grid search in a loop. We create a dictionary named `fitted_models` to store the grid search outputs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Hyperparameter tuning for KNN:\n",
      "Fitting 15 folds for each of 15 candidates, totalling 225 fits\n",
      "Best KNN model: {'n_neighbors': 5, 'p': 1}\n",
      "\n",
      "Hyperparameter tuning for DT:\n",
      "Fitting 15 folds for each of 12 candidates, totalling 180 fits\n",
      "Best DT model: {'max_depth': 4, 'min_samples_split': 2}\n"
     ]
    }
   ],
   "source": [
    "fitted_models = {} # this creates an empty dictionary\n",
    "for m in models: # this will loop over the dictionary keys\n",
    "    print(f'\\nHyperparameter tuning for {m}:')\n",
    "    gs = GridSearchCV(estimator=models[m], \n",
    "                      param_grid=models_parameters[m], \n",
    "                      cv=cv_method,\n",
    "                      verbose=1, \n",
    "                      scoring='neg_mean_squared_error')\n",
    "    gs.fit(D_train, t_train);\n",
    "    fitted_models[m] = gs\n",
    "    print(f'Best {m} model: {gs.best_params_}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To compare KNN and DT models, we predict housing prices from the test data and compute the MSE (via `mean_squared_error(<true target value>, <predicted target value>)` from `metrics`) as below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE of KNN is: 0.36735193335669697\n",
      "MSE of DT is: 0.5527616617419007\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "for m in fitted_models:\n",
    "    t_pred = fitted_models[m].predict(D_test)\n",
    "    mse = metrics.mean_squared_error(t_test, t_pred)\n",
    "    print(f'MSE of {m} is: {mse}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "KNN has a lower test MSE error compared to DT, implying (optimized) KNN is more accurate in predicting the housing price.\n",
    "\n",
    "### MAE and R-Squared Metrics <a class=\"anchor\" id=\"regression_metrics\"></a> \n",
    "\n",
    "Besides MSE, we can compute other metrics:\n",
    "\n",
    "* Mean Absolute Error (MAE) which is more robust to outliers. This can be calculated via `metrics.mean_absolute_error`.\n",
    "* $R^{2}$, a domain-independent measure of error. This metric measures the amount of variability in the target feature that is explained by the descriptive features. It is between 0 and 1 with higher values being better. It can be calculated via `r2_score`.\n",
    "\n",
    "Let's check whether KNN still outperforms DT if we evaluate them using MAE or $R^{2}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE and r-squared KNN are: 0.4046782580749354, 0.7323287461112485\n",
      "MAE and r-squared DT are: 0.5534859610267931, 0.5972298124359738\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "for m in fitted_models:\n",
    "    t_pred = fitted_models[m].predict(D_test)\n",
    "    mae = metrics.mean_absolute_error(t_test, t_pred)\n",
    "    r2 = metrics.r2_score(t_test, t_pred)\n",
    "    print(f'MAE and r-squared {m} are: {mae}, {r2}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "KNN has a lower test MAE error and a higher $R^{2}$ than DT. Thus, KNN outperforms DT with respect to these two metrics as well. In practice though, using a different metric during hyperparameter tuning will likely result in a different model evaluation. Recall that we used MSE to optimize the hyperparameters of each model. In our case, it is just a coincidence that KNN has lower MSE and MAE values and a higher $R^2$ than DT. In summary, whatever metric you want to optimize, you should use the same metric for both hyperparameter tuning and model evaluation. That is, you should avoid using different metrics for tuning and evaluation.\n",
    "\n",
    "**Refresher Questions**: \n",
    "\n",
    "* Why does a higher $R^2$ value indicate a better model performance? Hint: $R^2$ is defined as:\n",
    "\n",
    "$$R^{2} = 1 - \\frac{\\text{Sum of squared error}}{\\text{Total sum of squares}}$$\n",
    "\n",
    "* What is the range of MSE? How about MAE?\n",
    "\n",
    "\n",
    "**Important Side Notes**\n",
    "\n",
    "1. There are many ways to evaluate multiple models in `scikit-learn`. Our example makes use of dictionaries and for loops because this approach is easier. Other approaches include utilizing `pipeline` from `scikit-learn` or defining our own \"classes\" in an object-oriented programming framework. We do not cover the latter.\n",
    "2. `GridSearchCV` allows to optimize parameters using multiple metrics. Again we do not cover in this tutorial because it would return a `GridSearchCV` object with nested information.\n",
    "3. We can define our own performance metrics. If you are curious, please refer to \"[How to make scorer in scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html#sklearn.metrics.make_scorer)\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Residual Analysis <a class=\"anchor\" id=\"regression_residuals\"></a> \n",
    "\n",
    "The regression metrics help us evaluate and rank model performance. However, using metrics alone cannot help us validate the models, including checking the underlying model assumptions. The model validation process primarily stems from statistics. One way to validate a model is to conduct a residual analysis. Residual is the difference between an actual value and a predicted value. That is, for observation $i$,\n",
    "\n",
    "$$\\text{Residual}_{i} = t_{i} - \\mathbb{M}(d_{i}).$$\n",
    "\n",
    "For simplicity, we shall use histograms to visualize the residuals. The goal here is to make sure that there are not too many residuals with very large negative or positive values. The intuition is that if a regression model has a good predictive power, its predictions should not deviate too much from the actual values. Likewise, we would expect residual values to be close to zero on average for a good model.\n",
    "\n",
    "To illustrate the concept, let's create a histogram of residuals for the KNN and DT models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABI4AAAOWCAYAAACJSdnhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAB7CAAAewgFu0HU+AAC7LklEQVR4nOzdd3hUVeL/8c+kA0kICYFA6L1KCR2EAKKCFF1AsSKuuOti26+y664iovhD0BVcC3bswoIoYKcX6V3phFBDCCEJCenl/v5gMzuTuUkmYWYSyPv1PHmeuXPPPefM5OZO8sk551oMwzAEAAAAAAAAFOFV0R0AAAAAAABA5URwBAAAAAAAAFMERwAAAAAAADBFcAQAAAAAAABTBEcAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBAAAAAAAAFMERwAAAAAAADBFcAQAAAAAAABTBEcAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBAAAAAAAAFMERwAAAAAAADBFcAQAAAAAAABTBEcAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBKBSeP7552WxWKxfx48fr+guedSaNWvsXv/HH3/skrLXuqp+3lRWq1ev1v3336+2bdsqJCREXl5e1u9R586dK7p71zTbn4f777/fLW18/PHHdu2sWbPGLe1UJlf7tSYpKUkzZ87U4MGDFRERIX9/f7vX8+2331Z0FwHYuP/+++1+RiuaJz5bULkRHAGwOn78uN0Hg9mXr6+vAgMDFRkZqa5du2r06NF67rnn9MMPPygtLa2iXwKACpSVlaU77rhDgwYN0ieffKKDBw/q4sWLMgzDZW0UDU7Nvry8vBQcHKyGDRsqOjpaTz75pNauXeuyPgBXk5UrV6ply5Z6+umntWrVKp07d045OTkV3S2Pi46OvqLAc+PGjapZs6ZdHZ06ddL58+ftyhUNGS0WiwIDAx3Klabote6pp54qsXzRoMFisahRo0bKzs4uU7tFg+E333yzTMc7w+y6Xa1aNV28eLFc9S1YsMC0zjFjxri450DVRXAEoEzy8vKUnp6uuLg47dq1S4sXL9aLL76oW265RXXq1NHo0aOvyj/Qrvb/Jl+tGD11bXnqqaf0n//8p6K7IcMwlJaWptOnT2vt2rV67bXXFB0drQ4dOmjTpk0V3T3AY2JjY3XbbbcpKSmportyVVu9erVuvPFGpaamWp/r1q2bVq9erfDw8FKPT09P14wZM9zZRVOnTp3Su+++6/F2yyMrK0sLFy4s17GffPKJi3sDoCiCIwAuk5WVpcWLFys6Olo33nijjh07VtFdAuAhp0+f1jvvvGPdDg0N1RtvvKFdu3bp2LFjio2NVWxsrH744YcK6+O+ffvUr18/ffnllxXWB8CTZs6caTcaeNSoUfrll190+PBh689kbGysbrzxxgrsZeX2888/65ZbblF6err1uT59+mjlypUKDQ11up65c+cqLi7OHV0s0YwZM5SRkeHxdsvj008/LfMx586d0y+//OKG3gCw5VPRHQBQeUVGRmrDhg12zxmGodTUVKWkpCghIUHbtm3Txo0btWnTJhUUFFjLLV++XF27dtXChQs1ZMgQT3cdgIctXbpU+fn51u2PPvpIo0aNcnu7PXv21Pz58x2eT01N1ZEjR7Rs2TJ9+eWXys3NlSQVFBRowoQJ6tChg6677jq39w+oSIsXL7Y+7tq1q7755ptKsV7K1WLZsmUaO3as3XSv6OhoLVu2TIGBgWWqKysrS9OnT9fbb7/t6m6WKD4+Xm+++ab+9re/ebRdZ/n6+lqvzxs2bFBsbKyaNm3q9PFffPGF9bPHti4ArsWIIwDF8vHxUZMmTey+mjZtqk6dOmnAgAEaO3asZs2apQ0bNujQoUOaNGmSvL29rcdfvHhRI0eO1Lp160pt6/nnn5dhGNavJk2auPGVVT7R0dF2r5+FB51T1c+bymTHjh3Wx76+vho2bJhH2g0ICHC4TjVp0kTXXXedRo8erY8//libNm2yGxmQk5OjZ5991iP98zTbnwemflZtp06dsltXZ+TIkYRGZbBo0SKNHj3aLjS68cYb9cMPP5Q5NCr0wQcfVMhU+FmzZtlNs6tMOnTooIYNG0q6fP367LPPynS87SglT33uAFURwREAl2jRooXefPNNLV++XHXq1LE+n5WVpXHjxunChQsV2DsA7paQkGB9HB4eLl9f3wrsjb2oqCi7aXSS9MMPPyglJaViOgR4gO3PpCTVr1+/gnpy9fniiy80btw4u9ErI0aM0NKlS1WtWrUy1TVixAjr49zcXE2bNs1l/XS23QsXLmj27NkeabesvLy8dPfdd1u3P//8c6eP3bNnj/bs2WPdvu+++1zaNwD/Q3AEwKUGDhyon3/+Wf7+/tbnzp49q+eff77iOgXA7S5dumR9XJlCo0JjxoxR3bp1rdv5+fkOU3GBa4ntz6RUOX8uK6OPPvpI9913n93U2zFjxujrr7+2+93GWQ888ICaN29u3f7ss8906NAhl/S1JJMnT1bNmjWt27Nnz660i6TbBj5Hjhxx+iYGtqON2rdvr65du7q8bwAuY40jAC7XuXNnzZw5U0888YT1uffff19Tp05V7dq1XdpWQUGBfv/9d/32229KSEhQenq6/Pz8FBwcrEaNGql169Z2v7BVlN9//1379+/X2bNnlZ6eriZNmuiuu+5yS1uXLl3S+vXrderUKSUlJalu3bpq166devTowTQFE3v27NHvv/+uhIQE5eTkqE6dOmratKn69OkjPz8/l7a1fft2HTx4UGfOnFG1atUUGRmp6OhohYWFubQdZ2RmZmr9+vU6efKkEhMTVa1aNdWpU0ddu3ZV69aty1yfYRhu6KXrWCwWRUVF2S3OferUqTLXk5KSol9//VVxcXFKTExUjRo1FBERod69e1unW5RHYmKidu7cqZiYGF28eFH5+fmqUaOG9Xy87rrrVKNGjXLX7wzDMLRlyxbt379fCQkJCg0NVcOGDXX99deXe2pORcjLy9OBAwd04MABnT17VpcuXVL16tUVGhqqDh06qHPnznbTqt2pIj+jXPkzmZubq40bN+rYsWM6f/68fHx8VKdOHev76UrZ2dnasGGDTp06pfj4ePn5+Sk6OtojocDcuXM1adIku/funnvu0ccff1zuc8bHx0dTp061hiP5+fmaOnWq6dpsrlSrVi09+eSTeu655yRdXj5g1qxZevnll93abnm0bdtWUVFR1inPn376qXr37l3iMfn5+XY3Orj33ntd0hd3n+vZ2dlas2aNYmNjlZKSonr16qlZs2bq06ePy69L586d06ZNmxQfH6+kpCTVrFlT9erV0/XXX+/U3QABOwYA/FdsbKwhyfrVuHHjcteVlZVlhIeH29U3e/bsYstPnTrVrmxsbGyJ9aelpRnPPvusUb9+fbvjzL7Cw8ONe+65x9iyZUuJr9fZr6lTpzr0p3Hjxtb9AwYMsD7/0UcfGe3bt3eoo2bNmnbHr1692m7/vHnzin3txZWNj483Jk6caAQGBpr2u3HjxsZHH31U4vtqy/bY8ePHO32cM6/F9v1y9sv2fS1U1vOmUEZGhvHSSy8ZDRo0KLa9wMBA4/777zdOnTrl9Gsv7j379NNPjbZt25q24+XlZYwbN844efKk0+1ciUOHDhljx441qlWrVuxrb9asmfHGG28Yubm5xdZTnp+fK7mmFCp6fpmdF8W5++677Y596aWXnD72559/NgYMGGB4e3sX+/o6d+5sLFmypEyvZ+3atcaQIUMMLy+vEt87b29vo3v37saMGTNK/L6U9+f2gw8+KPbnMjAw0Jg4caIRHx9vGIZhzJs3z27/6tWri613wIAB5f7+l+W1pKSkGB999JExfPhwIygoqMT3Mjg42HjiiSeMM2fOON2XiviMKo/x48eX+eeypM+bM2fOGA8++KARHBxc7PH169c3pk2bZqSnpzvVx+I+I5KTk42HH37YCAkJcWjj8ccfv+L3xvZcNDtvX3vtNYd2H3zwQSM/P79M7RQ9V5YtW2bk5+fbfQZYLBZj7969JdZT9H168sknSyxf9Hv/22+/GampqUbt2rWtz9WoUcP6c1ycoj/fb7zxRplevzNs64+KijIMwzBef/1163O1atUysrOzS6zjhx9+sPscPX36tMPn0ujRo53ukzvOdVsZGRnG3/72N6NmzZqmdUdGRhovvfSS9XUX/X46q6CgwJg/f77RrVs3w2KxmLbl5eVlXH/99ca6deucrre8ny24djBVDYBb+Pv7649//KPdc666DffRo0fVsWNHTZ8+3alb254/f16ff/65R2/BnZ2drdtvv10PPPCA9u3b5/b29u7dq86dO+v99993mJ5Q6MSJE3rggQd06623Kicnx+19qqz279+vdu3a6ZlnntHp06eLLXfp0iV9/PHHatWqlb744otytZWTk6P77rtP9913nw4cOGBapqCgQPPnz1fPnj21f//+crXjrDlz5qhDhw5auHChMjMziy137NgxPfroo+rSpYtOnjzp1j55UtHFYQMCAko9Ji0tTaNGjdJNN92ktWvX2k1fKWr37t0aNWqUbr/9drsFdYvz7LPPasCAAVq+fLndXSnN5Ofna9u2bfrHP/5R7M94eeTk5GjUqFF68MEHdeLECdMyly5d0vvvv6/OnTtr7969LmvblUaMGKEHHnhA3333nd3t582kpqZqzpw56tixo1atWuXyvlwNn1HOWLhwoVq2bKkPPvigxIWV4+LiNHXqVLVp06bc58fu3bvVuXNnzZ07t0LWHpsxY4b+7//+z+65Rx55RO+99568vK78zyUvLy+7tY0Mw9CUKVOuuN7SBAUF2d1NLT09XTNmzHB7u+Vx5513WqdTJicna9myZSWWt52mNmjQIEVGRpa7bXef6ydPnlSnTp00a9YsXbx40bTMmTNn9Mwzz2jgwIHl/hmIj49X3759NW7cOG3fvr3YUYcFBQVav369+vfvr7/+9a+VfsQwKgemqgFwm0GDBtkNid68ebMMw7ii6VJZWVkaOnSow11JGjVqpHbt2ik0NFT5+fm6ePGijhw5omPHjlXIB+ITTzyhhQsXSro8RaZLly5q0qSJLBaLjh07ptjYWJe1df78eQ0dOlTx8fGSpMDAQPXu3Vu1a9dWQkKCNm3apIyMDGv5JUuW6I477tDixYur3NS1PXv2aNCgQQ7rPDRt2lQdOnRQQECAjh07pp07d1rPm8zMTN17771KT0/XQw89VKb2Jk2aZL1DjK+vr7p3764GDRooNzdXv/32m44ePWote/bsWY0dO1a7du1y+RQ5SZo+fbrDHyre3t7q3r27GjdurEuXLmn37t06c+aMdf/vv/+uvn37av369dfEHet2795tt13aa0pMTNSQIUMcjgsLC1PXrl1Vu3Ztpaen67fffrP7mV64cKEuXryoH3/8sdg/Oj/44AO99NJLds/5+/urc+fOatiwoQICAnTp0iWdO3dO+/btc8sdkQzD0B133KGlS5faPV/0GrJ582alp6crPj5ew4YN0+OPP+7yvlyposFb4RTd0NBQBQQEKCUlRfv377f7PiUlJWnYsGHasmWLOnXq5JJ+XC2fUaX55JNP9MADDzi8r126dFHz5s2Vm5ur33//XTExMdZ9p06dUv/+/bVixQp169bN6bYSExM1cuRI69TRoKAg9ejRQ+Hh4UpOTtZvv/3mmhdVjKlTp+qFF16we+6pp57SK6+84tJ2xowZo86dO1uvJ0uWLNG2bdvUvXt3l7ZT1COPPKLZs2fr7NmzkqR33nlHTz31lBo0aODWdssqPDxcN998szUw+vTTTzV69GjTsqmpqfr222+t21eyKLa7z/Xz589r8ODBdp/3khQZGanOnTsrMDBQJ06c0NatW1VQUKCNGzdq3LhxdmvyOSMmJkaDBw92+AdAvXr11LlzZ9WqVUupqanasWOH9VyQLv9DKS0tTR988EGZ2kMVVHGDnQBUNq6cqmYYl4edFx0me+zYMdOyzk4DePPNN+3Kde/e3di6dWuJffjqq6+MYcOGGX/961/t9uXm5hqxsbFGbGys8fjjj9vVu379euu+ol/JyckO7dhO8bCdKnbPPfeYTnUq+vquZKpa4bB+X19f46WXXjIyMjLsyl+6dMl47rnnHKbYvPPOO8W2YRjunap26tQpIzY21vjqq6/syr7yyivFvu9nz551qKcs00cyMjIcpos1b97cWLFihUPZmJgY4+abb7Yr6+/vb+zZs6fE125bPiwszDok/B//+IfpefPdd985TMt4++23S2yjPFatWuXws3jnnXcacXFxduUKCgqMb775xqhXr55d2b59+xp5eXl2ZW1/fmJjY42ePXvaDbk3+x6WZdpfcco7Ve2XX36xO87b27vEKRsFBQUO50CHDh2M77//3igoKHAov3btWqNdu3Z25YubCpeXl2fUrVvXWs7X19eYMWOGkZaWVmxfduzYYUyZMsWIiIgwPZcKleXndu7cuXbli7uGpKenG9OmTTN8fHys00hsj6sMU9X69etn9OnTx3j77bdLnPb522+/GaNGjXL4vpp9T21VxGdUeZw/f9768+bs9bXoeXfgwAGHqaw33HCDcfjwYYf21qxZY7Rq1cqubIsWLYxLly4V28eiP8OFn5nBwcHG3LlzHaYo5eXluWQqr9lUtb/97W92z0kynn322Stqx2yqWqFly5bZ7bvxxhuLrccVU9UKvfHGG3b7HnrooWLrqaipaoZhGAsXLrS7HiUmJpoe//7779udP4XnW1mnqrn7XDcMw7jjjjvsjqlTp46xaNEihymQZ86cMW6//XZruaLX2ZJkZWUZnTp1sivfr18/Y8OGDabllyxZYkRGRtqV/+KLL0psoyzXY1ybCI4AWLk6ODIMw4iIiLCrc+3atablnP2l3PYPubCwsBL/gCoqMzOz2H3lXSunkNnaIE8//bTTx19JcCRdXi9hwYIFJbbx0Ucf2R1Ts2ZN4+LFi8WWL+8vCa5Yr8lZZfm+vfjiiw6/8J07d67Y8vn5+cbYsWPtjunTp0+J/SnP9+Wnn35y+EPTlfLz842WLVvatfHYY4+VeMyRI0fsgg1JxnvvvVfiMVcSEJRFeYKjEydOOPyM3nrrrSUe88477zj8gVc0UCkqJSXFuO6666zHBAQEGOfPn3cot3nzZru6X3zxxVJfQ6Hs7OwS11xx9uc2JSXFbq0NZ87VL774wuEclypHcHT8+PEy1f3oo4/a1f/DDz+UWL6iP6PKo7zX18GDB9sdd9tttzkEx7bOnz9vtG7d2u6Yf/7zn073S7q89s727dvL+hLLpGhw1LdvX4d+lGXds+KUFBwZhmH06tXLbn9x68y4MjjKzs42GjVqZN3n6+trxMTEmNZTkcFRVlaWXWBSXNvXX3+9tcx9991nfb6swZG7z/U1a9bYlQ0LCzMOHDhQYp8eeugh0+tsSZ5++mm7svfff3+Jr8MwDOP06dN24VH9+vWNnJycYsuX5XqMaxNrHAFwq5CQELvtxMTEK6rPdr2VgQMHOtRfEmfWM3GVzp07a/r06R5r77777tPtt99eYpkJEybYDfu+ePGiPv/8c3d3rVLIzc3V3LlzrdsWi0WfffaZ6tSpU+wxXl5e+vDDD1W/fn3rcxs3btT27dudbnfixImlfl9uuukmu7vH7NixQ+np6U63UZoff/xRR44csW536NBB//rXv0o8pkWLFnrrrbfsnvv3v//tsj55Qlpamnbu3Klp06apc+fOdsP3a9asWeI0lPz8fM2aNcu6XbduXS1cuFDVqlUrsc2aNWvq888/t04BzcrK0nvvvedQrui6UbfddptTr0mS/Pz8XLLmyueff2631oYz15C77rpLd9999xW37Q6NGzcuU/lXXnlF9erVs24vWLDAJf24Wj6jirNv3z6tXLnSul23bl3NmzevxLs91a5dW5999pndefnee+8pKyvL6XZfeOEFRUVFla/T5fTrr7/abb/22mv65z//6fZ2i/5u8Oyzz7q9TT8/P+vd1aTLn4m2ay5VFv7+/nbXIdt1jArFxsZqw4YN1u3yTlPzxLn+5ptv2m2/+uqratOmTYn9+ve//12mOy2mpqbq7bfftm537NhR77//fql3aIuMjNS7775r3Y6Li7MusQCYITgC4FZFf2kuaUHesjp//rzL6nK1J554wmO3e5bk9CKbtr84Sir3os9Xm9WrV9stUnvzzTerV69epR5XdGFRSWUK24oeW5xhw4ZZHxcUFLh0TY+i3+MpU6bIx6f0JQ5Hjx5td+vh33//3WGtn8pg7dq1slgsDl/BwcGKiorS888/r+TkZGv52rVr67vvvlOLFi2KrfPnn3/WsWPHrNuTJ09WcHCwU/3p2LGjBg4caN3+7rvvSj2mIq5lZueFM4peQ65W/v7+uvnmm63bW7ZscXkblfkzqjhFz4v/+7//U82aNUs9rnv37ho5cqR1OzExUT/99JNTbQYGBupPf/pT2TrqBq4IZJ0xePBgRUdHW7fXrVunX375xe3tjh8/Xi1btrRuf/HFFzp48KDb2y0r2yBo27ZtDn387LPPrOuCNWzY0O56WxbuPtfT09O1ZMkS63ajRo00fvz4Uuv39/d3+ncH6fLvJLZr4E2dOtWpz3hJuuWWW9SsWTPrtjOfV6i6CI4AuFVpdwoqq9atW1sfb9iwwWFR18pixIgRHmura9euTv936rrrrrP7b9eOHTuqxB3WNm7caLd95513On3snXfeabeIeNG6itOyZUunvy9F/wPpyj84bftbvXp1u194S3PXXXcVW9fVJjQ0VE8++aQOHDigfv36lVh29erVdttjxowpU1vXX3+99fGOHTsc7rBmex2TLocxrgzVS5OTk6OdO3dat8tyDWnVqpVdoFjZ5ebmKikpSSdPntTx48ftvmrUqGEtd/jwYZd8Xl0tn1HFuZJrZXmvF4MGDbL7XniK7Ygz6fI/fGxHYLhT0VFHnrjDmo+Pj6ZOnWrdzs/Pr5RBcJ8+feyC/aKjjmy377777nIHfu4+17dv367c3Fzr9pgxY5y+IcnYsWOdfl22n1cBAQG65ZZbnDqukO3nVdFReIAtgiMAblX0tqOlTfUozbhx46yP8/Pzdeutt2r06NH69ttvXXqL6ivRqFEjhYaGeqy9st6RxbZ8dna29u3b5+ouVTo7duyw2+7Zs6fTx9apU0dNmza1bu/evbvEW7IXatu2rdNtFP0vp6vuoHXhwgW7KVqdOnUq03SYoqOyir6PV5P09HT5+fmpVq1apZa1/eU5MDBQhmE4hA4lfRXeUlq6HNIUvSV7x44d1a5dO+v2+vXr1bp1a02fPl0HDhxwwast2b59++zCrCu5hlQ2Fy5c0DvvvKMRI0aoUaNG8vPzU1hYmBo3bqymTZvafdlOIykoKHDJz93V8BlVEtuf8Xr16qlhw4ZOH1ve60VFBZHvvfeeQ58ffvhhffzxx25vu2/fvho6dKh1e+vWrR4JGe+88061b9/eur1o0SLt2bPH7e2W1T333GN9/MUXX1hHGP366692dze79957y92Gu89123BeKtt1s1atWk6H+bafV40bN1Z8fHyZPq9sfy8/deqUy//hi2uHc+PYAKCcUlJS7LbDw8OvqL4xY8Zo+PDh1uG0hmFo8eLFWrx4sXx8fBQVFaW+ffuqf//+GjBgQJnWl3CVK32NZVWWufCSHKboJCQkuLI7lZLtCB6LxVLiNCUzrVu3tk5dys3N1cWLF0sNB50Z8l7INmgobMMVio5csp2m4IyiI2Mq49Sbnj17av78+XbPXbx4USdOnNCKFSv0wQcfKDMzU9nZ2ZoxY4ZiY2P15Zdflvif39OnT1sfX7p0yS44LI+kpCS7OiwWi959910NHjzYOuLv1KlTmjJliqZMmaKIiAj169dP119/vaKjo3XdddddUftFnTt3zm77Sq8hlUFBQYH+9a9/6YUXXih3QJOamnrFnxlXw2dUcbKysuzeu7JeLxo2bKhq1apZR885e73w9GdmocDAQP30008aPHiw9Q9/wzD0xz/+Uf7+/mUagVIe06dP148//mjdnjJlikaMGOH0qJTy8PLy0gsvvGBd79AwDD377LNatmyZ29osj3vvvVfTpk2TYRg6efKk1qxZo4EDB9qNNoqKirIL4MvCE+e6K66ztusTmsnPz1d8fLx1+9ChQ1f0eWUYhpKTkxUWFlbuOnDtYsQRALdJTk52CCXK8h8dM15eXvr666/1xBNPOMzhzsvL05YtW/Taa6/p1ltvVZ06dTRixAitWLHiitosq8DAQI+25+zaK4WKBhpFw71rke1rrFGjRpmHthd9z2zXzCmOp9bLKEnR7+2VnivOvG5PCwgIUJMmTey+OnXqpJEjR+rf//63jhw5YvfHxfz58zVz5swS60xKSnJpH82CjH79+mnNmjWmC6XGx8dr0aJFevzxx9WpUyc1bdrUYa2mK+Hq86KiFf6x/7e//e2KRvW44j/tV8NnVHGu9LyQ7M8NZ89XT39m2qpZs6Z++eUXu3C2oKBA9913nxYvXuzWtrt27Wq3MP7evXv1n//8x61tSpcX4+/atat1+7vvvnPLGl9XolmzZurbt691+9NPP1V2drbd+1PeRbElz5zrnrjOJicnW0djucrVMDISFaPif6sFcM3aunWr3QdacHBwme98Y8bPz0+zZ8/W4cOHNWXKFHXu3Nn0j/Tc3Fx99913GjJkiEaPHq20tLQrbhvA1SUyMlLLli2z+6V96tSpJU4Jc9WIr0LF/WLfu3dv/f777/r66681ZsyYYkexHT9+XNOmTVPz5s0r3ciAyuDTTz+1m15ksVh044036s0339SmTZt06tQppaWlKS8vT4ZhWL9s13txJT6jri6hoaFasWKF3fTivLw8jRs3zu2LBb/wwgt258bzzz/v1FToK2GxWPTiiy/aPeeJO7uVlW0w9PXXX+urr76yhjG+vr5uHxF2NXD1Z5VU/OcVQHAEwG1WrVplt92rVy+XDsFu2rSpXnjhBe3atUuJiYn64Ycf9PTTT6t79+4O7SxevFhjx451WduVSVnX5Si67pSrp0pUxvnxtq8xPT29zH0s+p45s05OZVD0e3ul58rV8rqLatasmV544QXrdk5Ojv7v//6v2PK2AU6dOnXswobyfNneQakob29v/eEPf9DChQuVmJiovXv36p133tGdd97pECQlJydr9OjRWr9+ffnfDLn+vHCHsvyM2v4R7O3trcWLF+vnn3/WpEmT1KtXLzVo0ECBgYEOd7p0d1BztX1GXel5IdmfG1fT9SI8PFwrV660m7KUm5urMWPGuPWOZx06dLBbF+vgwYP67LPP3NZeoWHDhqlPnz7W7RUrVmjt2rVub7csbr/9duuafGlpafrrX/9q3XfzzTdf0RRHT5zrnrjOFv2M6NGjxxV/XjVp0qRM/UTVQXAEwC2ysrL00Ucf2T1X1js9lEWtWrU0dOhQzZgxQ1u3btWJEyf05JNP2v2h8PPPP9utJ3CtsF0o0hlHjx61265Tp45pOdv3Li8vz+n6K+PUN9tfMA3DKPN7dvjwYetjX1/fSjdVpzhFf7Eu+r0vje3rNqvvavKXv/xFjRo1sm7/9NNP2rBhg2lZ25+JpKQkj4WhFotFHTt21J/+9Cd9+eWXSkhI0JIlS+wWs83NzdVTTz11Re3UrVvXbvtKryElsZ2u5Y7ryKFDh+z6P2HCBN16661OHWu7Noi7XQ2fUQEBAXbTxsp6vTh9+rTd3QGvtutFvXr1tHLlSrs/nLOzs3XrrbdqzZo1bmv3+eeft/s5eeGFF9wykqSoond2q2yjjmrWrGl3F1Dba8KVTFOTPHOue+I66+/vbzeaNjExsUxtAGVBcATALd555x27DzB/f3+H25e6U8OGDfXqq69q2rRpds8XN83DnYtRutu2bdvKXd7f39/uj1Jbtr+MlCUM2r9/v9NlPfW+R0VF2W2XZT2H8+fPWxfGli7fAajoyIXKqvBuUoX27NnjcGv4kmzevNluu+j7eDXx9fXVP/7xD7vnil4fCtneMScvL8/h7jie4u3trZEjR2r16tV2tw7funWrw8KrZdG+fXv5+/tbt6/kGlIa2+tIWUYqOXsdKfrH1U033eR0G0XPb08q62eUp9j+jMfFxdktFF+aa+F60bBhQ61atUoNGjSwPpeZmakRI0aY3nLdFVq2bGkXhMTGxurDDz90S1u2Bg4cqEGDBlm3N2zYoJ9++snt7ZaFWUBUq1YtjRgx4orrdve5bruOlFS262ZycrLTQZPt51VsbGylvIkFrg0ERwBcbteuXXr66aftnps4caJq167t8b6MHz/ebvv48eOm5Wz/iJJkvdPR1WDnzp1O/7ds7969OnjwoHU7KipKfn5+pmVt/4Nme0xpfv75Z6fLeup9tx2SL0kLFixw+tivvvrKbs5/7969XdYvT7B97enp6WVas+PLL7+0277aXntREyZMUEREhHV7xYoVpuHBDTfcYLftiQVrSxIeHq5hw4bZPXfixIly1+fn52f3R01ZriGHDx/W7t27nW7L9jpy6dIlp/84c/Y6UjSMcnYB2s2bN9sFwhXF2c8oT7mSa+W1cr1o2rSpVq1aZRfWXrp0SUOHDi1zyOqs5557zu6zePr06crKynJLW7Zeeuklu+0pU6a4vc2yuOmmmxxGRd9+++0OvzuUh7vP9W7dutndMXXRokVOrx+0cOFCp0e62n5eGYahhQsXOnUcUFYERwBcas2aNbr55pvtRjXUq1dPzz//fIX0p+gfEcWFJEWnHnlyCoMrFB1yXhzbdV4k6e677y62bKdOnayPY2JiSr0trCT9+uuvxU7/MeOp933gwIF2fwT88MMP1tsvl+TSpUt65ZVX7J675557XN4/dyo60u+ll15y6hfSb7/9Vrt27bJut2/fXl26dHF5/zzJ39/fYW2joovEStKIESPszpe3335bsbGxbu9fSZy9ljmr6M9+ea8hpbG9jkhyakRDcnKy3n33XafqL7qOSNHplWYKb0FeGbj6+3qlil4vZs+e7dRdlnbu3KklS5ZYt8PCwjR06FCX989TWrZsqZUrV9oFn6mpqbrpppvKFJw6q3Hjxpo4caJ1+8yZM5o7d67L2ymqV69edssIbN++Xd98843b23WWj4+PVq9erfXr11u/ynoNKo67z/UaNWpo1KhR1u2TJ0/qk08+KbX+7OxszZo1q9Ryhe677z5Vq1bNuj1jxgyX3xkUkAiOALhITEyMHn30Ud1www1KSEiwPh8QEKAFCxYoLCzMJe289tprZVrQ9IsvvrDbbt26tWm5os+vXr267J2rQJ9++mmp/2X6+OOP9fXXX1u3a9asWWIIMnDgQLttsz+wbcXFxenee+91orf/06xZM7u1Hdz1vvv6+urPf/6zdbugoED33nuvLly4UOwxBQUFmjhxot0IiV69eql79+5u6aO7DBs2TM2bN7dum40ILOrYsWN6+OGH7Z579NFH3dI/T/vzn/9st5DpDz/84DAVLSAgwO49Sk9P1/Dhw3Xy5MkytbV7925t377d4fmff/65TNOkMjIy9O2331q3fX191axZszL1pah77rnHLrh15hry5ZdfOlxTS1P0OjJr1qwSR1Lk5ORo/PjxTk+36Nixo93222+/XepIjX/+859auXKlU/WXlbs+ozylQ4cOdt+zM2fOaOLEiSWGzRcuXNA999xjV2bixInWhY2vVm3bttWKFSvsFiBOTk7WkCFDtG/fPpe398wzz9gFAEuXLnV5G2ZefPFFu2njnmrXWe3atVO/fv2sX8Wty1hWnjjXJ02aZLf91FNP6dChQyX26/HHHy/Tekh169a1+/3m9OnTuu2228ocHq1bt86p4B1VF8ERgGLl5eXp+PHjdl+xsbHau3ev1q1bp0WLFunvf/+7rr/+erVq1Upvvvmm3W1ka9asqSVLluj66693WZ+efPJJNWzYUA899JB++eUXu8UJbWVmZmrOnDl2d+GwWCzFrrPUvXt3u1/YZs6cqZdeekmbN29WTEyM3XtQ2RZ/DgkJkWEYuvvuu/X//t//c3hP0tPT9fzzz+vBBx+0e37mzJklTusYN26c3Xvy2Wef6cknn3Sov6CgQIsXL1avXr0UGxtbpru0+fv7q2fPntbtNWvW6MEHH9TKlSt15MgRu/f9SkcjTZ482e6PsgMHDqhv376md5KJjY3ViBEjNH/+fOtzfn5+HvkPsKt5eXnp3XfftfvD4JVXXtH48eMd1skxDMP6M2v7fvfu3dvh/LlaBQUF6ZFHHrF7zmy0zSOPPGL3X+T9+/erS5cu+te//qXk5ORi6z958qTeeustDRgwQF26dDENjjZt2qTevXurV69emjNnTomjmfbu3aubbrrJrsyIESOcnpJVnJo1a+rll1+2bpd0DcnIyNCLL76o+++/X1LZ7sTYtm1buzU4jhw5ohEjRujMmTMOZXfu3KlBgwZp2bJlTrfRsGFD9ejRw7p94MABDR8+3HQq37FjxzR27Fjr63bH9Gl3fUZ50ptvvmn3h/D8+fM1fPhw06l969atU9++fXXgwAHrc82aNdMzzzzjkb6623XXXadffvnFLmRNTEzUDTfc4PI/suvVq+cQNHhCly5dNHr0aI+3Wxm4+1yPjo7WHXfcYd2+cOGCBgwYoK+//tohoDp79qzGjRtnHW1Zluvs9OnT1blzZ7u+du7cWe+//74yMjKKPe7w4cN65ZVXFBUVpQEDBlSK6buoxAwA+K/Y2FhDkku+hgwZYhw9etTptqdOnWp3fGxsrGm5ou34+PgYHTt2NIYNG2bcfffdxrhx44x+/foZ1apVcyj7xBNPlNiHP//5z069tqlTpzoc27hxY+v+AQMGOP26C61evdqujXnz5jlddubMmUa9evWs20FBQcaNN95o3HnnncYNN9xg1KhRw+E13HrrrUZBQUGp/XrppZccjg0ODjZuvvlm46677jKGDh1qhIeHW/fVrl3b+Oijj5x+LYZhGPPnz3fqfTd7X509bwrt3LnTCAkJcai7efPmxqhRo4zbb7/d6N69u2GxWOz2WywW4+233y71/bI9Zvz48aWWL1SW7395FX2vJBne3t5Gnz59jHHjxhkjRowwGjRo4FCmfv36RkxMTKn1DxgwwHpM48aNXd7/QkXfq/L8vCUmJtr9XFgsFuO3335zKJecnGz06NHD4T3x8vIyOnXqZIwcOdK45557jNtuu83o37+/Ubt2bYeyc+fOdajX7HtRu3ZtIzo62hg9erRxzz33GCNGjDCaNWvmUC4kJMQ4fvx4sa+tLOdgQUGBMWrUKIc2bK8hQ4YMMQIDA6376tWrZ8yaNcuu/OrVq0tsZ/369Q4/U76+vsb1119v3HnnncaoUaOMli1b2r2/3377rdOvZfny5Q71e3t7Gz179jTuvPNO4w9/+IPRqVMnu/29e/c2/vnPfzp9/agMn1FldSXXlQ8//ND0OhgVFWWMHTvWuPXWW40WLVqYfj5s2bLFbf26ErbXKGfOW1sbN260+zmQZERGRppeG4ueK8uWLXO6nfPnzxtBQUGmn4FPPvlkiceOHz/errzZNa04+/fvN7y8vEzbfeONN5yux1m29UdFRbms3qK/x44ePbrUY9x5rhuGYSQkJBjNmzd3OD4yMtIYPny4MW7cOKNPnz6Gt7e3dd+QIUOM++67z658aY4fP27aT19fX6N79+7Grbfeatxzzz3GqFGjjD59+hg1a9Z0KPvjjz8WW39ZPltwbSI4AmB1pcFRQECA8Yc//KFMv4wVKu8v5c58WSwW44knnjDy8/NL7ENaWprRv3//UuurbMHRvHnzjF27dtkFOCV9jRw50sjOznaqX7m5ucbtt9/uVL0RERHGzp07y/VHwV//+tdS63dFcGQYhrF3716jUaNGZTqvP/nkE6fer/L+YuWpP6ReffVVw8fHx+nX3q5dO6feU8O4uoIjwzCMJ554wq6eO+64w7RcVlaW8eCDDzr8YeHstefLL790qNMsOHLmq1GjRsbu3btLfF1lPQezsrKMESNGONV+nTp1jF27dhnz5s2ze96Za/7rr7/u1Hvo6+tr/Xkry2uZPXu209+jXr16GYmJiWW6flSGz6iyutLryldffWUacBX3FRkZaezcudPt/SqvKwmODMMw1q5da1SvXt2ujsaNGxsnTpywK3clwZFhGMazzz5r+v66MzgyDMO45557TNu91oMjw3DfuV7oxIkTduF4SV89evQwkpKSHL6fzkhOTjZGjhxZruuQj4+PsX79+mLrLsv1GNcmpqoBKBMvLy9Vq1ZNERER6ty5s2677TY988wz+v7775WQkKCvv/5a0dHRbmt/w4YNmjx5slO3RPfz89PIkSP166+/avbs2fLyKvmSFxgYqNWrV2vx4sW666671K5dO9WsWdNuDZ7KqnPnztq9e7cmTJig6tWrm5Zp3LixPvzwQy1ZssTpBVh9fHz01Vdfac6cOcVO6wgMDNRDDz2kPXv2lHvx5Ndee01btmzRpEmT1L17d4WFhbltkdiOHTvqwIEDevHFF1W/fv1iywUGBmr8+PE6dOiQ6S2Br0ZPPvmkfvvtN40ZM6bE9UeaNm2qOXPmaPfu3WrSpInnOuhBTz31lN05tnDhQtO1J/z9/fX+++9r9+7duvPOO0udIubt7a2ePXtq2rRpiomJ0Z133ulQ5pFHHtEHH3yg2267zanpUs2aNdP06dN14MABh8Wmr5S/v7+WLl2qDz74QI0aNTItU716dU2YMEG7d++2mw5RFo899pi+//57tW/f3nS/l5eXhg0bpi1btpTr5+2JJ57QTz/9VOL706JFC82aNUvr1q1z2bp7RbnzM8rTxo0bpyNHjuiPf/yjgoKCii1Xr149TZ06VYcOHbrqF9AvSf/+/bVkyRK7a+eJEyc0aNAgxcXFuaydp556ym4dNk95/vnnr4rfd9zB3ed6o0aNtHv3bk2ePLnYz5DCG8msW7eu3N//kJAQLVmyROvWrdPw4cPtlhsw4+fnp+joaL3yyis6deqU+vXrV652UTVYDMPJ+wICQCWTlpam33//XTExMUpISFBGRob8/f0VEhKi1q1bq0uXLiX+AnCtSktL07p163Tq1CklJyerTp06at++vXr27Gm3zk1Z5eXladOmTdq/f7+SkpIUEhKiRo0aacCAAQoMDHThK/Cs3bt367ffftP58+eVk5Oj8PBwNWvWTH379q3wOxy5U0ZGhtavX6+TJ08qMTFR1apVU506ddSlSxe1bdu2ortXaeXl5Wn79u06cuSILly4oPT0dNWoUUOhoaFq3bq12rVrV+brztGjR3Xo0CGdPHlSFy9eVH5+voKCglS/fn116tRJLVu2dNOrsWcYhjZv3qz9+/crISFBoaGhatCggfr37+/Sa+m+ffu0detWJSQkyN/fXw0bNlSvXr0UGRnpsvq3bNmi8+fPy9fXV/Xq1VOrVq0UFRXlkvqddS19RuXm5urXX3/VsWPHdP78efn4+Fg/W7p06XJFny1AZeLucz0rK0urV69WbGysUlNTFRERoaZNm6pfv36lhs1llZ2drc2bN+v48eNKTExUVlaWAgMDFR4erjZt2qht27alhktAIYIjAAAAAAAAmKpcY2IBAAAAAABQaRAcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEz5VHQHUHUYhqGCgoKK7kal4O3tLUnKz8+v4J6gsuCcQFGcEyiKcwJmOC9QFOcEiuKcqFq8vLxksVhcWifBETymoKBA586dq+huVDgvLy9FRERIks6fP0+YBs4JOOCcQFGcEzDDeYGiOCdQFOdE1VO3bl1rWOgqTFUDAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmPKp6A4AAABUBfkTR5b/WEmnXNcVp3m/v7QCWgUAAJUJI44AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgyqeiO1CZxMTEaNeuXTp48KBOnz6t1NRUeXt7KzQ0VK1bt9agQYPUpk0bp+vbtWuXVqxYoZiYGKWmpio4OFjNmzfXDTfcoC5dujhVR35+vlauXKkNGzbozJkzysrKUmhoqDp27KihQ4eqYcOGTtWTmpqqH3/8Udu2bdP58+clSeHh4erevbuGDRumoKAgp18XAAAAAACoGgiO/mvq1Kk6cOCAw/N5eXk6e/aszp49qzVr1qh///7685//LB+f4t+6goICvffee1q1apXd80lJSUpKStK2bds0aNAgPfTQQ/LyKn7QV2pqqmbMmKGYmBi758+dO6dz585p7dq1euCBBzR48OASX9uRI0f0yiuvKCUlxe75kydP6uTJk1q1apUmT56sFi1alFgPAAAAAACoWgiO/ispKUmSVKtWLfXu3Vtt2rRR7dq1VVBQoMOHD+u7775TUlKS1q1bp/z8fD3++OPF1jV//nxraNS0aVONHDlSdevW1blz57R06VLFxsZq1apVCg4O1l133WVaR0FBgV599VVraNSjRw/dcMMNCgwM1JEjR7R48WJdvHhR7733nkJDQ4sdwZSYmKiZM2daR0/dcsstioqKkiTt2LFD33//vZKTkzVz5ky9/PLLCgsLK/d7CAAAAAAAri0ER/8VGRmpO++8U7169XIYBdSqVSv1799fU6ZM0dmzZ/Xrr79qyJAhateunUM9cXFxWrZsmSSpefPmmjZtmvz8/CRJLVq0ULdu3fT8888rJiZGy5Yt06BBgxQREeFQz5o1a3Tw4EFJ0o033qgHH3zQuq9Fixbq0qWL/v73vyszM1Pz5s3TddddJ29vb4d65s+fr9TUVEnSY489pt69e1v3tW3bVs2aNdOcOXN08eJFzZ8/X5MmTSrrWwcAAAAAAK5RLI79X08//bT69OlT7NSx4OBg3XfffdbtzZs3m5b74YcflJ+fL0maMGGCNTQq5O/vrwkTJki6vH7Rd999Z1pPYfgUGBioe++912F/RESEbrvtNklSfHy8tm7d6lAmJSVF69evlyR16tTJLjQq1KdPH3Xq1EmStG7dOofpbAAAAAAAoOoiOCqD9u3bWx+fO3fOYb9hGNq2bZukyyOYWrVqZVpPq1atVL9+fUnS9u3bZRiG3f64uDidOXNGktS7d2/5+/ub1hMdHW19bBYc2dY9cODA4l6WtR7DMLR9+/ZiywEAAAAAgKqF4KgM8vLyrI/NRiYlJCQoOTlZ0uVpYCUpnOaWlJRkvctZocIparblzISEhKhevXqSpEOHDjnsd7Ye2322xwAAAAAAgKqNNY7KYP/+/dbHkZGRDvtPnz5d4n5bhSOOCo+rU6dOueqJjIzU2bNndeHCBWVlZSkgIMChnurVqyskJKTYOmrVqqVq1aopMzPTOtLJWRcuXCi1TEhIiHX9pZLuIldV2L4HvB+QOCfgiHPi2pRf0R0oB86/yo1rBYrinEBRnBNwBYIjJxUUFOjbb7+1bvfp08ehjG2IUtrdyWrXrm16nPS/O7xJUmhoaIn1FLZjGIaSkpLsAqnCep25U1rt2rV16tQpp4IgWw8//HCpZebOnauwsDB5e3ubLgReldkGhoDEOQFHnBPXjlMV3YFy4HP76sG1AkVxTqAozgmUF5Gjk77//nsdPXpUktSjRw81a9bMoUxWVpb1se3IHzO26xbZHidJmZmZLqmncLu0OmzrKVoHAAAAAACouhhx5IT9+/fryy+/lCTVrFlTEydONC2Xk5NjfezjU/Jb6+vra3qcJOXm5rqknsLt0uqwradoHaWZO3duqWUKp8nl5+c7rOdUFXl5eVnT/oSEBBUUFFRwj1DROCdQFOcEKov4+PiK7gJKwLUCRXFOoCjOiaonPDzculSMqxAcleLUqVN65ZVXlJ+fL19fX/31r39VzZo1Tcv6+flZH9supG3GNhyyPU6yD4Py8vIc9jtbj5+fn7Kzs0vti209JbVlxplpcLa4UNkrKCjgPYEdzgkUxTmBisS5d/XgWoGiOCdQFOcEyoupaiVISEjQ9OnTlZ6eLi8vLz3xxBMl3p3MdkpYaVO+srOzTY+TpGrVqrmknsJtZ6afFdbjzLQ2AAAAAABQNRAcFSMpKUkvvviikpOTZbFY9PDDD6t79+4lHmM7+qa0RaYTExNNj5PsF8S2XSjbTGE7FovFYSHtwnqdWfC6sD9lHUEEAAAAAACuXQRHJlJTUzV9+nSdO3dOkjRhwgQNGDCg1OMaNGhgfVzabe3j4uJMjytrPYX7w8LCHEYLFdaTkZGhlJSUYutITk62LsgdGRlZYnsAAAAAAKDqIDgqIiMjQy+99JJOnz4tSbrrrrt08803O3VsnTp1VKtWLUnSgQMHSixbuD80NFTh4eF2+9q0aWN9vH///mLrSElJ0dmzZyVJrVu3dtjvbD22+2yPAQAAAAAAVRvBkY3s7GzNmDFDsbGxkqQ//OEPuvXWW50+3mKxWKeznTlzRocPHzYtd/jwYetIoW7duslisdjtr1+/vnXkz6ZNm+zWMbK1Zs0a6+MePXo47Lete/Xq1cX2u7Aei8Wibt26FVsOAAAAAABULQRH/5WXl6dXX31Vhw4dkiQNGzZM48aNK3M9w4YNk5fX5bd13rx5Dre3z8nJ0bx58yRJ3t7euuWWW0zrGTFihCTp0qVL+vzzzx32x8fH65tvvpEkRUREmAZHISEhuv766yVJe/bs0ebNmx3KbNq0SXv27JEk9e/fXyEhIc68TAAAAAAAUAX4VHQHKos5c+ZYA5QOHTpo0KBBOnnyZLHlfXx8VL9+fYfn69evr5EjR+rbb79VTEyMpkyZolGjRqlu3bo6d+6clixZYh3RNGLECNWrV8+0/ujoaK1evVqHDh3Szz//rJSUFA0ePFiBgYE6evSovv76a2VmZspisWjChAny9vY2rWfcuHHavXu3UlNT9frrrysmJkZRUVGSpB07dui7776TJAUHB5crKAMAAAAAANcui2EYRkV3ojK4/fbby1Q+PDxcb731lum+goICvfvuuyVODxs0aJAeeugh6+gkM6mpqZoxY4ZiYmJM9/v6+uqBBx7Q4MGDS+zrkSNH9MorrxS7QHZISIgmT56sli1blljPlcrPz7cuOF6VeXl5KSIiQtLlkWMFBQUV3CNUNM4JFMU5cW3KnziyortQZt7vL63oLqAEXCtQFOcEiuKcqHrq1q1b7MCS8mLEkRt4eXnp4YcfVs+ePbVixQrFxMQoLS1NQUFBat68uYYMGaIuXbqUWk9wcLCmT5+ulStXasOGDTpz5oyysrIUGhqqDh06aNiwYWrYsGGp9bRs2VKvvvqqfvjhB23btk3nz5+XdHkx727duumWW25RUFDQFb9uAAAAAABwbWHEETyGEUeXkfqjKM4JFMU5cW1ixBFcjWsFiuKcQFGcE1WPO0YcsTg2AAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwJRPRXfATG5urg4fPqyLFy8qODhYrVu3lq+vb0V3CwAAAAAAoErxWHCUl5endevWSZJCQkLUtWtX03KbN2/Whx9+qNTUVOtz1atX17333qtBgwZ5pK8AAAAAAADwYHC0d+9evfvuu5KkcePGmQZHBw8e1Ouvv66CggK75zMyMqzHEh4BAAAAAAB4hsfWONq7d6/1cd++fU3LfPLJJ9bQyMfHR02bNlVISIh1/6effmo3EgkAAAAAAADu47ERR7GxsZKkOnXqqE6dOg77jx8/rmPHjkmSateureeee05169ZVQUGB3nnnHa1du1aZmZlat26dhg8f7qluAwAAAAAAVFkeG3GUkJAgSWrYsKHp/h07dlgf33777apbt64kycvLS/fdd598fC5nXLYjlwAAAAAAAOA+HguOLl26JEkKDg423b9//35Jl6eo9ezZ025fYGCgWrduLUk6deqUG3sJAAAAAACAQh4LjvLy8iTJOnLIVkFBgY4ePSpJatasmQICAhzKhIaGSvpfAAUAAAAAAAD38lhwVBgGmQU/x48fV1ZWliSpTZs2psf7+flJkvLz893UQwAAAAAAANjyWHAUFhYm6X+LZNvauXOn9XFxwVFh4FStWjU39A4AAAAAAABFeSw4atGihSQpPj5ee/bssT6fk5OjVatWSbo8ja1t27amx585c0bS5TuuAQAAAAAAwP0cFxxyk379+mn16tWSpNdee03Dhg1TcHCw1q1bpwsXLkiSunbtqurVqzscm5GRobi4OElSgwYNPNVlAAAAAACAKs1jwVGHDh0UFRWlHTt2KCsrS4sXL7bviI+PxowZY3rs9u3bVVBQIElq2bKl2/sKAAAAAAAAD05Vk6THH39c3bp1c3je399fkyZNUuPGjU2PW7lypfXxdddd57b+AQAAAAAA4H88NuJIuhwQTZ48WSdOnNCBAweUmZmpsLAwde3aVYGBgabHpKWlqW7duqpbt64CAgJUv359T3YZAAAAAACgyvJocFSocePGxY4uKiooKEh/+ctf3NwjAAAAAAAAFOXRqWoAAAAAAAC4ehAcAQAAAAAAwBTBEQAAAAAAAEy5dI2jRYsWubK6Yo0ZM8Yj7QAAAAAAAFRlLg2OFi5c6MrqikVwBAAAAAAA4H5MVQMAAAAAAIApl444YiQQAAAAAADAtcOlwdHYsWNdWR0AAAAAAAAqEFPVAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmXLo4dlllZWXp+PHjSktLU2ZmpgzDcOq4AQMGuLlnAAAAAAAAqJDgaMOGDfrxxx8VExPjdFhUyGKxEBwBAAAAAAB4gEeDo5ycHL322mvatWtXuesoa9AEAAAAAACA8vFocDR37lxraOTr66v27dsrISFBcXFxki5PQcvMzFRiYqJOnDih/Px8SVJAQIB69Oghi8Xiye4CAAAAAABUaR4Ljo4cOaKNGzdKkiIiIvTss88qPDxcH330kTU4+stf/mItn5GRoZUrV2rRokXKyspSamqqnnjiCVWrVs1TXQYAAAAAAKjSPHZXtbVr11ofP/zwwwoPDy+xfPXq1TVixAi9/PLLqlWrlnbv3q23337b3d0EAAAAAADAf3ksODp48KCky6ON2rRp4/Rx9erV06RJkyRJW7du1c6dO93SPwAAAAAAANjzWHCUnJwsSWrSpEmxZfLy8kyf79ixoxo0aCBJWrduncv7BgAAAAAAAEceC44yMjIkSUFBQXbP+/n5OZQx07RpU0lSbGysG3oHAAAAAACAojwWHPn7+0tyHFVUo0YN6+PExMRS6ykcuQQAAAAAAAD38lhwFBYWJkm6dOmS3fP16tWzPj58+HCxx58+fdo9HQMAAAAAAIApjwVHjRo1kiTFxcXZPd+iRQvr4xUrVig/P9/h2D179linqNWtW9eNvQQAAAAAAEAhjwVHbdu2lXQ5OLIddVS7dm3rXdZOnTqlWbNmKTY2Vnl5ecrIyNC6dev073//21o+KirKU10GAAAAAACo0nw81VDXrl314YcfyjAM7dixQwMGDLDuu/vuuzVlyhRJ0u7du7V7927TOoKDgzVs2DBPdBcAAAAAAKDK89iIo9q1a2v48OHq3bu3UlNT7fa1atVKf/rTn+TlVXx3goODNXnyZAUHB7u7qwAAAAAAAJAHRxxJ0r333lvsvkGDBqlVq1b6/vvv9fvvvys5OVkWi0V169ZVVFSUbrnlFkIjAAAAAAAAD/JocFSaBg0a6E9/+lNFdwMAAAAAAADy4FQ1AAAAAAAAXF0IjgAAAAAAAGCqUk1Vq2gXL17U0aNHdfToUcXExCgmJkZpaWmSpAEDBmjSpEml1rFmzRq9/fbbTrX3l7/8RdHR0SWWyc7O1k8//aTNmzcrPj5eeXl5CgsLU9euXTV06FCFh4c71db58+f1448/aufOnbpw4YJ8fHwUERGh3r1766abbpK/v79T9QAAAAAAgKqD4MjGxIkTK7oLduLj4zVjxgydPXvW7vm4uDjFxcVp5cqVeuyxxxQVFVViPdu3b9cbb7yhzMxM63PZ2dnWcGzlypX6xz/+oYiICLe8DgAAAAAAcHXyWHB0xx13uKQei8Wi+fPnu6SuktSuXVuRkZHas2dPuet45plnVKtWrWL3h4WFFbsvMzPTLjQaPHiw+vbtKz8/P/3+++/69ttvlZmZqTlz5ujFF19UkyZNTOuJjY3VnDlzlJOTo4CAAN16663q0KGDcnJy9Ouvv2rlypU6e/asZsyYoZdfflnVqlUr9+sFAAAAAADXlqtuxJFhGG6re8yYMWrevLmaN2+ukJAQJSQk6JFHHil3ffXq1VOdOnXKdezSpUutodE999yjkSNHWve1atVK7du31/PPP6/s7Gx9/PHHev75503r+fjjj5WTkyNvb289++yzatWqlXVfhw4dVK9ePX3++ec6e/asli1bpttvv71c/QUAAAAAANceFse2cfvttysqKkohISEV2o+8vDz9+OOPkqTIyEgNHz7coUzr1q01cOBASdL+/ft19OhRhzJHjx7VgQMHJEkDBw60C40KDR8+XJGRkZKkH3/8UXl5eS57HQAAAAAA4OrmsRFHCxYscKqcYRjKyMjQyZMntXHjRq1atUoWi0UPPfSQ+vfv7+ZeVg779u1TRkaGpMuLcnt5med70dHRWrFihSRp69atatGihd3+rVu3Wh8XhkxFeXl5acCAAfryyy+Vnp6uffv2qVOnTq54GQAAAAAA4CpX6UYcWSwW1ahRQ23bttUf//hHTZ8+XQEBAXrrrbe0fPnyiu6eRxw8eND6uF27dsWWa968ufVuaIcOHXLYX/icv7+/mjVrVmw9tm2Y1QMAAAAAAKqmSr/GUdOmTTVp0iS9/PLL+vjjj9WuXTvr1KrKbu7cuYqLi1NqaqqqV6+uiIgIdezYUTfeeKNCQ0OLPe706dPWxyW9Vm9vb0VEROjEiRM6c+ZMsfVERETI29u72Hrq169v2jYAAAAAAKjaKn1wJEldunRR/fr1FRcXp19++UUTJkyo6C45Zd++fdbHaWlpSktL05EjR7Rs2TLdf//9GjJkiOlxSUlJki6PFKpRo0aJbYSFhenEiRNKTU1Vbm6ufH19JUk5OTlKS0uzlilJYGCg/P39lZ2drQsXLjj9+iQ5VT4kJMQaXBU37a4qsX0PeD8gcU7AEefEtSm/ojtQDpx/lRvXChTFOYGiOCfgCldFcCRdnpYVFxenvXv3VnRXSlW3bl316NFDrVq1soY2CQkJ2rx5s7Zs2aLc3Fy9//77slgsuuGGGxyOz8zMlCQFBASU2lbhVDVJysrKsgZHWVlZ1uedqScgIEDZ2dl2xznj4YcfLrXM3LlzFRYWZh0hhf8p7133cO3inEBRnBPXjlMV3YFy4HP76sG1AkVxTqAozgmU11UTHBUGImUdEeNpPXr00IABA2SxWOyeb9Gihfr06aMdO3bo1VdfVX5+vj755BN169bN4S5uubm5kiQfn9K/PYXvi3R5lJHZY2fqKSxjexwAAAAAAKjarprgKC4uTpIcApnKpnr16iXuj4qK0pgxY7RgwQJlZ2dr1apV+sMf/mBXpjAMysvLK7W9wpBJkvz8/EwfO1NPYRnb45wxd+7cUssUBmP5+fk6f/58meq/Fnl5eVnT/oSEBBUUFFRwj1DROCdQFOcEKov4+PiK7gJKwLUCRXFOoCjOiaonPDy8xDWOy+OqCI4OHjxovdPYtTC87oYbbtB//vMfGYah/fv3OwRH1apVkySnpo1lZ2dbH9tOSbN97Ew9hWWcmdZmq7T1k4riQmWvoKCA9wR2OCdQFOeEufyJIyu6C1UC597Vg2sFiuKcQFGcEyivSr06VnZ2tlasWKFZs2ZZn4uKiqrAHrlGzZo1FRgYKOl/C2HbKrzjWnZ2ttLT00usq3DqXnBwsN20NT8/PwUFBdmVKc6lS5esAVRZgyAAAAAAAHDt8tiIo2nTpjldtqCgQGlpaYqPj1d+/v/uQRIcHKzhw4e7o3seV9KUuwYNGmjLli2SpDNnzqhVq1am5fLz861DyCMjI03rOXDggPV9LG64WuE0wMJjAAAAAAAAJA8GR/v377+i42vVqqW///3v1pE6V7PU1FSlpaVJuvy6imrTpo318f79+4sNjmJiYqwjhVq3bu2wv3Xr1jpw4ICys7N17NgxtWzZ0rQe2++NWT0AAAAAAKBqqtRT1aTLI2nuuOMOvfbaa2ratGlFd8clVqxYIcMwJEnt2rVz2N++fXvrIttr1661li1qzZo11sc9evRw2G/73OrVq03rKCgo0Nq1ayVJNWrUUPv27Z17EQAAAAAA4JrnsRFHU6dOdbqst7e3qlWrpvDwcOtC0VeDhIQEpaenlxhw7dixQ4sWLZJ0eR2igQMHOpTx8fHR0KFD9fXXX+vMmTNatmyZRo60XwT08OHD1jCoXbt2atGihUM9LVq0UNu2bXXgwAGtXr1a0dHRDqOXvvvuO505c0aSNHToUPn4XBXrpQMAAAAAAA/wWEpgNrKmsjl48KDdbWdTU1Otj+Pj4+1G+EhSdHS03fb58+c1bdo0tWrVSlFRUWrcuLFq1qwpSTp37pw2b96sLVu2WEcQ3XvvvdaFsIsaOXKkNm7cqLNnz+rzzz9XfHy8+vTpIz8/P+3bt0/ffPON8vPz5efnp/vvv7/Y13T//fdrypQpysnJ0fTp03Xbbbepffv2ysnJ0caNG7VixQpJUr169TRixAhn3yoAAAAAAFAFMLzExsqVK63Ttoo6dOiQDh06ZPdc0eCo0OHDh3X48OFi2/H399f48eN1ww03FFumWrVq+sc//qEZM2bo7NmzWrFihTXksS3z2GOPqUmTJsXW07RpUz3xxBN64403lJmZqa+++sqhTL169fSPf/zjqhrdBQAAAAAA3I/gyIWaNWumRx99VIcPH9axY8eUnJystLQ05efnq0aNGmrYsKE6dOigwYMHW0cilSQiIkIzZ87Uzz//rM2bNys+Pl55eXkKCwtTly5dNGzYMIWHh5daT7du3fTqq6/qhx9+0M6dO5WUlCQfHx9FRESoV69euvnmm+Xv7++KtwAAAAAAAFxDLEZxKy8DLpafn69z585VdDcqnJeXlyIiIiRdngJZUFBQwT1CReOcQFGcE6XLnziy9EK4Yt7vL63oLqAEXCtQFOcEiuKcqHrq1q0rb29vl9ZZ6e+qBgAAAAAAgIrh0qlqjzzyiCurM2WxWPTGG2+4vR0AAAAAAICqzqXB0fnz511ZHQAAAAAAACoQU9UAAAAAAABgyqUjjt58881Sy+zYsUOfffaZ8vLyVLt2bfXr10+tWrVS7dq15e/vr+zsbF24cEGHDx/Wr7/+qoSEBPn4+Ojee+9VVFSUK7sLAAAAAACAErg0OCrt1vCrVq3SvHnzZLFYdMcdd2jUqFGmq303btxYXbt21e23366lS5dq/vz5mjdvnvz8/DRo0CBXdhkAAAAAAADF8NhUtbi4OH344YeSpLvuukt/+MMfSr1FnJeXl2699VbdfffdkqSPPvpIcXFxbu8rAAAAAAAAPBgcLV++XHl5eapVq5ZGjhxZpmOHDx+uWrVqKTc3V7/88oubeggAAAAAAABbHguO9u7dK0lq27ZtmY+1WCzW43777TeX9gsAAAAAAADmPBYcJSYmSpICAgLKdXzhcRcuXHBZnwAAAAAAAFA8jwVHhc6ePXtFxxmG4cruAAAAAAAAoBgeC47q1KkjSTp06FCZF7iOi4vTwYMHJZV+5zYAAAAAAAC4hseCo65du0qSCgoKNGfOHKWlpTl1XFpamubMmWMdaRQVFeW2PgIAAAAAAOB/PBYcDR06VNWrV5cknThxQk899ZSWL1+ujIwM0/KZmZlasWKFnnrqKZ04cUKSVL16dQ0dOtRTXQYAAAAAAKjSfDzVUEhIiB5++GHNnj1bBQUFSklJ0QcffKB58+YpMjJSYWFh8vf3V3Z2ti5cuKAzZ84oPz/feryXl5f+/Oc/KyQkxFNdBgAAAAAAqNI8FhxJUo8ePTR58mTNnTtXqampkqT8/HydPHlSJ0+eLPa4oKAg/fnPf1a3bt081VUAAAAAAIAqz6PBkXR5raPZs2dr2bJlWrNmjVJSUootGxISooEDB+qWW25RUFCQ5zoJAAAAAAAAzwdHkhQYGKg777xTd955p06fPq3jx48rNTVVWVlZCggIUHBwsJo0aaLIyEhZLJaK6CIAAAAAAECVVyHBka0GDRqoQYMGFd0NAAAAAAAAFOGxu6oBAAAAAADg6kJwBAAAAAAAAFMERwAAAAAAADDl0jWOFi1aZLc9ZsyYYvddCdt6AQAAAAAA4B4uDY4WLlxot20b8BTddyUIjgAAAAAAANyPqWoAAAAAAAAw5dIRRyWNBGKUEAAAAAAAwNXFpcHR2LFjy7UPAAAAAAAAlQ9T1QAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgyqVrHLnKli1btH37dl28eFHBwcHq0qWL+vbtW9HdAgAAAAAAqFI8FhylpKRo9uzZkqTWrVvrrrvucihTUFCg1157Tdu2bbN7fv369VqxYoX+/ve/KyAgwCP9BQAAAAAAqOo8NlVt69atOnjwoA4ePKhmzZqZllm6dKlDaFRo//79euedd9zZRQAAAAAAANjwWHB08OBBSZKPj4+6dOnisD8vL09Lly61bl933XWaMGGCRowYIV9fX0nSpk2bFBMT45kOAwAAAAAAVHEem6p26tQpSVKjRo3k7+/vsH/Xrl1KT0+XJHXr1k2TJ0+27mvWrJlef/11SZenrTVv3twDPQYAAAAAAKjaPDbiKCkpSZJUr1490/179+61Ph45cqTdvl69eqlWrVqSpCNHjriphwAAAAAAALDlseAoMzNTklS9enXT/YVT2YKDg9W6dWu7fV5eXtZ1keLj493YSwAAAAAAABTyWHBksVgkSfn5+Q77MjIyrFPZioZGhWrWrCnpfwEUAAAAAAAA3MtjwVHhSKPCKWu29u/fL8MwJElt2rQxPb4wcPLy8liXAQAAAAAAqjSPpTD169eXJB0+fFg5OTl2+zZv3mx9XFxwdPHiRUlSUFCQm3oIAAAAAAAAWx4Ljjp27Cjp8rS0L7/80vr8oUOHtGnTJklSSEhIsXdMO378uCSpbt267u0oAAAAAAAAJEk+nmpo4MCBWrJkiXJycvTjjz9q27ZtCgwM1KlTp6zT0AYPHmxdC8nW6dOnlZKSIklq0qSJp7oMAAAAAABQpXlsxFFYWJjGjx9v3U5MTNTx48etoVG9evU0cuRI02MLRyRJxU9lAwAAAAAAgGt5bMSRJN1www0KDg7W119/bZ165uvrq+7du2v8+PEKCAhwOCYvL08rVqyQJHl7e+u6667zZJcBAAAAAACqLI8GR5LUo0cP9ejRQ1lZWcrMzFRQUJB8fIrvRl5enh5//HFJkp+fn/XubAAAAAAAAHAvjwdHhQICAkxHGJmVa9eunQd6BAAAAAAAAFseW+MIAAAAAAAAV5cKG3FUKDMzUxcuXFB6erry8/MZXQQAAAAAAFBJVEhwlJmZqeXLl2v9+vU6deqUDMOQJFksFs2fP9+u7MWLF7Vs2TJJUqNGjdS/f3+P9xcAAAAAAKAq8nhwtH//fv373/9WcnKyw77CAMlWzZo19dtvv+n48eOqUaOG+vTpU+Ji2gAAAAAAAHANj65xdPDgQb300kt2oVFkZKRCQkJKPG7IkCGSpPT0dO3du9edXQQAAAAAAMB/eSw4ysnJ0Zw5c5SXlydJGjBggN555x299tpr6tmzZ4nH9uzZUxaLRZIIjgAAAAAAADzEY8HRqlWrrCONbrzxRv3lL39RrVq1nDo2KChI9erVkyTFxsa6rY8AAAAAAAD4H48FRzt27JAkVatWTXfffXeZj4+MjJQkxcfHu7RfAAAAAAAAMOex4OjkyZOSpLZt2yogIKDMxwcGBkqSMjIyXNovAAAAAAAAmPNYcHTp0iVJUmhoaLmOL1zjqKCgwGV9AgAAAAAAQPE8Fhz5+/tLurxIdnmkpKRIurzeEQAAAAAAANzPY8FR4ULYp0+fLvOxhmHoyJEjkqQ6deq4tF8AAAAAAAAw57HgqE2bNpIu3xUtISGhTMdu2bJFaWlpkqR27dq5vG8AAAAAAABw5LHgqHfv3pIujx766KOPnD4uKSlJ8+bNk3R5naN+/fq5pX8AAAAAAACw57HgqEOHDtbRQrt27dJrr71mHUVUnB07duiZZ56xrm/Uq1cvNWjQwN1dBQAAAAAAgCQfTzb2yCOP6J///KdSUlK0ZcsW7dy5Ux06dFBSUpK1zMcff6yUlBQdPnxYFy5csD5fp04dTZw40ZPdBQAAAAAAqNI8NuJIksLCwjRlyhTVr19fkpSbm6tdu3bpxIkT1jI//vijNm3aZBcaNWjQQFOmTFGNGjU82V0AAAAAAIAqzaMjjqTLIdDLL7+sZcuW6eeff1ZqamqxZatXr65bbrlFw4cPV0BAgAd7CQAAAAAAAI8HR5Lk7++vMWPG6LbbblNMTIwOHz6s5ORkZWRkyN/fXyEhIWrRooXatGkjH58K6SIAAAAAAECVV6GpjLe3t1q1aqVWrVpVZDcAAAAAAABgwqNrHF2p33//XdOmTavobgAAAAAAAFQJV8U8sD179ujrr7/WoUOHKrorAAAAAAAAVUalDo527NihxYsX6+jRoxXdFQAAAAAAgCrHrcFRTk6Otm3bpgMHDigpKUm5ubmqWbOmWrVqpT59+igwMND0uF27dmn+/Pk6fvy4w77mzZu7s8sAAAAAAAD4L7cFR9u2bdMHH3yglJQUh33r16/XV199pYcfflg9evSwPp+QkKB33nlH+/btczimRYsWGjNmjLp06eKuLgMAAAAAAMCGW4KjrVu3avbs2SooKCi2TEZGhubMmaO//e1v6ty5s3bu3KnXX39dWVlZduVatWqlMWPGqFOnTu7oKgAAAAAAAIrh8uAoKytL7733nl1o5Ovrq8jISPn5+Sk5OVnnz5+XJOXn5+vTTz9VUFCQ/vWvfykvL896TOvWrTV27Fh17NjR1V0EAAAAAACAE1weHG3cuFFpaWmXK/fx0T333KMhQ4bIx+d/TcXFxenjjz/Wnj17dObMGc2aNcsaGoWGhmrChAl2U9gAAAAAAADgeV6urnD37t3WxxMnTtTQoUPtQiNJql+/vp5++mm1aNFCkqzrIDVp0kQzZ84kNAIAAAAAAKgEXB4cnThxQpIUFham6Ojo4hv28tKoUaPsnps0aZKCg4Nd3SUAAAAAAACUg8uDo9TUVEmXF7UuTZs2bayPW7RooUaNGrm6OwAAAAAAACgnlwdHmZmZkqSgoKBSy9qWqVu3rqu7AgAAAAAAgCvg8uDIMAxJksViKbWsbZnAwEBXdwUAAAAAAABXwOXBEQAAAAAAAK4NBEcAAAAAAAAw5eOuipOSkrR//363lG/Xrl15uwUAAAAAAAAnuS042rZtm7Zt2+by8haLRfPnz7+SrgEAAAAAAMAJV91UtcLFtwEAAAAAAOBeV11wBAAAAAAAAM9w+VS1BQsWuLpKAAAAAAAAVABGHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEz5uLKyadOmSZJ69OihoUOHurJqAAAAAAAAeJhLg6P9+/dLkho2bOiw74477pAk3XTTTXrggQdc2SwAAAAAAADcgKlqAAAAAAAAMOXS4MjH5/IApuzsbFdWCwAAAAAAgArg0uAoKChIknT69GlXVgsAAAAAAIAK4NLgqGnTppKko0ePavHixUpOTnZl9QAAAAAAAPAgly6O3b9/f+3cuVOStGDBAi1YsMChzM8//6yff/653G1YLBbNnz+/3McDAAAAAADAOS4dcdS7d2/17dvXlVU6MAzDrfUDAAAAAADgMpeOOJKkxx57TF26dNH69esVGxurS5cuqaCgwNXNAAAAAAAAwM1cHhxJ0vXXX6/rr7/e7rk77rhDknTTTTfpgQcecEezAAAAAAAAcCGXTlUDAAAAAADAtcMtI47M1K5dW5IUFBTkqSYBAAAAAABwBTwWHL311lueagoAAAAAAAAuwFQ1AAAAAAAAmPLYiKPixMXFKTY2VmlpacrMzFS1atUUFBSkpk2bqn79+hXdPQAAAAAAgCqrQoKjjIwM/fjjj1q+fLmSk5OLLRcaGqohQ4bo5ptvVvXq1T3YQwAAAAAAAHg8ODp8+LBef/11JSYmllo2KSlJCxYs0MqVK/X444+rVatWHughAAAAAAAAJA+vcXTs2DG99NJLdqGRxWJR/fr11blzZ/Xs2VOdO3dW/fr1ZbFYrGUSExP10ksv6dixY57sLgAAAAAAQJXmsRFH+fn5ev3115WVlSVJql69um677TZFR0crODjYoXxaWppWr16tb775RhkZGcrKytK///1vvfbaa/LyYk1vAAAAAAAAd/NYArN+/XrFx8dLkurWratZs2Zp5MiRpqGRJAUFBWnkyJGaNWuWIiIiJElnz57V+vXrPdVlAAAAAACAKs1jwdH27dutj5944gmFh4c7dVx4eLgef/xx6/bWrVtd3jcAAAAAAAA48lhwFBsbK0lq2bKlmjVrVqZjmzVrppYtW0qSjh8/7uquAQAAAAAAwITHgqOLFy9Kkho0aFCu4wuPK6wHAAAAAAAA7uWx4Mjb21uSlJubW67j8/Ly7OoBAAAAAACAe3ksOAoJCZEkHT16tFzHHzlyxK4eAAAAAAAAuJfHgqM2bdpIkuLj47Vp06YyHbt582brHdkK6wEAAAAAAIB7eSw46tOnj/XxO++8o927dzt13N69ezV37lzTegAAAAAAAOA+Pp5qqFOnTurQoYN+//13ZWVlacaMGerevbuio6PVunVrBQUFWcteunRJhw4d0po1a7R161br8x06dFCnTp081WUAAAAAAIAqzWPBkSQ9/vjjeuaZZ5SQkCBJ2rZtm7Zt2yZJ8vPzU0BAgLKyspSTk+NwbEREhB5//HFPdhcAAAAAAKBK89hUNUkKDg7W9OnT1blzZ4d9OTk5Sk1NNQ2NOnfurBdeeEHBwcEe6CUAAAAAAAAkD484kqSaNWvqH//4h37//XetWLFC+/btU2pqqkO54OBgtW/fXkOGDFH79u093U0AAAAAAIAqz+PBUaEOHTqoQ4cOkqSkpCSlpqYqKytLAQEBCg4OVmhoaEV1DQAAAAAAAKrA4MhWaGgoQREAAAAAAEAl49E1jgAAAAAAAHD1IDgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKZ+K7kBlcvHiRR09elRHjx5VTEyMYmJilJaWJkkaMGCAJk2aVKb6du3apRUrVigmJkapqakKDg5W8+bNdcMNN6hLly5O1ZGfn6+VK1dqw4YNOnPmjLKyshQaGqqOHTtq6NChatiwoVP1pKam6scff9S2bdt0/vx5SVJ4eLi6d++uYcOGKSgoqEyvDQAAAAAAXPsIjmxMnDjRJfUUFBTovffe06pVq+yeT0pKUlJSkrZt26ZBgwbpoYcekpdX8YO+UlNTNWPGDMXExNg9f+7cOZ07d05r167VAw88oMGDB5fYnyNHjuiVV15RSkqK3fMnT57UyZMntWrVKk2ePFktWrQo2wsFAAAAAADXNI8FRydOnLA+btiwYYmBSWVQu3ZtRUZGas+ePWU+dv78+dbQqGnTpho5cqTq1q2rc+fOaenSpYqNjdWqVasUHBysu+66y7SOgoICvfrqq9bQqEePHrrhhhsUGBioI0eOaPHixbp48aLee+89hYaGFjuCKTExUTNnzlRqaqq8vb11yy23KCoqSpK0Y8cOff/990pOTtbMmTP18ssvKywsrMyvFwAAAAAAXJs8Fhz97W9/k3R5etSbb77pqWbLZMyYMWrevLmaN2+ukJAQJSQk6JFHHilTHXFxcVq2bJkkqXnz5po2bZr8/PwkSS1atFC3bt30/PPPKyYmRsuWLdOgQYMUERHhUM+aNWt08OBBSdKNN96oBx980LqvRYsW6tKli/7+978rMzNT8+bN03XXXSdvb2+HeubPn6/U1FRJ0mOPPabevXtb97Vt21bNmjXTnDlzdPHiRc2fP7/M0/EAAAAAAMC1y2PDfgpDjZYtW3qqyTK7/fbbFRUVpZCQkHLX8cMPPyg/P1+SNGHCBGtoVMjf318TJkyQdHn9ou+++860nsLwKTAwUPfee6/D/oiICN12222SpPj4eG3dutWhTEpKitavXy9J6tSpk11oVKhPnz7q1KmTJGndunUO09kAAAAAAEDV5bHgqDCMCQgI8FSTHmcYhrZt2yZJioyMVKtWrUzLtWrVSvXr15ckbd++XYZh2O2Pi4vTmTNnJEm9e/eWv7+/aT3R0dHWx2bBkW3dAwcOLLbfhfUYhqHt27cXWw4AAAAAAFQtHguOIiMjJV1ec+dalZCQoOTkZEmXp4GVpF27dpIuL5hdeJezQoVT1GzLmQkJCVG9evUkSYcOHXLY72w9tvtsjwEAAAAAAFWbx4KjwmlSBw8etN7i/lpz+vRp6+PCoKw4hSOOih5X1noK91+4cEFZWVmm9VSvXr3E6Xe1atVStWrVJMk60gkAAAAAAMBji2P369dP33//vU6fPq0PP/xQTzzxhKea9pgLFy5YH5d2d7LatWubHiddHoVUKDQ0tMR6CtsxDENJSUl2gVRhvc7cKa127do6deqUQ19K40z5kJAQ6xpXlf1uep5g+x7wfkDinIAjzonS5Vd0B6oIzr/KjWsFiuKcQFGcE3AFjwVHfn5++r//+z/9v//3/7Rp0yZlZmZq/PjxdkHH1c52xE9paznZrltUdKRQZmamS+op3HZmXanCeorWUZqHH3641DJz585VWFiYvL29Te8gV5XVqVOnoruASoZzAkVxTpg7VdEdqCL43L56cK1AUZwTKIpzAuXlseBo0aJFkqSoqCgtX75cu3fv1u7du9W4cWM1a9ZMwcHBDncgK86YMWPc2dVyy8nJsT728Sn5rfX19TU9TpJyc3NdUk/hdml12NZTtA4AAAAAAFB1eSw4WrhwoenzJ06c0IkTJ8pUV2UNjmyDr7y8vBLL2oZDRQMz2zAoLy+vxECtpHr8/PyUnZ1dal9s63E2vCs0d+7cUssUrq+Un5/vsBB4VeTl5WVN+xMSElRQUFDBPUJF45xAUZwTqCzi4+MrugsoAdcKFMU5gaI4J6qe8PBw61IxruKx4KgqsJ0SVtqUr+zsbNPjJFkXqi6sp6Qwp6R6AgIClJ2d7dT0s8J6nJnWZsuZ9ZNscaGyV1BQwHsCO5wTKIpzAhWJc+/qwbUCRXFOoCjOCZSXx4KjyjpKyJVsQ5TSFo1OTEw0PU6yXxA7KSlJwcHBxdZT2I7FYnFYSDssLEwXL150agHrwv6UNQgCAAAAAADXLo8FR2PHjvVUUxWmQYMG1sel3dY+Li7O9Dizepo0aVJsPYXthIWFOYwWatCggY4dO6aMjAylpKRYp4wVlZycbF2QOzIyssR+AwAAAACAqoP78blQnTp1VKtWLUnSgQMHSixbuD80NFTh4eF2+9q0aWN9vH///mLrSElJ0dmzZyVJrVu3dtjvbD22+2yPAQAAAAAAVRvBkQtZLBZ1795d0uWRQIcPHzYtd/jwYetIoW7duslisdjtr1+/vnXkz6ZNm+zWMbK1Zs0a6+MePXo47Lete/Xq1cX2u7Aei8Wibt26FVsOAAAAAABULQRHLjZs2DB5eV1+W+fNm+dwe/ucnBzNmzdPkuTt7a1bbrnFtJ4RI0ZIki5duqTPP//cYX98fLy++eYbSVJERIRpcBQSEqLrr79ekrRnzx5t3rzZocymTZu0Z88eSVL//v2Lnc4GAAAAAACqngq7q1pOTo52796tgwcP6sKFC0pPT1dBQYGee+45u3KGYVjDF29vb/n4uK/LBw8etLvtbGpqqvVxfHy83QgfSYqOjnaoo379+ho5cqS+/fZbxcTEaMqUKRo1apTq1q2rc+fOacmSJYqNjZV0ORyqV6+eaV+io6O1evVqHTp0SD///LNSUlI0ePBgBQYG6ujRo/r666+VmZkpi8WiCRMmFHu7vXHjxmn37t1KTU3V66+/rpiYGEVFRUmSduzYoe+++06SFBwcrHHjxjn9XgEAAAAAgGufxTAMw9ONLl26VEuXLlVaWprDvgULFthtp6Wl6S9/+YtycnLUsmVLTZ8+3W39euutt7R27Vqny//nP/8xfb6goEDvvvtuidPDBg0apIceesg6OslMamqqZsyYoZiYGNP9vr6+euCBBzR48OAS+3nkyBG98sorSklJMd0fEhKiyZMnq2XLliXWc6Xy8/N17tw5t7ZxNfDy8lJERISky4Ekt8QE5wSK4pwoXf7EkRXdhSrB+/2lFd0FlIBrBYrinEBRnBNVT926dYsdWFJeHh1xlJeXp1deeUW7d+92+pigoCANGDBAy5cv15EjRxQfH2898SsrLy8vPfzww+rZs6dWrFihmJgYpaWlKSgoSM2bN9eQIUPUpUuXUusJDg7W9OnTtXLlSm3YsEFnzpxRVlaWQkND1aFDBw0bNkwNGzYstZ6WLVvq1Vdf1Q8//KBt27bp/Pnzki4v5t2tWzfdcsstCgoKuuLXDQAAAAAAri0eDY4++OADa2jk6+urAQMGqEOHDtqwYYO2b99e7HHXX3+9li9fLknauXOnhg0b5pb+TZo0SZMmTXJZfV27dlXXrl2vqA5vb2/deOONuvHGG6+onsKpaExHAwAAAAAAzvJYcHTs2DHr1K3Q0FA9++yz1juHlXbr+tatW6t69erKyMjQwYMH3RYcAQAAAAAA4H88dlc12/V+Hn30UWto5KwmTZpIkvU29gAAAAAAAHAvjwVH+/btkyQ1atRI7dq1K/PxoaGhkqSkpCSX9gsAAAAAAADmPBYcJScnS/rfyKGyCggIkCRlZWW5qksAAAAAAAAogceCo5ycHEmXF8Uuj8LAqDBAAgAAAAAAgHt5LDgKDg6WJKWkpJTr+Li4OLt6AAAAAAAA4F4eC44KF8M+cuSICgoKynRsYmKijh8/Lklq3ry5q7sGAAAAAAAAEx4Ljjp37ixJSk1N1dq1a8t07IIFC6xhU2E9AAAAAAAAcC+PBUfR0dGqXr26JOnTTz9VTEyMU8ctWrRI69atk3T5zmp9+vRxWx8BAAAAAADwPz6eaigwMFB33HGH5s2bp4yMDD333HO66aab1K9fP+Xm5lrLZWRkKCUlRQcPHtTy5ct17Ngx677x48fLx8djXQYAAAAAAKjSPJrC3HzzzYqPj9ePP/6ovLw8ff/99/r+++/tykyYMMH02NGjR6tXr16e6CYAAAAAAADk4eBIku6//341atRIn332mTIyMkotX716dY0fP17R0dHu7xwAAAAAAACsKmTe16BBg9SnTx+tWrVKu3bt0uHDh5WVlfW/Tvn4qEWLFoqKitINN9xgXRsJAAAAAAAAnlNhCwYFBARo2LBhGjZsmCQpKytLGRkZCggIICgCAAAAAACoBCrNStMBAQEKCAio6G4AAAAAAADgv7wqugMAAAAAAAConCpNcJSVlaXk5GS7tY4AAAAAAABQcSpsqlpCQoJWrlypffv26fjx48rNzbXu8/X1VZMmTdS+fXsNGjRIdevWrahuAgAAAAAAVFkeD46ysrL02WefaeXKlTIMw7RMbm6ujhw5oiNHjmjJkiUaNGiQ7r33XlWrVs3DvQUAAAAAAKi6PDpVLTU1VVOmTNGKFSuKDY2KMgxDK1eu1LPPPquLFy+6uYcAAAAAAAAo5LERR4Zh6JVXXtHJkyetzzVr1kz9+/dXq1atVLt2bfn7+ys7O1sXLlzQ4cOHtW7dOsXExEiSTp8+rVdffVUvvviip7oMAAAAAABQpXksOFq/fr0OHz58uVEfH/3xj3/UoEGDHMoFBASoZs2aatasmW6++WatWbNG77//vvLy8qxhUv/+/T3VbQAAAAAAgCrLY1PV1q9fb31cXGhkJjo6Wg8++KBpPQAAAAAAAHAfjwVHJ06ckCTVqVPH6dCo0MCBA1WnTh27egAAAAAAAOBeHguO0tPTJUmtWrUq1/GFxxXWAwAAAAAAAPfyWHAUEhIiSfL19S3X8YXHFdYDAAAAAAAA9/JYcNS4cWNJl++OVh5nzpyRJDVq1MhlfQIAAAAAAEDxPBYcDRgwQJJ09OhRxcbGlunY2NhY6x3ZCusBAAAAAACAe3ksOOrZs6eioqJkGIZmz56thIQEp447f/68Zs+eLUnq2rWrevXq5c5uAgAAAAAA4L88FhxJ0mOPPaYePXro3Llzmjx5shYuXKhz586Zlk1ISNCiRYs0efJknTt3Tj169NDjjz/uye4CAAAAAABUaT6urGzatGnONerjo6ysLC1atEiLFi1ScHCwateuLT8/P+Xk5CgxMVGpqal25S9duqSZM2fKYrHoueeec2W3AQAAAAAAYMKlwdH+/fvLdVxqaqpdUFRUXl5euesGAAAAAABA+Xh0qhoAAAAAAACuHi4dcTR16lRXVgcAAAAAAIAK5NLgqF27dq6sDgAAAAAAABWIqWoAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBAAAAAAAAFMuXRzbWYmJidq4caOOHj2q8+fPKyMjQ/n5+U4da7FY9MYbb7i5hwAAAAAAAPBocJSTk6NPP/1UK1euVEFBgSebBgAAAAAAQBl5LDgqKCjQjBkztH//fk81CQAAgCuQP3FkRXehXLzfX1rRXQAA4JrhseBo+fLldqFRx44d1bdvXzVs2FCBgYHy9vb2VFcAAAAAAADgBI8FR+vWrbM+vvfeezV8+HBPNQ0AAAAAAIBy8Nhd1eLi4iRJDRs2JDQCAAAAAAC4CngsOCpcDLtFixaeahIAAAAAAABXwGPBUXh4uCQpPz/fU00CAAAAAADgCngsOGrbtq0k6cSJE55qEgAAAAAAAFfAY8HR0KFDZbFYdOLECR08eNBTzQIAAAAAAKCcPBYc1a9fX2PHjpUkvf7669bFsgEAAAAAAFA5eSw4kqTRo0dr3LhxSklJ0d///nd9+umnOnz4sDIyMjzZDQAAAAAAADjBx9MN3nbbbfL399cnn3yi77//Xt9//32ZjrdYLJo/f76begcAAAAAAIBCHg2OMjIyNGfOHO3Zs6fcdRiG4cIeAQAAAAAAoDgeC45ycnI0bdo0HT9+3FNNAgAAAAAA4Ap4LDj6/vvvraGRl5eXoqOj1bdvXzVq1EiBgYHy8vLocksAAAAAAAAohceCo40bN1ofP/roo+rTp4+nmgYAAAAAAEA5eGyYz9mzZyVJLVq0IDQCAAAAAAC4CngsOPLxuTy4qVGjRp5qEgAAAAAAAFfAY8FRWFiYJCk3N9dTTQIAAAAAAOAKeCw46ty5syTp6NGjnmoSAAAAAAAAV8BjwdGQIUPk5+ens2fPauvWrZ5qFgAAAAAAAOXkseAoIiJCEydOlMVi0dtvv63ff//dU00DAAAAAACgHHw81VBiYqLatWunBx54QJ988ommT5+ubt26qVevXmrYsKGqV68ui8XiVF21a9d2c28BAAAAAADgseBo0qRJDs9t27ZN27ZtK1M9FotF8+fPd1W3AAAAAAAAUAyPTVVzFcMwKroLAAAAAAAAVYLHRhwxvQwAAAAAAODq4rHg6K233vJUUwAAAAAAAHCBq26qGgAAAAAAADyD4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApjy2OHZiYqLL6uIObQAAAAAAAO7nseBo0qRJLqnHYrFo/vz5LqkLAAAAAAAAxbvqpqoZhlHRXQAAAAAAAKgSPDbiyNnpZYZhKCMjQ5mZmdbnfHx8FBIS4qaeAQAAAAAAwIzHgqO33nqrTOUTExO1ceNGLVmyROnp6Ro4cKDGjBnjpt4BAAAAAACgqEo7Va127doaOXKkZs2apfDwcC1cuFD/+c9/KrpbAAAAAAAAVUalDY4KhYWF6dFHH5UkLV68WEePHq3gHgEAAAAAAFQNlT44kqRWrVqpSZMmMgxDy5cvr+juAAAAAAAAVAlXRXAkSY0bN5YkHThwoIJ7AgAAAAAAUDVcNcGRl9flriYnJ1dwTwAAAAAAAKqGqyY4On78uCTJx8djN4IDAAAAAACo0q6K4GjLli2KjY2VJNWvX7+CewMAAAAAAFA1VOrhO2fPntWaNWv03XffWZ/r0aNHBfYIAAAAAACg6vBYcPTII484XTY/P1/p6enKzs62e75u3boaOnSoq7sGAAAAAAAAEx4Ljs6fP39Fxzdu3FhPPfWU/Pz8XNQjAAAAAAAAlKRST1ULDAxUixYt1K9fP/Xt29d6ZzUAAAAAAAC4n8eCozfffNPpst7e3qpevboCAgLc2CMAAAAAAACUxGPBUXh4uKeaAgAAAAAAgAsw9wsAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYMrli2O//vrrrq7SjsVi0WOPPebWNgAAAAAAAOCG4Gjjxo2urtIBwREAAAAAAID7MVUNAAAAAAAAplw+4mjMmDEurW/Pnj06cuSIS+sEAAAAAABA6VweHI0dO9Yl9Rw4cEDz5893CI2qV6/ukvoBAAAAAABQMpcHR1fq2LFjmj9/vvbs2WP3vJ+fn4YOHapRo0ZVUM8AAAAAAACqlkoTHJ06dUoLFizQtm3b7J7//+3deXhV1b3G8TcDSZhCSCAJYSZhCvMMijIjIDhWpFZ6xVauiF5bawccrlCgULQVRdSCldtbar1ApQxlUGaBMEQQkEACISBkHghJSHJCTs79I092z0l2JjKcDN/P8/g8+5y99tq/JPuE7Ne11nZ3d9ekSZP06KOPqlWrVk6qDgAAAAAAoPFxenCUkJCgDRs2KCwsTAUFBcb7rq6uGjdunB5//HH5+fk5sUIAAAAAAIDGyWnBUUpKijZt2qSDBw86BEYuLi4aPXq0nnjiCQUEBDirPAAAAAAAgEav1oOj9PR0ffHFF9q7d6/y8/Md9g0fPlxPPvmkOnToUNtlAQAAAAAAoJhaC46ysrK0ZcsW7dq1S3l5eQ77Bg4cqFmzZqlr1661VQ4AAAAAAADKUePBUW5urrZt26Z//etfysnJcdgXGhqqWbNmqWfPnjVdBgAAAAAAACqpxoKjvLw87dy5U1u3blVWVpbDvpCQEM2aNUv9+vWrqdMDAAAAAACgiqo9OMrPz9eePXu0efNmpaenO+zr3LmznnzySQ0ZMqS6TwsAAAAAAIBqVu3B0csvv6yUlBSH94KCgjRz5kyNGjWquk8HAAAAAACAGlLtwVHx0KhHjx667777dPv2be3Zs6dazjFx4sRq6QcAAAAAAAClq/HFsaOiohQVFVWtfRIcAQAAAAAA1DxXZxcAAAAAAACAuqnaRxz17t1bLi4u1d0tAAAAAAAAalm1B0cLFy6s7i4BAAAAAADgBExVAwAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmHJ3dgEAAMC5rM895OwSAAAAUEcx4ggAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgyt3ZBTREM2fOrFC70NBQLVy4sMw2p0+f1p49exQdHa2MjAx5e3srODhYEydO1KBBgyp0HqvVqr179+rw4cOKjY1Vbm6ufH191a9fP02dOlUdO3asUD8AAAAAAKBxITiqowoKCrRmzRrt27fP4f20tDSlpaXp5MmTGj9+vObOnStX19IHjmVkZGjZsmWKjo52eD8xMVGJiYk6ePCgnn32WU2YMKFGvg4AAAAAAFB/ERzVoMmTJ2vy5Mml7vfy8ip13+eff26ERl27dtVDDz2kgIAAJSYmauvWrYqJidG+ffvk7e2tp556yrSPgoICvfPOO0ZoNHz4cE2cOFEtWrTQpUuX9MUXX+jWrVtas2aNfH19KzyCCQAAAAAANA4ERzXI29tbnTp1qvRxcXFx2rZtmyQpODhYixYtkoeHhyQpJCREQ4cO1cKFCxUdHa1t27Zp/PjxCgwMLNHPgQMHdPHiRUmFIdZPf/pTY19ISIgGDRqkX//618rJydG6devUv39/ubm53c2XCgAAAAAAGiAWx66DduzYIavVKkmaM2eOERoV8fT01Jw5cyQVrl+0fft2036KwqcWLVpo9uzZJfYHBgbq0UcflSQlJCToxIkT1fY1AAAAAACA+o/gqI6x2Ww6efKkJKl9+/bq0aOHabsePXooKChIkhQeHi6bzeawPy4uTrGxsZKkUaNGydPT07SfsWPHGtsERwAAAAAAwB7BUR2TlJSkmzdvSpJ69+5dZtvQ0FBJhQtmJycnO+wrmqJm386Mj4+P2rVrJ0mKjIy8q5oBAAAAAEDDxBpHNejYsWMKCwtTcnKyXF1d5ePjox49emjs2LHq27ev6TE3btwwttu3b19m/0UjjoqO8/f3v6t+2rdvr/j4eKWmpio3N7fMRbuLS01NLbeNj4+PsXZSWU+Aayzsvwd8PyBxTaCk2r4mrDV+BqB2NZbfpfz7geK4JlAc1wSqA8FRDbIPb6TCdYQSEhJ06NAhDRs2TPPnz1ezZs0c2tgHMX5+fmX236ZNG9PjpMJRSEV8fX3L7KfoPDabTWlpaQ6BVHnmzZtXbpuPPvpIfn5+cnNzM13EuzGzD/sAiWsCJdXGNXG9xs8A1K7G+PcG/36gOK4JFMc1gbtFcFQDPD09NWTIEPXr10/t27eXl5eXMjIyFBERoa+++kqZmZk6efKkVqxYoTfeeEPu7v/+MeTm5hrb5Y38sV+3yP44ScrJyamWfgAAAAAAQONFcFQDPv74YzVv3rzE+/3799eUKVO0bNkyxcTEKCIiQl9++aWmTZtmtMnLyzO27QMlM02aNDE9TpLu3LlTLf2U56OPPiq3jY+Pj6TCJ8AVX4upMXJ1dTXS/qSkJBUUFDi5Ijgb1wSK45oAqiYhIcHZJdQKflegOK4JFMc10fi0bdvWWCqmuhAc1QCz0KiIj4+PXnnlFf3sZz+T1WrVrl27HIIjDw8PYzs/P7/M89iHQ/bHSY5hUH5+fon9Fe2nPOVNpyuOX1SOCgoK+J7AAdcEiuOaACqvMX5m+F2B4rgmUBzXBO4Wq2M5QUBAgPr37y+p8P+I2a9HZD+trLxpYxaLxfQ4SWratGm19AMAAAAAABovgiMn6dChg7FtHxzZj+Ap74llKSkppsdJjgti2/dvpug8Li4u5S6kDQAAAAAAGg+CIydxcXExfd8+UIqNjS2zj7i4ONPjKttP0X4/Pz9GHAEAAAAAAAPBkZPcuHHD2LYf5ePv76/WrVtLki5cuFBmH0X7fX191bZtW4d9vXr1MrYjIiJK7SM9PV3x8fGSpJ49e1awegAAAAAA0BgQHDlBUlKSzp49K6lwvSP74MjFxUXDhg2TVDgSKCoqyrSPqKgoY6TQ0KFDS4xgCgoKUvv27SVJYWFhDusY2Ttw4ICxPXz48Lv7ggAAAAAAQINEcFTNwsPDZbVaS92fnp6uP/zhD8YT0x544IESbaZNmyZX18Ifzbp165SXl+ewPy8vT+vWrZMkubm56cEHHzQ914wZMyRJWVlZWr9+fYn9CQkJ2rx5syQpMDCQ4AgAAAAAADhwd3YBDc26deu0du1ajRgxQj169JC/v788PDyUkZGhiIgIffXVV8rMzJRUOJ3MLDgKCgrSQw89pH/+85+Kjo7Wm2++qYcfflgBAQFKTEzUli1bFBMTI6kwHGrXrp1pLWPHjtX+/fsVGRmp3bt3Kz09XRMmTFCLFi10+fJl/eMf/1BOTo5cXFw0Z84cubm51dw3BgAAAAAA1DsERzXg5s2b2rVrl3bt2lVqmxEjRuj5559XkyZNTPfPmjVLt27d0v79+xUTE6OVK1eWaDN+/HjNmjWr1HO4urrql7/8pZYtW6bo6GgdP35cx48fd2jTpEkTPfvssxo0aFDFvjgAAAAAANBoEBxVs/nz5ysiIkJRUVFKTExUZmamcnJy5OXlJT8/P/Xo0UNjx45Vjx49yuzH1dVV8+bN04gRI7Rnzx5FR0crMzNTLVu2VHBwsCZNmlShsMfb21tLlizR3r17dfjwYcXGxio3N1e+vr7q27evpk2bpo4dO1bXlw8AAAAAABoQgqNqFhoaqtDQ0Grrb/DgwRo8eHCV+nBzc9PkyZM1efLkaqoKAAAAAAA0BiyODQAAAAAAAFMERwAAAAAAADBFcAQAAAAAAABTBEcAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBAAAAAAAAFMERwAAAAAAADBFcAQAAAAAAABTBEcAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBAAAAAAAAFMERwAAAAAAADBFcAQAAAAAAABTBEcAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBAAAAAAAAFMERwAAAAAAADBFcAQAAAAAAABTBEcAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBAAAAAAAAFMERwAAAAAAADBFcAQAAAAAAABTBEcAAAAAAAAwRXAEAAAAAAAAUwRHAAAAAAAAMEVwBAAAAAAAAFMERwAAAAAAADDl7uwCAAAAgOpkfe4hZ5dQaW5rtzq7BAAATDHiCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACm3J1dAAAADYn1uYeq3oek61UvBQAAAKgyRhwBAAAAAADAFCOOAAAAACe7m9GKzh6d6LZ2qxPPDgCoLYw4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKXdnFwAAAACg/rE+95CzS6g0t7VbnV0CANQ7jDgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYcnd2AQAAlMb63EPOLgEA0IDUx39X3NZudXYJABo5RhwBAAAAAADAFMERAAAAAAAATBEcAQAAAAAAwBTBEQAAAAAAAEwRHAEAAAAAAMAUwREAAAAAAABMERwBAAAAAADAlLuzCwAAAAAAmLM+91DF20q6XnOlNGhua7c6uwSgzmLEEQAAAAAAAEwx4qgRSU5O1s6dO3Xq1CmlpqbK3d1dgYGBGjVqlB544AF5eno6u0QANagy/8cSAAAAACSCo0YjPDxcq1atUk5OjvGexWJRdHS0oqOjtXfvXi1YsECBgYFOrBIAAAAAANQlBEeNQExMjFauXKm8vDx5eXnpkUceUd++fZWXl6cjR45o7969io+P17Jly7R8+XI1bdrU2SUDAAAAAIA6gOCoEfif//kf5eXlyc3NTW+88YZ69Ohh7Ovbt6/atWun9evXKz4+Xtu2bdPMmTOdWC0AAAAAAKgrCI4auMuXL+vChQuSpHHjxjmERkWmT5+u/fv3KzY2Vjt37tRjjz0md3cuDaAs1bleEE9AAQAAcK76uBYkT4JDbeGpag3ciRMnjO1x48aZtnF1ddWYMWMkSbdv39b58+drpTYAAAAAAFC3ERw1cJGRkZIkT09PdevWrdR2oaGhJY4BAAAAAACNG/ORGrgbN25IkgIDA+Xm5lZqu6CgoBLHVERqamq5bXx8fIxzu7qSVdp/D/h+1F9WZxcAAACARq0i9xLce6A6EBw1YHl5ecrMzJQk+fn5ldm2RYsW8vT0lMViqVAYVGTevHnltvnss88kSW5ubgoMDKxw342Bv79/tfeZn5JY7X3CxF/+5ewKAAAAgHLYjPsDX1dJri7OLacecm8T4OwSnI7gqAHLzc01tr28vMpt7+XlJYvF4nBcdXBx4ZdTbeIXGwAAAACguhAcNWB5eXnGdkWeklbUxv648nz00UfltmFIpCOr1ar09HRJjtP40HhxTaA4rgkUxzUBM1wXKI5rAsVxTaA6EBw1YB4eHsZ2fn5+ue2L2tgfV57ypsChpPT0dGOK30cffcT3EFwTKIFrAsVxTcAM1wWK45pAcVwTqA4MBWnA7KenVWT6WVGbikxrAwAAAAAADR/BUQPm4eGhli1bSir/6WdZWVmyWCySGEUEAAAAAAAKERw1cB06dJAkJSQkyGot/QHicXFxJY4BAAAAAACNG8FRA9ezZ09JksVi0ZUrV0ptFxERUeIYAAAAAADQuBEcNXDDhw83tvfv32/apqCgQAcPHpQkNW/eXH369KmV2gAAAAAAQN1GcNTAhYSEqHfv3pIKg6OoqKgSbbZv367Y2FhJ0tSpU+XuzsP2AAAAAAAAwVGj8Mwzz8jDw0NWq1VLlizR5s2bFRUVpe+++05r1qzR+vXrJUnt2rXTjBkznFwtAAAAAACoK1xsNpvN2UWg5oWHh2vVqlXKyckx3d+uXTstWLBAgYGBtVwZAAAAAACoqwiOGpHk5GTt2LFDp06dUlpamtzd3RUYGKiRI0dqypQp8vT0dHaJAAAAAACgDiE4AgAAAAAAgCnWOAIAAAAAAIApgiMAAAAAAACYIjgCAAAAAACAKYIjAAAAAAAAmCI4AgAAAAAAgCmCIwAAAAAAAJgiOAIAAAAAAIApgiMAAAAAAACYcnd2AQD+7dSpU7p8+bKio6OVlJSkjIwMZWdny8vLS/7+/urTp48mTpyooKAgZ5eKWpSUlKRvvvlG58+f1/fff6+0tDTZbDa1bNlS3bp107333quRI0fKzc3N2aWiluTm5urKlSu6fPmy8TsjOTlZktS2bVutXr3ayRWiOiUnJ2vnzp06deqUUlNT5e7ursDAQI0aNUoPPPCAPD09nV0iasmtW7ccPvfR0dHKzMyUJI0ZM0bz5893coWobdHR0Tp9+rQuXryoGzduKCMjQ25ubvL19VXPnj01fvx49erVy9llopZkZ2fr9OnTxu+HtLQ0ZWRkKC8vT82bN1eHDh00aNAgjR8/Xi1btnR2uahHXGw2m83ZRQCQrFarfvjDH5bbzs3NTU8++aQeeeSRmi8KTvf5559r8+bNKu9XdXBwsH7xi1+oTZs2tVQZnGnRokU6f/686T6Co4YlPDxcq1atUk5Ojun+du3aacGCBQoMDKzlyuAMM2fOLHUfwVHj89Zbb+nChQvltrv//vv1/PPPy92dMQMN3dmzZ7VkyZJy27Vs2VIvvfSSBg4cWPNFoUHgtwdQhzRr1kyhoaHq3r27AgIC5OPjI09PT928eVPnz5/X/v37lZ2drc8++0zNmjXT5MmTnV0yalh6erpsNps8PT01fPhw9evXT4GBgfLw8NCNGze0c+dO4/8qLV68WL///e/l5eXl7LJRw+yDxBYtWig4OFiRkZHKzc11YlWobjExMVq5cqXy8vLk5eWlRx55RH379lVeXp6OHDmivXv3Kj4+XsuWLdPy5cvVtGlTZ5eMWtSmTRu1b99eZ86ccXYpcJK0tDRJUuvWrTVq1Cj16tVLbdq0UUFBgaKiorR9+3alpaXp0KFDslqtevnll51cMWqDn5+f+vTpo27duqlNmzby8fGRzWZTamqqjh07phMnTigzM1MrVqzQ7373O3Xp0sXZJaMeYMQRUIcUFBTI1bX0pceSkpL061//Wrdv35a3t7fWrFlTZnvUf+vXr1fLli01efJk05vCgoICvffeewoLC5NU+H+jf/CDH9R2mahle/bskZeXl0JCQoyRJvPnz1dycjIjjhqQotEEbm5uWrRokXr06OGwf+vWrVq/fr0k6Qc/+EGZo1HQMGzYsEHBwcEKDg6Wj4+PkpKS9OKLL0pixFFjtHz5ct1///0aOXKk6d+DGRkZevPNNxUfHy9JWrhwoUJDQ2u7TNSi8u4lJOnEiRN65513JEnDhw/Xq6++WhuloZ7jjhOoQ8r7Re/v769Ro0ZJKvxjIDY2tjbKghM9/fTTevjhh0sdSeDq6qqf/vSnxvDzY8eO1WZ5cJKJEydq9OjRTE9qwC5fvmxMQRk3blyJ0EiSpk+frvbt20uSdu7cqfz8/FqtEbVv5syZGjJkiHx8fJxdCuqA3/zmN7rnnntK/fvR29tbP/7xj43X/I3Q8FXkfygPHz7cWC+1IlMdAYngCKh37AOEO3fuOLES1BUtW7ZU586dJUmJiYlOrgZAdThx4oSxPW7cONM2rq6uGjNmjCTp9u3bpa57BaDx6tOnj7HN3wgoUnQ/wb0EKorgCKhH8vLyFB4eLklycXFRu3btnFwR6oqif/iZugg0DJGRkZIkT09PdevWrdR29tNOio4BgCL2IxH5GwGSFBcXp6tXr0qSMWoVKA+LYwN1XH5+vtLT0xUZGaktW7YY89THjRvHQqiQVPh45qJpi/wBADQMN27ckCQFBgbKzc2t1HZF0w3sjwGAIhEREcY2fyM0XhaLRWlpafrmm2+0ZcsWWa1WSdK0adOcXBnqC4IjoA6yX+zSzIABAxzmrKNx27p1q/EHQNEaWADqr7y8PGVmZkoqfDpOWVq0aCFPT09ZLBalpqbWRnkA6omCggL985//NF7fc889zisGte7AgQP68MMPS93/yCOPaPTo0bVYEeozgiOgHmnZsqV+8pOflPr0DDQ+ly5d0o4dOyQV3mBOnjzZyRUBqKrc3Fxj28vLq9z2Xl5eslgsDscBwL/+9S9dvnxZUuGCyGVNe0Xj0aVLF82dO1chISHOLgX1CMERUAf5+voaj8ksKChQWlqavv32W+3bt09r165VYmKiHn30USdXCWdLT0/XH//4R1mtVrm4uGj+/Pny9PR0dlkAqigvL8/YLnpiYlmK2tgfB6Bxi4iI0GeffSZJatWqlZ577jknV4TaNmzYMON+Ii8vT4mJiQoLC9OJEyf03nvv6ZlnntGQIUOcXCXqC4IjoJJmzpxZ5T5eeOEFjR07ttT97u7u6tSpk/G6S5cuGjx4sCZMmKBFixbp73//u+Lj4/XCCy9UuRZUj9q4Luzl5ORo+fLlxtSUp556Sn379q1yDag+tX1NoOHw8PAwtu0Xti1NURv74wA0XtevX9fbb78tq9WqJk2a6Oc//7latWrl7LJQy5o3b67mzZsbr0NCQnTvvffq0KFDWr16tVasWKF58+bxdwYqhLkuQD3SuXNnzZo1S1LhvOUzZ844uSI4Q15enlasWKErV65IkmbMmKGHH37YyVUBqC7209MqMv2sqE1FprUBaNiSkpK0ZMkS3b59W66urvrZz37m8PRF4P7779fIkSNls9n05z//WVlZWc4uCfUAI46ASnr33Xer3Efr1q3v+tihQ4fqk08+kSQdO3ZMAwYMqHI9qLraui6sVqveffddnT9/XpI0fvx4zZ49u8rnRvVz9u8K1F8eHh5q2bKlMjMzy13wOisrSxaLRVL5C2kDaNjS0tK0ePFi3bx5Uy4uLpo3b56GDRvm7LJQBw0bNkxhYWGyWCz69ttvWSQb5SI4AirJ2Y8y9fb2NrZTUlKcWAns1cZ1UVBQoFWrVumbb76RVPh0lLlz59b4eXF3nP27AvVbhw4ddOHCBSUkJMhqtcrNzc20XVxcnMMxABqnjIwMLVmyRImJiZKkOXPmaMyYMU6uCnWV/f1EcnKyEytBfcFUNaCeSUtLM7ZZCLlxWbNmjY4ePSpJGjJkiF566SWergc0UD179pQkWSwWY1qqmYiIiBLHAGhcsrOztXTpUt24cUNS4bqHU6ZMcXJVqMvs7yeY5oyK4I4DqGeOHTtmbNsvoI2G7S9/+Yv27dsnSerXr59eeeWVUkcgAKj/hg8fbmzv37/ftE1BQYEOHjwoqXAR1D59+tRKbQDqDovFomXLlikmJkaS9Nhjj+mRRx5xblGo88LCwoxt7idQEQRHQB1x4sQJ3bx5s8w2ERER2rRpkyTJzc2N+ciNxIYNG/Svf/1LUuGIgl/+8pdq0qSJk6sCUJNCQkLUu3dvSYXBUVRUVIk227dvV2xsrCRp6tSpcndnBQKgMcnPz9c777yjyMhISdK0adOMh6igcTpw4IDy8vLKbLN9+3adPn1akuTv72/8WwOUhb8wgDri5MmTWrlypQYPHqy+ffuqY8eOat68ue7cuaPExESFh4crLCxMNptNkvT4448rKCjIyVWjpu3cudMIC319ffWjH/1ISUlJZR4TFBTEDWQDl5CQoIsXLzq8V/RkrdzcXB04cMBh38CBA+Xj41NL1aG6PPPMM3rzzTeVl5enJUuW6NFHH1WfPn2Ul5eno0ePas+ePZKkdu3aacaMGU6uFrXh4sWLSkhIMF5nZGQY2wkJCSU++zxmu2FbuXKl8YTdvn37avz48fr+++9Lbe/u7s7fjg3cxo0b9b//+78aMWKEevXqpYCAAHl5eSk3N1fff/+9vv76ayNodHd319y5c1n2ABXiYiu6CwXgVKtXrzamHJTFw8NDs2bN0vTp02uhKjjbwoULHdYwqYgPPvhA/v7+NVQR6oIDBw7oww8/rHD7t956i2lM9VR4eLhWrVqlnJwc0/3t2rXTggULFBgYWMuVwRkq+rdCkQ0bNtRgNXC2mTNnVqp927ZttXr16hqqBnXB/PnzK7TYtZ+fn+bNm6f+/fvXQlVoCPhf0kAd8fTTTys0NFQXLlzQ9evXlZ6eroyMDLm4uKhFixbq2LGj+vTpozFjxvCIbgBoJIYOHap33nlHO3bs0KlTp5SWliZ3d3cFBgZq5MiRmjJlCg9KAABIkl5//XWdOnVKFy9eVGJiotLT05WVlSUPDw95e3urS5cuGjJkiEaNGsW/HagURhwBAAAAAADAFBMaAQAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACm3J1dAAAAQEWcP39eixYtkiSFhoZq4cKF1dLv/PnzlZycLEn64IMP5O/vXy391raa+v5UtxUrVig8PFw+Pj56//335eXlVWvnTkpK0osvvihJatu2rVavXl1r526oZs6caWxv2LChxP6MjAy99NJLysnJ0fjx4/X888/XZnkAgGpAcAQAQD22cOFCRURElLrfy8tLzZs3V4cOHdS7d2+NHTtWvr6+tVgh8G/ffvutwsPDJUlPPPFEqaGRfZhnxsXFRV5eXvLx8VGXLl00bNgwjRgxQk2aNKmRunH3vL29NX36dG3cuFH79+/XpEmTFBwc7OyyAACVwFQ1AAAasNzcXKWmpurMmTP6/PPPNX/+fG3cuFE2m83ZpaGRKSgo0F//+ldJkp+fn8aNG3fXfdlsNuXk5Cg+Pl5hYWF6//339corrygyMrK6ykU1evDBB9W0aVPZbDatX7/e2eUAACqJEUcAADQQwcHBCgkJcXgvOztb165d0/fffy9Jslqt2rhxo27fvq1nnnnGCVWisTpy5IiuX78uSZoxY4bc3Sv2Z2i/fv0UFBTk8F5BQYEyMzN15coVJSUlSZISExO1ZMkSLVy4kBEtdUyzZs00adIkbd26VefPn9fZs2fVv39/Z5cFAKgggiMAABqIQYMGOaw3Yi8yMlLvvfeeUlJSJEk7duzQfffdV69usPv06WO6hgrqhy1btkiSPD09NXbs2Aofd99995XZPjw8XB988IGys7NlsVj0ySefaNmyZaZt/f39uYacZNKkSdq2bZtsNpu2bNlCcAQA9QhT1QAAaAR69uypX/3qV3JxcTHe27NnjxMrQmNy7tw5Y9TbyJEj1axZs2rre+jQoXruueeM19HR0YqPj6+2/lE9AgIC1LdvX0mO1wMAoO4jOAIAoJHo0qWLQkNDjdcXLlxwYjVoTPbt22ds33PPPdXef/GFsW/cuFHt50DVjRo1ytg+cOCA8woBAFQKU9UAAGhEunTpovPnz0uSbt68WaFjbty4oUOHDuncuXNKSUlRVlaWmjVrpoCAAA0YMECTJk2q0JPacnNzdejQIX3zzTf6/vvvlZmZKavVKg8PD7Vu3VqBgYHq0aOHhg4dqk6dOpU4vrKPm79z54727NmjsLAwxcbGKjc3V76+vgoJCdGECROM0Q8VUd4jx4uzf9rdW2+9pT59+pi2y87O1qlTpxQREaGrV68qMTFR2dnZ8vDwkLe3t4KDgzV8+HCNHDlSrq7V9//7YmNjtX//fl24cEEJCQnKzs6Wq6urmjZtKj8/P3Xu3FmhoaEaOnSoWrRoUaVz5ebm6uTJk5Kkpk2bql+/ftXxJThwd3dXixYtjGvaYrGYtktKStKLL74oSWrbtq1Wr15t2s7s5x0XF6cvv/xSZ86cUUpKilxdXeXv769BgwZp+vTp8vb2LrNG+yfFffDBB/L391dqaqq++uorffPNN0pOTpbVapWfn5/69++vGTNmqG3bthX+HuTn5+vo0aMKDw/XlStXlJGRIZvNJm9vb3Xv3l333HOPhg0b5jDqsCzZ2dnavXu3Tpw4oYSEBOXn58vX11e9e/fW5MmT1a1btwrXVmTYsGFau3atbDabDh8+rNmzZ1e4HgCA8xAcAQDQiHh4eBjbeXl5Zba9c+eO1q1bp3379qmgoMBhX2ZmpjIzM3X58mVt27ZNTz/9tKZMmVJqX1FRUfrjH/+otLS0EvtycnKUk5OjuLg4nTp1Sp9//rn+/ve/y83NrZJf3b/duHFD77zzjuLi4hzeT0xMVGJioo4cOaJJkyZpzpw5d32Oqjp+/Ljef/993blzp8S+ou9JYmKijh49qs6dO+uXv/yl/P39q3zeDRs26IsvvijxM7Varbpz544yMjIUExOjAwcOaPTo0fqv//qvKp3vu+++M661nj17VnhR7MrIz89XVlaW8drHx6da+//yyy/1l7/8pcTP6tq1a7p27Zr27t2r1157rVJrhp04cUIffvihsrOzHd6Pi4tTXFyc9u3bp1deeUWDBw8ut6/z58/r448/VmJiYol9ycnJSk5O1tGjR9W9e3f94he/KDfovXjxot59990S4XJ8fLzi4+O1f/9+PfHEE/rBD35Qga/031q1aqUOHTro+vXrSk9PV3R0dIkF/QEAdQ/BEQAAjYj9jWBZN9e5ublaunSpw+PNAwIC1K1bNzVv3lxZWVmKjIzUzZs3lZeXp08//VTZ2dl67LHHSvSVkpKipUuXKicnR5Lk5uamkJAQBQQEyNPTUxaLRcnJybp69arRpiqSk5O1ePFih6+1Y8eO6tq1qyQpJiZG169f11dffSVPT88qn+9u3bp1ywgi/Pz81KFDB7Vq1Uqenp7Kzc1VbGysYmJiZLPZdO3aNb311ltasWKFWrZsedfn3LFjhzZt2mS8btmypbp3767WrVvLxcVFWVlZio2NVWxsbIlg6W6dPXvW2O7Vq1e19FlceHi48b1s0qTJXY2GKc2BAwf0ySefSJKCgoLUrVs3eXh4KC4uTpGRkbLZbMrMzNSKFSv07rvvVmj9pnPnzmnt2rUqKChQmzZt1KNHDzVt2lRJSUmKiIiQ1WpVXl6e3n33Xf3hD38oMzAMCwvT+++/L6vVKqkwHO7evbvatm0rV1dXxcfHKyoqSlarVZcuXdLrr7+uZcuWlfr5v3Llin73u98pNzfXeC84OFgdO3ZUfn6+Ll26pMTERG3YsEHNmzevxHeyUO/evY2n6509e5bgCADqAYIjAAAaCavVqnPnzhmvu3fvXmrbTz75xAiN2rVrp7lz55aYblVQUKA9e/YYIzE2bNigvn37qkePHg7ttm/fbgRCvXv31ssvv2w64sFqtSoyMlJ79uyp0vSVjz/+2AiNmjVrppdeeklDhgxxaHP69Gm9//772r59e5VGNlWFr6+vnnrqKY0cOVKBgYGmbZKSkrR27VqdOXNGqamp+tvf/qbnn3/+rs5ntVr1j3/8w3j91FNPafr06aYjgLKysnTy5EllZGTc1bnsXbp0ydju3Llzlfsr7ttvv9WaNWuM15MnT67WxbfXrl0rb29vvfjiixo4cKDDvoiICP3+979XTk6Obt68qR07dlRoFM6nn36qJk2a6LnnntN9993ncL1fv35dS5cuVVpamiwWizZt2qQXXnjBtJ/r169r9erVslqtcnFx0fTp0/XYY4+VCHQSExO1evVqXbx4Uampqfroo4+0YMGCEv3l5+dr1apVRmjk5+enn//85yU+0wcPHtSaNWv017/+tdyvtbguXboY25cvX6708QCA2kdwBABAI/HPf/5TqampxuuJEyeatrtw4YIOHTokqXCU0eLFi03Xb3F1ddXkyZPl4eGhDz/8UAUFBdq0aZNee+01h3YXL140tufNm1fqNBk3NzeFhoY6LOBdWWfPnjXCMRcXF7366qumaxkNGjRIv/rVr7Rw4UJjpEZtGzp0qIYOHVpmG39/f/3617/WggULdO3aNX399dd6+umn72rdodjYWGVmZkoqnDL2yCOPlNq2RYsWGjduXKXPUZzNZnN4elb79u0r3cfXX3+t6Ohoh/cKCgqUlZWlmJgYJSQkGO9PnjxZs2fPvvuCS/Hmm2+ahl6hoaH64Q9/qE8//VSSdOTIkQoFR/n5+VqwYEGJIEoqHB03d+5cLV++XJJ07Ngx/ed//qdpwLlu3TpjGuDs2bM1ffp00/MFBATotdde02uvvaYbN27o9OnTunTpUonw+MCBA4qNjZVUOHLrjTfeMP2ZjRkzRq6urlq1alW5X2tx9v1du3at0scDAGofT1UDAKABy87O1oULF/Tee+/p//7v/4z3H3zwQfXv39/0mO3btxvbP/7xj8td9Hfs2LHGzeCZM2eMcKKI/fSz8vqqqr179xrbI0aMKHMB7N69e+vee++t0Xqqg7u7u0aPHi2pcN0p+yCuMmrz51AkPT3dYV2giiyiXty5c+e0e/duh/+++uorhYWFGaFRu3bttGjRIv30pz+t1kXEJWnChAlljpQaM2aMEerExcWVWLPIzODBg01DoyKDBg0yppIVTVss7urVq/ruu+8kSV27dtWDDz5Y5jm9vLz0+OOPG6+//vrrEm3sn343derUMoO+++67Tz179izznGbsr4G0tLRqmxIJAKg5jDgCAKCB2LRpk8P6NWZatmypGTNmlDraxGq1GmvSNG3atMQUr9L06dNHsbGxstlsioyMdBhJ4+fnp/j4eEmFiwyXNdKlqoqeGCcV3tCXZ8yYMTp8+HCN1VNRt2/f1qVLl3T9+nVlZmYqNzdXNpvN2G+/yPfVq1fLHalkxs/Pz9g+f/684uLiFBQUVLXCy3Hr1i1j29PT02Fx9uoUHx+vxYsXa/LkyXrqqaeq9Tz2j5A307RpUwUEBCguLk42m00pKSmmTwWsTJ8uLi7q3Lmz0tPTJRVOWSze5+nTp43te++9t0LTO+2DVPv1y6TCYNF+ZNf9999fbn9jxowp0U957NfoslqtysjIqPbFzAEA1YvgCACARsLV1VU/+tGPNH78+FLbXLt2zXiUubu7u9atW1ehvu1vOFNSUhz2jRo1yhgZ8dlnn+ncuXMaPXq0+vfv7xBmVFVaWprDmjxlreFk38bFxcUhpKlNResWHT9+3PTpamaKj+iqqDZt2qh79+66dOmSsrOz9Zvf/Eb333+/hg8frp49e9bIQuH2CyzfbZjzwgsvaOzYsQ7v2Ww25ebmKj4+XidPntT27dtlsVi0Y8cOXbt2Ta+//nq1Pb2tvBBIcgxDKjLiqLJ9mi0aHxUVZWyfP39eycnJ5fZpf50X/5xeu3bN2N+0aVN17Nix3P6Kr31UEcWvs6LfNwCAuovgCACABiI4ONjhCUW5ublKSUlRVFSU7ty5o4KCAuOR3T/84Q9N+7B/EllmZqZ2795d6Tpu377t8HrChAn69ttvdfLkSUmFU4+K1iFq06aNevXqpb59+2ro0KFVmkJlHxp5enpWqK9mzZqpWbNmJWquDTExMfrtb39b6XNX5clz8+bN06JFi3Tr1i3l5ubqyy+/1Jdffik3Nzd16dJFvXv31oABA9SvX79qn/JVnVxcXNS0aVN169ZN3bp106hRo/Tmm28qJydH58+f1+bNm/XEE09Uy7kqstC2/fpDFVkzqzr6tP+s2o8+qqji153958fPz69CI5jatGlT6fM6K6QFANw9giMAABqIQYMGaebMmSXeT09P11/+8hcdOXJEkrR582Z17txZ99xzT4m2FRktUZ7iN7murq569dVXtX//fm3fvl03btww9qWkpOjw4cM6fPiw3NzcNGbMmLte/PluR7d4enrWenB0584d/eEPfzDO6+3trYkTJ6pfv34KDAxUixYt5OHhYdy8HzhwQB9++KGkqt14d+jQQW+//ba++OILHTp0yPh5W61WRUdHKzo6Wtu3b5evr6+eeOIJTZgwoUpfp5eXl7FdtIhzTejUqZOmTJmizZs3S5J27typRx99tFpGHVXlCX81qaqf1eJrC9l/fio6+uxuRqkVvw5qYqQbAKB6ERwBANDA+fj46KWXXlJWVpbOnDkjSfrkk0/Uv3//EgGN/U1c586d9fbbb1dLDS4uLho/frzGjx+vuLg4RUREKDIyUhcvXlRiYqKkwvBi3759On/+vJYuXVrp0Ud3G1LUxFSZ8sKd48ePKykpSVLhYsHLli1T69atS21flVFGxfn4+OjZZ5/V7NmzdenSJV24cEFRUVG6ePGicZ60tDT96U9/0rVr1/Tss89W6VxFLBaL8vLyamydowEDBhjBUdET1yoyXbG+sv+svvrqqxo+fHiV+rP//FT0M3E3nx37kU1ubm61tlA7AODu1d0xyAAAoNq4urrq+eefN242s7KyjJtse/Y3+kUL81a3oKAgTZw4UfPnz9eqVau0cuVKTZ8+3ZgalZiYqI0bN1a6X/sbUIvFUqG1gHJycio0cqOyU5HK67Noqp4kTZs2rczQSFKF1q+prCZNmig0NFSPP/64FixYoD//+c967bXX1KtXL6PNrl27dPny5bs+R6tWrRyCotTU1CrVXJbi38Oa+J7VJdX9WbX//KSmplZoZFvxdZIqIi0tzdj29fWt01MiAQCF+E0NAEAj4efn5/DI7l27dpW44ezSpYuaNGkiqfCJWEWPO69JQUFB+vGPf+wwzS48PLzS/fj6+jrc/F66dKncYy5dulShG+SmTZsa2+UFUvn5+Q5PQTNjvz5NRRZKvnDhQrltqsrd3V0DBw7Um2++6bAw8jfffHPXfbq4uDh8feV9X6qi+OiXhh5I2K9ndvHixSr317lzZ2NaXk5OjsOU0tLYL9BdUbGxsQ7nBADUfQ37X1QAAOBg+vTpRghy584dbdmyxWG/h4eHwyO772Zx7Ltl/4h5+8e4V0afPn2M7UOHDpXb/uDBgxXqt23btsb21atXy2wbHh5e7hPS7NfNKW9a3ZUrVxyeWlfTmjRpogEDBhiv7/ZnUcQ+4Lh27VqV+ipLTEyMw2tfX98aO1ddMGTIEGP7xIkTVR511LRpUwUHBxuvK/L5qUib4uyvAftrAwBQdxEcAQDQiLRo0UJTpkwxXu/Zs8dhzRFJevjhh43tXbt26ezZsxXu3+zmtXj/pbGf9tKqVasKn9Oe/WLOYWFhioiIKLXtxYsXdfjw4Qr1a79WzoEDB0ptl52drb/97W/l9hcQEGBslzW6ymKx6E9/+lOFaixPVlZWiQWRS2P/s6jqGjT9+/c3tqtjZIyZ/Px87dq1y3hd9MS1hiwkJMQISvPy8vTBBx8oPz+/Qsfm5+crKyurxPvjx483tnfu3FnmCLEjR47c1c/TfvSc/bUBAKi7CI4AAGhkpk+fbiyEa7FYtG3bNof9oaGhGjNmjKTC9XyWL1+uzZs3Ozx1yV5eXp5OnDihFStW6Pe//32J/S+88ILWrFmjiIiIUoOL6OhorVu3zng9cODAu/nS1L9/f+Nm2maz6e2339apU6dKtDtz5oxWrFghm83msH5RaUaPHm1sHz161CGkKBIbG6vf/va3SkxMNKb7lcZ+tMjBgwe1bdu2Et+bhIQELVmyRDExMdXy5Knw8HC9/PLL2rp1q7Ewd3F37tzRrl27dPz4ceO9QYMGVem8ffv2NdY5ioyMrHC4UVE3b97UH//4R4cRR1OnTq2WJ6rVdXPmzDE+y2fPntVbb71V5hTNuLg4bdq0SfPnz1dkZGSJ/WPGjFFQUJCkws/1kiVLTPv7+uuv9eGHH1b6e3zr1i1jCpyPj0+DD/cAoKFo+P+iAgAABy1bttQDDzxgTFPbvXu3Hn74YYcnrM2dO1fp6ek6c+aM8vPz9fe//11ffPGFQkJC1KZNGzVp0kS3b99WYmKirl+/bkzNMrsRzMvL0549e7Rnzx41bdpUXbp0UZs2beTp6anMzEzFxcXp+vXrRntvb2898cQTd/31zZs3T6+//rpu3bql27dva/ny5erYsaO6du0qFxcXXb161ZguM336dB0/frzchZR79eqlwYMHGyHUp59+qt27dxsjkeLj4xUVFSWbzaaxY8cqKSmpzNFOAwYMUO/evXXhwgXZbDb99a9/1e7du9W1a1c1a9ZMCQkJioyMVEFBgXx9fTVt2jStX7/+rr8nRRITE7V+/XqtX79ebdq0UadOnYzRXenp6bp06ZLDSJTRo0erZ8+eVTqnl5eXhg0bpiNHjignJ0fnzp2rVBj19ddfm07Vs1gsio+P1+XLlx0WLO/Zs6ceffTRKtVcX3Tq1Ekvv/yyVq5cKYvFokuXLun1119XQECAunbtqhYtWujOnTvKyMjQtWvXHBamNtOkSRO9+OKLWrRokSwWi1JSUvT6668rJCREHTt2VH5+vi5dumSsfTZnzhyHwLc8J0+eNNYUu/feexv8OlQA0FAQHAEA0AjNmDFDu3btksViUW5urrZv365Zs2YZ+5s0aaIFCxZo48aN2r59uywWiywWi86fP19qn25ubqaPP/fy8jJGK+Xk5JS50HPnzp31s5/9rErr0/j7++u///u/9c477yg+Pl6SdP36dYdwSiqc1vbUU085jK4py4svvqilS5caIUZsbKzDQr9S4VSfn/zkJ1q6dGm5/f385z/XsmXLjJEySUlJJUYCdejQQa+88kqVnmxWxMvLSy4uLsaNe0pKSqlPxXJxcdGkSZP0zDPPVPm8UuH35ciRI5IKR2xVJjg6d+6cw1PoyjJu3Dg988wz1TJCq74YMmSIFi9erI8//lhXrlyRVBgQJiYmlnpM27Zt5efnZ7ovJCRECxYs0MqVK42pp5cvX3a4Bl1cXPT4449r6tSplQqOwsLCjO1x48ZV+DgAgHMRHAEA0Ah5e3tr8uTJxjS1Xbt2acaMGWrevLnRxtXVVU8++aSmTp2qgwcP6ty5c7px44YyMzOVn5+vZs2aGaNW+vTpo8GDB5uuh/Ppp58qIiJCERERio6OVkJCgtLT03Xnzh15enrK19dX3bp104gRIzR06NBqGYXQsWNHvf3229qzZ4/CwsIUGxsri8Wi1q1bKzg4WBMmTKj0+iotWrTQ4sWLtW/fPh05ckTXr19Xbm6u0efEiRMr1aePj4+WLFmivXv36ujRo7p+/bosFotatWqloKAgjRo1Svfdd588PT2rJTgaOXKk/vSnP+ns2bO6ePGirl27pqSkJN2+fVuS1KxZM7Vr1069evXSmDFj1KFDhyqfs0i/fv3UqVMnff/99zp27JjmzJmjZs2aValPDw8PNW/eXEFBQerZs6fuv/9+Y5pVY9OlSxctX75cZ86c0cmTJxUZGam0tDRlZ2fL3d1d3t7eCgoKUvfu3TVgwAD16NHDYYH24kJDQ/Xuu+9q9+7dOn78uBITE2W1WtW6dWv17t1bkyZNqvTC1klJSfruu+8k/ft6AADUDy62ijyDFgAAAKiCw4cP6/3335ck/cd//IcefPBBJ1eE2rR+/Xpt3bpVkvTGG2+wMDYA1CNMLAYAAECNu+eee9SxY0dJ0vbt26t9kWzUXdnZ2frqq68kFY5mIjQCgPqF4AgAAAA1ztXVVbNnz5Ykpaamav/+/U6uCLVlx44dysnJkYuLi55++mlnlwMAqCSCIwAAANSKgQMHaujQoZKkjRs3Goumo+HKyMgw1lIbN25cpddGAgA4H2scAQAAAAAAwBQjjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApgiOAAAAAAAAYIrgCAAAAAAAAKYIjgAAAAAAAGCK4AgAAAAAAACmCI4AAAAAAABgiuAIAAAAAAAApv4fQ3Q3TCXEtJgAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 459,
       "width": 583
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t_pred_knn = fitted_models['KNN'].predict(D_test)\n",
    "residuals_knn = t_test - t_pred_knn\n",
    "\n",
    "plt.hist(residuals_knn,20)\n",
    "plt.xlabel(\"Residuals (Binned)\")\n",
    "plt.ylabel(\"Number of Residuals\")\n",
    "plt.title(\"Distribution of Residuals for KNN Model\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 459,
       "width": 583
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t_pred_dt = fitted_models['DT'].predict(D_test)\n",
    "residuals_dt = t_test - t_pred_dt\n",
    "\n",
    "plt.hist(residuals_dt,20)\n",
    "plt.xlabel(\"Residuals (Binned)\")\n",
    "plt.ylabel(\"Number of Residuals\")\n",
    "plt.title(\"Distribution of Residuals for DT Model\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "KNN residuals are somewhat more tightly distributed compared to that of DT. This might explain why KNN has a lower MSE value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beyond Evaluation  <a class=\"anchor\" id=\"beyond\"></a> \n",
    "\n",
    "Data is unlikely to be constant (or stable) forever. For example, consumers change their spending habits and housing prices fluctuate over time. This is known as **\"concept drift\"**. Thus, it is important to monitor the model performance in an on-going validation framework. Below are some common approaches to monitor changes in the underlying process:\n",
    "\n",
    "1. Monitoring changes in model performance metrics.\n",
    "2. Monitoring model output (target) distribution changes using stability index.\n",
    "3. Monitoring descriptive feature distribution changes.\n",
    "4. Conducting comparative experiments using control groups.\n",
    "\n",
    "We shall not cover model monitoring topics in this tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises <a class=\"anchor\" id=\"exercises\"></a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Using breast cancer data, build a DT model evaluated on **precision** and compute a confusion matrix.\n",
    "2. Using the DT model from the previous question, compute and visualize a ROC curve.\n",
    "3. Using the California housing data, build and evaluate three regressor models - KNN, DT and (Gaussian) Naive Bayes (NB) using MAE as the metric."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}