models/baseline_model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Baseline Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will first build some basic models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       " if (code_show){\n",
       " $('div.input').hide();\n",
       " } else {\n",
       " $('div.input').show();\n",
       " }\n",
       " code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "The raw code for this IPython notebook is by default hidden for easier reading.\n",
       "To toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import HTML\n",
    "HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    " if (code_show){\n",
    " $('div.input').hide();\n",
    " } else {\n",
    " $('div.input').show();\n",
    " }\n",
    " code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "The raw code for this IPython notebook is by default hidden for easier reading.\n",
    "To toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>.''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.linear_model import LogisticRegressionCV\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import RandomizedSearchCV, GridSearchCV\n",
    "from predict_test_data import predict_test_data\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import itertools\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('../data/cleaned/train_final.csv')\n",
    "test = pd.read_csv('../data/cleaned/test_final.csv')\n",
    "wc_playoffs_train = pd.read_csv('../data/cleaned/wc_playoffs_final.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our most basic model would be to just predict the majority class every time. In this case, `home_win` = 1 is the majority class. What are is the training accuracy from just doing this \"prediction\"? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.43806009488666314"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train['home_win'].value_counts()[1] / len(train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pretty decent when we have 3 classes. What about the test accuracy? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.421875"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(test['home_win'], np.ones(len(test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Still decent. Any model we build should be better than this test accuracy of just guessing.\n",
    "\n",
    "Our baseline model will be pretty simple. We will utilize the differences in FIFA rankings, offense ratings, defense ratings, midfield ratings, overall ratings, and whether the home team is actually playing at home. We will make a train and validation set out of the original train set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = train[['home_win', 'rank_diff', 'attack_diff', 'defence_diff', 'midfield_diff', 'overall_diff']]\n",
    "test = test[['home_win', 'home_win_no_pk', 'rank_diff', 'attack_diff', 'defence_diff', 'midfield_diff', 'overall_diff']]\n",
    "wc_train = wc_playoffs_train[['home_win', 'rank_diff', 'attack_diff', 'defence_diff', 'midfield_diff', 'overall_diff']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(14)\n",
    "X_train, X_validation = train_test_split(train, test_size = 0.2)\n",
    "y_train = X_train['home_win'].ravel()\n",
    "X_train = X_train.drop(['home_win'], axis = 1).values\n",
    "y_validation = X_validation['home_win'].ravel()\n",
    "X_validation = X_validation.drop(['home_win'], axis = 1).values\n",
    "y_test = test['home_win'].ravel()\n",
    "y_test_no_pk = test['home_win_no_pk'].ravel()\n",
    "X_test = test.drop(['home_win', 'home_win_no_pk'], axis = 1).values\n",
    "y_wc = wc_train['home_win'].ravel()\n",
    "X_wc = wc_train.drop(['home_win'], axis = 1).values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stores the score of each model\n",
    "score = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will first try out logistic regression. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr_model = LogisticRegressionCV(solver = 'lbfgs', max_iter = 5000, cv = 5, multi_class='multinomial').fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Train Score: 0.5128543177323666\n",
      "Logistic Regression Validation Score: 0.5684210526315789\n"
     ]
    }
   ],
   "source": [
    "score[\"Logistic Regression\"] = {}\n",
    "score[\"Logistic Regression\"][\"model\"] = lr_model\n",
    "score[\"Logistic Regression\"][\"Train Score\"] = lr_model.score(X_train, y_train)\n",
    "score[\"Logistic Regression\"][\"Validation Score\"] = lr_model.score(X_validation, y_validation)\n",
    "\n",
    "print(\"Logistic Regression Train Score: {}\".format(score[\"Logistic Regression\"][\"Train Score\"]))\n",
    "print(\"Logistic Regression Validation Score: {}\".format(score[\"Logistic Regression\"][\"Validation Score\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also try out Linear Discriminant Analysis. However, we need to first check whether the variances across the three outcomes are equal. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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>rank_diff</th>\n",
       "      <th>attack_diff</th>\n",
       "      <th>defence_diff</th>\n",
       "      <th>midfield_diff</th>\n",
       "      <th>overall_diff</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>home_win</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>-1</th>\n",
       "      <td>916.793268</td>\n",
       "      <td>40.858572</td>\n",
       "      <td>37.554931</td>\n",
       "      <td>38.133908</td>\n",
       "      <td>31.393396</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>960.540851</td>\n",
       "      <td>47.654088</td>\n",
       "      <td>43.559341</td>\n",
       "      <td>41.798216</td>\n",
       "      <td>36.158215</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>936.866455</td>\n",
       "      <td>49.295727</td>\n",
       "      <td>43.509512</td>\n",
       "      <td>42.634416</td>\n",
       "      <td>37.105145</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           rank_diff  attack_diff  defence_diff  midfield_diff  overall_diff\n",
       "home_win                                                                    \n",
       "-1        916.793268    40.858572     37.554931      38.133908     31.393396\n",
       " 0        960.540851    47.654088     43.559341      41.798216     36.158215\n",
       " 1        936.866455    49.295727     43.509512      42.634416     37.105145"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.groupby('home_win').var()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Surprisingly, besides `rank_diff`, they are actually quite similar! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "lda_model = LinearDiscriminantAnalysis().fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LDA Train Score: 0.5102175346077785\n",
      "LDA Validation Score: 0.5578947368421052\n"
     ]
    }
   ],
   "source": [
    "score[\"LDA\"] = {}\n",
    "score[\"LDA\"][\"model\"] = lda_model\n",
    "score[\"LDA\"][\"Train Score\"] = lda_model.score(X_train, y_train)\n",
    "score[\"LDA\"][\"Validation Score\"] = lda_model.score(X_validation, y_validation)\n",
    "print(\"LDA Train Score: {}\".format(score[\"LDA\"][\"Train Score\"]))\n",
    "print(\"LDA Validation Score: {}\".format(score[\"LDA\"][\"Validation Score\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also try out Quadratic Discriminant Analysis, which should perform similarly to LDA in this case due to the almost equal variances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "qda_model = QuadraticDiscriminantAnalysis().fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QDA Train Score: 0.5102175346077785\n",
      "QDA Validation Score: 0.5368421052631579\n"
     ]
    }
   ],
   "source": [
    "score[\"QDA\"] = {}\n",
    "score[\"QDA\"]['model'] = qda_model\n",
    "score[\"QDA\"][\"Train Score\"] = qda_model.score(X_train, y_train)\n",
    "score[\"QDA\"][\"Validation Score\"] = qda_model.score(X_validation, y_validation)\n",
    "print(\"QDA Train Score: {}\".format(score[\"QDA\"][\"Train Score\"]))\n",
    "print(\"QDA Validation Score: {}\".format(score[\"QDA\"][\"Validation Score\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also try out Random Forest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  42 tasks      | elapsed:    7.1s\n",
      "[Parallel(n_jobs=-1)]: Done 192 tasks      | elapsed:   27.6s\n",
      "[Parallel(n_jobs=-1)]: Done 250 out of 250 | elapsed:   37.1s finished\n"
     ]
    }
   ],
   "source": [
    "rf_params = {'bootstrap': [True, False],\n",
    "     'max_depth': [3, 5, 10, 20, 30, 40, None],\n",
    "'max_features': ['auto', 'sqrt'],\n",
    " 'min_samples_leaf': [1, 2, 4, 10, 20],\n",
    " 'min_samples_split': [2, 5, 10],\n",
    " 'n_estimators': [10, 50, 100, 200, 500]}\n",
    "\n",
    "rf_model = RandomizedSearchCV(estimator=RandomForestClassifier(), param_distributions=rf_params,\\\n",
    "                                   n_iter=50, scoring='accuracy', n_jobs=-1, cv=5, verbose=1).fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest Train Score: 0.5115359261700725\n",
      "Random Forest Validation Score 0.5552631578947368\n"
     ]
    }
   ],
   "source": [
    "score[\"Random Forest\"] = {}\n",
    "score[\"Random Forest\"]['model'] = rf_model\n",
    "score[\"Random Forest\"][\"Train Score\"] = rf_model.score(X_train, y_train)\n",
    "score[\"Random Forest\"][\"Validation Score\"] = rf_model.score(X_validation, y_validation)\n",
    "print(\"Random Forest Train Score: {}\".format(score[\"Random Forest\"][\"Train Score\"]))\n",
    "print(\"Random Forest Validation Score {}\".format(score[\"Random Forest\"][\"Validation Score\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also not forget XGBoost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 50 candidates, totalling 250 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  42 tasks      | elapsed:    4.0s\n",
      "[Parallel(n_jobs=-1)]: Done 192 tasks      | elapsed:   15.5s\n",
      "[Parallel(n_jobs=-1)]: Done 250 out of 250 | elapsed:   21.0s finished\n"
     ]
    }
   ],
   "source": [
    "xgb_params = {\n",
    "    'min_child_weight': [1, 5, 10],\n",
    "    'gamma': [0.5, 1, 1.5, 2, 5],\n",
    "    'subsample': [0.6, 0.8, 1.0],\n",
    "    'colsample_bytree': [0.6, 0.8, 1.0],\n",
    "    'max_depth': [3, 4, 5]\n",
    "    }\n",
    "xgb_model = RandomizedSearchCV(estimator=XGBClassifier(objective='multi:softmax', num_class = 3), param_distributions=xgb_params,\\\n",
    "                                   n_iter=50, scoring='accuracy', n_jobs=-1, cv=5, verbose=1).fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XGBoost Train Score: 0.5095583388266315\n",
      "XGBoost Validation Score 0.5578947368421052\n"
     ]
    }
   ],
   "source": [
    "score[\"XGBoost\"] = {}\n",
    "score[\"XGBoost\"]['model'] = xgb_model\n",
    "score[\"XGBoost\"][\"Train Score\"] = xgb_model.score(X_train, y_train)\n",
    "score[\"XGBoost\"][\"Validation Score\"] = xgb_model.score(X_validation, y_validation)\n",
    "print(\"XGBoost Train Score: {}\".format(score[\"XGBoost\"][\"Train Score\"]))\n",
    "print(\"XGBoost Validation Score {}\".format(score[\"XGBoost\"][\"Validation Score\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_result = pd.DataFrame(score).T"
   ]
  },
  {
   "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>Train Score</th>\n",
       "      <th>Validation Score</th>\n",
       "      <th>model</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Logistic Regression</th>\n",
       "      <td>0.512854</td>\n",
       "      <td>0.568421</td>\n",
       "      <td>LogisticRegressionCV(Cs=10, class_weight=None,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LDA</th>\n",
       "      <td>0.510218</td>\n",
       "      <td>0.557895</td>\n",
       "      <td>LinearDiscriminantAnalysis(n_components=None, ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>QDA</th>\n",
       "      <td>0.510218</td>\n",
       "      <td>0.536842</td>\n",
       "      <td>QuadraticDiscriminantAnalysis(priors=None, reg...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Random Forest</th>\n",
       "      <td>0.511536</td>\n",
       "      <td>0.555263</td>\n",
       "      <td>RandomizedSearchCV(cv=5, error_score='raise-de...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>XGBoost</th>\n",
       "      <td>0.509558</td>\n",
       "      <td>0.557895</td>\n",
       "      <td>RandomizedSearchCV(cv=5, error_score='raise-de...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    Train Score Validation Score  \\\n",
       "Logistic Regression    0.512854         0.568421   \n",
       "LDA                    0.510218         0.557895   \n",
       "QDA                    0.510218         0.536842   \n",
       "Random Forest          0.511536         0.555263   \n",
       "XGBoost                0.509558         0.557895   \n",
       "\n",
       "                                                                 model  \n",
       "Logistic Regression  LogisticRegressionCV(Cs=10, class_weight=None,...  \n",
       "LDA                  LinearDiscriminantAnalysis(n_components=None, ...  \n",
       "QDA                  QuadraticDiscriminantAnalysis(priors=None, reg...  \n",
       "Random Forest        RandomizedSearchCV(cv=5, error_score='raise-de...  \n",
       "XGBoost              RandomizedSearchCV(cv=5, error_score='raise-de...  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We choose the final model to be the one with the highest validation score, which is Logistic Regression in this case\n"
     ]
    }
   ],
   "source": [
    "model_name = df_result['Validation Score'].astype(float).argmax()\n",
    "print(\"We choose the final model to be the one with the highest validation score,\\\n",
    " which is {} in this case\".format(model_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Due to the elimination style during playoffs of the World Cup, there are no draws in these playoff matches. We will attempt three different approaches to predicting the outcome of theese playoff matches. \n",
    "\n",
    "The first approach is to predict the outcome at 90 minutes (when a regular game ends so that our train set and test set are more \"similar\" to each other) before accounting for penalty kicks and overtime, allowing the model which trained on the training set to also predict draws in the playoff matches of the World Cup. \n",
    "\n",
    "In the second approach, we will predict the outcome at the end of the match; for a playoff match, if the model predicts a draw as most likely, then we instead predict the second most likely outcome of that match. We will call this approach the \"Softmax Approach\". \n",
    "\n",
    "The third approach also attempts to predict the outcome at the end of the match. Instead of just predicting the second most likely outcome for a playoff match, we instead just train another model specifically on past World Cup playoff matches on the final outcome of these matches. We then just use this model to predict the playoff matches while the model trained on the training set will predict the preliminaries match. The third approach should be the more robust approach compared to the second approach. Since we have limited amount of past World Cup playoff matches (only 24 matches because some of them were removed to accomodate the team ratings dataset), we will train a basic logistic regression model as this model. We will call this approach the \"WC Playoff Model\". \n",
    "\n",
    "The implementation for the second and third approach are very straightforward and can be found [here](predict_test_data.py).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For the best Model, Logistic Regression, the test accuracy is 0.5625 at 90 mins\n",
      "For the best Model, Logistic Regression, the test accuracy is 0.59375 at end (Softmax)\n",
      "For the best Model, Logistic Regression, the test accuracy is 0.578125 at end (WC Playoff Model)\n"
     ]
    }
   ],
   "source": [
    "wc_model = LogisticRegressionCV(solver = 'lbfgs', max_iter = 5000, cv = 5, multi_class='multinomial').fit(X_wc, y_wc)\n",
    "test_pred = predict_test_data(X_test, df_result.loc[model_name].model)\n",
    "test_pred_playoff = predict_test_data(X_test, df_result.loc[model_name].model, False, wc_model)\n",
    "test_score = accuracy_score(y_test, test_pred)\n",
    "test_score_playoff = accuracy_score(y_test, test_pred_playoff)\n",
    "test_score_no_pk = df_result.loc[model_name].model.score(X_test, y_test_no_pk)\n",
    "print(\"For the best Model, {}, the test accuracy is {} at 90 mins\".format(model_name, test_score_no_pk))\n",
    "print(\"For the best Model, {}, the test accuracy is {} at end (Softmax)\".format(model_name, test_score))\n",
    "print(\"For the best Model, {}, the test accuracy is {} at end (WC Playoff Model)\".format(model_name, test_score_playoff))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#save for comparisons later\n",
    "save = {}\n",
    "save['Model Name'] = 'Baseline Model'\n",
    "save['Train Score'] = df_result.loc[model_name]['Train Score']\n",
    "save['Validation Score'] = df_result.loc[model_name]['Validation Score']\n",
    "save['Test Score (90 mins)'] = test_score_no_pk\n",
    "save['Test Score (Softmax)'] = test_score\n",
    "save['Test Score (WC Playoff Model)'] = test_score_playoff\n",
    "\n",
    "pd.DataFrame(save, index = [0]).to_csv(\"baseline_model_results.csv\", index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Impressive! We now have an idea of what our more advanced model should hope to achieve. In this case the Softmax approach did better than the WC Playoff Model approach; this might be due to the small training set for the playoff matches, the small number of features, or just pure luck. \n",
    "\n",
    "Let us do some quick analysis of the baseline model. First, let's see what exactly the model is getting wrong by plotting some confusion matrices. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#https://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html#sphx-glr-auto-examples-model-selection-plot-confusion-matrix-py\n",
    "def plot_confusion_matrix(cm, classes, ax,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "    ax.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    ax.set_title(title)\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    ax.set_xticks(tick_marks)\n",
    "    ax.set_xticklabels(classes, rotation=45)\n",
    "    ax.set_yticks(tick_marks)\n",
    "    ax.set_yticklabels(classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        ax.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    ax.set_ylabel('True label')\n",
    "    ax.set_xlabel('Predicted label')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.set_printoptions(precision=2)\n",
    "train_cm = confusion_matrix(y_train, df_result.loc[model_name].model.predict(X_train))\n",
    "test_cm_90mins = confusion_matrix(y_test_no_pk, df_result.loc[model_name].model.predict(X_test))\n",
    "test_cm =  confusion_matrix(y_test, test_pred)\n",
    "test_playoff_cm = confusion_matrix(y_test, test_pred_playoff)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5AAAANYCAYAAACy9wL9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd8XnX5//HXlaR7l+5B6QA6oEApKEPZQ1qKylQEWQIuQECGgCiKCnwVVMT1AytQoKIglErZSyiUPVqgFEpp07132qaf3x/3TUg6j9DkbpLX8/HIo/e5z+ecXCd3kyvv+5zPSaSUkCRJkiRpc4oKXYAkSZIkqXYwQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBK9VBEFEfE0ojYttC1SJJUm0XOixHRv4A1HBwRr3/GfUREvBoR22+pulQ3GSClWiAf9j7+WBsRKyotn/i/7i+lVJ5Sap5S+qg66pUkqSZt6T5Zab/PR8Q3NjPsGKA0pTQhv02TiLgxImZExPyIuCEiiivts31EjIqIZRExOSKO2cTn/1VEpIg4c53nL8k/fwlASunRlNIun/Y48/tIwPXATz7LflT3GSClWiAf9pqnlJoDHwFHVnpuxLrjI6Kk5quUJKkw/tc+uYWdDdxWafnHQL9KH18ELqq0/i/AAqADcDpwy2bO+k0EvrnOcyfln9/S7gGGRMQ21bBv1REGSKkOiIifR8TIiLgzIpYA34iIvfLvnC7Mvwv6u4hokB9fkn/ncrv88u359Q9GxJKIGBsRPQt4SJIkbTH5qRtXRMQHETE3IkZEROv8umYRcVf+bOHCiHghItpExK+BPYD/lz+T+esN7LcpuYD4VKWnjwRuSCktTCnNAm4ETsuPb5Nff0VKaVlK6XHgIWBTZ0n/C3SOiN75fQwGVgFvVqrj8IiYVGl5ZkT8ICLeiohF+eNtmF/XKSLG5I91XkQ8/vF2KaWl+f0enPVrq/rHACnVHV8B7gBaASOBNcC5QDtgH+Bw4KxNbP914AqgLbl3b39WncVKklSDfggcCuwLdANWk7tcE+AMoAToSq5nfg9YlVK6AHgROCN/JvOCDey3H7A4pTS30nOR/6i83CciGgN9gSUppSmV1r8ODNhE7Qm4HTg5v3wycOumDxfIXVp7ENAH+By5Pg9wMfAuuWPtzPqXrL4NfKbLYVW3GSCluuO/KaVRKaW1KaUVKaUXU0ovpJTWpJQ+IHfJzH6b2P6fKaWXUkqrgRHArjVStSRJ1e8s4JKU0vSU0krgp8DxERHkwmR7oHe+Z76YUlqWcb+tgSXrPPcgcH5EbBMRXYDv5p9vAjQHFq0zfhHQYjOf51ZyVxc1JBcM78hQ2/UppVkppTnAf/ikr68GugDbppRWpZSeXme7JfnjkjbIACnVHVMrL0RE34gYnb+MZTFwFbl3GzdmZqXHy8k1OUmSarV8SOwO/Cd/2eZC4FVyvwdvA9xM7hLUf0bEtIj4ReWb3mzGAtYPf1eSO8P3JvA0uXmFy1JKC4ClQMt1xrdk/RBaRUppEjALuBp4NX9p7OZsrK9fDUwHnoiISRFx/jrbtQAWZti/6ikDpFR3pHWW/wy8BfRJKbUkN6k/1ttKkqQ6LH930VLgwJRS60ofjVNKc1NKZSmlH6eU+pKbz3gscMLHm29m928DLSKi4g3a/NzGs1JKXVJKfYDF5C6FBXgHaLnOn9HaBRif4VBuBS4g2+WrG5VSWpRSOjel1AM4Grg8IvapNKQfuctqpQ0yQEp1Vwtyl8Usi4h+bHr+oyRJddmfgF9FRHeAiOgQEUfmHx8cEf0joohc2FsDlOe3mwX02thOU0orgCfJBU/y++uev1FNUUTsC1xCfp5h/izkA8BVEdE0IvYnd4+CLHeKvY3cPM5/Zz3oDYmIYRHRM39mdhG5Yy3Pr2sG7Aw89lk+h+o2A6RUd11A7rbfS8idjRxZ2HIkSSqYa4FHgcfzdyt/DhiUX9cVuI9cv3yL3HzBf+TXXQ+cHBELIuLajez7z+T+rMbHdgTGkbtc9a/AeSmlyndp/Ra5KSVzgeHA6Sml9zZ3APkzm4+mlMo2N3Yz+pELvUvIXWL7fyml5/Prvgr8Z52bAklVRO6sviRJkqT/Vf5M3gvAKSmlCYWu59PKH8fLwAkpper4G5OqIwyQkiRJkqRMvIRVkiRJkpSJAVKSJEmSlIkBUpIkSZKUSUmhC6hLSpq1So1adyp0GfoU+nZa928AqzaZPH95oUvQp7Bs7nTKliz0b5OqWpQ0a5Ua2pNrpX725Fpt6qKVhS5Bn9Kc98fPTSm139w4A+QW1Kh1J/qe/adCl6FP4dlLDyh0CfoMTr3j1UKXoE/hoStPLHQJqsMatu5E37P+WOgy9Ck8+6MDC12CPoML7q+1N6Kt9246esCULOO8hFWSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUSUmhC1Dh7dW7LRcetj3FAf9+dQbDn/uoyvojB3bi3IN7M3tJGQD/eLGUf782A4Bxl+3PpNlLAZi5uIzzR75Zs8XXcw8/NIYLzz+X8vJyTjntDH540SVV1peVlXH6qSfz6isv07btNtx+x0h6bLcdANdd80uG/+1miouL+fX1v+OQQw8rwBHUX7t0acHJe3SjKIInJs3j/rdmbXDcntu25gf79+Sy0e/wwbwVtGvWkF8f1Y/pi1cCMGnOcm5+YWpNli6pGu39cU8uCu59dQbDn51SZf2Ru3TivIP7VPTkkS9O49+v5nryuQf3Zt8+21AUwfMfzOe6h96r8frrO/ty7dW/YzOOGdiJogie/XABj0yct8Fxu3VpwRmf7841j3/ARwtX0rdDM44a0IHioqB8beLet2Yxcc7yGq6+Zhkg67migEsO34HvjHiNWYvLuO2MwTw1cS6T51b9j//whNlcO2b9RlS2ppyv//WlmipXlZSXl3PeOd9l9IOP0LVbN/b9/B4MHTqMfv37V4wZfsvNtGndhvHvTOIfI+/ish9dzO13jOTtCRO4e+RdvPL6eGZMn84Rhx/MmxMmUlxcXMAjqj8i4NTPdecXj0xi3vLVXH3Ejrw8dRGli1ZWGde4pIjD+7XnvTnLqjw/a0kZlz7wbk2WLKkGFAVc/KUd+c7trzJrcRm3nzGYp96ds35PHj+ba8ZMrPLcwG4t2aV7K47/8zgAbjl1d3bv0ZqXpyyssfrrO/ty7RXAcbt05vf/ncLCFau56IBevDljCTOXrKoyrlFJEfv3acvk+Z98Ty4tK+dPY6eyaOUaOrdsxPf22ZbLHqzbb954CWs9N6BLS6YuWEHpwpWsWZt4ePws9t+xXaHLUgYvjhtH79596NmrFw0bNuTY40/ggVH3VRnzwKj7OPGkbwLw1aOP4cnHHyOlxAOj7uPY40+gUaNGbNezJ7179+HFceMKcRj1Up9tmjJzSRmzl66ifG1i7IcLGNy91Xrjjtu1M6PemsXq8rUFqFJSTdupa0umLVhe0ZMfGj+b/Xdsn3n7RsVFNCguomFxESVFwfxlqza/kbYY+3LttV3bJsxZtop5y1dTnuDlaYsY2LnFeuOG9m/PIxPnsbo8VTw3bdFKFq1cA8CMxWWUFAUlRVFjtReCAbKe69CyEbMWf3LWY9biMtq3aLTeuIP6tueuM/fgmmMG0LHlJ+sblhRx2+m7M/zUQQbPGjZ9eindunWvWO7atRulpaXrj+meG1NSUkLLVq2YN28epaXrbzt9etVtVX3aNG3IvEq/2M1bvoo2TRtUGbNd2ya0bdaQV0sXr7d9++YN+eXQHfnxoX3YsUOzaq9XUs1o36IRMxeVVSzPXlxGhw305AP7tWfkWXty7TE7VfTkN6Yt5sUpC3n4/H146Px9Gfv+/PXOXKp62Zdrr9aNS1iwYnXF8sIVa2jdpGpf7taqMW2aNOCtmUs3up/durRg2qLcG0B1WbVdwhoRS1NKzSstnwIMTil9r7o+5zqffzjwQErpnzXx+WqrDb0/ktb5P//0e3MZM34Wq8sTRw/qwk+H9ePs218DYMhvxzJ36Sq6tm7Mn07alUmzlzJtwcoN7FVbWlr3hQIiItuYDNuq+mzuSx3ASYO78sdnP1pv3cIVq/n+PeNZWlZOz7ZNuOCAXvzw/rdZsdqzlNo0+/LWb4M9mao/r5+eOJcxb+V78u5duOqo/px126t0b9OEnu2acvj1zwHwx5N2ZdD7rXnlIy9hrSn25VpsA1/qtM7qowd25LaXp290F51bNOKonTpy4zrzlusiz0DWc7MWl9GxZeOK5Y4tGzF3aVmVMYtWrKk4VX/vq9PpV+mU/tylubMopQtX8vKUhezYaf3T/aoeXbt2Y9q0T26eUlo6jS5duqw/ZmpuzJo1a1i8aBFt27ala7f1t+3cueq2qj7zl61im2YNK5a3adqQBcs/eeezcYMiurduwo8P68PvvtqfPu2bceEBvem1TRPWrE0sLSsHYPL8FcxaUkbnluufoZBU+8xeUkanVp98P3do2Yg568zBqtKTX5lO33xPPqBve96ctpgVq8tZsbqcZyfNY+duLWuueNmXa7GFK9bQptIZx9ZNSlhU6Yxko5IiurRsxHlf6MFVh/WhZ9smnLVXd7Zt3bhi/Lc+341bXypl7rLV6+2/rilIgIyIHhHxWES8kf932/zzwyPijxHxRER8EBH7RcQtEfF2/p3Lj7c/NCLGRsQrEXF3RDTf6Cer+nkjIq6LiLci4s2IOD7/fOeIeDoiXsuv+0JEFOfr+XjsD6rli1FgE6YvoXvbJnRp3ZiSouDQAR15auLcKmPaNf/kF939dmjH5Lm5G3q0aFxCg+LcWzatmzRgl26t+GCdm32o+gzeYw8mTXqPDydPZtWqVdw98i6GDB1WZcyQocMYcdvfAbjnX/9kvwMOJCIYMnQYd4+8i7KyMj6cPJlJk95jjz33LMRh1Evvz1tOpxaNaN+8IcVFwV7bteHlqYsq1q9YvZYz//Em59wzgXPumcCkOcv4vyfe54N5K2jRqKTiDGaH5g3p1LIRs5Y4z0mfjX156zC+dAnd2zat6MmHDeiw2Z78Yb4nz1y0kt17tKY4cvOvdu/RuqJfq2bYl2uvKQtW0KF5Q7Zp2oDigN27teLNGZ9cqrpyzVouHj2RHz80iR8/NInJ81fw57FT+WjhSpo0KOLbe23L/eNn88H8FQU8ippTnXdhbRIRr1Vabgvcn398I3BrSunvEXEa8Dvgy/l1bYADgWHAKGAf4AzgxYjYFZgGXA4cnFJaFhEXA+cDV2Wo6avArsAuQLv8Pp8Gvg48lFK6OiKKgab5cV1TSjsBRETrDe0wIs4EzgRo2KpjhhK2LuUpce2Yidz49V0ojuC+12fwwZzlnL1fTybMWMzTE+dxwp7d+OIO7Shfm1i8YjU/uf8dAHq2a8plQ3ZkbcrdOW74cx8536IGlZSUcP1vb+TIIYdRXl7ON085jf4DBnDVT37MoN0HM/TIYZxy2umcdspJDOjbhzZt2nLbiLsA6D9gAEcfexy7DexPSUkJN/zuD97prQatTTB83DQuPbg3RRE8OWke0xat5JhdOjF53nJenrb+vMeP9evYjGN37Uz5WlibEjc/P5Vlq8prsHrVYnW+L1fuyQ1adcjw6bcu5SlxzYMT+cOJu1IUwf2vTeeDOcs4e/+eTJi+hKcnzuWEPbuxX74nL1q5hivvexuAR9+ezR492/CPs/ckAc+9P4+nN/JnCFQ97Mu119oE/3htJt/dZ1uKIhg7ZSEzlpQxpF97Plq4okqYXNd+vdrSvnlDvtS3PV/qm7vp1e+fnVJxtVBdFBu6FnuL7HgTcy0iYi7QOaW0OiIaADNSSu3y72Y+klIaERG9yDWP7fPb3wrcA6wBhpNrWAANgbEppdPX+fzDWWeuRURcD7yZUrolv3wbcDewELgFuB34d0rptYhoA7wE/AcYDTycUtrkJKNmXXdMfc/+0//6pdJW4NlLDyh0CfoMTr3j1UKXoE/hoStPZP7kCU7yqSH1rS837bpj6nvWHz/Nl0oF9tyPDix0CfoMLrh/QqFL0Kd009EDXk4pDd7cuK1lDmTlFPvxBLy1lR5/vFxCbh7rIymlXfMf/ddtUpuwwV9UUkpPA18ESoHbIuLklNICcu+IPgl8F/h/WQ9GkqRazr4sSdqgQgXI54AT8o9PBP77P2z7PLBPRPQBiIimEbFDxm2fBo7Pz6NoT645jYuIHsDslNJfgZuBQRHRDihKKf0LuAIY9D/UKElSbWJfliRlUp1zIDflHOCWiPghMAc4NeuGKaU5+ctu7oyIj29VdjkwcQPD/xwRN+QfTwX2BvYCXif37upFKaWZEfFN4IcRsRpYCpwMdAX+FhEfh+xL/5cDlCSpFrEvS5IyqbY5kPWRcyBrL+dA1m7OgaydnAOp6uQcyNrLOZC1m3Mga6/aNgdSkiRJkrSVM0BKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyMUBKkiRJkjIxQEqSJEmSMjFASpIkSZIyKSl0AXVJ6+YNOXrv7oUuQ6p3Hn96UqFL0KewZGlZoUtQHdaqWQOO2LNbocuQ6p1Hnv+o0CWomnkGUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpSJAVKSJEmSlIkBUpIkSZKUiQFSkiRJkpRJycZWRETLTW2YUlq85cuRJEkbYl+WJG0NNhoggfFAAqLScx8vJ2DbaqxLkiRVZV+WJBXcRgNkSql7TRYiSZI2zr4sSdoaZJoDGREnRMSP8o+7RcTu1VuWJEnaGPuyJKlQNhsgI+JG4ADgpPxTy4E/VWdRkiRpw+zLkqRC2tQcyI/tnVIaFBGvAqSU5kdEw2quS5IkbZh9WZJUMFkuYV0dEUXkJugTEdsAa6u1KkmStDH2ZUlSwWQJkH8A/gW0j4ifAv8FrqnWqiRJ0sbYlyVJBbPZS1hTSrdGxMvAwfmnjk0pvVW9ZUmSpA2xL0uSCinLHEiAYmA1uctlMt25VZIkVRv7siSpILLchfUy4E6gC9ANuCMiLq3uwiRJ0vrsy5KkQspyBvIbwO4ppeUAEXE18DLwy+osTJIkbZB9WZJUMFkue5lC1aBZAnxQPeVIkqTNsC9Lkgpmo2cgI+J6cnMrlgPjI+Kh/PKh5O74JkmSaoh9WZK0NdjUJawf39FtPDC60vPPV185kiRpI+zLkqSC22iATCndXJOFSJKkjbMvS5K2Bpu9iU5E9AauBvoDjT9+PqW0QzXWpRo0cdzTjL7p56xdW87gLx3Hfl87q8r6F0bdwQv3jSCKi2jUuBlfPv9ndOixPQtmTuOG0w6nXfeeAHTvtytfPu9nhTiEeuvhh8Zw4fnnUl5ezimnncEPL7qkyvqysjJOP/VkXn3lZdq23Ybb7xhJj+22A+C6a37J8L/dTHFxMb++/ncccuhhBTiC+uuAAR35+dd2o7goGPHMB/z+wXfXGzNscDcuHDaAlBITpi3i2399AYDpfzmGt6ctAqB0/nJOvvHZGq1dhWVfrtvef+lpHv7T1aS1a9n18GPZ+7gzq6x/efSdvPzAHURREQ0bN+WIc35G+x59KF+zmtE3XM7M9yewtnwNOx/0ZfY5/qyNfBZVF/ty7fWFHdpx2VH9KA64e9w0/vLk5PXGfGlgJ75/SB9SSrwzYwkX3PkG/Tq34CdfHUDzRsWUJ/jT4+/zn9dnFuAIak6Wu7AOB34O/B/wJeBUYG011qQatLa8nFG//wmnXjOclu078cfvHk2/vQ+kQ4/tK8bscuCRfO7IrwPw9nOP8Z8//pJTfnULAG27bMv3/zyqILXXd+Xl5Zx3zncZ/eAjdO3WjX0/vwdDhw6jX//+FWOG33IzbVq3Yfw7k/jHyLu47EcXc/sdI3l7wgTuHnkXr7w+nhnTp3PE4Qfz5oSJFBcXF/CI6o+igF+dOIjjfvM00xcs56HLD+ah16YzccaSijE9OzTnnCP6cuSvHmfR8tW0a9GoYt3KVeUcdNUjhShdW4fh2JfrpLXl5Yz5w1V8/Rd/o2W7jtxy7jFs/7kDad+jT8WYnfY/kt2HfA2Aic8/xqN//SVf+/nNvP3MGMpXr+LMP45i9coV/PmsIQzYfwitO3Yr1OHUO/bl2qso4Mqv9OfUv77IzEUr+df39+KxCbN5f/ayijE92jXlrAN6ccJNz7N4xRraNmsIwIrV5Vw08g2mzF1Oh5aNuOecvXjm3bksWbmmUIdT7bLchbVpSukhgJTS+ymly4EDqrcs1ZRp775B2y49aNtlW0oaNGTg/kN4+9nHqoxp3KxFxeNVK5dDRE2XqQ14cdw4evfuQ89evWjYsCHHHn8CD4y6r8qYB0bdx4knfROArx59DE8+/hgpJR4YdR/HHn8CjRo1YruePenduw8vjhtXiMOolwb1bMvk2UuZMncZq8sT/x43lcN37VplzDe+2JO/PfE+i5avBmDukrJClKqtk325jpo+MdeT23TuTnGDhvTfbwgTn6/akxs1a17xePXKFRU9OSJYtXIFa8vXsHrVSoobNKBR0+ao5tiXa6+B3VszZe5yps5fweryxOjXZ3LwgI5Vxhy3ZzdGjP2IxStywXD+slUAfDh3OVPmLgdg9uIy5i9dRdvmDWv2AGpYljOQZRERwPsRcTZQCnSo3rJUUxbPnUmrDp0rllu278TUd15fb9zz993Os/+8hfI1qzntutsqnl8wcxo3njWMRs2ac8ipP2C7nfeokboF06eX0q1b94rlrl27MW7cC+uP6Z4bU1JSQstWrZg3bx6lpaV87nOfr7Lt9OmlNVO46NSmCdMXLK9Ynr5gOYN6bVNlTO+OuTduRl1yAMURXHf/eJ4YPwuARg2KeOjygygvT/z+wXd48LXpNVe8tgb25TpqydxZtGjfqWK5ZbuOlL77xnrjXho1ghfu+Rvla1bzjV/9HYC++x7GxLGP8duv78vqspUcfOalNGnRusZql325NuvYqhEzF62oWJ65aCW7dG9VZUzPds0AuPM7n6M4gt8/MolnJs6tMmZg91Y0KC7io3nLqcuyBMgfAM2Bc8jNuWgFnFadRX0aEVEOvAk0ANYAfwduSCl5Wc8mpLT+c8H6Zxg/f9Q3+PxR3+D1x+7nyRE3cczF19KibXsuGvEUTVu1oXTiW4y48tuc8//+U+WMpapP2sCLF+ucHd7omAzbqvps6Hts3dekpCjo1aEFX7nuSbq0acJ9Fx3Aflc+zOIVqxl00WhmLVpJj3bN+OeF+zGhdBFT5ixbf5+qq+zLddYGfjZv4OfF4CNPZPCRJ/LWE6P4751/ZNiF1zD93TeIoiLOGfEMK5cu5tYLv07P3famTefu622v6mFfrr029JVe9xUpLg62a9eMk/40jk6tGnPHtz/HkN/8t+JS1fYtGnHtCQO5eOQbG/z9ui7Z7CWsKaUXUkpLUkofpZROSikNSyltjXdsWJFS2jWlNAA4BDgCuHLdQRGRJTTXG63ad2LR7BkVy4vnzKTlNht/I3vnA4Yy4dnc3KuSho1o2qoNAF132Im2nbdl7rQPq7VefaJr125Mmza1Yrm0dBpdunRZf8zU3Jg1a9aweNEi2rZtS9du62/buXPVbVV9ZixYTpc2TSuWu7RpysyFK6uMmb5gBWNeK2VNeeKjuct5f9YSenXMXY42a1Fu7JS5y3ju3TnsvK1nGeoT+3Ld1aJdJ5bM+eTmG4vnzqL5JnrygP2GMHHsowCMf/IBeg/+AsUlDWjWehu69R/EjPferPaa9Qn7cu01c1EZnVo1qVju1KoxsxeXrTNmJY+On82atYlpC1Ywec4ytmuX6+XNGhXzl9MGccOYibz+0aIarb0QNhogI+LeiLhnYx81WeT/KqU0GzgT+F7knBIRd0fEKODhiGgeEY9FxCsR8WZEHAUQERdFxDn5x9foGoZDAAAgAElEQVRHxOP5xwdFxO0FO6Bq1HXHnZlX+iHzZ0xlzepVvPHkaPrufVCVMZVD4bsvPME23bYDYNnCeawtLwdg/vSPmFs6hba+01ljBu+xB5MmvceHkyezatUq7h55F0OGDqsyZsjQYYy4LXd50z3/+if7HXAgEcGQocO4e+RdlJWV8eHkyUya9B577LlnIQ6jXnr1wwX06ticbds1pUFx8OU9u/PQ61UvQ33w1VL26Zv7xbFt84b06tiCKXOW0appAxqWFFU8v2efbZg4fXGNH4Nqnn257vflLjvszPzpH7Jw5lTKV69iwlOj2eHzB1YZM7/0w4rH7417kjZdewDQsn1nPnz9BVJKrFq5nOnvvM423XvVZPn1nn259npz2iK2a9eUbm2a0KA4GLJLJx6bMLvKmEffms3ne7cFoE3TBmzXvilT56+gQXFw08mD+PfL0xnz5qxClF/jNvWu3401VkU1SCl9EBFFfDIvZC9gYEppfv7dzq+klBZHRDvg+Yi4H3gauAD4HTAYaBQRDYB9gWc29Hki4kxyTZFWHWrfO0XFxSUc+f0rGX7JaaS15Qw6/Bg6brc9jw6/ga477Ey/vQ/i+ftu4/1XnqOopIQmzVtxzEXXAjD5jRd57O+/pai4hCgq4qjzfkrTlp4JqSklJSVc/9sbOXLIYZSXl/PNU06j/4ABXPWTHzNo98EMPXIYp5x2OqedchID+vahTZu23DbiLgD6DxjA0ccex24D+1NSUsINv/uDd3qrQeVrE5fe8Sp3nfdFiouCO5+dzLvTF3PRUQN4/cP5PPT6DJ4YP4v9B3Ti6asOY+3axFV3v8GCZasY3Hsb/u+k3VmbEkUR/P7Bd6rcvVV1mn15M325ck9uWQt7clFxCYd9+8fcefkZrC0vZ5dDj6Z9j+156tbf0nmHndjh8wfx0qjbmfzq2HxPbsmwC64Bcpe1jvrNpfzl7KGQEgMP/Sode/Yt8BHVL/bl2qt8beKq+yZw8xmDKS4K/vniNCbNWso5h/bhrWmLeHzCHJ6ZOJd9d2jHfy7Yl/K1iWtHv8vC5asZtltnBvdqQ+tmDfjq4NwN8S4Z+SZv1+HeHBu6Frs2ioilKaXm6zy3ENiR3G3O90spnZp/vgFwPfBFcrc+3xHoCcwD3gV2Ae4FxgN3AT8DzkkpTdhUDV133Dl996Z7t+RhqYacv1+fzQ/SVqvH2XcXugR9CvPvu4TVc953kk8dVei+3HmHndLpv9uqT8xqIy4/2D9pWpsN/NGYQpegT+m96770ckpp8ObG1dl5BxHRCygHPj7/XPkOEycC7YHdU0qrI+JDoHGlx6cCzwFvkLs1em/g7RoqXZKkOse+LEl1Q5a/A1nrRER74E/AjWnDp1hbAbPzjekAoEeldU8DF+b/fQY4G3htI/uRJEmbYV+WpLoj8xnIiGiUUtqa/5J1k4h4jU9uF34b8JuNjB0BjIqIl4DXgHcqrXsGuAwYm1JaFhEr2cj8R0mSCsW+LEkqhM0GyIjYE7iZ3LuD20bELsAZKaXvV3dx/4uU0kZnGqeUhgPDKy3PJTd5f0NjHyPX7D5e9kJ8SdJWw75sX5akQspyCevvgKHkJrKTUnqd3PwDSZJU8+zLkqSCyRIgi1JKU9Z5rrw6ipEkSZtlX5YkFUyWOZBT85fLpIgoBr4PTKzesiRJ0kbYlyVJBZPlDOS3gfOBbYFZwOfzz0mSpJpnX5YkFcxmz0CmlGYDJ9RALZIkaTPsy5KkQspyF9a/Auv9raWU0pnVUpEkSdoo+7IkqZCyzIF8tNLjxsBXgKnVU44kSdoM+7IkqWCyXMI6svJyRNwGPFJtFUmSpI2yL0uSCinLTXTW1RPosaULkSRJn4p9WZJUY7LMgVzAJ3MtioD5wCXVWZQkSdow+7IkqZA2GSAjIoBdgNL8U2tTSutN3JckSdXPvixJKrRNXsKab0r3ppTK8x82KUmSCsS+LEkqtCxzIMdFxKBqr0SSJGVhX5YkFcxGL2GNiJKU0hpgX+BbEfE+sAwIcm+C2rwkSaoh9mVJ0tZgU3MgxwGDgC/XUC2SJGnj7MuSpILbVIAMgJTS+zVUiyRJ2jj7siSp4DYVINtHxPkbW5lS+k011CNJkjbMvixJKrhNBchioDn5dzwlSVJB2ZclSQW3qQA5I6V0VY1VIkmSNsW+LEkquE39GQ/f4ZQkaethX5YkFdymAuRBNVaFJEnaHPuyJKngNhogU0rza7IQSZK0cfZlSdLWYFNnICVJkiRJqmCAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVSUugC6pKWDUs4aLt2hS5DqncWv/xUoUvQp1C+bEmhS1Ad1rZxQ44b0LnQZUj1ztRHHih0CapmnoGUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoCUJEmSJGVigJQkSZIkZWKAlCRJkiRlYoAUY596lOMO2YNjDhzErX+6fr31r457lpOH7cc+O7bj8Qfvq7Luxmuv5Otf2ouvf2kvHhl9T02VrLyHHxrDwAE7MqBvH6679lfrrS8rK+MbXz+eAX378IW9P8eUDz+sWHfdNb9kQN8+DBywI488/FANVi2AQ/bux+v3XsFb913Jhacest767p3aMOYv5zD2zosZN/JSDtu3PwBtWzVjzF/OYc6zv+b6i4+t6bIlVbNnn3yEYfsPYugXduHmP/xmvfUvv/Asxx/xBQb1bMMjo/9dZd2M0qmcdeJRfPnAwXzlwD0onTqlpspWnn259vq0fbny+jnP/przTjqopkouGANkPVdeXs7//eSHXH/z3dw55nkefuBfTH7vnSpjOnbpzhXX/oFDjzymyvPPPvEQ745/g1tHPcPN/3qUEX/9PcuWLK7J8uu18vJyzjvnu9w36kFefWMCd991J29PmFBlzPBbbqZN6zaMf2cS3z/3B1z2o4sBeHvCBO4eeRevvD6e+x8Yw7nf/w7l5eWFOIx6qagouOGS4zjqezex29E/59jDd6dvr05Vxlx8xuH865FX2Otr13DypX/jt5ceD8DKstVcddMDXHr9vYUoXVI1Ki8v5xeXX8BNf/8X9z72ImPu/yfvT6zakzt16cbPfv1HvnTU+m8gXf6DszjlrHP59+MvMWLUE7Rt176mShf25drss/Tlj1174dE8/Oz4miy7YAyQ9dyE11+mW49edN12Oxo0bMghQ77K04/+p8qYLt22Zfu+OxFFVf+7TJ70LrvtuQ8lJSU0adqM7fvuxNinH6vJ8uu1F8eNo3fvPvTs1YuGDRty7PEn8MCoqmeIHxh1Hyee9E0Avnr0MTz5+GOklHhg1H0ce/wJNGrUiO169qR37z68OG5cIQ6jXtpjp+14f+pcPiydx+o15dz90CsM3X9glTEpJVo2awxAq+ZNmDFnEQDLV67iudc+YGXZ6hqvW1L1euu1l+i+XS+69ehJg4YNOfzIo3ny4dFVxnTt3oMd+u1E0To9+f2J77BmzRr2+uKBADRt1pwmTZrWWO2yL9dmn6UvAxy5/0AmT5vLhPdn1mjdhWKArOfmzJpBh85dK5Y7dOrCnFkzMm27fd+dGPvUI6xcsZyF8+fx8gvPMGtGaXWVqnVMn15Kt27dK5a7du1GaWnp+mO658aUlJTQslUr5s2bR2np+ttOn+5rV1O6dGjFtFkLKpZLZy2ga/tWVcZc/ef/cMIRezJpzM+49/ff5vxr7q7pMiXVsNkzZ9CpS7eK5Q6duzBr1vRM206ZPIkWLVvxgzNP5Lgv7ctvrr7cM1g1zL5ce32Wvty0cUMuOPUQrv5z1RMwdVmNBMiIWLrO8ikRcWMNfe5dIuK1Sstfi4jlEdEgv7xzRLyRf/z/IqL/xvZVF6WU1n8yItO2n/vCgey9/yF867jDuOIHZ7DTbntQUlKyhSvUxmzotYt1XruNjsmwrapPsP7Xet1X5LjDB3P7qOfpc/gVfOX7f+Tmn5/sa6Qtxr68dcryc31jytes4dUXx3LBZT/njlFPMu2jD7nv7hFbukRtgn259vosffmKbw/h97c/zrIVq2qm2K1AfTgD+SbQIyJa5Jf3Bt4Bdqu0/CxASumMlNKE9XdRd3Xo1IXZlc4azp45nfYdOm1ii6pO/c6F3DbqGX7/93shJbpv16s6ytQGdO3ajWnTplYsl5ZOo0uXLuuPmZobs2bNGhYvWkTbtm3p2m39bTt3rrqtqk/p7IV069imYrlrxzZMr3QpDMA3v7wX/3r4FQBeeGMyjRs2oF3rZjVap1RN7Msb0bFzF2ZOn1axPHvGdDp06Jx5274DBtKtR09KSko44NAhvPPWa5vfUFuMfbn2+ix9eY+denD1eV/mndE/5Xsn7s8PTz+Us4//Yo3WX9MKHiAjokdEPBYRb+T/3Tb//PCI+GNEPBERH0TEfhFxS0S8HRHDK21/aESMjYhXIuLuiGheef8ppbXAi8Dn8k/tDvyBXIMi/+9z+X09GRGD84+XRsTVEfF6RDwfER2r8+tQKP0GDmLqlPeZPnUKq1et4pHR9/CFg76Uadvy8nIWLZgPwHvvvMWkd8az574HVme5qmTwHnswadJ7fDh5MqtWreLukXcxZOiwKmOGDB3GiNv+DsA9//on+x1wIBHBkKHDuHvkXZSVlfHh5MlMmvQee+y5ZyEOo156afwU+mzbnh5dtqFBSTHHHjaI0U++UWXM1Jnz2X/PHQHYsWdHGjdqwJwFSze0O2mLsi8XzoBdduejyR8w7aMPWb1qFWNG/Yv9Djki87aLFy1k/ry5AIx77ml6bd+3OsvVOuzLtddn6csHn34DfYdcSd8hV3LjiCe57uaH+dPIpwtxGDWmpq43bFL5chWgLXB//vGNwK0ppb9HxGnA74Av59e1AQ4EhgGjgH2AM4AXI2JXYBpwOXBwSmlZRFwMnA9ctc7nfw7YOyLGAmuBJ4FfAjeQa1Q/3UDNzYDnU0qXRcS1wLeAn687KCLOBM4EqsxbqC1KSkq48MprOffUo1lbXs7QY0+k1w79+MsNv6DvTrvyxYOPYMIbr3Dxt09iyeKF/PfxMfz1t7/izjFjWbNmNWedkGtszZq34Ce//ouXsNagkpISrv/tjRw55DDKy8v55imn0X/AAK76yY8ZtPtghh45jFNOO53TTjmJAX370KZNW24bcRcA/QcM4Ohjj2O3gf0pKSnhht/9geLi4gIfUf1RXr6WH1zzD0bd9F2Ki4K/3/c8b38wkyu+PYRXJnzE6Kfe5JLf3MtNV3yN73/jAFKCb/34tort3xn9U1o0a0zDBiUcecBAhn7nD7zzQf2YuK8tpk725co9uXPX7uvvYStXUlLCpT+7jm+f9BXWlpfz5eNPos+O/fjDr3/OgJ0Hsf+hR/DW6y/zg2+dyOJFC3nq0Qe56Te/4N7HxlFcXMz5l/2cM792JCkl+u+8K0d/7ZRCH1K9Yl+uvT5rX65vYoNz4Lb0J4lYmlJqXmn5FGBwSul7ETEX6JxSWp2f/zAjpdQu/27mIymlERHRC3gopbR9fvtbgXuANcBwcg0LoCEwNqV0+jqf/xDgAuAaYFhK6QcR8QpwGPBGSqlzftyTwIUppZciogxonFJKEXE8cEhK6YxNHWe/nXdLw//9xKf+OqlwdunRutAl6DNos8f3Cl2CPoWyd//B2uWzneRTAPWhLw8YOCjdOfqpz/R1UmHs0LnF5gdpq2VPrr1WvvaHl1NKgzc3bms8XVQ50Zbl/11b6fHHyyVAOblm9rXN7PN5YA9gX2Bs/rlpwAnkL5PZgNXpk3Rdztb5tZIkqbrZlyVJFQo+B5Jcozgh//hE4L//w7bPA/tERB+AiGgaETusOyiltASYCpzCJ41qLHAeG29UkiTVR/ZlSdJGbQ0B8hzg1Pwtu08Czs26YUppDrnmc2d+++eBjc0YfxZolFL6+BZXY4Fe2KgkSarMvixJ2qgamQNZXzgHsvZyDmTt5nyL2sk5kKpOzoGsvZwDWbvZk2uvrHMgt4YzkJIkSZKkWsAAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKxAApSZIkScrEAClJkiRJysQAKUmSJEnKJFJKha6hzoiIOcCUQtdRTdoBcwtdhD4VX7vaq66/dj1SSu0LXYTqpjrek6Hu/3yoy3ztaq+6/tpl6ssGSGUSES+llAYXug7973ztai9fO0kb48+H2svXrvbytcvxElZJkiRJUiYGSEmSJElSJgZIZfWXQhegT83XrvbytZO0Mf58qL187WovXzucAylJkiRJysgzkJIkSZKkTAyQkiRJkqRMDJCSJEmSpEwMkKo2ERGFrkGqT/yek7Qp/oyQalZd/Z4zQKpaRESk/B2aIuKYiBhW6JpUVUTsGxElha5DW8Y633Pt62rTkvTp2Je3fvbluqUu92UDpKpFpW+Y84BLgLcLW5Eq/+CKiObAN4FjC1eRtpSIKFrne+5h4LqI+EZhK5O0tbAvb33sy3VXXe/LBkhVm4joS+4H4b7AlIg4NCIujIhGBS6tXqr0g2znlNJS4Glgh7r0jlh9lVJaCxARXwT6A+eQ++XwwIj4ViFrk7T1sC9vXezLdVdd78ueJtcWs86p+sbAh/mP+4APgDZAU6AduXc/VcMi4nPAPyLi18Bo4ExgHnBjQQvTpxIRuwMLyX1/7Qo8CVyaUnomIiYCC4AhEdE4pfT7wlUqqRDsy1s/+3LdUl/6smcgtUWs06TOAy4CGgM/AV4GbkgpnQD8E1hdqDrrs3V+eTgdGAg8C3wnIj5fuMr0GfQHVgLNUkqvAlcDl0REx5TSLHKN61Ggb0S0LlyZkmqafXnrZ1+uk+pFXzZAaouo1KTOJnd5zN9SSgtTSu+llH6UUno3Is4CzgVGFrLW+igi9gauALoAX+eTd57fAfoCRzhxv/aIiJ0i4t/AP4BGwH0R0T+ldAVwE/BKRHRLKc0HxgCXpJQWFrBkSTXMvrx1sy/XLfWtL/sfU1tMRBSTm1fxKyBFxHeA3YA3yV2WsQ9wSkrprcJVWT9Ufuc5bzG55vQX4G/Ag8DSlNI/ImI18HxKaU0BStX/oNLrOhtYAhydUrojIt4AfhoRP04pXZZ/TSdFRK+U/j979x1mV1U1fvy7ZiaVhBQCCUmoCR2UDgoC0kQpgoL0Iij2hqi8oFhRsb/8LOirgBRpgiIgHakCQQhIr6FlaCEhARJCMrN+f5wzYWYySU5CZm5m5vt5njzcc86+96wzl5l11z5775uNNQ1aUs2Yl5cd5uWeqbfm5Wj7/7JUXbnCVMsk4cjMLIfJfICic+IWoAkYDBwPNGTm7JoF3Eu0G7a0D8WQpXsz88FyAYWfAkOBscDamenQpW4iIlbMzJfLD4VHAVsAn87Mpoj4BbAacEJmPhwRxwMXZuZjtYxZUtcxLy+bzMs9V2/NyxaQWiLt/hgeAKwCPAPcC9QDkzPz1fLYF4DdMvO1mgXcC0XE54FDgT8DJwMHZ+Y/ImIFYAfgy8BhmTmpdlGqqohYh+L368sUdw5epFgI44nM/HzZ5ifApsBnM/PRWsUqqeuZl5d95uWepTfnZedAaom0SlJHAd8EplAsUbwfMBeYFRFHUozvP9ok1flaL/sdEesDBwI7AwE8DfwqIg7MzFcy8yJgR5PUsq/V+/oWcD1F7+bHKN7fjwGbR8ThAJn5deDfwMwahCqphszLyx7zcs9kXraA1BKKwgBgR+BzmXk6cDBFj+dHKJJVAh/JzAdqF2nv0K7n+UCKJcD3AnalGI+/IcWS4OdExC4ADpHpNtYAKD9U/LXcvoJiXtNJwFnA1hExtmx3YmY+V6NYJdWIeXnZYl7u0Xp9XraA1BLJwiyKHrQdImJIZj4F/D+KP471wJ8z85EahtlrtEpSewOfAOoz8xWKFd3uK5s9A1wEdPux971FucT3nyPi3Ijom5mnATcCB2XmJ4HpFB8WPwVsV8NQJdWYeXnZYl7umczLBQtIVRIR60XEjhHRp9xuuX1/JzAc2CUi+lH0wsyi+EPZXJtoe6eI2JxiXssFmdlYTuh+BhgeEedTfAfYseUHCnUD5RLfH6H4wPF/EXEIxXL7L0XEFuXy4D+i+IA4sXaRSupq5uVln3m55zEvF1xER5VExHcphsH8Gfh362EW5bLgm1GsNDWQYqLwPTUJtBeJiLWAFSh+5neV//0usDbF8KUHyuFMm1B8OfENmflwreLV4mtZUbH80PFJiu8G24TiA+KTmfnbsl375eEl9XDm5WWPebnnMy8XLCBVSUTUAScAKwMXAre0S1brAC8DfTLzxdpE2XtExO7A9ymGKg0GxgN7AK9S/EEbDpzqPJfuLyLqM7OpfLwSxTLhx1L0fh6emWfVMj5JtWFeXraYl3sP87JDWFVBq++VOonii1L3A7ZrNWzmaOA0ii/ANUl1sojYjWIVva9k5j6ZuTPFlxBfRpG0fkOx+t7Xyg8Q6iZar9jXovwuqfry8UuZ+SOKZeDPAu7o4hAlLQPMy8sW83LPZV7umHcgVUmrW/Z1wInAShSrh20HfBXYz+ExnS8ihlMkob0y87KI6J+Zb5bHvgscRDEsZi2KL44+KzNfqFnAqqzdin0foLhzQGbe3apN6y8J75uZb9UkWEk1Z15eNpiXey7z8oJZQGo+Cxq3HRF9MnNOmay+BbwPWB/4YGbe29Vx9lblMJkfAztk5isR0S8zZ5fHbqDoAZ3Yer+6j4j4CrA3cC3wfuC4zJxQ26gk1ZJ5edlmXu7ZzMvzcwir2mjf2xIRm0bEplB8P1GrnpbvAxcD25mkulZmXk6xctuEiBiWmbNbhi1RLB/dVLYzSXUzEbE2sEtmbg8MoZg785+I6F/byCTVinl52Wde7rnMyx2zgFQbrZLUV4Djgd2Bn0XEluXx5nLycHNm/jYzH69huL1WZl4BfJ7ij9iw8kPEYcAowKEx3UQHcyvqKJYC/zbFym4HlR8Md42IkV0eoKSaMy93D+blnsG8XI0FpOazqN6WlpWnVFutktVNEfEZ4NPAUZn5Um0jUxXt7iqMBSiXc+9DMRl/v8x8MyKOAr4BzK1ZsJJqyrzcPZiXuzfzcnUNtQ5AtdfB3Ir2vS37lj2cu0bEHa7otuzIzCvKlcAuBjZxefDuo1WS+jxwWEQ8BJwCnEGxquIlEXEj8DHg4Mx8pVaxSupa5uXuy7zcfZmXq3MRnV6ufW9LZj5XPj4H2ArYKDNnlb0tR1KsMtZrf2GWVRExMDNn1joOLVq7FdvGA78EvgR8juJD4lXARGAv4HXgrsx8tEbhSupi5uWewbzcfZiXF58FpIC3e1uAlt6W4cCHgA2A1r0t99csSKkHiYgDgH7AuzPzmIhoAL4JjAAuAa53WJrUe5mXpa5lXq7OOZC9VLnkd8vj8RTfTXQAxXcZHQLUUyxJfSHwJMW4b5OUtBRExH7Ad4D1gKMi4uOZOTczvwO8QfEhsV/tIpTU1czLUu2YlxePdyB7OXtbpK4VETtT3FX438y8q9z+Wbl9etlmRGZOqWWckmrDvCx1LfPy4vMOZC9mb4vU+VqWBG+1NPiGwNrA9hExODOvBb4KfDciDgUwSUm9k3lZ6nzm5XfOO5C9lL0tUudrtxjGOsDzmTkjIvYF9gQuAP6VmTMjYgfgmcx8snYRS6oV87LU+czLS4df49FLtPzCtPrFad3b8mhmXhsRXwVOj4i5mXmWSUp6Z1olqc9SrJb4WEQMp0hSfYF9gX4RcWVm3lCzQCV1OfOy1PXMy0uHQ1h7gXbfJ7V2RCyfmb+i6Nl8N7Bdudz0dRS9n7fWKlapJ4iIYa0evw84miIpHQ48DiY+B0cAACAASURBVNwMnA/cC7wfiA5eRlIPZV6WupZ5eenyDmQvYG+L1HUiYjXgmxFxbmZeD0wDbsvMp8oPjZ+LiPOAPTPzVxExPDPfqG3UkrqSeVnqOublpc87kD2YvS1STdQDk4CPRsQ2wFRg14jYo9Udh0ZgGEBmTq1NmJK6mnlZqgnz8lLmIjo9VEtvC3BuZl4fERsCn8vMz7Sad3EecF5m/r3sbfEXRloKImIwxQpuawPHAWOAfwA/p0hkHwUOyMxHaxakpC5lXpZqx7y8dHkHsueyt0XqIhGxU0R8ptWuAcBHgD7At4AXgB2AZmB54GCTlNTrmJelLmJe7lzegezB7G2RukZEbAHcDhyUmedHxC3A2eW/o4F1gNMz8/YahimpxszLUtcwL3cu70D2IPa2SLWRmXcCWwGnRsQU4DeZeWpmvg5cAjwD7B8RA1t9cbGkHs68LNWGeblzeQeyB7G3RaqtiNgIuAn4TGaeFxF1mdlczn16zSFpUu9iXpZqy7zcOSwge5iI2By4BmgCvpCZ55b7xwEHACOAE4BZ6ZsvLXXlB8argf/JzFNrHY+k2jIvS7VlXl76/B7IHiYz/xMR21H0trR8z1RdZj4REWdT9LbMrGmQUg+WmXdGxM7AnRExOzNPr3VMkmrHvCzVlnl56fMOZA9lb4tUWxGxCTAzMx+pdSySas+8LNWWeXnpsYDswSJiM+BO4Ch7WyRJqi3zsqSewAKyh7O3RZKkZYd5WVJ3ZwEpSZIkSarE74GUJEmSJFViASlJkiRJqsQCUpIkSZJUiQWkJEmSJKkSC0hpKYuIpoi4JyLuj4gLI2LgO3itHSLisvLxXhFx3ELaDo2Izy7BOb4TEcdW3d+uzRkRse9inGv1iLh/cWOUJGlJmZcX2t68rMVmASktfbMyc+PM3BB4C/h064NRWOzfvcz8R2b+eCFNhgKLnagkSerhzMvSUmQBKXWum4HxZQ/fQxHxW+BuYJWI2DUibouIu8se0UEAEbFbRDwcEbcAH2l5oYg4IiJ+XT4eGRF/i4h7y3/vBX4MjCt7WX9atvtaRNwZEf+NiO+2eq0TIuKRiLgWWGdRFxERnyxf596IuKhd7+3OEXFzRDwaEXuU7esj4qetzv2pd/qDlCRpKTAvm5f1DllASp0kIhqADwL3lbvWAc7MzE2AN4BvAjtn5qbAf4BjIqI/8H/AnsD7gFELePlTgBsz893ApsADwHHAE2Uv69ciYldgLWBLYGNgs4jYLiI2Aw4ANqFIhFtUuJyLM3OL8nwPAUe1OrY6sD2wO3BqeQ1HAdMzc4vy9T8ZEWtUOI8kSZ3CvGxe1tLRUOsApB5oQETcUz6+GfgTMBp4OjNvL/dvDawP3BoRAH2B24B1gUmZ+RhARJwNHN3BOXYEDgPIzCZgekQMa9dm1/LfxHJ7EEXiGgz8LTNnluf4R4Vr2jAifkAxHGcQcFWrYxdkZjPwWEQ8WV7DrsC7Ws3DGFKe+9EK55IkaWkyL5uXtRRZQEpL36zM3Lj1jjIZvdF6F3BNZh7Yrt3GQC6lOAL4UWb+vt05vrwE5zgD2Dsz742II4AdWh1r/1pZnvsLmdk6oRERqy/meSVJeqfMy+ZlLUUOYZVq43Zgm4gYDxARAyNibeBhYI2IGFe2O3ABz78O+Ez53PqIWB54jaIXs8VVwJGt5nCMiYiVgJuAfSJiQEQMphiWsyiDgecjog9wcLtj+0VEXRnzmsAj5bk/U7YnItaOiOUqnEeSpFowL0sVeQdSqoHMfLnsMTw3IvqVu7+ZmY9GxNHA5RExBbgF2LCDl/gS8IeIOApoAj6TmbdFxK1RLMd9RTnfYj3gtrKn9XXgkMy8OyLOB+4BnqYYzrMo3wLuKNvfR9uE+AhwIzAS+HRmvhkRf6SYg3F3FCd/Gdi72k9HkqSuZV6WqovMpXVXXpIkSZLUkzmEVZIkSZJUiQWkJEmSJKkSC0hJkiRJUiUWkJIkSZKkSiwgJUmSJEmVWEBKkiRJkiqxgJQkSZIkVWIBKUmSJEmqxAJSkiRJklSJBaQkSZIkqRILSEmSJElSJRaQkiRJkqRKLCClbiQKd0bE+kvhtcZExL8j4rWIOGlpxPcOYvlYRJxRyxgkSd3f0syTSyGW3SLi8S44zw4R8UREvF6esyb5PSJeiIhtK7RbNyLmttq+PCJ26NTgtFRZQEqLqfwD3fKvOSJmtdo++B287u0Rccgimu0LTM7MB8vnrBARZ0bEixExIyIejoivVDzlZ4GnMnNwZp4QET+OiD8uafzv0F+B90TEOjU6vyRpKVlW8mRErBERTRExtNVrfH8B+/7eavu9EXF1REyPiFfK83YYd0R8OiLmltc2IyLujojdlvQal9BJwE8yc1BmXkm7/N5BzOdFREbEru32n1ruP6CL4m5xMsU1qJuwgJQWU/kHelBmDgKeAfZste+cTj79p4GzWm3/GghgbWAo8BHgqYqvtRrw4NIMbkllZjNwAfDJWsciSXpnlpU8mZmTgMnA+1od3w54tIN9N0FxNw+4GrgSWAMYAXwR2H0h57yhvNZhwLnAhRExaClcS1WrAQ+0215Ufn8UOLxlIyL6AXtT/TPE0nQzsEpEbFSDc2sJWEBKS1lE1EfEtyLiyYiYEhHntPR0RsRyZc/f1Ih4NSLuiIhhEfFzYAvgj2Uv5s87eN2BFEnuxla7twDOyczpmdmcmQ9m5t9aPWf7sjd0etmDukW5/1xgf+Bb5fm+BRwDHF5uTyjb3R4R34mICeX+i8u7nheUPa23R8TYVuf7XUQ8Vx6bEBFbl/sjIq5rPZQmIv4eEb9tdS03sPAELUnqAbo4T95c7iMi+gLrA79tt29LygIS+Bnw+8z8RWZOzcKEzDxoUdeVmU3AacAgYPUO4jsxIiZFMbT0/ojYvSXuMm+u1art2IiY2ern8rkohqm+UubikeX+54DRwNXlz6V9fn9f+zhKFwM7R8TgcntP4DbglVYx1EfEdyPimShGOp3Wqj0RcVR57OWI+Fq7a13ge9zBzy0p3rMPLfCHq2WKBaS09H0N2BXYFhgLzAF+WR77BNAAjKHo1fw88FZmfhW4E/hE2UP71Q5edz1gRmZOabXvduDkiDg8Isa3bhwRKwGXAj8GVgBOBf4ZEUMy80DgIuD75fm+D/wC+HO5vWWrl9of+BiwKrARcCvwG2A48DTQenjMbWWbFYBLKHph+5TJ4QjgUxGxTUQcVV7Psa2e+xCwbtkLKknquboyT95EWSxSFIoTKTosW++bA0wsC5zNKKZVLLaIaACOAqYDkzpo8gjwXmAIxbDN8yJiRGbOLM/ZenjuwcDlmflqRHwI+BawD8XPZQpwNkBmjgVeAnYtfy7t8/vNCwj3DeAqiiG/AIcBZ7Zr8ymK/P8+YC1gJYrPCkTExsCvKD4jjKUomEe0eu7C3uOOPAS8eyHHtQyxgJSWvk8Bx2VmY2a+CXwX2D8iguIP6IrAuMycm5l3ZuYbFV93KPBaB+e6CPgK8HBEPBIRO5fHPgzck5kXlOc6A3gO+OBiXs8fM/OpzJxKMaznocy8MTPnUiS8TVoaZuaZmTktM+cAP6QoJNcsjz0LfAk4B/gpcGiZNFu0XNuQxYxPktS9dGWevBHYNCKWoyiEbgbuB1Zvte/W8u7hCuVznl/M69k+Il4FXqDIvXt3FHNmnp+Zz5cjhs6iGF67WXn4zxRFY4tDeHvKysHAHzLzv+XP6+vAThExajHjbO9M4LCIGEFxd/fydscPBn6amU9n5gyKDuODy/fpY8BFmXlbZs4GjqdtXbGw97gjr1G8f+oGLCClpaj8w7gKxZ2+V8uEMpHid20F4E8Uyeyv5VDPH0ZEfcWXnwYMbr0jM9/IzO9l5sbl618KXFQOMRlNcYewtacpei8Xx4utHs/qYHvePI+I+J+yiJ1extuftj2SFwPLARMzc0K787Rc2/TFjE+S1E3UIE8+DEyluPO3HXBzOSrmzlb7WoavtgzfXHkxL+vGzByamSMyc5vMvKGjRuWQz/+2uu7xvJ0jbwLqI+I95d29lYErymNt8nlmvgrMYPHzeXvXU3TyHgdcnJlvtTve/nPE08AAihFIo4FnW8U0nTJ/V3iPOzIYePUdXo+6iAWktBSVSWkysGOZTFr+9c/MKZk5OzNPzMx1KZLWfkDLame5iJd/CBhc9hR2dO7pFMNVl6cYbtpIMZG+tVXL+Dp8iUVd38JExC7AFyiG2AylSDCzKBb5afET4C5g7YjYp91LrAc8XPZkSpJ6oBrlyZuBHYDNgTva7XsvZQFZFmZ3AR99J9fYkYhYG/h/wNHA8MwcCjxOmSPLn8uZFHceDwXOK0fzQLt8HhFDKHL9gvJ5JeUCdudSrIHQfvjqfOel+Awxi6Igf56iSGwd05BW17LA93gB4awH3PtOrkddxwJSWvpOBX4cEatAMRcxIvYsH+8cEetHRB1F7+FcoKl83ouUwz07kpmzaDtvgygWuNk0IvpExACKleKmUCSlfwCbRMS+EdEQEYdR/PG/cgGneBFYYyHDSxZlMMXQo5eBvsD3KO5AtsS6C8WQl8Mp5kOe2rIIQGl73u5tlST1XF2WJ0s3UcytfKxsA3BLua8Pxd3IFscCn46IL0fE8ChsFhFnL/nlAsVonWaKHFkXEZ+muAPZ2pkUefJA2hZ05wKfjIgNI6I/xfzJ6zPzhXcYExSLBu2cmXd0cOxc4NiIWLUc2fQD4C9lgXgB8JGI2Kpcu+AH5fW1WOB73F75uWM7/AzQbVhASkvfT4Brgesj4jXg38Cm5bExFIvLvEYxB+OfFH+EoZhcflhETIuInyzgtX9P0TPZoo5iIv1UivmN2wAfKntwXwT2opiz8ArFQgR7lD2sHTkPGAhMjYh/L94lA8Xw2ZuAJ4AnKQrZlwEiYhhwOvCpzHwxM68rz/d/5fGgmIj/hyU4rySpe+nKPAnFkNiVKIrGFndS3MW7o/XQzXL46a4UK4I+RZHLfs388wMXS2beTVFU/Yfi7t0a5ePWbZ6gWGjntdbTPDLzMuBHFB3DjcCoDq5xSeOakpnXL+Dw7yimnvybIrdPpbhbSWZOBL5KsRbCcxRf19L67uLC3uP2tqX47s7/vrOrUVeJohNBUndQFlp3AEdk5jLxHY5LQ0TsR/E9YYfVOhZJUvfV3fNkRPwFeDAzf1DrWLpKRFwG/GIhhayWMRaQkiRJUo2VX8d1N7BeZr6j+Y1SZ3IIqyRJklRD5ZDcicD3LB61rPMOpCRJkiSpEu9ASpIkSZIqaah1AD1Jw8Ah2XfoyEU31DJnvZWXr3UIegeefnXWohtpmfP6y428OWPakn5tjLRQdf0HZ92gFWsdhpbAu1cbXusQ9A48Pc2c3F29MunBKZm5yD+cFpBLUd+hIxn/id/WOgwtgVtP3LnWIegd+NxF99U6BC2BS44/YNGNpCVUN2hFhu7xw1qHoSVw6x/929Cdffav5uTu6vQD3/V0lXYOYZUkSZIkVWIBKUmSJEmqxAJSkiRJklSJBaQkSZIkqRILSEmSJElSJRaQkiRJkqRKLCAlSZIkSZVYQEqSJEmSKrGAlCRJkiRVYgEpSZIkSarEAlKSJEmSVIkFpCRJkiSpEgtISZIkSVIlFpCSJEmSpEosICVJkiRJlVhASpIkSZIqsYCUJEmSJFViASlJkiRJqsQCUpIkSZJUiQWkJEmSJKkSC0hJkiRJUiUWkJIkSZKkSiwgJUmSJEmVWEBKkiRJkiqxgJQkSZIkVWIBKUmSJEmqxAJSkiRJklSJBaQkSZIkqRILSEmSJElSJRaQkiRJkqRKLCAlSZIkSZVYQEqSJEmSKrGAlCRJkiRVYgEpSZIkSarEAlKSJEmSVIkFpCRJkiSpEgtISZIkSVIlFpCSJEmSpEosICVJkiRJlVhASpIkSZIqsYCUJEmSJFViASlJkiRJqsQCUpIkSZJUiQWkJEmSJKkSC0hJkiRJUiUWkJIkSZKkShpqHYBqb5vxK/CND61NXQQX3z2Z025+us3xvTZemWM+sBYvzZgNwHl3PMvFdzeyxRrD+Npua89rt8aIgXz9wvv518Mvd2n8vdnVV13Jscd8iaamJo448hN87evHtTk+e/Zsjvr4YUy8+y6GD1+Bs/9yPqutvjoAPz35R5xx+p+or6/n5788hV12/UANrqD32nDUIA7cZDQRcPOT07hiAb83m41dns9usxrfu/pxnp42izWGD+CwzccAEAGX3P8SEyfP6MrQJXWiHTcaxQ8P2pS6uuDsm57klMsfmq/Nh7dYha/vvSEJPPDMq3zq97cBcP5Xt2fzcStwx6Mvc9Cvbu7iyAXm5e5sw1GDOGjTt/PyPx9qm5d3GDecHddageZMZs9t5s93TqZxxmzq64LDNx/N6sMHkpn8ZeLzPPLSGzW6iq5hAdnL1QUcv8c6HP3nibw4403O/dSW3PDwFJ58ue3/+Ffd/yI/uvyRNvvunDSNj/3uDgCWH9DA5V/ahtueeKXLYu/tmpqa+PIXP8flV1zDmLFj2XbrLdhjj71Yb/3157U547Q/MWzoMB54+HEuOP88Tjj+G5z9l/N56MEHufD887j73gd4vrGRD+22M/c9+Cj19fU1vKLeIwIO3mw0P79hEtNmzeVbu4zjnsYZPF920rTo31DHzmuN4IlXZs7bN3n6m3z/msdpThjSv4HvfGAt7m2cQXN29VVIWtrqIjj50M3Z96f/onHqLK759i5cOXEyjza+3Um05shBfGmP9fnQSdcyfeYcRgzuN+/Yr//5MAP71XP4DuNqEX6vZ17uviLgkM1H8/N/TWLqrLmcuMs47pk8g8ZWefn2p1/lhiemArDx6MHsv8nK/PLGp9h+zWEAnHjlYwzuV89Xtl+D71/9OD05LTuEtZfbcOwQnpk6i8nTZjG3Kbnyvhd5/7orLvbr7LL+SG55bApvzmnuhCjVkTsnTGDcuPGsseaa9O3bl/32P4DLLr2kTZvLLr2Egw89HICPfHRfbrj+OjKTyy69hP32P4B+/fqx+hprMG7ceO6cMKEWl9ErrTl8IC+99hZT3phDU3My4ZnpbDJm+fna7b3RSK54+GXmNL39e/VWU84rFvvUB9mjU5TUu2y65nAmvfgaT7/8BnOamvnbHc/wwU3GtGlz6PbjOO26x5g+cw4AU157+wPuzQ+9yOtvzu3SmPU283L31ZKXXy7z8h3PTGfjdnn5zblv5+J+DXW0pN/RQ/rz4IvFjZfXZjcxc04Tqw8f0GWx14IFZC83cnA/Xpz+5rztF2e8yUrL95uv3c7rr8RfP7sVP99/I0Z2cPyDG43kivte7NRY1VZj42TGjl1l3vaYMWOZPHny/G1WKdo0NDSw/JAhvPLKK0yePP9zGxvbPledZ+iABqbOmjNve9rMOQwd0KdNm1WH9mf4gD789/nX5nv+GsMH8L3d1uK7H1iLs/7T6N1HqYdYedgAGqe+PeKgcdosVh7W9oPouFGDGTdqMJefsBNXfmtndtxoVFeHqQUwL3dfQwc0MHVmq7w8aw7D2uVlgB3HD+fHe6zNfhuP4py7GwF49tVZbDJmeeoCRizXh9WHDWD4wPmf25N0WgEZEa+32z4iIn7dWefr4PxnRMS+XXW+bivm35XtPoze+MgUdvvFLez72zu4/YmpnPSRDdocHzGoL+NHDuLfjzt8tStl+zcKiIhqbSo8V52n4590tjm+/yYrc/49z3fYctLUWZx45WP84Jon+NB6K9JQ53unRTMvL/s6+jvc/q91Q12w5sjBfPjH13P0727jVx/fkuV7+IfV7sK83H119KPuaITP9Y9P5bjLHuXCe19gzw1WAor5ktNmzeHEXcdz4CajeXzKTJo6eD97Eu9A9nIvzpjNyCH9522PXL4/L7/Wdh7W9FlzmNNU/CJcdNdk1hvd9pb+BzYcyfUPvcRcb4N0qTFjxvLcc8/O2548+TlGjx49f5tnizZz585lxvTpDB8+nDFj53/uyiu3fa46z7RZcxneqmdz2MA+vDrr7WFn/fvUMWZIf76+45qcvMc6jFthIF9832qs1u5OxPOvzeatuc2MafU7LKn7apw6k9HDB87bHj1sAC9Mm9W2zbRZXDFxMnObkmemvMHjL7zGuJGDuzpUdcC83H1Nmzm3zV3DYQPa5uX2Jjz99tST5oTzJj7Pd656nP93y9MM7FvHS6+91ekx11JNCsiIWC0irouI/5b/XbXcf0ZE/C4i/hURT0bE9hFxWkQ8FBFntHr+rhFxW0TcHREXRsSgiueNiPhpRNwfEfdFxP7l/pUj4qaIuKc89r6IqC/jaWn7lU75YdTYA5NnsNrwAYwZ2p+G+mC3jUZyQ7vVIEcM6jvv8Q7rrsikdgvsfHCjUQ5frYHNt9iCxx9/jKcmTeKtt97iwvPPY/c99mrTZvc99uKcs/4MwMUX/ZXt378jEcHue+zFheefx+zZs3lq0iQef/wxtthyy1pcRq80aepMRg7ux4jl+lBfF2y56hDuabWS6qw5zXz57w/xjcse4RuXPcITr8zklJuf5ulpsxixXB9abjiuMLAPo5bvxytv9OxEpc5nXl42TJw0lTVHDmbVEcvRp76OfbZalSsnth3G+M+7n2PbdYs7H8MH9WXcyME89dLrHb2cuph5uftqn5e3apeXAVZq9Xn4XaMH89LrxQ2XvvVB3/oiMa8/chBNzbRZfKcn6sxVWAdExD2ttocD/ygf/xo4MzP/HBFHAqcAe5fHhgE7AnsBlwLbAJ8A7oyIjYHngG8CO2fmGxHxDeAY4HsVYvoIsDHwbmBE+Zo3AQcBV2XmSRFRDwws243JzA0BImLokvwQlnVNzckPL3+E3x22CfV1wd/vbuSJl9/gszuuyYOTZ3DDI1M4aOtV2GHdFWlqTqbPmsM3//bAvOePHtqfkUP68Z+nptXwKnqnhoYGfvm/v2bP3T9AU1MThx9xJOtvsAHf+86JbLrZ5uyx514cceRRHHnEoWyw7niGDRvOWeecB8D6G2zAR/f7GJu8a30aGhr41Sm/caW3LtSccM7djXxl+zWoC7jlyWk0zpjNhzdciaemzuLexvnnPbZYa8RyfHC94vcxgbPvauT1t5q6Lnh1Z+blZVxTc3Lc2Xdx4bHbU1dXx19ufpJHGmdw3D4bcs+kqVx5TyPX3/cC799gFLee9EGampPvXHAP08pOpEv/ZyfWWnkwy/Vv4L+/2IsvnTaBf93/Qo2vqvcwL3dfzVnk02O2X4O6urfz8t5lXr6n8TV2WmsF1h81iKbm5I23mvjj7c8BMLh/A1/dfg2aM3l11lz+ePuzizhb9xcdjcVeKi8c8XpmDmq1fQSweWZ+PiKmACtn5pyI6AM8n5kjyt7MazLznIhYkyJ5rFU+/0zgYmAucAZFwgLoC9yWmUe1O/8ZwGWZ+ddW+34J3JeZp5XbZwEXAq8CpwFnA3/PzHsiYhjwH+CfwOXA1Zk53xKjEXE0cDRAnyErbbbuF89Z4p+ZamfCiTvXOgS9A5+76L5ah6AlcMnxBzDliQec5NNFekNebp2T65Ybsdmwff/fO/qZqTae++MBtQ5B78Bn/2pO7q5OP/Bdd2Xm5otqt6zMgWxdxbbc821u9bhlu4FifYlrMnPj8t/67ZPUQnT4QSUzbwK2AyYDZ0XEYZk5jaJH9Abgc8AfF/DcP2Tm5pm5ecPAIRXDkCRpmdYt83LrnBz9nRcoSZ2hVgXkv4GW7qWDgVsW47m3A9tExHiAiBgYEWtXfO5NwP7lPIoVKZLThIhYDXgpM/8P+BOwaUSMAOoy8yLgW8CmixGjJEndiXlZklRJZ86BXJgvAqdFxNeAl4GPV31iZr5cDrs5NyJavpDwm8CjHTT/fUT8qnz8LPBe4D3AvRS9q1/PzBci4nDgaxExB3gdOAwYA5weES1F9v8szgVKktSNmJclSZV02hzI3mjg6LVz/Cd+W+swtAScA9m9OQeye3IOpDpTw4g1c+geP6x1GFoCzoHs3pwD2X11tzmQkiRJkqRlnAWkJEmSJKkSC0hJkiRJUiUWkJIkSZKkSiwgJUmSJEmVWEBKkiRJkiqxgJQkSZIkVWIBKUmSJEmqxAJSkiRJklSJBaQkSZIkqRILSEmSJElSJRaQkiRJkqRKLCAlSZIkSZVYQEqSJEmSKrGAlCRJkiRVYgEpSZIkSarEAlKSJEmSVIkFpCRJkiSpEgtISZIkSVIlFpCSJEmSpEosICVJkiRJlVhASpIkSZIqsYCUJEmSJFViASlJkiRJqsQCUpIkSZJUiQWkJEmSJKkSC0hJkiRJUiUWkJIkSZKkSiwgJUmSJEmVWEBKkiRJkiqxgJQkSZIkVWIBKUmSJEmqxAJSkiRJklSJBaQkSZIkqRILSEmSJElSJRaQkiRJkqRKLCAlSZIkSZVYQEqSJEmSKrGAlCRJkiRVYgEpSZIkSarEAlKSJEmSVIkFpCRJkiSpEgtISZIkSVIlFpCSJEmSpEosICVJkiRJlVhASpIkSZIqsYCUJEmSJFViASlJkiRJqsQCUpIkSZJUSUOtA+hJRizfj6N2GVfrMKRe55IrHqh1CFoCr06fVesQ1IOtNHw5jj5ws1qHIfU65575r1qHoE7mHUhJkiRJUiUWkJIkSZKkSiwgJUmSJEmVWEBKkiRJkiqxgJQkSZIkVWIBKUmSJEmqxAJSkiRJklSJBaQkSZIkqRILSEmSJElSJRaQkiRJkqRKLCAlSZIkSZVYQEqSJEmSKrGAlCRJkiRVYgEpSZIkSarEAlKSJEmSVIkFpCRJkiSpEgtISZIkSVIlFpCSJEmSpEosICVJkiRJlVhASpIkSZIqsYCUJEmSJFViASlJkiRJqsQCUpIkSZJUiQWkJEmSJKkSC0hJkiRJUiUWkJIkSZKkSiwgJUmSJEmVWEBKkiRJkiqxgJQkSZIkVWIBKUmSJEmqxAJSBTlSjwAAIABJREFUkiRJklSJBaQkSZIkqZKGBR2IiOUX9sTMnLH0w5EkSR0xL0uSlgULLCCBB4AEotW+lu0EVu3EuCRJUlvmZUlSzS2wgMzMVboyEEmStGDmZUnSsqDSHMiIOCAiji8fj42IzTo3LEmStCDmZUlSrSyygIyIXwPvBw4td80ETu3MoCRJUsfMy5KkWlrYHMgW783MTSNiIkBmTo2Ivp0clyRJ6ph5WZJUM1WGsM6JiDqKCfpExApAc6dGJUmSFsS8LEmqmSoF5G+Ai4AVI+K7wC3AyZ0alSRJWhDzsiSpZhY5hDUzz4yIu4Cdy137Zeb9nRuWJEnqiHlZklRLVeZAAtQDcyiGy1RauVWSJHUa87IkqSaqrMJ6AnAuMBoYC/wlIv6nswOTJEnzMy9Lkmqpyh3IQ4DNMnMmQEScBNwF/KgzA5MkSR0yL0uSaqbKsJenaVtoNgBPdk44kiRpEczLkqSaWeAdyIj4JcXcipnAAxFxVbm9K8WKb5IkqYuYlyVJy4KFDWFtWdHtAeDyVvtv77xwJEnSApiXJUk1t8ACMjP/1JWBSJKkBTMvS5KWBYtcRCcixgEnAesD/Vv2Z+banRiXutBDd9zIxad8j2xuZuvdP8bOh3ymzfFbLzmHWy4+i6ivp9+Agez/tR8yavW1ePrBezn/Z8cXjTLZ7eNf4l3bfaAGV9B7XX3VlRx7zJdoamriiCM/wde+flyb47Nnz+aojx/GxLvvYvjwFTj7L+ez2uqrA/DTk3/EGaf/ifr6en7+y1PYZVffu66040aj+OFBm1JXF5x905OccvlD87X58Bar8PW9NySBB555lU/9/ja2XXclvn/QJvParLXy8nzyd//mirsnd2H0qiXzcs/2+H9u4srfnURzcxOb7rYf2+7/qTbH/3P5udx56TlEXR19+w9kzy/9gBVXG8/kR+7l0v/9VtEok+0P+QLrbbNrDa6gdzMvd1+7bLYaP/vUdtTXBWdc9QA/u/Cu+dp89H1rccLBW5GZ3DdpCkf85Cq2e9dYfvLJ981rs84qwzjs5Cu59LaeOzW9yiqsZwA/AH4GfBD4ONDciTGpCzU3NfHXX36bz/ziTIauOIpfHL03G267M6NWX2tem8123ottPnwwAPffci1///VJfPpnZ7Dymmvz1T9cQn1DA9OnvMRPj9ydDd67E/UNVb9eVO9EU1MTX/7i57j8imsYM3Ys2269BXvssRfrrb/+vDZnnPYnhg0dxgMPP84F55/HCcd/g7P/cj4PPfggF55/Hnff+wDPNzbyod125r4HH6W+vr6GV9R71EVw8qGbs+9P/0Xj1Flc8+1duHLiZB5tnDGvzZojB/GlPdbnQyddy/SZcxgxuB8Atzz8Eu8/8SoAhi7XlztP3p0b7n+hJtehmjkD83KP1NzUxD9/810O/eHpLD9iFP/3xY+yztY7seJq4+e12WiHPdl89wMBeOS267jqDz/ikJP+xEqrrc3R/+9i6uobeO2Vlzj1s3uxztY7UldvTu4q5uXuq64u+NVnd2D3E/7G5Cmvc8uv9uey2yfx8LNT57UZN3oIx35sc3Y89kJefX02Kw4ZAMBN/32Orb9wLgDDBvXj/j8dzrV3P1OT6+gqVVZhHZiZVwFk5hOZ+U3g/Z0blrrK0w/dy4gxqzFi9Ko09OnLJjvtwX23XNOmTf/lBs97PPvNmRABQN/+A+YVi3Pfmg3RdXEL7pwwgXHjxrPGmmvSt29f9tv/AC679JI2bS679BIOPvRwAD7y0X254frryEwuu/QS9tv/APr168fqa6zBuHHjuXPChFpcRq+06ZrDmfTiazz98hvMaWrmb3c8wwc3GdOmzaHbj+O06x5j+sw5AEx5bfZ8r7PX5qtw3X3PM+utpi6JW8sM83IPNfmR/zJ85dUYtvKq1Pfpywbb787Dt13bpk2/5QbNe/zWm7NaUjJ9+g+YVyzOnTObCJNyVzMvd19brD2SJxpf5akXZjBnbjMX3vQYe7xnzTZtjtxtQ35/2X959fUiH788fdZ8r7PPtuO5+j9PMWv23C6Ju1aqdEvNjuKv0BMR8WlgMrBS54alrjJ9ygsMW2nledtDV1yZpx+8Z752N198JjdccBpNc+bwuV+dPW//Uw/ew3k//gZTX5zMISf83LuPXaixcTJjx64yb3vMmLFMmHDH/G1WKdo0NDSw/JAhvPLKK0yePJmtttq6zXMbGx0C2VVWHjaAxqkz5203TpvFZmsOb9Nm3Kii4+byE3aivi74yd/v5/r72t5p3GerVfndVY90fsBa1piXe6jXXnmR5VccNW97+RGjmPzIvfO1m/CPs7n9b6fTNGcOh5185rz9zz18L//4xf/w6kuN7PO1n3j3sYuZl7uv0SsM4rkpr8/bnjzldbZcZ2SbNmuNGQrA9T/bl/q6On5wzh1cc9fTbdrst/3anPK3iZ0fcI1VuQP5FWAQ8EVgG+CTwJGdGdSSiIimiLgnIh6IiHsj4piIqHJ9vVvOv6ujXsv3feQwvnXeDez56a9z9Zm/mbd/9fU35rgzr+KY3/+da8/+HXNmz3+XRJ0jc/43r/17t8A2FZ6rztPRz7r9O9JQF6w5cjAf/vH1HP272/jVx7dk+YF95h0fOaQ/640dwvX3P9/J0WoZZF7uoTr6m00Hfy+23OsQvnj6dex81Ne4+dzfzts/dt1389k//JNPnvJXbjn/98XoIHUZ83L31dGPuv1bUl9fx/jRQ9n1Gxdz2MlX8rsv7cSQ5frOOz5q2EA2WH0E19zVs4evQoUCMjPvyMzXMvOZzDw0M/fKzFu7IrjFNCszN87MDYBdgA8B327fKCLsjmtlyIqjmPbS2x9AX335eZYfseCO7E122pP7brl6vv2jVh9P3wEDeX6Sd0O6ypgxY3nuuWfnbU+e/ByjR4+ev82zRZu5c+cyY/p0hg8fzpix8z935ZXbPledp3HqTEYPHzhve/SwAbwwre1QmMZps7hi4mTmNiXPTHmDx194jXEj3x5O/uEtV+WfdxfH1buYl3uu5UeMYsbLb480mDHlBQYPX3BO3nD73Xn439fOt3/FVcfTt/9AXnrq0U6JUx0zL3dfk6e8ztgRbw8PHzNiEI1T35ivzaW3P8ncpmaefnEGjz43jfGjh847/tHt1uIf/36CuU09f0r6AgvIiPhbRFy8oH9dGeTiysyXgKOBz0fhiIi4MCIuBa6OiEERcV1E3B0R90XEhwEi4usR8cXy8S8j4vry8U4RcfYCT9iNrbruu5jy3FO80vgsc+e8xcTrLmPDbXZu0+blZyfNe/zgbf9ixbGrA/BK47M0zS3GeE99YTIvPfMkw0eN7bLYe7vNt9iCxx9/jKcmTeKtt97iwvPPY/c99mrTZvc99uKcs/4MwMUX/ZXt378jEcHue+zFheefx+zZs3lq0iQef/wxtthyy1pcRq80cdJU1hw5mFVHLEef+jr22WpVrpzYdqjSP+9+jm3XLT44Dh/Ul3EjB/PUS28Pr/nI1qty8e1th86oZzMv9/y8PGadjXil8SmmvfAsTXPe4oEbL2edrXdq0+aVyU/Ne/zohBsYPmZ1AKa98CzNTUVOfvXFyUx5bhJDR7adW63OZV7uvv7z6IuMHz2U1UYuT5+GOvbbbi0uv73tKqqX3vYk27+r+Jy7wvL9WWvMUCa98Pbidx/bfh0uuLF3dNosrNfv110WRSfIzCfLoTItXXfvAd6VmVPL3s59MnNGRIwAbo+IfwA3AV8FTgE2B/pFRB9gW+Dmrr+Kzlff0MBHv/wdTj32cJqbm9nqQ/ux8hpr888//ZJV19mIDbfdmZsvPotH77qVuoYGBg4ewkHH/wyAJ+/7D9edcyp1DQ3URR37HvM9Bg0dvogzamlpaGjgl//7a/bc/QM0NTVx+BFHsv4GG/C975zIppttzh577sURRx7FkUccygbrjmfYsOGcdc55AKy/wQZ8dL+Pscm71qehoYFfnfIbV3rrQk3NyXFn38WFx25PXV0df7n5SR5pnMFx+2zIPZOmcuU9jVx/3wu8f4NR3HrSB2lqTr5zwT1Me+MtAFYZsRxjhg/k1kdeqvGVqIuZl3t4Xq6rb+BDnz2Rs084imxuYuNd92Wl1dfiX2f+L6PX2pB13rMTE/5xNpMm/pu6hgYGDBrC3l89GYBn7r+LWy/4A3UNDUTUsfvnv83AIebkrmRe7r6ampOv/O4GLv3Bh6mvq+PPVz/AQ89M5VuHbMXdj73E5XdM4pq7nmbnTVfl7lMPoam5meP/dAtTX3sTgFVXGszYEYO4+b7nanwlXSM6HG/fDUXE65k5qN2+V4F1KJY53z4zP17u7wP8EtiOYunzdYA1gFeAR4B3A38DHgDOA74PfDEzH+zgvEdT9KoybOTozb594S2dcn3qXJ96zxq1DkHvwNhPnFfrELQEXr3seOZOedJJPj1ULfJy65w8ZKXRm335zBs66/LUiY7baa1FN9Iya9hep9Q6BC2hN6/40l2Zufmi2vXYyewRsSbQBLR00bceyHwwsCKwWWZuDLwI9M/MOcBTFN+p9W+K3s33A+OA+b/lG8jMP2Tm5pm5uXffJEnqWFfk5dY52btvktQ5emQBGRErAqcCv86Ob7EOAV7KzDkR8X5gtVbHbgKOLf97M/Bp4J4FvI4kSVoE87Ik9RyVVz6LiH6ZuSyvBz0gIu4B+gBzgbOAXyyg7TnApRHxH+Ae4OFWx24GTgBuy8w3IuJNeuA8C0lS92ZeliTVwiILyIjYEvgTRe/gqhHxbuATmfmFzg5ucWTmAmcaZ+YZwBmttqdQTN7vqO11FMmuZXvtpRakJEnvkHnZvCxJtVRlCOspwB4UE9nJzHsp5h9IkqSuZ16WJNVMlQKyLjPbf9lYU2cEI0mSFsm8LEmqmSpzIJ8th8tkRNQDXwB6x7dkSpK07DEvS5JqpsodyM8AxwCrUiyrvXW5T5IkdT3zsiSpZhZ5BzIzXwIO6IJYJEnSIpiXJUm1VGUV1v8D5vuupcw8ulMikiRJC2ReliTVUpU5kNe2etwf2Ad4tnPCkSRJi2BeliTVTJUhrOe33o6Is4BrOi0iSZK0QOZlSVItVVlEp701gNWWdiCSJGmJmJclSV2myhzIabw916IOmAoc15lBSZKkjpmXJUm1tNACMiICeDcwudzVnJnzTdyXJEmdz7wsSaq1hQ5hLZPS3zKzqfxnkpIkqUbMy5KkWqsyB3JCRGza6ZFIkqQqzMuSpJpZ4BDWiGjIzLnAtsAnI+IJ4A0gKDpBTV6SJHUR87IkaVmwsDmQE4BNgb27KBZJkrRg5mVJUs0trIAMgMx8ootikSRJC2ZeliTV3MIKyBUj4pgFHczMX3RCPJIkqWPmZUlSzS2sgKwHBlH2eEqSpJoyL0uSam5hBeTzmfm9LotEkiQtjHlZklRzC/saD3s4JUladpiXJUk1t7ACcqcui0KSJC2KeVmSVHMLLCAzc2pXBiJJkhbMvCxJWhYs7A6kJEmSJEnzWEBKkiRJkiqxgJQkSZIkVWIBKUmSJEmqxAJSkiRJklSJBaQkSZIkqRILSEmSJElSJRaQkiRJkqRKLCAlSZIkSZVYQEqSJEmSKrGAlCRJkiRVYgEpSZIkSarEAlKSJEmSVIkFpCRJkiSpEgtISZIkSVIlFpCSJEmSpEosICVJkiRJlVhASpIkSZIqsYCUJEmSJFViASlJkiRJqsQCUpIkSZJUiQWkJEmSJKkSC0hJkiRJUiUWkJIkSZKkSiwgJUmSJEmVWEBKkiRJkiqxgJQkSZIkVdJQ6wB6kuX6NPDeMcNrHYbU67xx7y21DkFLoHnm67UOQT1Y/4ZgnRUH1DoMqfd5/tFaR6BO5h1ISZIkSVIlFpCSJEmSpEosICVJkiRJlVhASpIkSZIqsYCUJEmSJFViASlJkiRJqsQCUpIkSZJUiQWkJEmSJKkSC0hJkiRJUiUWkJIkSZKkSiwgJUmSJEmVWEBKkiRJkiqxgJQkSZIkVWIBKUmSJEmqxAJSkiRJklSJBaQkSZIkqRILSEmSJElSJRaQkiRJkqRKLCAlSZIkSZVYQEqSJEmSKrGAlCRJkiRVYgEpSZIkSarEAlKSJEmSVIkFpCRJkqT/3959h8tVlnsf/95kJ6FjAhJIgrQAIaEYuij10JTASwuEJkgEaSIICEoThQuE4wGlqHiULiWHHqQr1URKpBOK9NBCVVogO/f7x5qEyQ6RRdh71t6zv5/rypUpa2buyWTmN/eznvWMVIoNpCRJkiSpFBtISZIkSVIpNpCSJEmSpFJsICVJkiRJpdhASpIkSZJKsYGUJEmSJJViAylJkiRJKsUGUpIkSZJUig2kJEmSJKkUG0hJkiRJUik2kJIkSZKkUmwgJUmSJEml2EBKkiRJkkqxgZQkSZIklWIDKUmSJEkqxQZSkiRJklSKDaQkSZIkqRQbSEmSJElSKTaQkiRJkqRSbCAlSZIkSaXYQEqSJEmSSrGBlCRJkiSVYgMpSZIkSSrFBlKSJEmSVIoNpCRJkiSpFBtIMfa2m9luo9XYZoNhnPvbU2a6fvzdd7HrluvytWUX5JbrrprhutN+cQwjN/saIzf7GjeNubxRJavmxhuuZ6WhyzF08CBOPunEma6fPHkyu+y0A0MHD2KdtdfkuWefnX7dyb84gaGDB7HS0OW46cYbGli1ADZee3keuOIoHr7qGA75zsYzXb/YIn24/qwDGHvRYdx9yY/Z9BtDAOi7wDxcf9YBTLrrl5xy2IhGly2pgz3wt79y8DbrcdD/+wZXn33GTNdfe8FZHLrdhhy2w8Ycv/dIJr384vTrXn95IifsuxOHbLsBh263IZNeeqGRpQtzuSv7rFw+6eBtGHfx4Yy7+HAevPJoXr79pBmun2+eOfnnDcd1i2xuqboAVau1tZWTfnoIp597JQsv0p/dtt6Adf7rmyy1zODp2yzSfyBHn3QmF/z+tBlue+dfb+DxRx7ggjF38PFHk/nejpvztfU2Yt755m/00+iWWltbOfCA/bj2upsYMHAg31hrdYYP35LlhwyZvs05f/wDfb7Uh0cmPMWll1zMET85jAv+dAmPPfoooy+5mPEPPMLLL73EtzbbiIcefYIePXpU+Iy6jznmCE49fHs23+d0Jr76NndeeChjbnuICU+/Mn2bw767GZfdNJ7fj76TwUstwpWn7cPgzY/hw8kf87MzxzBkUH+GLr1ohc9CUnub2trK2SceyY/P/BML9luUI3cdzirrbczApZadvs0Sy63AcedfS++55uKm0edx0a+O54ATfwPAb445kK32+D4rrrUuH77/HhHuJ2gkc7nrKpPLP/rlJztK9hm5HisvN3CG+zhm3825476nGlZzlfxk6eYeeeA+Bi6+FAO+sgQ9e/Vik+HbcvvNf55hm/4DF2eZwSswxxwz/nd55snHGbbG12lpaWGuuedhmeVXYOzttzSy/G7tnrvvZumlB7HkUkvRq1cvRuwwkjHXzLiHeMw1V7HzrrsBsM2223HrX24hMxlzzVWM2GEkvXv3Zokll2TppQdxz913V/E0uqXVV1iCf77wOs9OfIOPp7Qy+obxDF9/pRm2yUzmn2dOABaYdy5envQOAO9/+BF/u/9pPpz8ccPrltSxnnrkfvottgT9Bi5OS89efG2TLbnv1htn2Gbo6mvTe665AFhmxVV487XiC+6LTz9B65RWVlxrXQDmnHue6dupMczlrqtMLtfbfrNVufT6+6afH7b8Yiy84PzcPPaxRpRbORvIbm7Sqy/Tb9EB088vvEh/Jr36cqnbLrP8Coy97WY+/OB93n7zDe4bdwev1U2lUcd66aWJDBy42PTzAwYMZOLEiTNvs1ixTUtLC/MvsABvvPEGEyfOfNuXXprxtuo4/RdegBdffWv6+YmvvsWALy8wwzbH/+7PjPzWGjx1/c+54rR9+OEvRje6TEkN9tZrr7Bgv/7Tz/fttyhvTnplltv/9aqLWXnt9QF4+bmnmWe++TnlkD358U6bceGpxzG1tbWjS1Ydc7nrKpPL03xl0T4s3n9Bbr3ncQAighN/uA0/OeWKhtTaGTSkgYyId9uc3z0iTm/QY68cEffXnd8xIt6PiJ618ytGxIO10/8bEUNmdV/NKDNn+7ZrrbMha6+/MaNGbMKRB45ixWFr0KOHs6Ib5dNeu4got02J26rjBDP/W7d9RbbfbDUuuGYcgzY7iq2//xv+cNy3fY3UbszlzqnM5/o0d/75cp559EGGf3tvoJj+OuEfd7PTgUdy3HljeG3i89x2jQNPjWQud11lcnmaEZuuypW33M/UqcUW39t+HW648xFefPXtDqywc+kOeyAfAhaPiPlq59cGJgDD6s7fBZCZ383MRxtfYnUWXqQ/r778yQjXa6+8xJf7lT+uao/9DuHCMXdy+nlXkpkstsTSHVGmPsWAAQN58cVPFkiYOPFF+vfvP/M2LxTbTJkyhX+98w59+/ZlwMCZb7voojPeVh1n4mtvM7Bfn+nnB/Trw0u1KarT7LbV17jsxvEA/P3BZ5izV08W+tI8Da1T6iDm8iz07bcob7z60vTzb776Mn0W6jfTdg/9/Q6u/MNpHHzKH+nZq/f02y4xeCj9Bi5Oj5YWVlt/U56d8FDDape53JWVyeVpttt0VS69/t7p59dcaUn23mFdJlx7LCcctDU7DV+Dnx+wZYfXXKXKG8iIWDwibomIB2t/f6V2+TkR8ZuI+GtEPB0R60XEHyPisYg4p+72m0TE2IgYHxGjI2Le+vvPzKnAPcCatYtWBc6gCChqf/+tdl+3RsRqtdPvRsTxEfFARIyLiJk/wZvAkJVW4YVn/8nEF57l448+4sYxl7HOf32z1G1bW1t5+603AXhywsM8NeER1lxnw44sV3VWW311nnrqSZ595hk++ugjRl9yMZsPn/EDa/PhW3Lh+ecCcPll/8d6G2xIRLD58C0ZfcnFTJ48mWefeYannnqS1ddYo4qn0S3d+8hzDPrKl1m8/4L0bOnBiE1X4dpbH5xhmxdeeZP111gOgOWW7MecvXsy6a13P+3upHZlLldn6SEr88oLz/LaxOeZ8vFHjL3xalZdb8bVIJ+d8DB/OP5wDj7ljyzQd6EZbvvev97hX2+9AcAj99zFgKWWaWj93Z253HWVyWWAZRZfmD7zz824B56Zftl3jjiXZb91NIM3P4Yfn3IFfxpzN0f9+upGlt9wjZpvOFf9dBWgLzDtX/Z04LzMPDci9gB+DWxVu64PsCGwJXAN8HXgu8A9EfFV4EXgSGCjzHwvIg4Dfgj8rM3j/w1YOyLGAlOBW4ETgFMpgurYT6l5HmBcZh4REScBewLHtd0oIvYC9gJYpP9iba/u9FpaWjj0mJM5YPdtmTq1lS2224Wll12e351yPMuvOIx1N/oWjz44nh/tswv/eudt7vjL9Zz1qxO45PpxTJnyMd8bWTSb88w7Hz/7n9/R0uIU1kZpaWnhlF+dzhabb0prayu77b4HQ4YO5Wc/PZpVVl2N4Vtsye57jGKP3Xdl6OBB9OnTl/MvvBiAIUOHsu2I7Rm20hBaWlo49ddnuNJbA7W2TuWgX1zKNWfuR485gnOvGsdjT7/CUftszvhHn+fa2x7i8P+5gjOP2pHv77IBmbDn0edPv/2Ea49lvnnmpFfPFrbYYCWG73vGDCvFSSU0ZS7XZ/JCiwyY+R46uR4tLez+o59z4v67MLW1lfX/3w4MXHo5Rv/mv1lqyEqsut4mXPir4/nwg/f59WHF1NUFF+nPIaeczRw9erDzgUdy/N4jIZMll1+RDbfeqeJn1L2Yy11XmVyG4vCS0Tfc9xn31vziixwDV/pBIt7NzHnrzu8OrJaZ+0fE68Cimflx7fiHlzNzodpo5k2ZeWFELAXckJnL1G5/HnA5MAU4hyKwAHoBYzNzVJvH3xg4GPgFsGVmHhQR44FNgQczc9HadrcCh2TmvRExGZgzMzMidgA2zszv/qfnufyKw/K8q26d3X8mVWjFr3z6gdLqGvqsvn/VJWg2TH78Uqa+/5oH+VSgO+TyUkNWyuMv+POsrlYntvVKAz97I3VaZnLX9eH9Z9yXmat91nadcXdRfUc7ufb31LrT0863AK0UYbbjZ9znOGB14BvA2NplLwIjqU2T+RQf5yfddSud899KkqSOZi5Lkqar/BhIiqAYWTu9M3Dn57jtOODrETEIICLmjohl226Umf8GXgB255OgGgscyKyDSpKk7shcliTNUmdoIA8AvlNbsntX4Adlb5iZkyjC56La7ccBg2ex+V1A78yctsTVWGApDCpJkuqZy5KkWWrIMZDdhcdAdl0eA9m1ebxF1+QxkOpIHgPZdXkMZNdmJnddZY+B7Ax7ICVJkiRJXYANpCRJkiSpFBtISZIkSVIpNpCSJEmSpFJsICVJkiRJpdhASpIkSZJKsYGUJEmSJJViAylJkiRJKsUGUpIkSZJUig2kJEmSJKkUG0hJkiRJUik2kJIkSZKkUmwgJUmSJEml2EBKkiRJkkqxgZQkSZIklWIDKUmSJEkqxQZSkiRJklSKDaQkSZIkqRQbSEmSJElSKTaQkiRJkqRSbCAlSZIkSaXYQEqSJEmSSrGBlCRJkiSVYgMpSZIkSSrFBlKSJEmSVIoNpCRJkiSpFBtISZIkSVIpNpCSJEmSpFJsICVJkiRJpdhASpIkSZJKsYGUJEmSJJViAylJkiRJKsUGUpIkSZJUig2kJEmSJKkUG0hJkiRJUik2kJIkSZKkUmwgJUmSJEml2EBKkiRJkkqxgZQkSZIklWIDKUmSJEkqxQZSkiRJklSKDaQkSZIkqRQbSEmSJElSKTaQkiRJkqRSbCAlSZIkSaXYQEqSJEmSSrGBlCRJkiSVYgMpSZIkSSrFBlKSJEmSVEpkZtU1NI2ImAQ8V3UdHWQh4PWqi9Bs8bWJsSY1AAAQNUlEQVTrupr9tVs8M79cdRFqTk2eydD8nw/NzNeu62r2165ULttAqpSIuDczV6u6Dn1+vnZdl6+dpFnx86Hr8rXrunztCk5hlSRJkiSVYgMpSZIkSSrFBlJlnVV1AZptvnZdl6+dpFnx86Hr8rXrunzt8BhISZIkSVJJ7oGUJEmSJJViAylJkiRJKsUGUpIkSZJUig2kOkxERNU1SN2J7zlJ/4mfEVJjNet7zgZSHSIiImsrNEXEdhGxZdU1aUYR8Y2IaKm6DrWPNu+5LzdraEmaPeZy52cuN5dmzmUbSHWIujfMgcDhwGPVVqT6D66ImBfYDRhRXUVqLxExR5v33I3AyRGxS7WVSeoszOXOx1xuXs2eyzaQ6jARMZjig/AbwHMRsUlEHBIRvSsurVuq+yBbMTPfBW4Hlm2mEbHuKjOnAkTEusAQ4ACKL4cbRsSeVdYmqfMwlzsXc7l5NXsuu5tc7abNrvo5gWdrf64Cngb6AHMDC1GMfqrBImJN4NKI+CVwLbAX8AZweqWFabZExKrA2xTvr68CtwI/zsw7IuIJ4C1g84iYMzNPq65SSVUwlzs/c7m5dJdcdg+k2kWbkDoQ+BEwJ/BT4D7g1MwcCfwf8HFVdXZnbb48jAJWAu4C9o2ItaqrTF/AEOBDYJ7M/AdwPHB4RPTLzFcpgutmYHBEfKm6MiU1mrnc+ZnLTalb5LINpNpFXUjtTTE95uzMfDszn8zMn2Tm4xHxPeAHwCVV1todRcTawFFAf2AnPhl5ngAMBr7lgftdR0SsEBFXApcCvYGrImJIZh4FnAmMj4iBmfkmcD1weGa+XWHJkhrMXO7czOXm0t1y2f+YajcR0YPiuIoTgYyIfYFhwEMU0zK+DuyemQ9XV2X3UD/yXPMvinA6CzgbuA54NzMvjYiPgXGZOaWCUvU51L2urwH/BrbNzD9FxIPAsRFxdGYeUXtNn4qIpTLzpUqLllQZc7nzMJebU3fN5Zjx/7JUXm2FqWkHCUdmZm2azKYUgxN3Aq3AfMBPgJbMnFxZwd1Em2lLW1NMWXogMx+tLaBwMvAlYCCwbGY6damLiIgvZ+ak2pfCUcDqwN6Z2RoR/wMsDhyRmRMi4ifA6Mx8ssqaJTWOudw5mcvNq7vmsg2kZkubD8ORwGLA88ADQA9gYma+Xbvu+8BmmfnvygruhiJif2BX4FzgF8DOmXl1RCwIrA8cCHw7M5+prkqVFRHLUby/DqTYc/AqxUIY/8zM/WvbnASsAuybmU9UVaukxjOXOz9zubl051z2GEjNlrqQGgUcCbxOsUTxCGAK8EFE7EExv38vQ6rj1S/7HRFDgB2BjYAAngNOjYgdM/ONzLwM2NCQ6vzqXtePgL9QjG5uT/H6bg+sFhG7AWTmj4C/Ae9XUKqkCpnLnY+53JzMZRtIzaYozAVsCOyXmWcDO1OMeG5DEVYJbJOZj1RXaffQZuR5R4olwLcENqGYj78CxZLgF0bExgBOkekylgSofan4v9r56yiOazoeOB9YKyIG1rY7OjNfrKhWSRUxlzsXc7mpdftctoHUbMnCBxQjaOtHxAKZ+SxwGsWHYw/g3Mx8vMIyu426kNoK+C7QIzPfoFjR7aHaZs8DlwFdfu59d1Fb4vvciLgoInpl5h+B24CdMnNP4B2KL4vfA9atsFRJFTOXOxdzuTmZywUbSJUSEctHxIYR0bN2ftru+3uAvsDGEdGbYhTmA4oPyqnVVNs9RcRqFMe1XJqZL9UO6H4e6BsRl1D8BtghtS8U6gJqS3xvQ/GF4/cRsQvFcvuvRcTqteXBT6D4gviP6iqV1GjmcudnLjcfc7ngIjoqJSKOpZgGcy7wt/ppFrVlwVelWGlqbooDhe+vpNBuJCKWARak+De/r/b3scCyFNOXHqlNZxpG8ePEt2bmhKrq1ec3bUXF2peOPSl+G2wYxRfEpzPzzNp2bZeHl9TkzOXOx1xufuZywQZSpUTEHMARwKLAaODONmG1HDAJ6JmZr1ZTZfcREZsDP6eYqjQfMAgYDrxN8YHWF/itx7l0fRHRIzNba6cXplgm/BCK0c/dMvP8KuuTVA1zuXMxl7sPc9kprCqh7neljqf4odQRwLp102b2Av5I8QO4hlQHi4jNKFbROygzt87MjSh+hHgMRWidQbH63qG1LxDqIupX7Jum9ltSPWqnX8vMEyiWgT8f+HuDS5TUCZjLnYu53LzM5U/nHkiVUrfLfg7gaGBhitXD1gUOBkY4PabjRURfihDaMjPHRMScmflh7bpjgZ0opsUsQ/HD0edn5iuVFazS2qzYtynFngMyc3zdNvU/Et4rMz+qpFhJlTOXOwdzuXmZy7NmA6mZzGredkT0zMyPa2F1FLAOMAT4ZmY+0Og6u6vaNJkTgfUz842I6J2Zk2vX3UoxAvqP+svVdUTEQcBWwM3ABsDhmXl3tVVJqpK53LmZy83NXJ6ZU1g1g7ajLRGxSkSsAsXvE9WNtPwcuBxY15BqrMy8lmLltrsjok9mTp42bYli+ejW2naGVBcTEcsCG2fmesACFMfO3BsRc1ZbmaSqmMudn7ncvMzlT2cDqRnUhdRBwE+AzYH/jog1atdPrR08PDUzz8zMpyost9vKzOuA/Sk+xPrUvkR8G1gEcGpMF/Epx1bMQbEU+DEUK7vtVPtiuElE9Gt4gZIqZy53DeZyczCXy7GB1Ew+a7Rl2spTqlZdWN0eEfsAewOjMvO1aitTGW32KgwEqC3n3pPiYPwRmflhRIwCDgOmVFaspEqZy12Dudy1mcvltVRdgKr3KcdWtB1t2a42wrlJRPzdFd06j8y8rrYS2OXAMJcH7zrqQmp/4NsR8Rjwa+AcilUVr4qI24DtgZ0z842qapXUWOZy12Uud13mcnkuotPNtR1tycwXa6cvBNYEVszMD2qjLXtQrDLWbd8wnVVEzJ2Z71ddhz5bmxXbBgGnAD8A9qP4kngD8A9gS+Bd4L7MfKKiciU1mLncHMzlrsNc/vxsIAV8MtoCTBtt6Qt8CxgK1I+2PFxZkVITiYiRQG9g5cz8YUS0AEcCCwFXAX9xWprUfZnLUmOZy+V5DGQ3VVvye9rpQRS/TTSS4reMdgF6UCxJPRp4mmLetyEltYOIGAH8FFgeGBUR38nMKZn5U+A9ii+JvaurUFKjmctSdczlz8c9kN2coy1SY0XERhR7FX6VmffVzv937fzZtW0WyszXq6xTUjXMZamxzOXPzz2Q3ZijLVLHm7YkeN3S4CsAywLrRcR8mXkzcDBwbETsCmBISd2TuSx1PHP5i3MPZDflaIvU8doshrEc8HJm/isitgO2AC4F/pqZ70fE+sDzmfl0dRVLqoq5LHU8c7l9+DMe3cS0N0zdG6d+tOWJzLw5Ig4Gzo6IKZl5viElfTF1IbUvxWqJT0ZEX4qQ6gVsB/SOiOsz89bKCpXUcOay1HjmcvtwCms30Ob3pJaNiPkz81SKkc2VgXVry03fQjH6eVdVtUrNICL61J1eB9iLIpR2A54C7gAuAR4ANgDiU+5GUpMyl6XGMpfbl3sguwFHW6TGiYjFgSMj4qLM/AvwFjA2M5+tfWncLyIuBrbIzFMjom9mvldt1ZIayVyWGsdcbn/ugWxijrZIlegBPANsGxFfB94ENomI4XV7HF4C+gBk5pvVlCmp0cxlqRLmcjtzEZ0mNW20BbgoM/8SESsA+2XmPnXHXVwMXJyZV9ZGW3zDSO0gIuajWMFtWeBwYABwNfBLiiDbFhiZmU9UVqSkhjKXpeqYy+3LPZDNy9EWqUEi4r8iYp+6i+YCtgF6AkcBrwDrA1OB+YGdDSmp2zGXpQYxlzuWeyCbmKMtUmNExOrAOGCnzLwkIu4ELqj92QtYDjg7M8dVWKakipnLUmOYyx3LPZBNxNEWqRqZeQ+wJvDbiHgdOCMzf5uZ7wJXAc8DO0TE3HU/XCypyZnLUjXM5Y7lHsgm4miLVK2IWBG4HdgnMy+OiDkyc2rt2Kd/OyVN6l7MZala5nLHsIFsMhGxGnAT0Ap8PzMvql2+NDASWAg4AvggffGldlf7wngj8OPM/G3V9UiqlrksVctcbn/+DmSTycx7I2JditGWab8zNUdm/jMiLqAYbXm/0iKlJpaZ90TERsA9ETE5M8+uuiZJ1TGXpWqZy+3PPZBNytEWqVoRMQx4PzMfr7oWSdUzl6VqmcvtxwayiUXEqsA9wChHWyRJqpa5LKkZ2EA2OUdbJEnqPMxlSV2dDaQkSZIkqRR/B1KSJEmSVIoNpCRJkiSpFBtISZIkSVIpNpCSJEmSpFJsICVJkiRJpdhASu0sIloj4v6IeDgiRkfE3F/gvtaPiDG101tGxOH/YdsvRcS+s/EYP42IQ8pe3mabcyJiu8/xWEtExMOft0ZJkmaXufwftzeX9bnZQErt74PM/GpmrgB8BOxdf2UUPvd7LzOvzswT/8MmXwI+d1BJktTkzGWpHdlASh3rDmBQbYTvsYg4ExgPLBYRm0TE2IgYXxsRnRcgIjaLiAkRcSewzbQ7iojdI+L02ul+EXFFRDxQ+7M2cCKwdG2U9eTadodGxD0R8WBEHFt3X0dExOMRcTOw3Gc9iYjYs3Y/D0TEZW1GbzeKiDsi4omIGF7bvkdEnFz32N/7ov+QkiS1A3PZXNYXZAMpdZCIaAG+CTxUu2g54LzMHAa8BxwJbJSZqwD3Aj+MiDmB3wNbAOsAi8zi7n8N3JaZKwOrAI8AhwP/rI2yHhoRmwDLAGsAXwVWjYh1I2JVYCQwjCIIVy/xdC7PzNVrj/cYMKruuiWA9YDNgd/WnsMo4J3MXL12/3tGxJIlHkeSpA5hLpvLah8tVRcgNaG5IuL+2uk7gD8A/YHnMnNc7fK1gCHAXREB0AsYCwwGnsnMJwEi4gJgr095jA2BbwNkZivwTkT0abPNJrU//6idn5ciuOYDrsjM92uPcXWJ57RCRBxHMR1nXuCGuusuzcypwJMR8XTtOWwCrFR3HMYCtcd+osRjSZLUnsxlc1ntyAZSan8fZOZX6y+ohdF79RcBN2Xmjm22+yqQ7VRHACdk5u/aPMaBs/EY5wBbZeYDEbE7sH7ddW3vK2uP/f3MrA80ImKJz/m4kiR9Ueayuax25BRWqRrjgK9HxCCAiJg7IpYFJgBLRsTSte12nMXtbwH2qd22R0TMD/ybYhRzmhuAPeqO4RgQEQsDtwNbR8RcETEfxbSczzIf8HJE9AR2bnPdiIiYo1bzUsDjtcfep7Y9EbFsRMxT4nEkSaqCuSyV5B5IqQKZOak2YnhRRPSuXXxkZj4REXsB10bE68CdwAqfchc/AM6KiFFAK7BPZo6NiLuiWI77utrxFssDY2sjre8Cu2Tm+Ii4BLgfeI5iOs9nOQr4e237h5gxEB8HbgP6AXtn5ocR8b8Ux2CMj+LBJwFblfvXkSSpscxlqbzIbK+98pIkSZKkZuYUVkmSJElSKTaQkiRJkqRSbCAlSZIkSaXYQEqSJEmSSrGBlCRJkiSVYgMpSZIkSSrFBlKSJEmSVMr/Byx8jAchfblZAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1008x864 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(2, 2, figsize = (14, 12))\n",
    "axs = axs.flatten()\n",
    "plot_confusion_matrix(train_cm, ['Home Loss', 'Draw', 'Home Win'], axs[0], True, 'Train')\n",
    "plot_confusion_matrix(test_cm_90mins, ['Home Loss', 'Draw', 'Home Win'], axs[1], True, 'Test (90 Mins)')\n",
    "plot_confusion_matrix(test_cm, ['Home Loss', 'Draw', 'Home Win'], axs[2], True, 'Test (Softmax)')\n",
    "plot_confusion_matrix(test_playoff_cm, ['Home Loss', 'Draw', 'Home Win'], axs[3], True, 'Test (WC Playoff Model)')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow! Our model does not predict draws at all. This is a bit concerning, but it makes sense given that from our EDA of these simple features we saw that we really could not distinguish draws from home wins and home losses at all for any of the features. For most of the feature distributions, they were always \"sandwiched\" between the two other distributions. Maybe our more advanced models will be able to better predict draws.\n",
    "\n",
    "We see that across train set and test set, the proportions in each entry of the confusion matrices are approximately the same, which is good. This might be an indication that our train and test sets are approximately similar. \n",
    "\n",
    "While it seems like because the accuracy in predicting home loss and home win in the 90 minutes model are higher than those in the softmax approach, we must remember that the true labels of the former approach and the latter two approaches are different, where all the draws in the playoff matches of the test set became either home losses or wins. As a result, the overall accuracy of the the softmax approach is still higher than the former approach despite having lower home loss and home win accuracies; thus we can only compare the overall accuracies of the former approach with the latter two approaches. We can still compare the home loss and home win accuracies between the latter two approaches though since they are using the same test labels, and we see that while the WC Playoff Model is better at predicting home losses, it is worse in predicting home wins by a larger magnitude, resulting in lower overall accuracy. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More importantly, we are curious just how important each feature is, especially the FIFA ranking feature, the one feature we are trying to replace. Feature importance of random forest allows us exactly to do so, and since it has similar performance to logistic regression in the train/validation set, we can utilize it in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns = np.array(['rank_diff', 'attack_diff', 'defence_diff', 'midfield_diff', 'overall_diff'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_importances = rf_model.best_estimator_.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "indices = np.argsort(feature_importances)[::-1]\n",
    "plt.title(\"RF Feature Importances\")\n",
    "plt.bar(range(len(columns)), feature_importances[indices],\n",
    "       color=\"r\", align=\"center\")\n",
    "plt.xticks(range(len(columns)), columns[indices], rotation = 90)\n",
    "plt.ylabel('Feature Importances')\n",
    "plt.xlim([-1, len(columns)]);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It seems like the FIFA rankings is not that important of a feature! Hopefully we can make a better model than the baseline model."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}