nba_ml.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](pngs/nba_ml.png)\n",
    "1. Define Foundation\n",
    "2. Get Data from MongoDB Cloud and create 'champ_data.csv'\n",
    "3. Analyze Champion Data \n",
    "<br> - Results ...\n",
    "4. Machine Learning Process \n",
    "5. PowerBi Charts\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 1 Define Foundation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import sys\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pymongo\n",
    "import seaborn as sns\n",
    "import shap\n",
    "from pandas import json_normalize\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.metrics import (mean_absolute_error, mean_squared_error,\n",
    "                             ndcg_score, r2_score)\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import OneHotEncoder, StandardScaler\n",
    "from xgboost import XGBRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_SEASON = 2022\n",
    "LAST_N_SEASONS = 3\n",
    "RANDOM_SEED = 12345\n",
    "random.seed(RANDOM_SEED)\n",
    "\n",
    "USERNAME = \"\" # YOUR USERNAME\n",
    "PASSWORD = \"\" # YOUR USERNAME\n",
    "DB_NAME = \"nba\"\n",
    "COLLECTION_PLAYER = \"player\"\n",
    "COLLECTION_TEAM = \"team\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_percent(cell_value: str):\n",
    "    if cell_value is None or cell_value is np.nan or cell_value == 'nan':\n",
    "        return None \n",
    "    if cell_value == \"0-0\":\n",
    "        return 0\n",
    "    \n",
    "    splits = cell_value.split(\"-\")\n",
    "    splits = [int(i) for i in splits]\n",
    "    \n",
    "    if sum(splits) == 0: return 0\n",
    "    \n",
    "    if len(splits) == 2:    \n",
    "        return splits[0] / sum(splits)\n",
    "    \n",
    "    numerator = 0\n",
    "    for i in range(0, len(splits)):\n",
    "        if i % 2 == 0:\n",
    "            numerator += splits[i]\n",
    "            \n",
    "    return numerator / sum(splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MongoDBAgent:\n",
    "    name = \"MongoDBAgent\"\n",
    "\n",
    "    def __init__(self, con_string: str, db: str):\n",
    "        self.__client = pymongo.MongoClient(con_string)\n",
    "        self.__db = self.__client[db]\n",
    "        self.__connect_db()\n",
    "\n",
    "\n",
    "    def __connect_db(self):\n",
    "        self.__client.server_info()\n",
    "\n",
    "\n",
    "    def find(self, collection_str: str, query: dict, count=False):\n",
    "        collection = self.__db[collection_str]\n",
    "        documents = collection.find(query)\n",
    "        if count: return collection.count_documents(query)\n",
    "        if collection.count_documents(query) == 0: return None\n",
    "        return documents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "MONGODB_AGENT = MongoDBAgent(con_string=f\"mongodb+srv://{USERNAME}:{PASSWORD}@maincluster.grb4d.mongodb.net/test\", db=DB_NAME)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 2 Get Data from MongoDB Cloud and create 'champ_data.csv' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "documents = MONGODB_AGENT.find(collection_str=COLLECTION_TEAM, query={}, count=False)\n",
    "df = json_normalize(list(documents))\n",
    "df.drop(['_id', 'lg', 'per_game-team.G', 'per_game-team.MP', 'per_game-opponent.G_opp', 'per_game-opponent.MP_opp', 'advanced-team.Arena', 'advanced-team.Attend.', 'advanced-team.Attend./G', 'playoff.Rk'], \n",
    "        axis=\"columns\", \n",
    "        inplace=True)\n",
    "df.columns = [col.split('.')[1] if '.' in col else col for col in df.columns]\n",
    "\n",
    "for col in ['Oct', 'Nov', 'Dec', 'Jan', 'Feb', 'Mar', 'Apr']:\n",
    "    df[col].fillna(\"0-0\", inplace=True)\n",
    "\n",
    "df['First_4_Months'] = df['Oct'] + \"-\" + df['Nov'] + \"-\" + df['Dec'] + \"-\" + df['Jan']\n",
    "df['Last_4_Months'] = df['Jan'] + \"-\" + df['Feb'] + \"-\" + df['Mar'] + \"-\" + df['Apr']\n",
    "\n",
    "df.drop(['Oct', 'Nov', 'Dec', 'Jan', 'Feb', 'Mar', 'Apr'],\n",
    "        axis=\"columns\",\n",
    "        inplace=True)\n",
    "\n",
    "# Convert string columns to numeric\n",
    "for col in ['Overall', 'Home', 'Road', 'Pre', 'Post', '≤3', '≥10', 'First_4_Months', 'Last_4_Months']:\n",
    "    df[col] = df[col].apply(lambda x: convert_to_percent(str(x)))\n",
    "\n",
    "df['Champion_Percent'].fillna(0.0, inplace=True)\n",
    "df['Playoff'] = df['Champion_Percent'].apply(lambda cell: True if cell > 0.0 else False)\n",
    "\n",
    "df['Champion_Win_Share'].fillna(0.0, inplace=True)\n",
    "df.sort_values(['season'], ascending=False, inplace=True)\n",
    "\n",
    "# Calculate team performance in the last [...] years\n",
    "df_filter = df[['name', 'season', 'Champion_Win_Share']]\n",
    "for year in [1, 3, 6, 10]:\n",
    "    series = []\n",
    "    for team, season in df_filter[['name', 'season']].values:\n",
    "        df_team = df_filter[(df_filter['name'] == team) & (df_filter['season'] < season) & (df_filter['season'] >= season-year)]\n",
    "        series.append(df_team['Champion_Win_Share'].sum())        \n",
    "    df[f'L{year}YP'] = series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_playoff_games(array: list, season: int):\n",
    "    if array == None or array == np.nan or str(array) == 'nan':\n",
    "        return 0\n",
    "    \n",
    "    count =  0\n",
    "    for dict_element in array:\n",
    "        if dict_element['Season'] < season:\n",
    "            count += dict_element['G']\n",
    "        \n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_champion(array: list, season: int):\n",
    "    if array == None or array == np.nan or str(array) == 'nan':\n",
    "        return 0\n",
    "    \n",
    "    count =  0\n",
    "    for dict_element in array:\n",
    "        if dict_element['Season'] < season:\n",
    "            count += 1\n",
    "        \n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_mvp_shares(array: list, season: int):\n",
    "    if array == None or array == np.nan or str(array) == 'nan':\n",
    "        return 0\n",
    "    \n",
    "    sum =  0\n",
    "    for dict_element in array:\n",
    "        if dict_element['Season'] < season:\n",
    "            sum += dict_element['Share']\n",
    "        \n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_dpoy_shares(array: list, season: int):\n",
    "    if array == None or array == np.nan or str(array) == 'nan':\n",
    "        return 0\n",
    "    \n",
    "    sum =  0\n",
    "    for dict_element in array:\n",
    "        if dict_element['Season'] < season:\n",
    "            sum += dict_element['Share']\n",
    "        \n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_all_nba(array: list, season: int):\n",
    "    if array == None or array == np.nan or str(array) == 'nan':\n",
    "        return 0\n",
    "    \n",
    "    count =  0\n",
    "    for dict_element in array:\n",
    "        if dict_element['Season'] < season:\n",
    "            count += 1\n",
    "        \n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_all_defensive(array: list, season: int):\n",
    "    if array == None or array == np.nan or str(array) == 'nan':\n",
    "        return 0\n",
    "    \n",
    "    count =  0\n",
    "    for dict_element in array:\n",
    "        if dict_element['Season'] < season:\n",
    "            count += 1\n",
    "        \n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1573/1573..."
     ]
    }
   ],
   "source": [
    "df_count = pd.DataFrame(data=np.zeros(shape=(len(df), 6)), columns=['count_playoff_games', 'count_champion', 'sum_mvp_shares', 'sum_dpoy_shares', 'count_all_nba', 'count_all_defensive'], index=None)\n",
    "df_count.insert(loc=0, column=\"team_id\", value=df['team_id'].values)\n",
    "\n",
    "i=0 \n",
    "for team_id, season in df[['team_id', 'season']].values:\n",
    "    i += 1\n",
    "    sys.stdout.write(f\"\\r{i}/{len(df)}...\")\n",
    "    \n",
    "    # search player that played this season in the playoffs\n",
    "    documents = MONGODB_AGENT.find(collection_str=COLLECTION_PLAYER, query={\"playoffs_per_game.Tm_id\": team_id}, count=False)\n",
    "    if documents == None: continue\n",
    "    \n",
    "    df_players = json_normalize(list(documents))\n",
    "    df_players.drop([col for col in df_players.columns if col not in ['playoffs_per_game', 'champion', 'mvp', 'dpoy', 'all_nba', 'all_defensive']],\n",
    "                    axis=\"columns\",  \n",
    "                    inplace=True)\n",
    "    \n",
    "    if \"playoffs_per_game\" in df_players.columns:\n",
    "        df_count.loc[df_count[\"team_id\"] == team_id, \"count_playoff_games\"] = df_players['playoffs_per_game'].apply(lambda cell: count_playoff_games(cell, season)).sum()\n",
    "        \n",
    "    if \"champion\" in df_players.columns:    \n",
    "        df_count.loc[df_count[\"team_id\"] == team_id, \"count_champion\"] = df_players['champion'].apply(lambda cell: count_champion(cell, season)).sum()\n",
    "        \n",
    "    if \"mvp\" in df_players.columns:\n",
    "        df_count.loc[df_count[\"team_id\"] == team_id, 'sum_mvp_shares'] = df_players['mvp'].apply(lambda cell: sum_mvp_shares(cell, season)).sum()\n",
    "        \n",
    "    if \"dpoy\" in df_players.columns:\n",
    "        df_count.loc[df_count[\"team_id\"] == team_id, 'sum_dpoy_shares'] = df_players['dpoy'].apply(lambda cell: sum_dpoy_shares(cell, season)).sum()\n",
    "        \n",
    "    if \"all_nba\" in df_players.columns:\n",
    "        df_count.loc[df_count[\"team_id\"] == team_id, 'count_all_nba'] = df_players['all_nba'].apply(lambda cell: count_all_nba(cell, season)).sum()\n",
    "        \n",
    "    if \"all_defensive\" in df_players.columns:\n",
    "        df_count.loc[df_count[\"team_id\"] == team_id, 'count_all_defensive'] = df_players['all_defensive'].apply(lambda cell: count_all_defensive(cell, season)).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.merge(right=df_count, how=\"left\", on=\"team_id\", validate=\"one_to_one\")\n",
    "df.to_csv(\"champ_data.csv\", index=False, encoding=\"utf-8-sig\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 3 Analyze Champion Data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"champ_data.csv\", encoding=\"utf-8-sig\")\n",
    "df.drop([\"team_id\", \"champion\"],\n",
    "        axis=\"columns\",  \n",
    "        inplace=True)\n",
    "\n",
    "df = df[df['season'] <= MAX_SEASON]\n",
    "\n",
    "df['Rk_Conference'] = df.groupby(['season', 'conference'])['W'].rank(\"min\", ascending=False)\n",
    "df['Rk_Conference'] = df['Rk_Conference'] + df['Rk_Season']\n",
    "df['Rk_Conference'] = df.groupby(['season', 'conference'])['Rk_Conference'].rank(\"min\", ascending=True)\n",
    "del df['conference']\n",
    "\n",
    "df['Top_3_Conference'] = df['Rk_Conference'].apply(lambda cell: True if cell <=3 else False)\n",
    "df.to_csv(\"champ_data_edit.csv\", index=False, encoding=\"utf-8-sig\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_detail_nan = []\n",
    "\n",
    "for season in df['season'].unique():\n",
    "    df_nan = df[df['season'] == season]\n",
    "    series_nan = df_nan.isnull().sum()\n",
    "    df_nan = series_nan.to_frame(name=\"Nan_Count\")\n",
    "    df_nan = df_nan.rename_axis('Col_Name').reset_index()\n",
    "    df_nan['season'] = season\n",
    "    df_detail_nan.append(df_nan)\n",
    "\n",
    "df_detail_nan = pd.concat(df_detail_nan, ignore_index=True)\n",
    "\n",
    "df_per_season_nan = df_detail_nan[['season','Nan_Count']].groupby(\"season\").sum().reset_index()\n",
    "df_per_season_nan = df_per_season_nan.sort_values(by=['season'], ascending=True)\n",
    "\n",
    "fig = plt.figure(figsize = (15, 4))\n",
    "sns.lineplot(data=df_per_season_nan, x=\"season\", y=\"Nan_Count\", sort=True)\n",
    "plt.ylim(0)\n",
    "plt.ylabel('Nan Count', fontsize=12)\n",
    "plt.xticks(rotation=45,horizontalalignment='right',fontweight='light', fontsize=10)\n",
    "plt.xlabel('Season', fontsize=12)\n",
    "plt.margins(x=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1584x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_per_season_nan = df_detail_nan[['Col_Name','Nan_Count']].groupby(\"Col_Name\").sum().reset_index()\n",
    "df_per_season_nan = df_per_season_nan.sort_values(by=['Nan_Count'], ascending=True)\n",
    "df_per_season_nan = df_per_season_nan[df_per_season_nan['Nan_Count'] > 0]\n",
    "\n",
    "fig = plt.figure(figsize = (22, 4))\n",
    "sns.lineplot(data=df_per_season_nan, x=\"Col_Name\", y=\"Nan_Count\")\n",
    "plt.ylim(0)\n",
    "plt.ylabel('Nan Count', fontsize=12)\n",
    "plt.xticks(rotation=45,horizontalalignment='right',fontweight='light', fontsize=10)\n",
    "plt.xlabel('Column Name', fontsize=12)\n",
    "plt.margins(x=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 3 Analyze Champion Data \n",
    "#### ➤ Results -> most nan values occur before 1980 season -> remove seasons before 1980\n",
    "- The 3 point shot was introduced 1979-1980 (= 1980)\n",
    "- Some stats, especially advanced stats, were not tracked back then"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "YEAR_3P = 1980"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABQUAAAF9CAYAAAC9Pg6/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAC75klEQVR4nOydd7gctdWH32Mbm44pxhgMmGZTApjeezEdA6aFXkMvoUMgIUDovffQQgnV9ISWEGoglEASAiGQwAeE9F4AfX+cM17d8e7e3b17i31/7/PMszuzM1qNRiMd/XQkWUoJIYQQQgghhBBCCCFE/2FAb0dACCGEEEIIIYQQQgjRs0gUFEIIIYQQQgghhBCinyFRUAghhBBCCCGEEEKIfoZEQSGEEEIIIYQQQggh+hkSBYUQQgghhBBCCCGE6GdIFBRCCCGEEEIIIYQQop8hUVAIIYQQQkxxmNnfzWzB+P5tMzu1t+MkhBBCCDElIVFQCCGEEKIbMLP3zOxfIV4V29w9HIcRZjbRzP7PzJKZjSr9Po+Z3WdmfzSzD8xsv+y3NUpx/3uEsU38PsTMzo+w/2Rml5nZNN10H0+Z2d75sZTSjCmldxu4tuU0iN+Tmf0jS4Nrst/MzM40sz/EdqaZWRdvVwghhBCiR5AoKIQQQgjRfWwe4lWx/V/+o5kN6ub//wJ4BNimxu83A78GhgObAt8ys3UAUkpP53EHNgP+HuEBHAssD3wJGA0sC3ytu26kC7ScBhlLZ2mRi5P7AuOBpYGlgM2Br7Qx7kIIIYQQ3YZEQSGEEEKIHiQ8zw40s7eBt+PYPmb2TnirTcw9CuP8A8zsbTP7m5mdYmYLmdmzZvZXM7vDzAZX+6+U0icppcuAH1eJx4zA2sBpKaX/pZReA+4E9qwR9d2AO1NK/4j9zYGLUkp/TCl9ClxU61ozGxX3MSg7Nsn7z8x2N7Mfmdk54XX4azPbOH47DVgDuCQ89S7J0mXhGnHtrjSolibnppQ+SCl9CJwL7N7gtUIIIYQQvYpEQSGEEEKInmc8sBKwuJmtC5wObAeMAN4HbiudPw5YDlgZOBq4CtgZmBf31NuxhThY6bP4/qXJTjSbAZgA3FAjjOL7SDObpYW4gKfHW8AcwFnAtWZmKaUTgKeBg8JT76AWw69Go2nwQzP72MzuLg0/XgJ4Ldt/LY4JIYQQQvR5JAoKIYQQQnQf95rZn2O7Nzt+enjY/QvYCbgupfSTlNJ/gOOAVUri01kppb+mlN4E3gC+l1J6N6X0F+BhYJlmI5ZS+hvwDHCimU1rZsviQ2ynr3L61sDvgR9kxx4BDjWzYWY2F3BIHK92fSO8n1K6OqX0OS4+jsCH9HYbDabBWsAoYFHg/4AHMo/HGYG/ZOf+BZhR8woKIYQQYkpAoqAQQgghRPcxPqU0NLbx2fHfZt/nxr0DAUgp/R34AzBPds4n2fd/VdmfscX47QQsEPG5HJ9f74Mq5+0G3JhSStmx04BXgFeBZ4F7gf+V4tYMHxdfUkr/jK+t3lcz1E2DlNIPU0r/TSn9GTg0zl0sfv47MHMW1szA30vpJIQQQgjRJ5EoKIQQQgjR8+Si0f8B8xc7MVR3duDDbo9ESu+nlDZLKQ1LKa2ED919MT/HzObF5927sXTtv1JKB6WU5kkpLYgLmS+nlL6o8lfFPIS5B95czUS1iXObopE0qBKXwhPwTXyRkYKl45gQQgghRJ9HoqAQQgghRO9yK7CHmY01syHAt4AXUkrvtSNwM5sWGBK7Q2K/+G0xM5vJzAab2c7AhsB5pSB2AZ5NKf2qFO48Zja3OSsDJwJfrxaHWIjkQ2BnMxtoZnsCCzVxG58ACzZxfgdaTQMzWyKey8BYlOTcuI+fx+U3Al8t0gI4Avh2q/EUQgghhOhJJAoKIYQQQvQiKaXHcEHtLuAjXCzboY1/8S98mCvAL2K/YBzwLvAnYD9goxDwcnZl8gVGiHg+i3sB3gAcm1L6Xp147AMchXsULhHXNsqFwIRYmfiiJq4raDUNhgO3A3+Nc0YBm6WU/he/XwncD/wUn+vxwTgmhBBCCNHnMU15IoQQQgghhBBCCCFE/0KegkIIIYQQQgghhBBC9DMkCgohhBBCCCGEEEII0c+QKCiEEEIIIYQQQgghRD9DoqAQQgghhBBCCCGEEP0MiYJCCCGEEEIIIYQQQvQzBvV2BNrFHHPMkUaNGtXb0RBCCCGEEEIIIYQQok/w8ssv/z6lNKzab1ONKDhq1Cheeuml3o6GEEIIIYQQQgghhBB9AjN7v9ZvGj4shBBCCCGEEEIIIUQ/Q6KgEEIIIYQQQgghhBD9DImCQgghhBBCCCGEEEL0MyQKCiGEEEIIIYQQQgjRz5AoKIQQQgghhBBCCCFEP0OioBBCCCGEEEIIIYQQ/QyJgkIIIYQQQgghhBBC9DMkCgohhBBCCCGEEEII0c8Y1NsREEIIIYQQQgghhBC9yycXvNTSdcMPW74SxoXPtRbGoatUwrjoB62Fcchak77/7uLHWgpjzoPXr4RxycOthXHQxpUwLr2vtTAO3LISxmV3thbGARM6PUeegkIIIYQQQgghhBBC9DMkCgohhBBCCCGEEEII0c+QKCiEEEIIIYQQQgghRD9DoqAQQgghhBBCCCGEEP0MiYJCCCGEEEIIIYQQQvQzJAoKIYQQQgghhBBCCNHPkCgohBBCCCGEEEIIIUQ/Q6KgEEIIIYQQQgghhBD9DImCQgghhBBCCCGEEEL0MyQKCiGEEEIIIYQQQgjRz5AoKIQQQgghhBBCCCFEP6NHREEzm9bMXjSz18zsTTM7OY5/28x+bWavxjY2jpuZXWRm75jZ62a2bE/EUwghhBBCCCGEEEKI/sCgHvqf/wDrppT+bmbTAD8ys4fjt6NSSneWzt8YWCS2lYDL41MIIYQQQgghhBBCCNFFesRTMDl/j91pYkt1LtkSuDGuex4YamYjujueQgghhBBCCCGEEEL0B3psTkEzG2hmrwK/A76fUnohfjothgifb2ZD4tg8wG+zyz+IY0IIIYQQQgghhBBCiC7SY6JgSunzlNJYYCSwopl9CTgOWBRYAZgNOKaZMM1sXzN7ycxe+vTTT9sdZSGEEEIIIYQQQgghpkp6fPXhlNKfgSeBjVJKH8UQ4f8A1wMrxmkfAvNml42MY+WwrkopLZ9SWn7YsGHdHHMhhBBCCCGEEEIIIaYOemr14WFmNjS+TwdsAPyimCfQzAwYD7wRl0wEdo1ViFcG/pJS+qgn4iqEEEIIIYQQQgghxNROT60+PAK4wcwG4kLkHSmlB8zsCTMbBhjwKrBfnP8QsAnwDvBPYI8eiqcQQgghhBBCCCGEEFM9PSIKppReB5apcnzdGucn4MDujpcQQgghhBBCCCGEEP2RHp9TUAghhBBCCCGEEEII0btIFBRCCCGEEEIIIYQQop8hUVAIIYQQQgghhBBCiH6GREEhhBBCCCGEEEIIIfoZEgWFEEIIIYQQQgghhOhnSBQUQgghhBBCCCGEEKKfIVFQCCGEEEIIIYQQQoh+hkRBIYQQQgghhBBCCCH6GRIFhRBCCCGEEEIIIYToZ0gUFEIIIYQQQgghhBCinyFRUAghhBBCCCGEEEKIfoZEQSGEEEIIIYQQQggh+hkSBYUQQgghhBBCCCGE6GdIFBRCCCGEEEIIIYQQop8hUVAIIYQQQgghhBBCiH6GREEhhBBCCCGEEEIIIfoZEgWFEEIIIYQQQgghhOhnSBQUQgghhBBCCCGEEKKfIVFQCCGEEEIIIYQQQoh+Ro+IgmY2rZm9aGavmdmbZnZyHF/AzF4ws3fM7HYzGxzHh8T+O/H7qJ6IpxBCCCGEEEIIIYQQ/YGe8hT8D7BuSmlpYCywkZmtDJwJnJ9SWhj4E7BXnL8X8Kc4fn6cJ4QQQgghhBBCCCGEaAM9Igom5++xO01sCVgXuDOO3wCMj+9bxj7x+3pmZj0RVyGEEEIIIYQQQgghpnZ6bE5BMxtoZq8CvwO+D/wK+HNK6bM45QNgnvg+D/BbgPj9L8DsPRVXIYQQQgghhBBCCCGmZnpMFEwpfZ5SGguMBFYEFu1qmGa2r5m9ZGYvffrpp10NTgghhBBCCCGEEEKIfkGPrz6cUvoz8CSwCjDUzAbFTyOBD+P7h8C8APH7LMAfqoR1VUpp+ZTS8sOGDevuqAshhBBCCCGEEEIIMVXQU6sPDzOzofF9OmAD4Oe4ODghTtsNuC++T4x94vcnUkqpJ+IqhBBCCCGEEEIIIcTUzqDOT2kLI4AbzGwgLkTekVJ6wMx+BtxmZqcCrwDXxvnXAjeZ2TvAH4EdeiieQgghhBBCCCGEEEJM9fSIKJhSeh1Ypsrxd/H5BcvH/w1s2wNRE0IIIYQQQgghhBCi39HjcwoKIYQQQgghhBBCCCF6F4mCQgghhBBCCCGEEEL0MyQKCiGEEEIIIYQQQgjRz5AoKIQQQgghhBBCCCFEP0OioBBCCCGEEEIIIYQQ/QyJgkIIIYQQQgghhBBC9DMkCgohhBBCCCGEEEII0c+QKCiEEEIIIYQQQgghRD9DoqAQQgghhBBCCCGEEP0MiYJCCCGEEEIIIYQQQvQzJAoKIYQQQgghhBBCCNHPkCgohBBCCCGEEEIIIUQ/Q6KgEEIIIYQQQgghhBD9DImCQgghhBBCCCGEEEL0MyQKCiGEEEIIIYQQQgjRz5AoKIQQQgghhBBCCCFEP2NQb0dACCGEEEIIIcTUwzV3/66l6/bees4O+7fe9WnTYey4zbAO+/fe+fumwxg/YY4O+w/f3nwYG2/fMYwnvtP8vaz75Y738syNzYex2q4dw/jx9c0/mxX26PhcXr+q+TCW2rdjGG9d9knTYYw5YHiH/fcu+LjpMABGHTbXpO8fnflRS2GMOGbEpO8fn/3rlsKY66gFKmGc+4vWwjhi0UnfPzn/9ZbCGH74Ui1dJ6YO5CkohBBCCCGEEEIIIUQ/o0dEQTOb18yeNLOfmdmbZnZoHP+GmX1oZq/Gtkl2zXFm9o6ZvWVm43oinkIIIYQQQgghhBBC9AcaGj5sZiullF6ocnzFlNKLDQTxGXBESuknZjYT8LKZfT9+Oz+ldE4p3MWBHYAlgLmBx8xsdErp80biK4QQQgghhBBCCCGEqE2jnoLfr3H8kUYuTil9lFL6SXz/G/BzYJ46l2wJ3JZS+k9K6dfAO8CKDcZVCCGEEEIIIYQQQghRh7qioJkNMLOB/tUs9ottEdwDsCnMbBSwDFB4Hh5kZq+b2XVmNmscmwf4bXbZB9QXEYUQQgghhBBCCCGEEA3SmafgZ8B/genj+/+y7WfAZc38mZnNCNwFHJZS+itwObAQMBb4CDi3yfD2NbOXzOylTz9tfiUmIYQQQgghhBBCCCH6I53NKbgAYMAPgDWz4wn4NKX0r0b/yMymwQXBW1JKdwOklD7Jfr8aeCB2PwTmzS4fGcc6kFK6CrgKYPnll0+NxkUIIYQQQgghhBBCiP5MXVEwpfR+fJ2/K39iZgZcC/w8pXRednxESumj2N0KeCO+TwS+Y2bn4QuNLAI0sqCJEEIIIYQQQgghhBCiExpdfXg24Eh8mO+M+W8ppTWrXVNiNWAX4Kdm9mocOx7Y0czG4p6H7wFfiTDfNLM78CHKnwEHauVhIYQQQgghhBBCCCHaQ0OiIPAdYAhwB/DPZv8kpfQjfBhymYfqXHMacFqz/yWEEEIIIYQQQgghhKhPo6LgqsCwlNJ/ujMyQgghhBBCCCGEEEKI7qez1YcLXscX+xBCCCGEEEIIIYQQQkzhNOop+ATwiJldD3yc/5BSuq7tsRJCCCGEEEIIIYQQQnQbjYqCawAfABuUjidAoqAQQgghhBBCCCGEEFMQDYmCKaV1ujsiQgghhBBCCCGEEEKInqEhUdDMas49mFL6on3REUIIIYQQQgghhBBCdDeNDh/+DB8qXI2BbYqLEEIIIYQQQgghhBCiB2hUFFygtD8COBa4v73REUIIIYQQQgghhBBCdDeNzin4funQ+2a2G/Bj4Nq2x0oIIYQQQgghhBBCCNFt1JwrsAFmBoa1KyJCCCGEEEIIIYQQQoieodGFRm6i45yC0wNrAjd3R6SEEEIIIYQQQgghhBDdR6NzCr5T2v8HcEVK6bE2x0cIIYQQQgghhBBCCNHNNDqn4MndHREhhBBCCCGEEEIIIUTP0PCcgma2h5k9YWZvxece3RkxIYQQQgghhBBCCCFE99DonIInALsC5wLvA/MDR5vZ3Cml07oxfkIIIYQQQgghhBBCiDbT6JyCewNrp5TeLw6Y2aPADwGJgkIIIYQQQgghhBBCTEE0Onx4BuDT0rE/ANO1NzpCCCGEEEIIIYQQQojuplFPwUeAW8zsWOA3+PDh04BHuytiQgghhBBCbHbn7U1f88CE7Uth3NlCGBM67G9+571Nh3H/hPEd9re484GmwwCYOGGzSd+3vLM18/u+CeMmfR9/5+MthXHvhPUmfd/qrh+2FMY926w56fvWdz3fUhh3b7PypO8T7vpJS2Hcuc2yk75ve9ebLYXx3W2WmPR9+7vfbSmM27decNL3Q+75bUthXLTVvJO+n3zP/7UUxte3mnvS9wvu+bilMA7baq6WrhNCCNF7NOopeBDwN+B14O/Aq8A/gYMbudjM5jWzJ83sZ2b2ppkdGsdnM7Pvm9nb8TlrHDczu8jM3jGz181s2fr/IIQQQgghhBBCCCGEaJSGRMGU0l9TSrviw4VHANOnlHZJKf25wf/5DDgipbQ4sDJwoJktDhwLPJ5SWgR4PPYBNgYWiW1f4PIG/0cIIYQQQgghhBBCCNEJdUVBM1vCzI4u9lNKX6SUfpdS+sLMjjazxRr5k5TSRymln8T3vwE/B+YBtgRuiNNuAMbH9y2BG5PzPDDUzEY0c2NCCCGEEEIIIYQQQojqdOYpeBJQa3KL9+P3pjCzUcAywAvA8JTSR/HTx8Dw+D5P6X8/iGNCCCGEEEIIIYQQQogu0pkouApwT43f7gVWb+bPzGxG4C7gsJTSX/PfUkoJSE2Gt6+ZvWRmL336aXlxZCGEEEIIIYQQQgghRDU6EwVnAz6v8dsXwKyN/pGZTYMLgreklO6Ow58Uw4Lj83dx/ENg3uzykXGsAymlq1JKy6eUlh82bFijURFCCCGEEEIIIYQQol/TmSj4a2DVGr+tCrzXyJ+YmQHXAj9PKZ2X/TQR2C2+7wbclx3fNVYhXhn4SzbMWAghhBBCCCGEEEII0QU6EwWvBq4xs+Xyg2a2LHAVcGWD/7MasAuwrpm9GtsmwBnABmb2NrB+7AM8BLwLvBNxOKDB/xFCCCGEEEIIIYQQQnTCoHo/ppQuMrOFgRfM7LfAR8AIfDjvZSmlixv5k5TSjwCr8fN6Vc5PwIGNhC2EEEIIIYQQQgghhGiOuqIgQErpEDO7CBfvZgf+ADyeUnqnuyMnhBBCCCGEEEIIIYRoP52KggAhAEoEFEIIIYQQQgghhBBiKqCzOQWFEEIIIYQQQgghhBBTGRIFhRBCCCGEEEIIIYToZ0gUFEIIIYQQQgghhBCin9HQnII5ZtZBSEwpfdG+6AghhBBCCCGEEEIIIbqbhjwFzWxZM3vOzP4B/C+2z+JTCCGEEEIIIYQQQggxBdGop+ANwP3AnsA/uy86QgghhBBCCCGEEEKI7qZRUXB+4ISUUurOyAghhBBCCCGEEEIIIbqfRhcauQfYsDsjIoQQQgghhBBCCCGE6Bka9RScFrjHzH4EfJz/kFLate2xEkIIIYQQQgghhBBCdBuNioI/i00IIYQQQgghhBBCCDGF05AomFI6ubsjIoQQQgghhBBCCCGE6Bka9RTEzAYDY4A5ACuOp5Se6IZ4CSGEEEIIIYQQQgghuomGREEzWx34LjAEmBn4KzAT8FtgwW6LnRBCCCGEEEIIIYQQou00uvrw+cBZKaXZgL/F5ynAZd0WMyGEEEIIIYQQQgghRLfQqCg4GriwdOwM4PD2RkcIIYQQQgghhBBCCNHdNCoK/gUfNgzwkZktDswKzNgtsRJCCCGEEEIIIYQQQnQbjYqCdwObxPfrgCeBl4E7uyNSQgghhBBCCCGEEEKI7qMhUTCldFhK6Tvx/RxgArBPbJ1iZteZ2e/M7I3s2DfM7EMzezW2TbLfjjOzd8zsLTMb19QdCSGEEEIIIYQQQggh6tLQ6sNlUkpPN3nJt4FLgBtLx88PkXESMTR5B2AJYG7gMTMbnVL6vJW4CiGEEEIIIYQQQgghOlJXFDSzJ4FU55SUUlqvsz9JKf3QzEY1GKctgdtSSv8Bfm1m7wArAs81eL0QQgghhBBCCCGEEKIOnXkK3lzj+DzAIcD0Xfz/g8xsV+Al4IiU0p8i7Oezcz6IY0IIIYQQQgghhBBCiDZQd07BlNK1+QbcCywGHIEvPjK6C/99ObAQMBb4CDi32QDMbF8ze8nMXvr000+7EBUhhBBCCCGEEEIIIfoPDS00YmYzm9kpwDvAcGDZlNK+KaUPWv3jlNInKaXPU0pfAFfjQ4QBPgTmzU4dGceqhXFVSmn5lNLyw4YNazUqQgghhBBCCCGEEEL0K+qKgmY2nZkdB7yLewiunlLaJaX0q67+sZmNyHa3AoqViScCO5jZEDNbAFgEeLGr/yeEEEIIIYQQQgghhHA6m1PwPVw4PAuf92+4mQ3PT0gpPdHZn5jZrcDawBxm9gHwdWBtMxuLL2TyHvCVCO9NM7sD+BnwGXCgVh4WQgghhBBCCCGEEKJ9dCYK/gsX7fav8XsCFuzsT1JKO1Y5fG2d808DTussXCGEEEIIIYQQQgghRPPUFQVTSqN6KB5CCCGEEEIIIYQQQogeoqGFRoQQQgghhBBCCCGEEFMPEgWFEEIIIYQQQgghhOhnSBQUQgghhBBCCCGEEKKfIVFQCCGEEEIIIYQQQoh+hkRBIYQQQgghhBBCCCH6GRIFhRBCCCGEEEIIIYToZ0gUFEIIIYQQQgghhBCinyFRUAghhBBCCCGEEEKIfoZEQSGEEEIIIYQQQggh+hkSBYUQQgghhBBCCCGE6GdIFBRCCCGEEEIIIYQQop8hUVAIIYQQQgghhBBCiH6GREEhhBBCCCGEEEIIIfoZEgWFEEIIIYQQQgghhOhnSBQUQgghhBBCCCGEEKKfIVFQCCGEEEIIIYQQQoh+hkRBIYQQQgghhBBCCCH6GT0iCprZdWb2OzN7Izs2m5l938zejs9Z47iZ2UVm9o6ZvW5my/ZEHIUQQgghhBBCCCGE6C/0lKfgt4GNSseOBR5PKS0CPB77ABsDi8S2L3B5D8VRCCGEEEIIIYQQQoh+QY+IgimlHwJ/LB3eErghvt8AjM+O35ic54GhZjaiJ+IphBBCCCGEEEIIIUR/oDfnFByeUvoovn8MDI/v8wC/zc77II4JIYQQQgghhBBCCCHaQJ9YaCSllIDU7HVmtq+ZvWRmL3366afdEDMhhBBCCCGEEEIIIaY+elMU/KQYFhyfv4vjHwLzZueNjGOTkVK6KqW0fEpp+WHDhnVrZIUQQgghhBBCCCGEmFroTVFwIrBbfN8NuC87vmusQrwy8JdsmLEQQgghhBBCCCGEEKKLDOqJPzGzW4G1gTnM7APg68AZwB1mthfwPrBdnP4QsAnwDvBPYI+eiKMQQgghhBBCCCGEEP2FHhEFU0o71vhpvSrnJuDA7o2REEIIIYQQQgghhBD9lz6x0IgQQgghhBBCCCGEEKLnkCgohBBCCCGEEEIIIUQ/Q6KgEEIIIYQQQgghhBD9DImCQgghhBBCCCGEEEL0MyQKCiGEEEIIIYQQQgjRz5AoKIQQQgghhBBCCCFEP0OioBBCCCGEEEIIIYQQ/QyJgkIIIYQQQgghhBBC9DMkCgohhBBCCCGEEEII0c+QKCiEEEIIIYQQQgghRD9DoqAQQgghhBBCCCGEEP0MiYJCCCGEEEIIIYQQQvQzJAoKIYQQQgghhBBCCNHPkCgohBBCCCGEEEIIIUQ/Q6KgEEIIIYQQQgghhBD9DImCQgghhBBCCCGEEEL0MyQKCiGEEEIIIYQQQgjRz5AoKIQQQgghhBBCCCFEP2NQb0fAzN4D/gZ8DnyWUlrezGYDbgdGAe8B26WU/tRbcRRCCCGEEEIIIYQQYmqir3gKrpNSGptSWj72jwUeTyktAjwe+0IIIYQQQgghhBBCiDbQV0TBMlsCN8T3G4DxvRcVIYQQQgghhBBCCCGmLvqCKJiA75nZy2a2bxwbnlL6KL5/DAzvnagJIYQQQgghhBBCCDH10etzCgKrp5Q+NLM5ge+b2S/yH1NKycxStQtDRNwXYL755uv+mAohhBBCCCGEEEIIMRXQ656CKaUP4/N3wD3AisAnZjYCID5/V+Paq1JKy6eUlh82bFhPRVkIIYQQQgghhBBCiCmaXhUFzWwGM5up+A5sCLwBTAR2i9N2A+7rnRgKIYQQQgghhBBCCDH10dvDh4cD95hZEZfvpJQeMbMfA3eY2V7A+8B2vRhHIYQQQgghhBBCCCGmKnpVFEwpvQssXeX4H4D1ej5GQgghhBBCCCGEEEJM/fT6nIJCCCGEEEIIIYQQQoieRaKgEEIIIYQQQgghhBD9DImCQgghhBBCCCGEEEL0MyQKCiGEEEIIIYQQQgjRz5AoKIQQQgghhBBCCCFEP0OioBBCCCGEEEIIIYQQ/QyJgkIIIYQQQgghhBBC9DMG9XYEhBBCCCHE1Mlmd97S9DUPTNipG2IihBBCCCHKyFNQCCGEEEIIIYQQQoh+hkRBIYQQQgghhBBCCCH6GRIFhRBCCCGEEEIIIYToZ0gUFEIIIYQQQgghhBCin6GFRoQQQgghxGRsdteNTV/zwDa7dkNMhBBCCCFEdyBRUAghhBC9xib3nNbSdQ9tdcKk75vec3ZLYTy41VGVMO6+sLUwtj60w/6md1/WQhgHdAzjrquaD2ObfTvsb3bXdU2H8cA2ezZ9jRBCCCGEmHLR8GEhhBBCCCGEEEIIIfoZEgWFEEIIIYQQQgghhOhnSBQUQgghhBBCCCGEEKKfIVFQCCGEEEIIIYQQQoh+hkRBIYQQQgghhBBCCCH6GX1aFDSzjczsLTN7x8yO7e34CCGEEEIIIYQQQggxNdBnRUEzGwhcCmwMLA7saGaL926shBBCCCGEEEIIIYSY8umzoiCwIvBOSundlNJ/gduALXs5TkIIIYQQQgghhBBCTPEM6u0I1GEe4LfZ/gfASp1d9OnlN7f0Z8P237kSxhXXtRbGfntmYVzWYhgHTPr+yeVntxTG8P2PmvT948u+3lIYcx1w8qTvH156SEthzHPgRZO+/+aiCS2FMd8hd076/stLWtOERx9036Tvr1++RUthLLX/xEnff3zl5i2FscJX7p/0/ZmrNmspjNX2fWDS9yev2bSlMNbZ+8EO+49eu0nTYYzb66EO+w9ct3HTYWy258Md9u+5fqOmw9hqj0c67N/eQhjbl8K46dvjmg5jl90f7bB/3Q0bNh3Gnrt9r8P+lTc1H4+v7NIxHhff0nwYB+/UMYxzb20+DIAjdqyEc9rtrYVxwvaVML723eafLcCp21ae7+F3tRbG+dtUwtjjntbCuH6rShgbT2zt/X94i8r7v/F9+7QWxpZXT/q+yb1HtBTGQ+PPzcI4scUwTmnpOiGEEEIIIUT7sJRSb8ehKmY2AdgopbR37O8CrJRSOig7Z19g39gdA7zVSbBzAL/vYtQUhsJQGP0zjL4UF4WhMBSGwpjSw+hLcVEYCkNhKIwpPYy+FBeFoTAURt8LY/6U0rCqv6SU+uQGrAI8mu0fBxzXxTBfakO8FIbCUBj9MIy+FBeFoTAUhsKY0sPoS3FRGApDYSiMKT2MvhQXhaEwFMaUFUZfnlPwx8AiZraAmQ0GdgAmdnKNEEIIIYQQQgghhBCiE/rsnIIppc/M7CDgUWAgcF1K6c1ejpYQQgghhBBCCCGEEFM8fVYUBEgpPQQ81OmJjXOVwlAYCkNh9HI4CkNhKAyFoTDaF47CUBgKQ2EojPaFozAUhsLoZ2H02YVGhBBCCCGEEEIIIYQQ3UNfnlNQCCGEwMxm7+04CCGEEEIIIcTUxlQnCppZr9+TmU3TxeutXXHpC/SFZ9Ju+sIzmlrSdWq5D9E9mNlCwAlmtkBvx0VUMLNZejsOUxtmNrgv1C1CCNEVzGx5M1s+vsvGaxPtSsu+Vs/0tfiIvkVv5o/+lDenioLazBY3syXNbO6U0hddKTS7+vDNbF3gq2bWlfkaB3YxDn0mA5vZkJTSF/F94VhJuivhNX1v7UoPM1vFzM4DSC2Muzezge2Ij5mNjjh80ZVwuhKX4rquGihmtj6wfV8QGMxsMTPbsA/EY53iGXchjGFmNqQL1y9nZit3sSydrdVrSwwEvgSsFeG2UgaM7Wp8zGwWM5u2K2FkYXWpjO9tzGxz4FYzm7m349Iu2lAuW/a96ffGzDYCbgfOMbNNuhKXrtId+bMv2SU9jZnNZmYrxPepwu4W3cdU8q7sDFwI7bFVp3TMbLqutAvNbKSZDetqWha2dittmHZiZiuY2YZmtnhX4mNmq5nZBvG9V96b8r30Fn3NrmyDTbVw5PvZU0qpN+pOM7Mib5rZmJ7+/55mijdOzGwccC9wFPATM/tSCINNZcZieFr28FtpeI4DzgOeTil91uz1Ecb8wKVmNqgLL8BcpTBbaaB0SbyLMNYDDo3v2+MGQlNxKT+HFiuOQozr6sI6/wEWMLP5mr0wnustZrY0MGN2vNl8OhDYxczm7oKgN4+ZHQ1dMgxGxfUti/DR8L0E+Aeetr2COYOB3YD12x12C5etArxu7iHXyn9uCtwCLGwteC1n4sRMZHm1yTDmBvaM763m0wXMbJaU0i+Bs4BzzWydZvNsVkeMyI41+95tgE/gO8HMRnR2fo0wFjezZc1s5pTS5y2GMdrMFmvl2rh+bTO7IdJ21jjWbJk8DjgVOCml9NcuxKVdnTVtCSeMzrXMbMGuXt9suRhpejLwIPBbYPVW4lAKc0kzG97CdbMAW8T3DYsGV5NhFJ1GI6MxPF2kz9QgdjSV5+Lc8cDaMHUIJN35HPtpHlnEzDYrbMuutEO6SrX/bCG/g7fJPjCz8W2KWq+QlWXzm9nCLYYxE3AiMKwLUdkYWK+IU4tt1IHA+WY2xnpRQDKzjYHrgX2AI81sVPZbQ/eVnXccMCf0jtBZ7156OB7DgG3je2961a1mZt8ys+mBwXGs1U7SicDpwEQzW7gNgnjT6ZKVxfsAJ8a73Oz/ztuKLdYbTNGioJmtDVwK7JVS2hW4GLjBzGZqpnAws1WBR83saDOb1cwGN6tKm3sY3Y03lJ5ttsDNMuufgD+klD5r5QUws0XxivgUM9sFKkZoE4XthsB3zOx0M9uh2ThEGIVA+qi5ILglcGxK6d/NvJjZC7mrmR1jZnuZ2TxNxGMO4B0zmy2l9Jl1TRj8EJgGWDPCbqaA2RTYDjgNOMbM9ocO99doXhuIGxYrZNc2K9z8mahEm8XMBprZDMBLZnYytCYMmgsbZwC7pJQmppT+HcenayFOhdE2jbU2dH9QSum/wM3AeDPbo4Uwyg3huWGSUNDoezcgrvkWcCXwhDU5ZNZcaP0WcFFK6c2U0v+avH4lXLzfJ6X0/UL0ye6t0ef8X2BNM1smy6cNPxtzT8m7gSvNbK6U0mPA0cDu5gJ7o+FsDpwA7J5SetNa6CU3F1nPwoXWJ1NKHzV6bSkeT+CdJM+Y2ZZhxDUTxmBgA2Ay77xG8liUfRsCuwB7Axeb2Up5PdNZOFGu3wi8B/w0jrVi8OW9r5uZ2epmtloXwxltLQh6Wd5eDBfmXmomnFrXN1oumtmywMPAYSmla4DfAOua2aFmtluL97I4cBJwUbP5DLcLFzSzV3CD/Okmry/KvY2Bu/BG281mNmMLgn5xP11uwJqLpEt2MY8sEMb99I1eF/f8KN5JUzSSFjKzeZuNRx6XVsnuZWEzG2UteOnH813PzM4ys10iD7can+XMxfQvZWE3LUJ1JY+0MU2XNrONzGxEk3n9BOC7+HvylbBbi7Roph1SxGNBMxtqLXjHx3+uaWYTzG33purL7FwD3gJWbjYOBdWeSxP21LJmtkZXy45Ij01xgeIOMzsn9psJ42/A/4B1svhNk31v5J7+AixaxIkWbPjojPwA+LwLHZM1RdIG7ZCNgAuAbVJK2wJDgcUtOlubeP+LkTD/pg1OBWa2jPmIkqWauKbuvTT5/10Vn4cCO5vZ/OX3tcUyZPFIj4bth6jfDgKOxdu6XzOzJZuxMeOcDYCzgX2B/XDb+XRrcqROdi/DzWxoF7xR18Rt5xNSSn9rND3NmQm/j8nK4mbrna7WU40wRYuCeM/Jy3ghBy4Q/hRo1ktvemAB/MGdgHukzNWoKBcVxBm48XygmQ1PKX3e5AMcChCN8OHmXnaY2b5mtpU10Ftv3uj7B/AOXmCuYWaPmg8DnLORwjYKubOB+4CPgFVLvzfyQhcC6YkppdeAkcAOhHcZzXsLHoZ7cb2HP6OtG702pfR74GDgWTObtRAGmzAsJjXAU0qf4GLNsWY2pklD6TLgJuDnwLPAdmZ2pZltbWYDOstrYTgvGuLV1USPo5kdjw8328PMluwkjMI4+gKYtzjfzNYNA2r5Bm5lYErpH8CKuEBzQtzfF5YJrlZHfI2KIwG/TSn92NyTZE8zuwe4xLxHpmEiX48HvgM8HPfTkKerma0InGFmI1NKbwAH4O/wqp1cWisehfF4spn90MymaTSfZOL9/rih8zvgR2a2SIP3MiM+ZOerKaUHzGxGc6/QVa3x4cgLA3emlJ40s9nNbBMz+xbwTTObI3XihW1m80XZ+Xs8HQrB5ivA8ebTKzTCu8CbwGrAmeZi519xwWSZCLOmsW9mA8wF5quBj1NKT5k3widaDONrBHNvzTOAw0O8/jCO72oNDjU3F9F3AHZIKe2GC4zbAFtaNP4aId79v0ZYRdhjGs1jyb3Xb8DT9Te4oXWmeQfS5nFOzXDMbDPgTFz4egZ/b+bvLE/UiEuRL74KHIl7xp1h3tHXSjhHARfhIvLZ1oRRHu/tJsCtwOW4QPdco+9dvesbFAY/AJ7E88MwPD1+DHyMe3Uc1OS9jAe+HeHOAFxoZnPVuw46dEr8CfgUmA/4ddZh00zDYim8c2IXvCybi2xalEbzS9zPRng+PdO8w6WZzoWiUbAubpOcDpxiZoc2E0Ymct6Le1F/3ToZ4h1lxxFmtkqUG4OAGc2nzDgBF2y3azQeBRGXNczsQDMbZ2YNiwPZvWwE3IPbJN9sNh5Rhp6BP9tlIoyGveyz57IW/t4cDhxnZqdB8yJUlF+3mdnFZrZt43fSIU1WNbMDzKeJabhczuKwIZ4/9sTrmZ2t8QWybgTuAI7B64ajzez0CLvRdkhxH+OA7+OjMG5s0K7Ln8lquC21BHCqmZ1dPqfG9SuZ2T3mosbQqK9uwL3rt2kkDmWq5fVGhFJz4X5z3KO9wzQozdZVUZYdBkzA25wf4h2enQ4lNLM5rDKk9IdU7Pbt8WdcdKxXze/mwv3G5h0ZE3GnBMxsV9xWPtzMdm8gHsOsIqi8jpfLhR3zNTPb0RoUouqJpJ29t+YCydbA2ymlt8KGWwE4EG/HnNtgOEvizwP8eRR2wJDiWTdSX2V5fk28zXsk3v4/uoFrG7qXRmlVfDazac1s2pTS28APcPEZ806bbay5DkrLyrI7cQeBU81svwbv4b+4ffssbn/8GXfUOtDMVi7us4Gg9gLeSCn9KNqb9wF/pEnxN6sb7gYeMe9obag8hEntiOmBXfG20QrWQHs9///oEPgImGQvWOY00sTtTKpnzOwoMzveusPbN6U0xW34wxmNG60X4gX/QniD5Q5cuGg2zINxwWklvGf7t8ARwBqdXLcIbvyuEvtXAD8ChsW+NfDfW+KNgKNwj7KtgY2AxXGjbRvg68DYOmGsCxwV308G7seN0P1x4+8RvOE1rE4Yc+LGydqxvyHecJwAjG8wHTcFfhL/9z1grjh+BN7T9aXYb+gZAdMBF8f3w/AG18A4Pm0Tz3dj4FfArLE/KD7XAZapcc1i+JDB4/I4A+cC23V2HxFPy/Z3xz1JAZbCvakm4kLhesCAGuGshoskF+OeRhvHdfPjAu4ckTY71onLl3BPp0OAJfECaj1c3HscF5OuAZarE8YGuAF/It4QmBsv7I4rnTcBF3Eny/v4sLTH8Hf3jsjfP8Ebsefjhe8DwOJNPNsvAS/gHpwH4Abx1vFbrTS1+DwD+Cc+bG9ZXMA+BPgaMFujccie6bPAvMCXcXF+lvJ/dhLGCvGs58Nd748BPgEWbDAO1wLH4+/yZfj78nrc37gGrl8TF4y+gr/7t+DePlfg73PNdw4Yh3eM3It3JmwSeWrVeL5L4kbLanXCmA8YHd/nwMuyUyI+5wDPA7fVi0dcOzg+F4j7OS/yxUFNPtPFgJtKeeZy4CXcs3S7BsO5Hvhatr955P1NY79eObIG3ls6V6TP8XH8gAj3IqIMq5bH8HpkKWDe2D+MSl1xOC4+vxnPea0acZgx4rB67K+M9wSfB8zXaP4uhTkKuC++fwuvpwYA0zVwbV6ubgA8Et+vxA3AunEp/x7/f3C2fwLe2Figi9cvGPuTlUP5Mwdmx+vs/wL7lt6pG+rljzxOeJ1zB2G3AGNwIexG6tf9eXquGc97Bfz9u5FKvVk1PaqE9yXcnlofeDFLh1WBaZrIIytH3twOL1cuBNZpMp+thpcZS+J2wxqRRts2EcYKeL20GC6W7IWXiWNrnD8nXkYcj4sBY/G6bYd45zaP8x6k8bK9KH9WBt7AbZNr4l7mb+Jelo//HYPXdzvFvazS4PVLxv8XdewcEcbVkY8bKgciL9wDLBX7Y/HybN9G7yWuG42L6rvgdsynwJ5NhrEO7tV2CW4PfR1Ysonrx+Dlzkqxv108mzXL71eN66fDHRz2jP0JeOftHbi91ZA9hE89cm6k7XB8SOMrwGJN5POLsmc7a+Tj0xu4dnZcTLw1nmPRJtoJr8Ono4Y91s68DmwW+WEw3q57GH/nB5TOW7iBeMyKixwfUKnn5o58u38DeeIl3IY6G5g23pFl8Lp2XtyW+GaN6+fE2ywXRvqNx22OsXFfC+Ll7PENvB/v4O3jY/B24Lfw9uGV+FzN+wE7NfhslsJtqUUijx0eYY9p8PqV4v26JvLm7nF8VVyIqtvmjnO/jL9vheDz5SrnNNrGXAf39lsx9r+E2/G798S9dCVdcdvulvj/YXgb85t4nTcR2D7en4bqmAhzuXhnRuPv7Hi8XKzZfsA1mZHAnLF/CjAhvn8d+APekXwzdd7fSPulIg4TgW/E8TNxO6Sh8iMLbxm8HbM4rpF8Hbdp5qpzzWrxfkxPtDNw2/s83JaqqhfUSMdtcJt2KdxJCrwNfwneVps5jjVaZ66Mv8t7R3peXqRno2F0+h/tCKQnN7zAfx1vfF4eD/q8ePDPURF76hYIwCxkDUu88rwnvs8H/D0y4m+AY2qEsSku5o0qHb884tepMIgPBbsIb0Cvhrvero03BDaj0ni7ANiyRhjjgFepNASG4ZWo4YXTB3jF9irekJuhTnwKEW/2yHRXRQZ8gc4rwWoC6XNZOhyBi0hj64RRbmwNwY2Mp/DeguL57kGNBmydsMvC4AHxgs1X4/z58QLxWbwBvz/uebETLm7Ue66L4IXzBKKRizcoXsIbS88CR8bx44CVa6VH5M2DY/+8eL6H4QXoA3gj7mC8EhpUJQ2nwSvOY/D35Qy8UXMh3kAoDMDDqVGJ4SL1i/E/p0Z6jMQrg99REU73wj1cJqvIsnxaGM4r4EPcjgTmyc67ncaN2EVxQ/T67NhWuFdpTaOPTHjADbZH8AL/wEiXK4ElUgNlSRbOgrgYuhP+vhQN4Zr5tMqzWqi4F6LxjBuQf6dGZYpXOgPi+/q4kfBHvNLZGDc+vwYcUuP6MfEciwp9F7xhdHqk7wDcQL2OGoINLkZcE9fOCTyEiz5H4WXt1XhZdzQumFQTSWaI824gOiEiPbfHjfMl8MbsF8AVddK0LF6PwMvxx7JzBnXyLItycAG8jB+T/XYinve3wcvVIQ3kjfXw926l7NgeuOAxY53rlqJSbl8SaXoD/j6ei8/7uDZwQY3rxwG/xA2qj+NZL4cLvJvjHRLrx7mnACOqhLEZ/n7MVzq+EhVhsBAc65WJufA0ADe0bsPr2fupGGBbF+E1EM6wyLuHA9+IeBaC8PI1rp+WqINwY3FMXHt6lpdnxOuuN4CRXbx+snuh8p4eDWyY3cv9wOXZeYfj739VIQ032ueI74vE5yPAgVlctsbF9MvIOilqhHcg8Hb2PBfGxfib4rdJhmyN6+fBG83z4XbH+1Tqv7Xwsn14Z+9LnD86/rcwpgfhZcetjVyfhXM6XmYsFvsz4XXOcQ1eP2Ok3YdU7I/5Iy2qdsThQtktkVdWxN/VHfFhVYviZek+eD2xSBP3sjxulxVi00hceGy0HJo+nucfs3wzN26z7tNgHEbi5VZeno7GhZLZm7iXw+K5bJDFbV/gW02EMRYfHfT17NgKwC8IsbHBfPY9KuXgirjt9pXYr1umxTM+CS9n846BY/F3cTL7IfLPLvm7hJen5+M2+2vxvm1BZlPXicdA3M77JW77TJP9djpwQCfXFyLc0cCvcVtxhix9HqZGuwGvo9alYvcvhJdbv4xwLsQF/VGNPtdG8nq154LXdz8Dls2OHR7xX4tKx/7euA0/tFZaZPuL4mLGBURdgIto51R7ttl1E4DL4vvtEbezcXvkoHjOa+Hv3nSla2eO/HBO7O+Mi1eb4PblaXhZuF7c72T1dhbWnrjdPiie70i8XbchcHMW/pUNPJOWRFK8nlyDSl0wFm8fPgnMlJ13O7BxZ/k0vn8ZF5/fi7x2D94Bcyte9p5DHRGJis18DV4OLZf9tjNwWnfeS1fTFX/f78WdGDbG8/ji8aznKOKP5/+GOknw9+prwL+ApePYbJFvj61xzUaRB2/C39eRuM3xWOSxn+G25vRxztw1wtkYL8vvx50IVsLb/E/j7ZGi7m20Y2FOvB33anZsLFlZX+WawZF/vsDL4lOp2Hpz4lrNGYSAXOe/V8F1qktx23uGiMuqkd+mxev/8xu5lwhzSfy9PSD2izbXzY2G0dD/tDOw7t4iQX9OxSviSrxBMiQy7dl4hdSZILhBvLA75xk0jt2PC0VbxLHRVDHa4kX4EbBR7E9T+v1yvJCYs0481sEL9qIxvWRcsyDeyBiCN67PjzhVE1o2xIcMF/EdEBnuGlww+jmVBvZihCFYJZzCKFgcFwRH5C8O3sN9ap17qSeQPktFGDwRF+YGU9/YWp1KD/LGuCBV9DzsHvfVkNdCKdyN42X9aoQxtso5q+EV7w5UhJ0vU+kNWhsv6Par8R+L4Q3Cwyj1KkTc/0MnvXtx7tD4XCD+bwe80NwAL6y+jAs+38FFv5o923jDexHcGC0EmpNww+tJXCD9lCqiIF4pfEHFu2Fe/F3ZNvYXwRtMT0WaTmaMRz79NNJwcJ14boM3lOapc46V4nYeXgGtRqXiuApYt8b1S+I9RsW7uyxekW6EG1k34d6DL1CnoUXlnVkJF2gXw0WA16kIE6vjFdr8ndxHYWDMEtcfmv22D175VyuHxkV878J7wFbEpyIYWzrvW8BZVa7fCDeovoN7bC6Ux6eUb5+muhE9d3yugzd216XS43krLiptHt9fpn7P51x4vv4AF+E3iHtbLn4fjpchC9W4vpp4PT/+Dn1KZthQo/zBy7IXIy4z4wbf3pQ8rXBj7LpqeQR/rxYq3dc58YxWzo7f2kl6rAHcEd+/hguke0Se2wU3fveu9mzwcuodKp1FJwIvxvfr8Hd6m3rpEen5GjU8xfGey2/idfHIOveR5/Xtqbx7V+Ai1OyxvxfecTJZvYk3wPNw9sEF07Xx9/8RYPr47UBKRnp23Wi8t/Yq3Ct3jsgfHxPCOf7enoMLPwe1+fpx+HtwNN4QuIpKb++cuCF8Ed6ofJbwrq+Rrmvi7/b+uAA3I/4efq94tni5eB1unK5UJ6w18DKg6BwYi5f1oyPv/YjoKKn2bPE8ORGvV4bgZfmz8bzHx7Pastb/Vwl3FVw0/h5Z3YbXrTUFnyw+hahhkT9fKPJD5LPv4g2ravm+CKNoOC4a+euq7LcTqDTai2PDI70G4SNAvoOXhUdEPM7FbavV4hlv1Gh6ZM/yn8C5Rfzied9Y7T5KcSvqxpF4/f2dLD0OxYXPAeVwsusXomKTzYPPk3ht7C+F1/31OuKKcGbJjn0triu8w7eNdJ6h1v1UCfdO3PacIfuPK4hGbSfXDoz/fJNMFMHrq6epLYSV89g0uAh4AbBJHFsx8li5Ll0Uf/8vADbLjhfP5VM6egvXs5eKeBQdiHMQ3mXZOScAZ3Ry/cjs+y7xDFaN+1oNf3dmqXL9lrgAezMuSrxBdMbg7+/+VDryrmn0mbaS1/G66gO8nFmw9FshDI7GhedfU78M2RwfmXM1Ls6sgYsBP8TLjtepIfjgdf098fxPxO32B4Cl8XrpgIjrqYRgUrp+aOTfJfD26DG4gHkcbltdGOedg3cUju8kHTfC39X58fdkQ7z9MxZv59yBl9Nb1csjpfzbsEiKC5lvUPGaHBvHV8A7Is/FBaMN8Pqnrlcb2fuA22qPRhjb4u27bQlPyk7y/NDs2JXAW9n+rng93KF+aOe9dDVd4/fdIk/Njtu6Y3DNYCM8z1+Ci6arN1CGDInPwlHpfqKNHelxM6V2e9znT3F7ZwZcrL41frsVb+tu3cC7vjbeDim8Ne+P/Dknbv+fEM+iM20nj9ugSIfH8c6EokPgTOCIOmEsg9s6R8T2E9zWHxO/Xxvxqdc2HE84LsTz3ALXdJbEy4/jcbH+u9Rx0qoS5tO4YFp02g7AhdianejNbm0JpKc2vJLaPdsfBtwf3+fExbNLqOPeiRcir8RDmqf02+p4A2Xj/CWpEkYhkoyP/YVw743Z6NhDdxP+glbzihmHVyyLx4t2Ay6gHRa/X4FXgEPwyqSaB0c+VPdRsh543Gh7l0ove6fqevzPReV0id+OwQ3iavfSiED6wyJ+dDIsE680fxr3dgRuHHw50utWvJE6WeOkiXy0aTy/pWv89qt46R/ADc5zs98PiTT6B17xl+91noj7zqXja+IF99C4rnipa3mAFML1brG/JD6EcofYnw84Or7PQJWCBTcCNsffkw3xRsDNVAqrO3DDY1Hc2Fi1kzR7k4q7880Rn6KgHR2/j61y7ebx7I7DRZGjKBViEccj49nWbASX3tXxVHqRz8QL333jtw+p7Sm0It4YeQqvOGfCK7NiKOfscX+vUUecjHM3ww2EtWN/R+D3eE9ZkY837ySM/eJZH42XB/NTGfJ6Ft6AmMzdPZ7Ju7jRuQ5upFyBN8bzynEX/F0aU7p+PdzAWR3vSDg5/rN4poY3Mg7Hy8zJhjDhRtKP8LJjDrwsuJiKp9KWpXRt1EtoWbwxfTRunD1FRbCsNSS8EfH6A+CUOv+7EV7xbpwdWwcvC/ah0nu6Oy5OVOuo2SDicRfuaVUIC/PjHVfnRH7bI+JT7dkuHluR/rfhhvvGuAF1VZz3FbwxX+3ZnBn3Xxh2Q/E6aZp4XldTEdHKQ6sszr+PiifPDPEMlyd7fyP/fK2RZ4s3En+aPcvlcUP6WVxcfJ0a7z+Zdyeed58h6kW8gXVt5Jej4z+WqHP9YfjcO+dnx5bE3/lr8elDlsHrn2PbcX2cMw6fh22tLE/enN8zno+fwr2DOx02GM/4X8CusT8YL39+jTfEP8AN7MuB7fNnXApn5XgWh+P59A0834+N3+t5tG6C1/FX4cMwD8Q7N9fHhcLLqIglnYlXS+L10hy4WHE+3omzCl7P/IIanQJZWJviBveNkVfmwsvSD3EB7DGiI7WTsuBcXHSdF/ewvSKezdZ4uTwuO3/R+O0svHE2EBeLi/dnIO7ZsnS1++4kTeam4r28Ol7XHhT7q+Ll+4g6abtpPP/LIg3Hxr39BG/wvVg8nzrP9028rrsCt5/njTT4JV6urNdAXt0Mt4kfwOupkfi79Bf8HX6QBoRjvA4fT8U79ha8rFottv+jdv1fpOmcVDpeN8Pz7uGxvzien+t16m+J1xWP4J5fs+Ll4NPxnF8s5zG8rfBzfIG1/HjxbDeP9Cwa6I3Y7Rvg7/mRkQdnxsufByOfvkQmPlZJh00iTjfj7ZAZ8Y6mH0e6TqSKYISX3b8gs/nw9/QJsuks8HrjeDrpxKcLeR2vE1+K9Ns58tfKpfAPj7Dep74guAxef2yBd6bcgb/7i8f3B4o8SnURbOZIy80iLx4DnBy/rUEMiYz9kfm9Z8cLZ5BC2JiQ/XYulU7nITWuXyT+d4t4BnvibZpvxu9rAWfH93mz9K5VfrQkkuLtjvfwEQ4D8PLn7NJ7fAr+zrxBjfoOrxPuy/JILgxuF89pAg1OKYXn+Ufw93T7OHYtbrsfjYtSW3fHvXQ1XeO8NXH7bG68/LwPuCR+3xvPw4NwO7rqKLQq8bgZb+8uH+l9At4W/ipua1UrQ24j89yPa6/Jwrwh+62e1+ZixLQgeF39Ef6enY4L64/gbZNOp3SK53QMbntNh5fTl+Fl2Ti8rFundE0jw5+fw9v+K1Jj+DH+3s0V4R0W5z8f6bI53mE6T/bMauoYVPL6GLy8mxavt2/D3+eFcWeUn1PD+7KVrS2B9NSGG1UzZ99H4o3VokBbCm9wVZ07B6+Qf0o04LPju+KiyDR4A3eX/KHUCKsQ5JbClejDqmX+apmHkndfHBtEJkJGRt67zv/Xncswjh1MRWSsdy+FCLBRZNqBuBhZHN+FGvOS0JxA+ih1eqLj+3S4uDMtbuBcjRdKo/BGwigaFBY6yUvTVzm2YLxga2RxGcPkQ7pmwF/yaoLAWGIoHxUx4ADceLonrj0DeKbWc6GOcF1cE+n8ALXnvBqDG3UnEAYdLrzl+WMT6sxDWCXMjXHR/BLcM7EY7jco/6zyzu5CVEx4wXgBbsAWBtEAvKFSd+4cKoXkyrjRex7eKDk/jp8a+9dTEfbzd3EDXBg9BDeWl4jnfQLey/8ylZ6q6elcvB6OixkrlI7vGM/4QipDkmoZW/vhBsAKeIPyIdwwmDN+O5HJxQ3DhcyJdPTmnQ6vbC6P5z8MF7KqCSRDcdHqluzYMri7+/xUBPyl4rzJhBq8vHiTEP2y43mar4aLFrO28I6OxA2jS/Ey5nCqlB9V3p164vVieKNr9nI4TF6WLQJ8O75vHc/zjchDr1DFMzeewTF4nXIOLkosQqUsGB5pcineO13Nq7YY8nszLugsEs+zMJpmIhsuTMmThE7m3I1zhuBGTk3v7zjvkshDIyOsB3Dvw2vI6lE6n+PRcGPoMUreRHiZuCNe3lX1NKIyJPxYXEwYD/yJbFgcXs4cg9eLi5auH4Mb31+nYmQdGGlzKJWyaFTc63DcJngl8kyXrs+e64u4kfh8FrfvxXYaLjZPG9dX9byM57sXYR9EuN/Gy70ls7y2AN54WJjKcJbC8z2vc0fideuASLvLqXS2XEF4LVG7DJsd98JZN4vP7fEsatb1NcLaEBd0vo13jKyAG77X4eXYg4QQVyc+K+J5e91I03NwMXp6PN++Q+VdqtUptzKVuQzvw+ua9SMvPB7PcK04d1AcfwXPxzNk4ZTF9l3xzoBBnaVFds1meF3+Mi46rRjbp7hNdStVGmyl9HgtwrkRz8ebRv64O+6lGMJerQ5fkorn9xDcnjkbfw/mweuHmzp7xrjN9DTuUXowXh4dief3b8Rz2apOPIr6fw28fPxu5LNT4vgNeKP9DDqZWga3r1/HPeAuiHuZgNvQT+HCVj2RdDTeUF0n0vdneDkwALcnricbspfFfbLh0Xjj9VlcvB6Mv3+7VkuDKvFYJZ7fAXhZfQ3+Dg3FG/SvUCmbqqXp8njDdW0qU948Ec95n0iPyTo1cftkLOGBSGZPx7P8GU3M+d2VvB73+yyVTofhkb/up+QZjXeg1hyuj5c115MNHY3n+Qxuyxae8RdSox0S551PDB2u8vsN1Jhug4rH59x43l669Ptg3G6o6X1Fxfa/Jv5rjyrnjCJEpAaeScsiKS6w5XXgbPh7uwGVDsnF8Xewnu0/I15WfTdPi+z7tnj7agKdlK14+VMMbT0Mrx+KeZqvxu2KwiO6eB7T4GXVK1Q8xlq6l66kK94m/gVe5v6eaKPQsV23HV5vNzR3b/zny3gZcEbkrwn4e1SM9CummCrael+i9tx/xRzc0+Pl9FFNlgEnEPNv43bOJXgZcAt15kWO81emMufec/EsFo1n9CxupxRtslz3aGT48wy47V/rvc/DeS7ivBqVOm1RsneOxubOHoe3dW/CPaAXxvPvg7j38H3Uqftb2doWUE9vxEpuwOOxv2tk6Hrz3dSaNP7leNir4cLHozQwfCEywRdUPAkGZOHW8map6t1X/i+8wLgdb2SWf6s3VPdpKkN1t4mMNJkAll2TD3t5MV6qRXADZ5ns5ainaHdFIM0bJ0fihfLrVLxblsMrt1PL99vGvFSkwVjC87RKvrmFSsVWzVtyWtwYKOZFKCqJEXgBvzwuuF6A9yRWXdCD2sL1boThnh3blSoFFF5w/ILS5Lt5+uON9HHAxGr5r05arR95vuhRyeflLOfTQoQ7mqxnJtLofDoKg0ZjRvCakYZFw3AQ3uA5ATeYzsMbLF8q5a1iWOkheC/QDbj4NQKvyIo5ge6lzvwspbiMwgv/WWK/6LXt9D7ivGG44TsLbsQ+gQuBD1ES2sp5LT6/HfnKyHqOcUOlWNBmUSafE22zuN9V8Qq96D2+GO8RexjvTf9GPKtqw2MXxXusC0N85kiPDck8tXHB4GgaqABr3Os0uAh2FY1PZN2ZeF3TWGLysuyI7LdBeCN4XmpMwxDnLUDH+uUG3FAvCwSTDQuj+pDfH5fTDy8nq3lvbEYDc+7GufMTw/ZKYeQe5zvjQsJf8J70zXCj9SI6mYibycuDaXGhc2myRZgivHpD5PIh4afEva+ND316mNKCEVXSeVHci+Ro3NC+lMpw/e3iXvaN72fhdsU8uHG8dFevj/PGRZ4sGhvfjed6Ni647IGLAz/De7WreuVFXF7Dy6w/0NFT4Ty8rhmJvwP7x/GxeINp6SrP5BBcVHgcb0jk+WMrvBG0UOmaMXjjOvcWvQoXSQtDe1fcmN2l2jOpcW9LRdqumYXxNl6Wj8LrjJOoP0n4vJG212bHJsT9zxH57vRI+6E1whjN5HMZnkhl/q0v4aLAFRHeIDLxNAtnj7gun490fRosx7Jn93ik+Vjc4+pbcS9r4aLWyXXeuUXw9/fM7NhX8cbEQNxWOJ1sKHHp+lnwd+5jOs4x9R0qDel5Ig+dU+c+5ia8zrJj4/D3d+HYPzyedz3RZhW8QVR4oi0WeW+v7L26r1Z6ZM/3gUjPWXGh6Vt4+bQ5Xr6c1EmaPk02lxPeAfMbXCQcEc/pUirCcVHW7U2lE3MgLrg+iLddJuINycNpYDJ7/J14gYoX3Zy4OHJl7A/D7cALqlw7EC+nPqUypcRA3Ja4isqIlGNxkTSfb22TeE7HAi9kx/Oy40E6mXerHXkdr49eZXKhcHa8DXM/pU7bBuJwVzyLL5Xup7D/18Y7h+bMfp+RjgtHzYzbEbtkx6bBy4rzmXwqkrlL+7Ph7Z6vZseKzp7VaqUt3n74DRUx6UDcDlqKaD9lefFCvO6tJ6C1JJLiddCsePttW8IrCq+33on8czfethxDjfo/nv2s8X0wbj/ck/2eLyh3MJ3Y7rgX1+OEB1s8jzXwMqCYy+86fATOoNK1s+D15cRIlzOauZeupitebv2YEHlx+2JHsg53Kp2vp5TjXye/3EB498WxPXBHhaF4WXYc3iYp0qehuf/i3OVoYEGfTuL4PRpYSIvqc+5dR2WKi83xNstRVN6ldg1/zsOZKZ7dbUxed1xLlEfl36qEuSwuWBdtgf1wD8r58LbbHXhnZ9ML69b933YG1htbZMrTcWGvqks4jU0aPwE30OeiiVVHIzP8goowUPNFpMmViqk+JLSRobpPUSlIOvXQwQvGb+GiQNFrMD7SdSs6UeezeDUlkFZJxx/G581kQzdwQ+lSmpjEusk8VFQ6c1Ldk2XGiE+tOTcWxyvw2ais6LULFTGimHdmAm4Q1BMlagnXL1Fa7bRWYYD3fn2zdOwAvKIru8Q3PMl5ds3GuBdFvaE15Yb89WTDkyOMc+L9qztEt5QWJ+Betntnvy0J3Bjf58AL3pOz9K81rLRwD58RL4BvxT2zquazLA75IiVX4oZX4Zm2Nt4Im6Wc76neQJmG8DrI8uDzkZ8m6+DADfKLqEz+fXT2W3G/m5I1ikvXb4aLCsW9z4VX7k/ieb/oGd0Sb5xMtghPPNs38ErpPLySugZvaP00PrfNzp+lO97bTvJLw+J1jfvLy7JBlOazazIuV1IZlrUT2Tx+Vc6tNuT3BiqdDHnv5uyla7s85y4uOn2BC+87xbFhTO4NeyY1Vk0sp3FcX+Sra/B6pRDQd8CNp8kEifi9/O7OF+dvnl1/L1kHSOm/Z8W9h4qhUrPgBm4+jHYTXMz7JRUv0QG4SDBbXH9OK9fH9w3xFcTvJOtcw8vEL+jo8TAjNcpVXFj5BSFU4x15L5MtQoAbvbfiZX3xjs9AZc7G3Ht/DbzhOjfeq/8QcHuWvx6n5A1LZV68/8X/XBhxPgD3DFwrzlscL1PeoOS1WeW+BuLl4F1xf5tQEfCPIryZI75X4OJprUbkPHiD/TWyjhW8rCw6MAbj9s78NcJYlepzGT5PZfGpZfB3ZK6I/6T6JH4fH8/8ZryOq7qYWSfpMgduk71FpfE7Ju5lQhbX96jiDRS/L43Xh0/QcZGjp6jM/bZYpEcxN2zZDp030v1yKl4yO+M2We7ZVPMe8ffoADy/5kLJbXR8dw+lzjBT3JP2C2KEA/6O7kxHD4yn8XZBtfp2bvw9/BFhd+D59xW80TUE70y/mY42RjlNjsM7WZanUjZ/k4oYMz/e6TknXld/Ay8TdgKezsIZnl1/ca3nWCMtRuEi6Jtk9j7uQbJUFv7r8TlZHRb54890nMP4dDpOeXAEFc+2YvjdsrF/ezyzol4qyvU7qTN/aTvyOv7uPUlldMdgKh0yg/H38hDcdq/VCV/YdEvhQs28kYY34KLkBrhQ+D7ZSCk62oCz42XBLfG9SIN9qHhQ5XXS0Pz/Y3s87vUgKh3lK+ICX81pfcr3gnud/YxKx8oP8Xf9Urysz4XORkSjsTQpkuK24/N4R8yzeCfX0bh49lz23hYdErVGB2yCtyHuoLJoxoz4u3lv9uwOwcv7mh21WZgz4O2j39JxpN69dGxbXYWPHFsEz3frULHxD232XrqarrgNegdwb3Zu4cTwOu40UswPazS+UOMCeDvsB3QcdTSRijf9/HjdPpI2zf1XLw+X9rfB64xOHTWoPefecxG/aXGB+mwqHpbtGv5cLZyrsjxatCH2oxNNhspIzZfx8nA0lfL1m1ScOLaO579Dq+ld9f/bFVBPb5HAg3EX+d9QQ9yguUnjr6UBlb/Kf2wcD6+mmEh7Viru8lDdGuGOwI3x70Z8lsQbMm/Tydw9pXAaFkhL162N9zQUK9gaXlA9SUXQ7XRlvRbz0Ya44FZ4nt1JZuRk551D9TkVxuA9mHnvxD6RjjtRMXBWxHuBNqgRj2ZWO606LINKQ+o0Ku7XA/Be1oci339MjZWXmky3LXEjo9pw8Foi3PjSeVvgjZF6782k+X+yY1/BG5tF5bkRboTMmv3/8FI4tYaVluNe0wslft8c95L4Dt6Q3jzyxn14g+VtOpk8PvLFSXiZMx8umryBVwRb4RXMZEI8FUGvcOUfi/eS71o67wjc26FDI4CKEV30VBWNkRVwIe8Yoje7yMtV4jAOf8dXiud6C5UFZNaP/zicTKzsrY0GxOs61zZdltHRK3oAHVeWPB033t6j+vx/dYf8lp8F1b2V2zHn7ki8wXwMLhLfEO/OLNk5u+LibzUvw3KeOxAXV87GjZfpcEPydvwdrNmZl4VRfndvobIy6My4QXwbVbzr8Abe8fF/q8ax8+L8CyLPFs+4KIPz5zgN/j7dRkzW3eT16+FG9E64h9YZdBx2fTvecOp0qA/egL8dr19GxbFrI9xDqLy3c1GZay33XsmHYK+PC8CXlZ7X83g9Mx21xckNIo8shJd7p+HlzTV43v0OLhwsiAuItVb669DJgvewX4/n08Ko35yOQ1NXoWNdUISxLN5wWxpvOB6MewnsiQuUvyRbkbRGPBbD38PZ8ffgAiafy7DwarNIv0J8+TohbuE2wGi8ATo00rzqf9eKS/Yfq+Fl86lE/sa9y0/K4r0KlU6E4tiSsc2HvwNnx3PaJO7zbTqKHNOUrt+UitAxmsqKvC9SmWO2njd7HrctcTtrSDyPa+Melo3nUnPOqyycmbM47o976KyaxfUpsk4SOnqxVhtp8xDecVvMSfoVKlPtzBhxnqsUh1Xx4Wyb4OX7V/HG80Fx7AM6vtuDqNiHe2TH7wGeLMVpZbzx2khaLITn82lxkfM03G4dFb+9Gc+48IYZULp+dTy/7oLn9dH4/KVX4PX7G1SxYejYubFoHNsBL0Nyj/pt8Pqhs/mYu5rXZyWEeypD0B/DhbDr8A6cWXAv7nqr2RednFfi7/h2uEh5E26Lf4dKh0I1m2hwxOsSvFw8FreP5sfz99hS+uf3PU12/xPwuuXX8X1hvKzfv9Z/V4nLtLgN+UDcy8nZ8dOA0xt5JrQokuJl8C9x55JZcVHtmUjbYyNejcwZXji/bBn/d1P2H4Nj/9uRPr+ghk2T3c9yeF2yDF7P7BR5Zx+8fvg5kw81L0aN3BP56jeRLkPwzqoHaWCYcDvSNb4vg7frj4z/Pj+OfznSuNM6JovH8ng5sCxu43wTb8fsgZct79JxrtDCtmh07r8uOfBEGu+Fl2W15pjOy8PZ45plqD7n3sgs3Blp0/DnTsK5kckdQ+o5jRX3U5QJw/CyLB8Nsh8dO8C2oI3zCaaUplxRMEuU3akxtJU2TBrfRDy2pLZI0oh335M00HilC0N164S5MC6MLZv9x6u1XsZOwmpEIC2nz/x4pXFL8Z94JXk5sVBL+Zo25p+D8Ynfv48XkqNxg/cwwksAN57eYvIVzebBe5x2jv3BuAFiuOF8JTHkATfCq05sTntWO12YEATwHpMnqEzmPzOVnuSj6GTYXxNpV2/i+aoiXJV82unKS5GnHsONs29RafS9H3nkdipCWb3enKrDSuO3SYtr1Ll+2XieG+CG8d145b4QLhwcTakBXCWvH4g3vA/FK88XcMP1HLwMeoPqC+CUBb3p8EprR7yBdAButO8d91hNeKpmRD9Fxeh5Ghctaq1QXjQK7qJimA+kZIzgDY5L6qVlT23UKZcbzHd1y7Iq18yCN4oeIevBw42UP1N99daGhvzSSaOALs65m4VzXrxTg6h44j0d1x9DjVVo49p86Miuce4oXNh8HW9AD8BFhi1pYFhIjXc3N5ZnpORVS8cyZhBeHt+Fi1Rv4Cvi3kjF06Z8/YL4u7ozbpzuGNefHefXvT4LZwUq4sUY3Gv6dDqKBw8DP6hz73NG/imGOl2EG4fH4ULESXgjfCL+fldruJY9t6+LZ/EEmSiLl6+NDJe5l8rw2j3wBTzejPS9JJ752rhRPapOOBvE8zwXt8OmwUW0RyKeL9L56pob4o2Yc/D6eCe88XI0LsI/SsWDsZZ3/Ub4u35tXLMcPtyt2lyGxRy4r1GZpH6H+O9yWbhUpHGnnhtUGgUb4PX0yXgDdhwutk7EvQPepEbnYlw/LtL9Unx+xg3jeVyM5/2JVOYQrJZXVonzxkWa3o8LNqMiPSZSWbypntfx+vFcTow0PSTSbe9I606fS/y2OV7ffg9/HxfAy5Z/xD3dS8VDrzzkr0jT9fB66Ui8Ablu5LMrIt+9SyaEMXm9vQluE5+P2zL343n1kEirC6g0lgsRbj78/SwWAJoOb4wPivz0DP4OH4TX4TVF1lJa/BwvM76PNwqXwgWST3B7ec1qaZDlrXdxIeJGXMhfGn9f/ozbGEUDOu9QyDs3jsA7p5fD65lt8PriJfzdf41OVn6mDXkdt7OPiHz0QaTB3rggdwPRiV8rb8X1s8VzKOZDHYt3cm6E15+FaDNZ2wzPywfhdeIq8VxXivv5kMqqw9dTZfoUvFPhJrzOv4LKfK+F0HpP3P8Pq12fhTMKb3esQKVjfFs8v26VnXcY2cJYdcJrWSTFPcWK4eyFp/y8cd1FEdbT1PDcjPMLp4JiLrYVcfHpMipD4wfj7+BndN6pOA4vfy6I+9oPf2f2w6fgeIKK59uALA2eJ5ubFC8/fkOlXXhwZ/fS1XTFPXzHULHhlsXz++N0fK+vokEvY7w++CWVhbf2iHicitd195AtjlUnnJbn/msgjtPgZW5dTSbS9HX8PX2ZOnPuZc+2LcOfGw2HxkZKFuXhulQ6zdbCy8QX8fLwK3GPW3YlbTuNS3cG3hMbNRp6tGHS+BbiUs1ToRnvvocazEBdGqrbSdi7RHo0LQhmYdRsiNOxINs8XqxV8EL+Mrw3Kx9i1bSXT5NxnQM39I6IF3p1KitC/jBe+J+W0wM3LGeIAunwODYRuDq+D8JFmF1x47jqPAK0Z7XTMRGPYv6m4XhPxalk3jxUJqXudDWqNqVtPRGu0TkMFyW8AvDK7HjcmB+AG+TvUzHoGulJrTmstJPrFsYbRHmvzVV4g6TqggBxzpDS/pVkQzHxivXq7D+qClDU7hW/GzfGH8ONrtuoUZZR24heDW/8HUyNCp3qjYI1q5y3G/7u1x0y2JMbdcTrBq6tWZaV/wPvNfxBPItfU/EgG4E3RqstKtLlIb814jOI5ufcLeqQwZGP5sKFnXcjXvdFWtQSBAtPtONw0WxrKvNlPkJlXqjjW3wW5Xe3akMJb6ydipc7F+OdNwNxz57fU6mLC6OtvCjJ4niZc1Hk8/fxxvNpcX150u1O8zoVg3QRvFf+9Pz9oY5XDd7Jcx2xYA4+r+p1kceWy57ZvFTvUKg1BHt1XGx8Hi9LT6CGB2iVPLICLtotjdtRe+NlxEl4GTWGTlaSx+ujt/DG0Tb4e3M8FU+QiYR3Zq244B1eE6l0uK6GiyXb4O/swbg4VjWcCGM4Lgyslb0r7+Ci4ChKcxlSWVRkQilNDsLL1S3wvLoO3qivuWBFlfisFWnyZbycviby4ypxXw9l9zqZAIbbJU8RKwFTaRCviXsenBX5r+Ywt0iz87L9A+NZzoCLJl/Dy4Oqw3wjHtPRcYqORSLuB8f+nvj7WXVKliysJYjhqrgN9K3II9NGPN+iIrrVEn/WxwWSw/B3+j28bFsTFwSupLIwWa32xNVUGpeD8DK6WO3zG3iHwaJU3vPZcGHmISoC7CN0nCNuf1y4PoHGVm4ejtsAS8f+AbjNvEQ892Ieq6odnPFcTqQi6M4bz+Hc2F8aF18OqPLf1To3ziQTwfFyakUa7+hpOa9nYcwY529Hx4Uar6W0wnON6weTDTeMYzsCF8X3ZePZHkLHaR4Wx9/tY3Fx9fK4h8LDeeXII8/jdcYcpf8dg49yOwwXAq7GhYxt4vfZcXvi4XgmteYQHIOXRffibYYj8Pw5A17/TsTFlUXwurvmKBa6IJJSKQMvJxsyneXFJXGhpBDjanpuxvmbxn0tHXnhZDy/vgDcFufMQP160yJ/3EZF5Foj8lnRmbMLbkOvnV1X1JfF+563W74Rz23GOG+fBu6lpXSNZ/sG3vH4O6KjH897jxFD/nEx6i06addFPGbC8+mmcWwJvK7bCS+zv4mXsVVXbu8k/Ibm/mvXFvnhVSpz7u2Lj4SbF7cDJptzjzYNf25XOKUw14y8tQdertyJd4LNjHeuP0FlBEiXdJ668eipB9gbG22YNL6b4nFY9lur3n0tDdXtJMxheI9Fy4JgFlatidKLyuOASJPTcKPvaLwhfAlemTY0J0KLcVuKyrCfAbhxcw1uQD9AVBD40J+F8/yRxf/mePFnwkWZ9+jENb9KPLosXOOCwStUJto2fEjJqrgI8BDulbYvXvg33EBpU1q3JMJl1y9Dx3kd5sYbxEXlWnghNDPMvelhpfFsLsKNtDWy49/GK+hq3psb4r1uX6di7N0NfL2UF69r4P/rCXrnU2l81V3Qg9pG9A1kwnSV62p5PK0Wx2bHG22vUmdRoilxoxNRERcOT8IbB9vjjcGit3xH3OCqutgTbRjy20ncvk0nc+5WyWeD4/negtcx4+O3BagtWpc90a6Md392XEycI8v/E2mxJ7mzd5eKIX04Xu5dgjeqVqAy5O92OnoA5HXwLHhnUD7cb278vb8SF4xuo2MjoikDDS9Lvo6XJ8X7U23+s6JBVXjjXIobuYNwj6PL8EZJp/PCMrnn9q3APvF9AhXBpCExP/Lmo8C/CA/wOJ6vQlp1lb7s900Ib8MsnR+JZzgH3hi6oNazzq67iI5TdYwnPC+pzId0ATW80iM9r8UbW0WaH0OlLs7nMpwOfyd/kV3/XSpC8e7xX9+LfLJlg+lZ2BVn0nGe2AuBu+P7BvH7ydRfPO7KyB+5l3IxV+Sy+DtxHLWnIdk87jdfmOw2KtN1rBTXd/Z8T4v8Wgz7Ww4fKj8o8s8BkVb1Oio2LO4/exaPUbHfdse9d2ouahHpdVC2f3QWjx1wT64dqTHXE15u3Eo2jBNvAOaL2VyE16FDYjsMt+G2j7z1FnBWI3mhzn1MiwtH+dxflxH2A14+X4p3VtYS0U4lvBxjf3G8sVnMJ7ki3gk0K9XLpHLnxhnUEe67O6/XCH9b3CZvyCbE7ev7sv3tcPu+eH+WJhuih4/QeJKO9fZskbZPMflQxXwuT4v8cw1wZCkeB+B1ZYfho9QQvvAOi99REXgm4ILEjNm1W+NC2p+oeKHV69xsSSTNzl0PF/GKzqoBuDgyDy5yNLzgHCXnlzg2I96GbrjNjr8jR2Z5fgIu0A3G6/v9cJtgxixvbop3kBVz8ea28pNURtU1JPo0m65UFpwsOjxOivueMTv/Ubysf40GvIyz/70onlPurXtvfF8YdxD4Og0sUJrtb0ODc/+1a8PLqOsjfxXl0qlURjBsQ2nOPdo0/LmJcJoZZbQrlU6zGfB22q24xjAXbl93qQ5pKB499QB7aysXLHRx0vg2xqPL3n20MLytgTBbWiW0gXAXpiJgDscrz8LInBU3RHbGvWouoJuEWryR+gU+1GcC3lgchBtT46IAmUhp5d7s+mLRkJnxyqaYz+A5Kiu+Npy36KJwjTd+X8UNkEG41+Ex8dt8cT834MbVho3Gq81p3rQIl107HPc23DU7dglhoMf+sZSGdjcQ7pbU8QDL3s1V8Ap0LG5knYZXPPmiKZOJ6PG+v4B7WZyMG4FD8d7ft6jMX7QTbpTP0kCcawl61wO7NZv3suu3JVzvGzi3msfTSll+a+v8FlPChhsIG+EN3TF45T03bpC/TR2hhTYN+a2Wf2lgzt0614/Be11PbODcWp5oW0WefQIXP3fFGwZdKttrvbt4A/cVStM04J03/xfxGoA3EB6q9s7hDe+bqJTzxRCokbjH4CF4463q9U3cw6K4sFL1uUb6n40b7MXE9RvjdeNBeFm/Ji4AHE0Dc+4yued2p1M3dBLeCni9V8zL1mEOswau3wbvqMrngruWyiT5c+KN83oLWhkV0a/oRV8Ob2AVIuFI6kzuHc/8FtwLpCj3twAuz85ZhUrH1iK4N8VNeAP49FJ4A/B3r5iztRl7YG9caBmaHXsMrwcH4lMNnE5FZC83zgZEnriISiN4I7zDIp/Xql6ajsI7sw7FO52Wx70iFs3OaSS/fSWeZyHgLY03ZIuG7RydvUN4OXo/UbbEsauI1XFjfzfq1P94g/qs+D4w0ujbVOzRvXEPp3ri5Lq4Z+6Wsb8WbmuNyM4ZRkX0ORo4MI5vF/kkj3PuvdLIvN9Fef61eC7Fgi/rkA0JxUXwes92HvxdKYb9LYJ3gsxPpeHc0PzddOzcaHhRkVbzegPhjcDF2MnmIcNtt3qjlp7AO35OwkfdVO08j7wzMM4ve8vNggsBxbDXakPzi7L8PCpiXt6RkgujdcvRSP9f0lFYvR+3h1ehYkNMoAFP1CyMpkTS0rUz4OXoWWTeZhHGU9RY8b1OXDbA7eWhsb8HLuhXXZis2vOlMkqi8Cj7El7/FeXzzFS3BTbG7adiSHZRnt5HCyMLG03XyGPfjPyYi4hX4KMgiqmgFsHL05qd+TXicTpunxV25zq4eFbkzQVo/J3rdO6/7tpw2/I5OnYsfgU4M9vfok5ebcvw5zaGszfeoV3kt+njuYyN/ZFkC7B2W7r25EPsrY1u8KrrK/GgC3Nm9eB9z4r3rp+Z3fudZD158fKeGd87nXS9i/FZF2/EfhNX9b+DN8CKuQF3j0JzJjoaDmNwl+R5cQNtfyoroY3Ee2xOayE+XRKu8fmYvotXumc3+/89lAeazqdUGpnj8J6XE3BPgddpcEW2TsLvzANsI3wltz3i+ayKN+a/iRt1tYaklUWSYnhA4RW0BN4LeH1UAi171tFkr3jp2ppGdIPXF42CiymtTtsfN1zE+DY+LHNtmvSapIUhvw2EuXur+Suu/QYNeGpQfw7Ro3CR5gWyyau7mNbVpupYHfgi28/nHTwv4jQgntP8NcKdNd75fOXaQlw6Gvc0nIk6K6Q2cQ/1VqFfK8qQt6h4bY6NtDyOWBk18llDk53H+Q0NwW40/nhnx3a03rF5Bl4vLI6Xr6/QsTHZqdCIN0yuwIWvGyOMusNSs2uLhuMIfIjOlXinz6uUFhajoy0wCh/y904WRpcXQ8Prt4m4t+P8+LC718jmecMb3nNSamBn8ZgOry9vwjsUXiET1WqlQSmML+ECxS24XVHUZc16xZ4e790deMdTp/NVlq6fFhfBzsLr/1UizRse3oZ3SH8EHBL7q0aa5vZnI9MqbIrPwXVxvJeFqFM06sdk72UxXHC72N8RFx736mL+WBHvjL4Zt1l/WX62+HyoVb3C8Tpm7XiuP4q8sU2t/NBAfOp2brQjrzcR3nTxjBYuHZ8dF7mLMi/P77k4uxveSbt2tXTA7Z2v4eXNzVQRY/B65sIa8VsCb/fMgDsh3J7n8/j8EnBjE/e8GC5OH487VXyA17X344LWEVQ8deu2KWhBJK0Rzjy4XfgDvHz/Jl6nLt1int8Yt5MPwEWRap3wM1F7+oBZIg43Rdq8Vs7znfx3LgzuitsxzYwyakV8HoGXv2fh7YdDgP/inZG/wdt8G1NjqoAG4nEzLoxeQpWO1CburaG5/9q9USmT58U7ay/GR6m8Ssz920KYbRn+3JVw4n25HfcMXIIYuZndb9tWGa4Zh558kL250Q1edX0lHnRhzqxuvtdJq23FfZ9C9MbjxuJLVOZlKuYzG9hIAdeGuK0XhcnseO/CD6KgHBwVzEyl88dEfHfOji2NG36FG/EI3GA9s4X4dEkwxr0lXqEyp8kkA6An0rPBONYaUj4LdYw/3JBdDu+hu4xunmi1iCvesBodeeV1Kh4xC0bhXbMiZHKR5EHcCC+Guo2mC1MX0EVBL8KoakQ3GUbRKOjW3qspYcMbgnvjhvgrtDhPLU0O+e0krJbf/Xi2E2lw+BZ1PNE6e8fb+AwKI74Y9lM0trYHbmkwjK/gUxSMjf3C8D6WBjwn23gvq+OT/4/BG31nR/3yFN74270LadSS53aVsCZNK9DAuVW9o/AG2/3EwglVrlsCbxxVm6KhEA2nwYe1bkbt+XtrNRqL5zt7lM37U5lf0EqfCxFzLuJeHWdFXpkjj08X03QrvMPobtwTYnwpDoviDY/Jhsxm9zIE91TemYqHTHH9SFyErerBnJ03Q6TriPx4dl7NqUDoOCR/ycjLY6uF01m64Z5jm+D24Q1FHqkWTp38sTguPl+L1+WbVvvfzp4fXm/n089YdvxVOo5oWB7vCJ8VL/+KURv7dDF/LIjbi4dSmn4ALyt+QUwn0sC9zJtf32J8Wu7E7yyvt2vDbccra/xWcyGS7Hth/+8U+6fjHSKzla7ZnhgxVDpejCAohoPOjQtUR5fO2wyvc2eolhfx8udIvHNqfBb2s8BfqAiA0+POD6tVCWOyYb/V0oJORNJO0ns6XPQ9FbdTuyQaRbr8l+oLtc2Di76TeYRl78W0uKg7jjrlUI3/LhaU2D/SudZquF1KV9zTeBG8HivmQ7wg8sNPCaEp7uEAsmmMSv9Vb4XbPB4b4vb/Ks0+357cqr0H+b3gAtqxeDukmL+17r2Uf6fF4c9dCafG+z0c71h4Bhf7t6r3f92S3r39wHtyo4941fWVePTAfXZYfQevMF8mlvjGG4/P4b38r9CEx0Ob4rdJFLbFcJZaE2ePwYcb53PbDcjCuJqKcTWCJudYycJsSDDOKpHV8B7o1WP/FOosNNEXNyo9nWvQ+Xx4+ZD7bntv8AbM4lQ8g56l0hD8MuEp2uDzfBvvxXoYN4C/ghuXV9M1D7AuC3ptTK9u9eydkjYqBnrTZRldHPLbTffT7HxOZU+0pq5vU5wLYXC27Nh43DtjMJ03/Ifh0wRcQWXBhlXx4YPr9sK9/JTopMI9CA/ChY31uxBut9sguHh1Di6cFVOF1GqAT0dlyHbeGB+Ne2YcVDo/P6dWo6GoK+aqdW29MMp1Dd4wfQ0X7Z/BvZsWxoWfO6gzRLle/Grc0/DYFirFoRAndqgTbtV7ia1YlOw6vKNqxUbiE/v5qowz4FOXDKH2/HW1nksuGI6kiWH4ZEOyszSZF6+z569xTS76DqM01BgXFcbVimNn+SbS9H3g0tLxuSJvrJz9/07UFhXmoDLkuBkBJs8bbxNT0NQKo5mwu2trJK+36X+KIZFL48POR9b6D2p4XUW6fkC0W+LYdPH+XIPXDTPhXqy/pORBmD2XJ0vXb4Z7Bd2Ae4Bujc+PvVmNe1kiwjkHd674Jd6hMjr+45k8jjXCGIOPKjqeGkOKaUAk7aU8U2te5pnxDvwhNZ5rl98D6oiS7UhXvB30Iu7p/mvcq3FbvFPmDNzLeCSVdmete5qVindys+Vyr5cLpfh06jhVLU2bfK5tGf7cSDjxnp6Ie30u0MmzmJ3KkPmenequtx98T2/0Ea+6vhKPbry/OaKCKxqHc0eldRneSDguji+LD2fo8nCsFuO5Cb7QSd6ALDdKfoL32DyIu4/nHjCz4z0Uy7YpPg011vDh1j/GRaunqcwpdwY+4WmPzu/Q4r2OwXvXD6zx+2TzJfVAnFYmhjniBt/fqHj7LRvxbXioLBWRZHh2bADdvLiRtt7baHIxnSrX784UvFgLbfRE62Ic3o3vhfdMzZUXq1w/PIy3t3AP8pfpAQ/lGnHZhMlFzi53jnSnDYILgi/iw+1OB/5IlVWNs/uo5RXzKRWvrmmAHev856A8zPg+NOr3O/G5tcqCUD3ha0Dpfp6IfLFV5KdCqB2Fe4Av3UmajME992at9h+dxGtgxOEd4JP8eKPpgXd0PRfpMCSeyyrV8lUeNu51NLAU9oJ4B2Snw8+zeFRrwB1AZTXcmsMbq6RH0TheFO+EOZFs8aAq91JVBMI9iH6E19Gn4F445VEi1dKkmOJlNN6hfT0u8GxZunY73O4tOo3rTRmwCFW8zGqcO01pf9GIx+P40M35at13lfto+5C0SNdGF2FoyKO3yf8fUdqfHfdEPrrG+UV6zIJ74hUed4vidvaTkU9Gle7xItyD9Xncbhyf3xMu5L2I2+XH4yJxsajLdHjZcQPe0XAnlbKunCYzR/xzT9QFcc/XU7K4vkqNKYzi9xfwzu6LKS1awOResw0PTe2NDRdih1FZhKFuJzuTl4dN3Re1RckupSsuCD5HeP7jHU07x/P+Ml7+XhDbcp3EcUXc63aycqbWe1aOX1/Y8OkxXo78PZbKPIp1y7MW/qctw587CycrR87Hh4W/RJVOrFbzZlvTvrcfvrapd8NXsXsDHxP/OJVe0LWpzDHYsrdUG+NZVYjDe6BPAXaJ/Q3xoVu70HGZ+v2BO9oYn2rzZeVG3PS4ITIUNzpfIFuhDBdd2yJSdnO6n0tlwY1BeOW+GtXnDCnuf0Z8ReK2F5q4gX8jFSPLorK+I/LrK7QgDOACxc/QEFttDWy9aRC08R6qlqk9HIeNgX/iAmVLq65HmTQX0RjsxXvZCF9psilvtF6K6xxRJ52SHbuIWACryvlF2T4dmecz7on3HyodXvdTY/W9LIyhuIdn0aifHW/M/wQfxvZL3Otjsk5IOgoD38AbZkVjpBCJD457WzCOrxufjXiOXwh8hg8DPzfPT9RuOBaeTiNwD79ton5/mjoNpSr3Mi0u4r2dnfMrfGjaj4HD66Tn41QWtpgpO+coKsNXN8WHxc1LxyFqeTg3U/IKxBu9x2f7tRbeyev/YfF9DP5u71g6N++AqyboDaHjQl3b46LPZXij/vt4Q3TWGnEYig/xWgr3Dtoxju+EdxyXFzo6EJ/epWoeoSJwzhTPo/CqLUYslD1di3jMigsRs+P2xS74IgGn4fZKVWGwdP29tLmDMuJzKz58tVPBgVJe7+J/Fwu93Ie/I1tS8cpZARfvVqzx/7PENavG/sy4mFcM+T0DFypGlf7PcG/TIl/m0yZ9Gdg3e55n4e2euarEfdr8+nIcce+xYiGKolxYCH8Hvhz7ixHDQcvvBO6Bli8w8zI+3UkuNFqVNJkkkvaVLd6Vy4B9cC/Qx8nKFjqWQQNKef7mduS1NqXrCLxuurwU7syRd27FvbLnxr0Fa4lO+fzJJ1HxiF0TdyAZXCce59DHnJTiffoF7lh0Mt4htyYd293le5kZr4O6fd69Ju9lrnhHD4j9QfhIsV1qnJ/XU03P1drVbQBCdBMppfvxgu914PsppUvjp6dxd+//4Rm/V0kp3YevePhFKkobs0Vxj7tnU0o3xXnfw1cd3AvY1symj+OXA/80s53aFJ+/5/tmNivwlJnNn1L6DDcQPsML/4PweU4+NLNNzWzRlNLRKaWftCMu3YGZLWxmI/AhGUua2Qy410IxsflpZrZPdv7AlNLnZjYUr/w/L55Tm5kZN+RWMLNlk7MKPl/JD/AVj+8zM2sm0JTSw7g36SNmpjJX1KWb8naPUq1M7YU4PIx3TH0tpfRQi2F8HNt7sd9b9/IIvuDR0r3x/03yd7wD5T9mtmIc+yfwefnEUtl+HzDAzOYyszEppffxRu+3zOwT4MWU0tGdhHEX8J2U0r/MbEBK6Q+4h86HuKi4Jy7SXGpmx5rZEDMbaGZWisefcK/xcWY2HG9YbhzXj08pvWtmqwMXmNnolNJ/ayWGmc0ZtsLD+DDT+4F5zOwW4HAzG5VS+qLG/dxrZmvhQwsPTindFWnwJnCnmQ1LKaW8TqqSpt9PKf0bn4PudTO7yczuxTu7tov0OMnMNixdP0uk5zdSSm+Z2RjgbjM7w8wWx73o1zKzeSKc6XCPvfkjnGlKz+WqlNJfzGwhM1vPzOaL+M0U5+8GXGJmh5nZzlXupxBtRsZP2wLXpZRuzc7dC7jCzLaAyvtaSpNrcU+UgudjuyKldDDuHfw94Bwz269KHO7F8/dJpf9/GLdf9i3+P3gRb+TORIlIx+vNbGtcsHgQ+MLMlsJt552AL4e9VL6PO3Ebak5cOL8ppfRrPH/9EzjMzObL80fp+tvxRTF+X45Xq5jZwrhY+hY+imW13OYp2z9mNqiU1+ftYhQGppQ+x71hb8ZHajxoZlsBf8Vt+klpWXrv78IF6mfNbHbc8+eOlNKNACmlY3HB+C4zG1X8YdiJH6aUPi32zWw2fCXlJ1NKV8XxH+H5Hfy9n7OUJv8prs/SZ2B8nQP3NhobZcV/4/36Fb440ti49ucppeeqpMvwiPtn8YzOx72O5wQ2NLPTs7jneb1oA/2rseTvGVJKf8PfqxXxETyfAVtF22JhYEEzm8/MZg4bJM/z16WU/tOmqHQpXfEy9Ha8rtw4u7+/4ouqLI6LvP8HHJpSeqscgWirXmlmp5nZECAB481sLD5d0ZeA281s+ohH/s7dB9xbbnP2NimlD/G5ue/H66kLcBH4IjPbO85JUccX9/Ig8PN4//sE8W7/FfgYmN7M5og2/Od4R135/Lx8nog7APUsqQeUR239e6O0iEZ2vMfnm2owvoviQz6KleTKPa0b4hX+XlTmI+zWSfTxISGvUBmGcgDewNg49tfEDbG67uW9veHeeG/jjYglcQP9Q7yS3BLvaduN8Aih4vI/FK98q06u22Jcip6mZfFe5JF4ZX4uPuytrXMz0sd647Rp6y9buQyfkre+ei+459YpuDfdyvgcjqfgHT7PUtvjaSguwqxFZdjxY7jX9ip4T/uHeKMIXKAre9bNWtQPVOYyPJsYho83KApvt9/gE5O/iA/dmzuLx6Q6Bh9KejY+nH9g2DGv4R6Dx+KjIGqu6hthLBr3slzsXwocG98PxRsLb+HC3MrZdbPgHWA7xv/snqdZfL8cF8mKRU7yefaKe9kSF+nmiuNz4CtYvleK5xlkc6HF9T+iMl/xYNwDcx/c8+RMfGGlU/D68+Y470TgyNJzeSxL0+G498eF+CIEW+DizeK4J+eCEd6x+f1GejxGNl8zbjscl937xrjXzlF4Q3utKmE8gQtGHeYgjPxxNe7l9gLunbIRnlcWzdLkSVyoex7Ys/w+UvHwuY9shVOqLPyBN/juw8W/o/GFSL6MN4C3pTJC5WKykR9U3pedcLv6ANybKI/HSrjH4NmUhqnFM/kebbSlItzRuFhdDAc/HBdK16DjsPyV8vSgkte7FB/8XbsKF2bOprLY1I6RzhfiNvPzZCt342L2vUV+yd79i/DpguYs/c8ZEUbdKY8iD71KeG1lx1fDnQsuIPNqrXL9rPj7PSr298XfgeWLdzIrR2oNGc7TfVm8LH4PuDaODcDFzyuYvPyY9N72pY1saGy8A4/gq4u/invuPoeX7c9QWXSqrXm+Dem6WeTLWfAy5yB8uqKN4rzi/KupsxAIXoY8gHsmHo17MI+M8JYGzo/zziXzTOuLz5fKnHuH4vXAnPE8h8bvH+F1xuu41+ws2b20tW3YpvtZFK/v98c1gwfi/op56juzh9bulXj3dsJp6x8bfWT1507iaLjn4kvESpW4q+/j+JDnfI6hTfAKe55yGG2OU94IOB5vIIzEjfQToiI8E583qeoExX1lozK31+FZ2k5PZQhSUSjuig91KoyemXFjvl0Vev4cN8KH3hyBTyQ8Bjdaz8CN6il2bjdt2rRp64ktDOA3ccHs3ig/54u66bVadRPeKHoKFw4Wxzu+1qHSsLkuC/93hFhUCmMw7uWzDh3nMjwD+AM+pHVvfLjsz6ksxDCYWMwHFwYeprIi5KzxOUkYjP01cfHqm3SyKidVFgXB7aDTcc+x13HBcS1clFoyzhkaabJzpMf4OD6AyQWeS/DhZ8OyY9PiXga7xv9/Hxc/iwbnMNz7vUjbYgGDYtikAfuV69uIzzURfiHA3hrpe3Q8g1eoLM4zKP53ndifM57RabG/Oy6QbIU3kM/BG4TrR9rMmaXH87iQN5pYFAT3njyrdO+FEHQaWZ7D89kPcdFtsjkII64P4V6u+YISxcImQ3DxcuNI76uyc06k47D3mfCOzUeYfG67XLgrpoH5Ei7c3ozn32JI8Ku4YPhrKsLAtBH/CfgwxXpzbK4UaXpBXDcgnu2txTNp4/tfLLZyaul4IQyuFftrxHlFXhyK5/WWFucrlT/vRP7ZLvLpS9n/Lox3/D6Ce1cunV07F1UWbKNjp8Cw0m/n4+XaZPMHM7nN/lMmFwbXirDrzmWGOwO8SmU46Im4R9Q6eJm1IvAuVRadimdycYRRCNtL42Ln6UTbBReofkilzJtMJO0LG9nqwmRD8fG22G2EgIu/y9NmaTYYLw/bkufbka54B9NlEeeZqAiDVxNTneAL2LxKTCdQJz5fwd+zwbiItjpeli2OtxGvxtuNxYJHQ/BOk7V7+5lm95DPuXcRXofPgne+/RRvox0Z504LLBPfZwAe7YN5dTG8njgQrxfPwev87+Jt4KKTsOxwNJQ2dJB0Ke69nXja+s9GH5hnqpP4FV5pG+JzD+2GD9E4v8b53bpYBJXeorHZsaNxg7no+V8PN6KXz6/paxuVSZCfwT0s56tx3lq4sbVRdmwcVeZJaTEei0VFMx0+jOQJ3GDcAG8wFvPCLIsb072+uq82bdq09dUtjPQ76djZ8zTu+TQz7qFzUrUyHBcRC8FjdeCL7LcxeCO+aGQtjA+LPKEUxkxRlleby/AS4Kvx/W7gmvheXjhjFJXVT7cAvkPFK39T3ANjD0qLUNRJk8kWBYnjM+KNny/IVlSmsvLyQEJwrJIeD2f3kgsPV+Vpi4sc6+INqw1xIe0IwqsuzimEwWciPpuU4jltdh/n4Y3dRXBPwduBc+L3nak0YtcAlsrCmC6rTxeN+K+PN5QPijxyFF6/nxnnXYR712yVhbMOLsaOxhuHu8fxleKZ7kzmdQEsh3s5Lp+l6Zm4IFhtDsLCU/QwojM4y8d5B+KIeH7H4ILOprgH2nlVnv/MZCJG6bd5I61mxId9PlNK0ztwQX0B3FZaLbt2FtyLZn2yeaxxO/BbcQ/rZMdXorTAD11cCKvK/YzBxeA7cXFmpdLvh0deOxz4LbB1lr6TxPUuxuFmQuzPjh3N5PNtT0NpsaHSNYXNnXcKnEl1YXAyQY/qNvtRVBcGa84Py+TC4uv4ez0QFxrexMXd58neleyaRXFR9GjcQ+kyKmXMKrhofjI+n+bzZO8/NUTS3txwMfsy4InsWC4M7oSvqL4npblW45m3ZW62dqZr5K1zIm/lwuAF8cx/TGl+0uza0fhcsQfjZf3+eF15Xvy+L162DMTFyVXzfEfUbX1ho/qce9fh9sNAXCQrOpLKCywtSR9z3MBF10eI+j2e6714G3M13EPzYKrUD5F/1uzV+Pd2AmrrXxt9dAhlFJQ/ojKB+Aa4Z8Gj2TnlhkS3C3B4L9gv6Di0qOh9rLvCXF/ZcEP2LdwbYGW8N+goMiMp0n9TsiFZ7b4vvBfmGXyhkukjXkfgw2+ep+I1MiF+69Yh4dq0adM2NWx4J8psVLy9j6EiEs6CeyuczuRTiJTr1I2orBq9FT6MZmYqizGMpopXTPw2LS4ofY1YTAD3Fjwmvu+JzxtXs27BG1ivUFqoC/faOBdvwNUc8hfn1lwUJH5fEZ8rqRAecuHJ6LiYx8a4J9D38bn9aqZddrzw2vpb6fnciwtKhQg2DPeg2To7r7zicuF1eSbuqTkfHSd73wG4qEocrBSfl4CdY3+2eLa5B+UFeANwANmCC1Qa9oUX6ZZ5OuH20d24184BEe4vmVzkHBr3URaO9qLSYJs17nHz8r3ggnN5uN9Pgfs7ex6lsIrVkk+iskjNnIQgHfsHUPG2rJVPF8LFw8NwMe523DvoXHwl2/lrXNdum2phvAFcDHU+GBdLysLgV3GRfHye12hQZK/z/0vgzgaXUvF0zRdduAQXzwaQDfmslzZU7xSYzGOQ2iuHV7PZi+kGRub/1Uk8xmbHjsHLlOL6+cnEHTq+b7PhQ1kLkXmWyBvbZecsGWn2J8Kjljqrf/eFDbfZbwTuyY7lCwbtE3l/RDf9/6yRrme3mq5UF53PoqMweARe5m9RLa/Q0avuPLxsnZtsmDsuwJ9eK2/1lS3ey+lx4e9IKlNhXIELm0YMte/tuDZ5X8V9DIr39i58hfqv4WXhE7g9VBY565ZRPRL33o6ANm19ZaPiqj9/7K8ZhfP2vRSfxXBDamzsz0NlSO1RdDQy+tSKS9k9zIX3jOfzFW0WFdqRefxxb41iDqjuWF14riigj8XnpFgQH4rx+yxdl8O9WZfu7bTTpk2btilhK9c/uNhyenyfL8r8yVaVrxHWJvgwzpeoDN8cQEfvmbLoVG8uwxFx3jC8UbcYJSEu+753NELmie934BP5D8EFyzPi3mqtkjsG9+RZKzt2BS4MFl5zc+Fi3PgG02M9fFG2okFZc+XM+P/ncWHjWuCVOL4LLni9hHeMXYJ7tgwup0Hs1/K6PLp03ky4d0Ot9KjqMVk6Z1p8uGfNFcKZ3GvyUSqi81p4o/ph3PMm987Jn3O9OQjvwocA7ktJ0Irzy8P9ZsaHql5GiHvV0rHKs6nmqVj2QNuSyjDtAaXrd6DiObsjPjz7FmB53IYqvFKqjsRo50ZFND40OzYX/h7eX05HKmK00cCqxA38/2jcXp+A25P5kO5idd41gaubCLNep0Dh1VXT64zObfZJHoPUsdmpLiweF/mn7rPFPeOOwL02izlBz4v983Hv4VkirsWUBX1KLMruZSG8c2V87E9LCIOld2Nl3JN7oW6My6y4Q8btVATohtOV+qJz7jE4M5UVs8vlctmrbhq8XNupdN48Edc+69hA53PuFeXFfLiDzkK0odzohfvMO79OxjuE5qA0/39feQe1Eqbo9xQrfKWUTsYbAQ+Zr/T7Q3xunVPMbI8eikuxStxovBC8HxhiZifiFeHTsVrh2Xjl+ISZzZP60IpLBVZZwfk6fLXm7QFSSg/gHiDzxPH5U0qfp5TeSym9GeekdscnpfQx/nxPAd5PKb2LV8R/Bs6PlcKuBU5OKb3W7v8XQoipkaL+yVbBHYyvqLg0vjjD/6WU3mgwrIfwhtNcKaV/xuEBeR1X1A9Rx9wNfIqLZ+Nxr7bBeMP6Wymlj2KVwk+BxZOv0PlFEd+UUjKzzc1sIj633uK4wDQzLhb9GxcWH8EFtYWAMVVWUh0d5/8jpfSDzK7YD+/AuydWH/wYrxcbWvExpfQ4LhT9Mq7/j5kNKp8XqwM/APwopTQxpbQX8Csz+z3ufTZ3pM9+eOPzXylWTa5S31ZbQfrv+LDnnM+BSyNty/EZgde3xwA3mNnT5is553aOJV8Z+Va8c65WGvwI2NTM3jWz7wPPpZTOj99+kFL6NrBpSunIlNJDWT5c2MzGxfcHgVktVmxOvjr58mFL/SLS5/qU0gtV/v/7+FDhpXCRAnzI6s+A7c1ssxrpmFNrteSrzGzL7Lwf4mLsv/N8iguWNwHnmdlpEZ+9Uko7AS/H+zEvbldNtrJlO4nVd+8CrkwpXVgcj7x9Pe75c6yZrZr99n/xmVK22naL/z8Gf57fSyndiXuIDY70JFVWl50JGGpm05ff1ywsy3YXxN/9T8xsbzO7w8yuxOdvfAwXMrYws2Hl6xu02W+iE5vdzBbDh9HvkFJ63szmMbPBKaXT4z4fNLORce7A7LoFzexAfOjqn/H8cbiZnY17pN2Di8b74J0UH6SUflonmXuVSM/7cEH2GDPbN8qK/fBpJO6J85bBvVV/n3w15nbHYwBASulPuFff88ARZnYuLmY1lK5Rz6yLC0PnpJR+G8cfxOuwJfGyZZqU0q9L+bLWSrb/w+dCL69S+x/gzpTSP9qRBu0m8vh38PJzfTwdv4KXr/sCB6eU/i9WSv4NXk7/qqvlRk9SPL+U0m3Z4efwaTj+lFJ6OT+/O9q8LdFbaqQ2bX1ho/YcIG9S8RjcGF+FruocMd0QlzVwt/Qv4QbKvXgP9Sy418Le2TVH4Csy9akeFCafNP7AiPts2Tnj8BUUj6bN89zUidf28Xz/QvSu4b02++E9jUXPap/otdGmTZu2KW3DBbpX8B7/uiv01gljI9y7rercW3RhLsNSOMvhnnvFSpWzUfEuXBZvuCyRnb8UpWGPWX03PvZrLQryKh2HIDZcz0R9+Um19Ij//zE+zPhYsnna8KHbvyidX29xlIZXkK4T10Y8JpuuY5nca7Km3UBzcxA+Q8xBWC2dqD3cbzbcs+U6Opljms5XS167k+s3wKe4WRi3CS+M51IMVdsYHwlRdR6ydm64rXRhlteXxhv12+J26oC4r4coTRnQhv/O8/px8VwHRpyujXRZDNgcH+lTs/zJnu/meBmwVqTt6/Fct4/wRmXnfQv3XB1Am2z2LJzRVEbSrIR7Tr2Ie+0WcTgaHyI/TylN3sHFxLPw6QOuwb14f082j2N8LtrdeaQNz/gVKlMJ7Yx7lC0d+9PiAunr+DyV4/N0bGM8RsezugRfXGSeyGtfjXQt/rdmuuZxokVPdJpcybYvb3Rhzr0pecPrrtep4xHfF7Zej4A2bb29UXsOkDezirjuPEJtjMsKuBFSCFZDqAyFWAIffrBy6Zo+5yJO7Unj5yydtwmdrK7VxXgUxtYyEafCgN4C73Xbrrv+W5s2bdr64xb12L/Jpo1oMZxNqCOW0OJchtn1Q/BhVv+kMuRvQBxfB/ccLOaGqtnxVqW+q7coyKq1wmkgPTYtpwe+oMeT+GT7s+CLN5xBR2HwtriXesNbW1pBuko4o3HPyN2r3P/luDBY1MOtCIObxL1MmrepyjldmoMwjxv1h/vNiDdqR9VJi6ZXS65z7/cCJ8b3XXHvzRdw76O3s//q1k5NXDx7BhdJr8M9PX+Kewl+G/fUHUaNuQ278L/V8vpZuH1nuJB9I+5hNhH3Hq2bHnSxU4Au2ux0UViksrL2Htnvc0cYV0YYt9GxPOhTTgRVnkm5PH097udV4OY4Ni0upk8o0rGd+R5vs7yBz893KC4MfhTPewAuyN1Ox46PAaUwuiQ6x7GWVrLtyxstzrk3JW64iLwoXl5WnSeyL229HgFt2npzo/M5QN6kYgx227x9WeVxRMTnSDpO6L0hbuRuUb6mr27UmDS+p+OO90D9Hz7c5yMqq0xuig+HkjCoTZs2bW3awtivOi9Si+HV8mxrei7DrK4thMSZ8AUaJlJZaGzaaJg1LODRwqIg7UoPOnq+jcHFktPpKATcRXjCVwmvXV6XjXpM/oQurAhKHa/J+L2lOQirhNPIwjOFsFd+Ji2tllzveeOCxCm4Z94b+OI568ezHtfOPNZJ+k+PL3LyauSbNfA515YkRMFu/O9qef1MYnGhOD4N2YI1dcJquVOANtrsdEFYxN/dm/L9+ByJewweggvgbffa7OY8VpSnjwEnxbHBuBB2fOwXZXi7PQSLcmyL0vET8LbEfJFPjuwsXemC6Ew/8KqjwTn3puQNFwaLZ96n2+1FoSZEvyGbR2g0brith/ekbYj31CR8cZH3zOxo3M173ZTSB90Yl7lTzLliZjviQyFOAl5MKX1hZtMBo1NKrxXXtDsu3YGZbYK7yP8CX2r9nz0Z/5hz6nDg2yml58zsG/hQ4VVTSu+a2RbAf1JKj/ZEfIQQoj/RE+V9Vo/uDwzH53m6G9g2pfSTKudvhncKzY6vLPov3ItsOeBrKaW3W4m3ma2HN+IGR3yGpMr8Zt1OzJ34hZktgi8uMgB4Mvm8hJ1duyy+EMtfUkqfm9kxwH9TSueb2Sy4gPZ74IyU0l9qhLE68MOU0oDYfxj4fkrpPDMbmCpzT16Fz9/3XBfudVN8/sanavy+MT7k7lfAMymlb5R+H5BKc0tW+b43Ps/cpbhIsSG+sughuGi0Ni4cTUzZvIpmtji+AMg3Ukr3xfxSM+Li2d645+WneCflmcBhyefS7Oye58QFoDXjmivj+LQppX/3tG1oZrOllP6Y7a+Fez1uC3zcnXGpktcHAo+nlJ6I36umRVZWDIx8PhPwDXyur8PCLpwWX7zli5TSszWu77LNnoV1BD409ArgkuRz52FmG+L54+sppYnV7svMZsW9kI5KPj8dMQfhf6P98hnuMT1HSunXLSV2LxHl6aN4eVq8q3sBQ1NK53bj/5bLselSSv+K7+fhK4bviotX06WU3q8RzhBcNP4a3uZ4NeYGnAbvWLgK76x4IC+PSmHMkVL6vfk8sj/By5u/4uXaP/GOrxdw4fR/7UuF7qXaO2FmG+FewLunPjhPfn9AC42IfkVWCa8BXIAbwYvic5O8j/fAvIr3vpJSOgt3wd/PakxU3BUiLhsBd5rZjWZ2A97z9B18zohVzWyalNK/Uix+MaUIglBz0viBdS5pC2Y2IAy7Q3HjbmTE5xv4ioE/NbOFk0/I/mh5Ul8hhBBdpyfqq+w/fokvynE53sCvJgiuiAtct+IePvvgIwZuwRtaZ5tZeeL2RuPR0KIg3UXRqEwpvY0Po5wGGGdmszVw+WsppT9mjbHf441f8CGK9wG31BIE43/LC4K8kFI6L3773CqLr+zbFUEwwngwpfRUrbo7+UIi++DC3cng4ln2+xfZ9w6CoHV94ZnZ8PnP7ov9R/Dhnw/hHmHv4x3Qq9GgIBjx/B0uMLyKex8V4ti/8/voKQpB0MymiQ7gi3BP3Y+6Oy5V8vogYCMzGxrHq/5/PN/NgEvM7A7c/r8e99Y83cwWifR8piwIZtd3yWbP8uyI+P3cuHZDYGyWl57GBZKJxTXlsJIvgHEhsI2ZjY3DxTs8APcg/NuUJgjCpPJ0C7xcx8wWprKKc3f+b1GO/crMZk8p/SsrO17Avb2+SCn9riwIFs8pROf/4HMRXg5808wWjHxr+NyouyVfeLFDeVSKy+/j8zN84axtUkp74GX7jMB2+KIiU4wgCFXfifXwqQBulSDYe8hTUPQ7zGwFfAjHiymlW6I3hzDgl8C9BvdJKT2fXTND6oaVnMy9Fe/HjddPgQm4IDkOOAgXKbdPKf253f/dk4QRdSMwJoyY7vqfwqgves5nxntvPwNuTym9EuedAvwgpfRYd8VFCCFEzxF1+9PAViEKVfOs2Qn3Wv9K7O+CL5KwOT48baaU0jtdjMc4vL5btDvruwbisQhMEk4avaYpr8saYfSqx2QpLpvgoskqhcdNNLBrnb8cPufgKSmlH4egOiT5KtbL4tOQbJtSejPOXwr4dUrpb6VwWvJUbOB+psFFhu/hYkCvrsgZ8VkRF14vTCnd30vxaCivR6fAjfgqpxvh3l7fxxdsOBAXgb+Mr85dzbuvLTZ72MQn4R0TCfc+3Qr3sjwdF9QbEnrMV0M+DPd8/m5K6XHzlZ9vwVeofqKRcPoqkVZ34wvzHBGCfE/878b4dAcrZAL4ePwZHw58Vu39szZ7ok/NXnXRUbQIvkjQmYUA3tMdHMKRKCj6DZmx27KrfhviMAifm+S/URgugK9It5dVhjNcATyRUrrDzBZKKf2qXf/fm4Rx/s9UY7hPG8Ivnu9GuHH3MT4vyJX4am5/A+5NKf24fE13xEcIIUTPEfXrvCmlX4fHxmB8Bcs7zWxpfLqQD3AP8m+llF6P674LnJe66L1Wikvd4a19nRD2zsEbtKc3K/Y0K8Z1J42KtNaG4X6l8Mri6LSFvdnF+1kBn4R/Mk+23iCEwdlTSh/3NZuqq50C3WGzd4czgJkNxxeuOBBfnXkx4Jup4q06RRPv0swppXt6+H83Bi5NKS1oZmNwj+nDagmTXRWdG4zTenib5tjUoJdxXybeqzmj46VPlR/9DYmCYqonE4t6dd4+MxuMzwXzCT5kYVHgBnzlsFNTStfEeacCf0g+l89UV0B2g9CazwG0MnANPiHwn/G5VG7GV1K8HPgd3sD5a7v+XwghRN8iREHDJ9k/FPgvPv/SX3FPsA/w4aG/xue9HZ9S+ll3xGNKrMOreV22EEaf8JiMuFQVaTP7sKU55hr43z4jjvY3QuRtuVOgXTZ7TzoDmNlc8XXa5POiT5HlTy16435CGLwLryuOyoW4rorOTcZDXnWiW+mxuU6E6C0y77GTzCx31R+Cz+Nxupm9kHwi2W6bty8Mgjlwg3MEcGhK6Tdm9mXghqjMX8cbLod1Vzx6mzYLggsAW5rZjcnd+2cCHi56R81sebxhMxFvCA6VICiEEFM3Uc8kM/sRXp/+L8W8WmZ2He6ZsyM+X95R3SEIZvGYEnkFWKzwumzlPpLP17snvlruU+2OYJNxKRZh6HAvYR9uhs8hVgz3ux4f7ne6mRXD/Z5pMQ0eMrPPgTfNrNfF0X7G/4C5zOxtOnYK/A6ff3AhXOhZGphsrsx22Oy5sGi+8F0hLK5nZnsXwiI+h+c88f3dVm84pfRxaX9KLX+q0hv3k1J62Mw2xz0Vc0FwCC725aLzu8DmZrZUSun1lNJN5gsaLhqi8yddiMfnkZcnyKtOdAdaaERM9YSr/oXAsfhcHe/gItFtwJO4MDhDN8eheNcewoe1vg38wcyGRs/zNngP0Hr4nBNPdWd8pgbCwLoLb9SNjcODgbVjOAshAD6Oi4EfpJTe6I24CiGE6BnCS7CYH24IMB6418x+aGYjUkqv4nNUbQ/smCorxIogpfRZasPiBKmTBUF6miqiTbctPJP956NAIY6KHiL58O4fEQs7pJR+nVL6A3Ad8AXeKXAmVToF2mWzp5T+iw8hvRwfsfJKSuk3+BDSY8zsayEabYYL8VOdkDc1kFJ6PKV0T6kcy0Xn7wAv4YuiFKLzVuaLv1QVnVuMx+cppY/iu/KJaCsaPiymOnrSVb/B+BTDU9bHV5s7F1/oZEXgnpTS/TE8ZbqiF1k9QPWJHtrvA+emlL5d+u0afELfPYFhwHn4ZMsv9HQ8hRBC9DwxdPVqYJvkC0ZMA3wLWCM+9wf2TSn9thejKXqYnhzu18j/i/aT2dzL4SPi/oHP27cuPlffR2a2IO4lOGtK6Y/5c2mXzW4x76T5gnfX4avFngz8PKX0Z/NFao7Ap7r5foqVaMWUQ4h+dwJ/TymNzY6tj+eXWYDL0lQyt6OYupGnoJiqCFf9tYExZrYtcDw+bKBw1S9WaWqLq34jhHFRzCvzfErp7ymlK4CfAluYz0fyLjBvfk13xmkqYBjwk0IQNLMBIQaTUtob9wQ9GDgSOEaCoBBC9A/MJ90/Adg1BEFLKf0vpXQU8CC+cuQlEgT7FzHcb5v4vnTYiO8Cs4RAQ0rpJuAjfLjfJ+0UBCN82XbdTNjc4/CVs7+IESKnAS8A94Rn3qXAyBSrylYZUt4lmz3KnC9CWDwc2B24F/dEXSNO+yU+b+WhyRev6RPetKI+8kQXUyuaU1BMVaQ+OG9feChsGnF5zMyGpJT+k3xS4i3woSp7pZj0WDTE58ASZjZPSunDML5SVLxL4JNI/8fMZkwp/V2980IIMXWTlfN/xRvtP4+fhgD/NrPhKaVTzOyilNJfVC/0O7o0x5yYMqjVKQAcZWYn4iLdObU6Bdphs2fC4tnAV1NKfweuMF/QcAszWwkfzbIR8Kfimnalgeg+MtG58ER/w8zewqehusfMJvNE17MVUwLyFBRTDe2aA6TdhDEyB7BK7P8n4rs48FBK6czkE9mqJ6lxfofP97NEdqxo4K0GHB6eg/8EVchCCDE1YkHsThufnwFz4auMklL6t/nK9Geb2Swppb/EcdUL/YjUhTnmRN8nKweqdQpQdArgK40/WMvmbofNXhIWHw0vVVJK5wP3A39DzgBTJPJEF1MrEgXFVEFfctXPXMtnN7M54/B1+BCVjeK3FYCr8NWqADVQmiGl9HvgB8CpZra+mc0ez381/Pm/kHyi9C96N6ZCCCG6ixSE58YtZvZVYFlgB2BrM7vezL4OXIHPByYPsH6GhvtNvbSjU6A7bHY5A0x9tEt0FqKvooVGxFRDyVX/0Th2OLA4vgz8nsBG3dkzVwxHiiEGRwH/Ah7BV7LbEdgE7yFcAu+Nvr+74jK1kg/5MrODgA1wt/238Ymkj1S6CiHE1IuZzQ8smFJ60sw2wBeUOgSfS3Zo7D8B7ISLBa+nlH6gIcP9E9PCM1M18Xy/gnuCPgO8BTwPPAe8B2wFnJxSuqd0XVts9iyc2YGBKaXfRZw2AB5LKT0SwuL5eD6TJ+oUQCHsxbOdLqX0ryg77sfnNT8+zlsZOAA4WB1PYkpFoqCYKohC+gLcE2DSHCDxWzEHyOsppYe76f8XA5ZPKd1kZuvh4uSmwB7AN4Hj8EmLZwMWBv6QUvq5GiitYbGqW3wfBQzHhcE/pJReU7oKIcTUiZktCtwAnJZSmmhmx+KLCsyPD/+8Cl899vqU0nd7L6aiLxDD/b4LnJRSeqrUsXgi3pl4Tkrpwd6Mp2icrnYKtNNmlzPA1E+rorMQUxJaaERMFaSU/me+wMgqeK9c2VV/Yuy3XSwys9HA7cAlcegLYD9gBWBjYJ34fURK6av4fIdFvCVc1cHMBqaUPg+3/E+K4zFU2GLk2Ht4pUz2u9JVCCGmMqK+/S5wRlGvA/cBnwIXA1umyuJi25vZCyml3/RSdEUvktl7WnhmKiLvFIhDywET8E6BBfBOgQOA6VJKV+fXhnjXFpu9irD4DSrC4lnAQFxYvA05A0xRVBGdz6EiOm+Gi87LUhGdD5UnupjS0ZyCYoqkO+YAaTEei+Fu5MellK4yX9ziLymlF/E5jc5KKT0N3ARsFV5tohPMbBhACIILA/eZ2dD8nJJxNrBnYyiEEKInMZ+s/yDgNymlW+LYvbgYMBj3EPos6uW/AMdLEOxfWBC7WnhmKiPrFLioSqfAkXinwOXATHinwHyl69tis2fC4nRxqJqweDjeefFxSulHKaWfg/JZXydE5zvwPAQV0XkaXHT+Li46b5pSujqldHFK6QegZyumbOQpKKY4qrnqm1nhqr8Y8FUz24eKq353zt2xFL6i8Q9ifyLuTv4TfGGTNc1sOlyY3Da82kQdzGwwcIKZzZhS2hv4LfBxSunPNc4vvAlnAlZIKT3Rg9EVQgjRA6SU/mNmdwEbmdnX8Pm6fpxSegTAzJ4CHsYbbyemlH7Za5EVvUI2LHgc8BUzK4b77QA8b2Yj6DjcT/N/TSHU6RS4AvgTjXUKdNlmj/DvxecvfzATFn9iZt8hhEUzuwnYLjxRJwtH9D3kiS76M/IUFFMMZraYme0SgmDhqr8d8BTuqr8rcFl8ng9slVK6P+s1bjsppdtxl/LfmNkLwHPJV58Cn2/i38Ax+NxGL3VXPKYyPseHhiQzOw9fwe39aidmguBQ3EiTgS+EEFMp4ZHxMO4dmPA5BIvfjsY9OjZKKd3VnXW/6FuY2fxmtk58L4b7XQysDpwen8sCzwJ/xIf73aM8MuUQ0wLdBbxuZl8zsx8A76SUHkkpfYy3BR6Oc66v1inQJpu9mrC4aXwvhMXtkDPAFIU80UV/RwuNiCmC6L25E7gkXP7XAf6BDwk5Cjged+W/LeYA6Yk45ZNV7wFcAyySUnq39NvQlNKfNddEfcxsbrzS/VNK6aOYD/IwYCHcADsFGAF8hE/afFfyuSSH4j17p6SUftgLURdCCNGDxPDPCcDvgPtSSm/1cpREL2FaeKZfYWZrArvgduG2KaVPs98WAf4T3lwdbO522uxmdhC+IMnbwAOFsBjTF62GLy5ycuZtJqYAzGwtYCO8fVl4oh8Zv50FjKPiiX5Xr0VUiG5AoqDo89Rw1V8qc9W/NTwCz8Q9B9fpqZ45M5smpfS/+H4w7r24YUrpZTMblFL6TGJg54RRfws+BOQT4LsppXvNbCm8V3ccnrbDAQNeTik9YmYzAo/i88NIEBRCiKkQM1sA+GM+3DMacJviq33enFJ6u7fiJ3qH6DC+Cx/uV3j3LIbbEbcBe4dA9HQc+6q8e6Z8Wu0U6KrNLmeAqZ9WRWchpnQ0p6CYEuhz8/aZ2RrAL1JKnxYVQ0rpYjP7DJ+3ZqWU0k9AE892RngE3gJ8FXgLn+tnGVwI/hlwEfBfYLGixy6uM2Al4MCU0qs9G2shhBDdSTZ/8MrAt/CVHieJgslXexyIe4F90UvRFL1Em+aYE1MA5U6BlNLz8fw3Bb5sZnU7Bdpls0d5NE1K6X8ppeujY/rHZtZBWCTKKdn/Ux4ppR+a2X9x0XkPM5skOud5TM9WTG1oTkHR52nTHCBtw8xWBS4E5ov4pWJemuSrnh0BzN7d8ZiKmA34//buPd7yse7/+OttGMPtMDLOpaPcRUlFJCS53WlySEROU8oxh/qFHEMi9cv5GMJElJxPRUlRhO6c9UhxS40ig5yNmff9x3WtZrXbY8zea+219lrv5+PhYa/vOl179t7re30/1+fzuVay/TPbUyiZf6tIehewpO07gZOBBSSt2HhSPSFfl4BgRETvqefWtYGtgRNtP9K4r+mcex1wqO0/dmiY0SFuQY+56F6Nv/G6KHAGMH/z/S79RX8ELMQrLAq0as4uaU1Ji7m0rWk8/3jgAEpg8d01IJiA0Sgj6Y2SFm7ctn0zZZfqCZSg83IdG1zECEn5cHS1bkvVl/QmSubaz2x/S3Wji4FjHex2zFrtw3KS7TdJ2pIygXsYeJHSs+V84FfOToEREX1D0nbAicA+tk+UNJftGfW+nGMj5X49rC4KbEaZc1/YdLx5/r+I7Sdm8fyWzNlrYPEE4HO2fzPIGHYH7rN9bQu+7RgBg2WiNy881cd8iJKJfkIWnqLXpXw4ulo3perXMqVpwJPAppIue6VU8kw+Xz2X/oCfl/QMZWK1uKTXAAsAXwamJCAYEdEfJK0ArGz7bEkG9pd0k0sv4Ub5X86xkXK/3vYGYBJwH0BjUaCR7Vc/BmYVEGzJnL0GFvcDzq3XHWNsTx8whuPqYxN4HiWaMtE3Y5BM9PpzvU7Sb2f1OxbRS1I+HF2rm1L1VTbCuImy6+2ewC+AXSW9ud6vdr5/P7B9FbAhZYdhbE+1/Sfbu9i+o7Oji4iIdms6l64GbCBpS9uTgaOAyZJWzUV3pNyvt0laQdLWts8GdgF2r3P+GU3XA7P8HGjVnH2QwOJyjUzDwcaQz6ZR5w2UoPOSUILO8G8l5gkIRl9IUDC6Uqt6gLSK7d8BvwWuoGx6cSJlsrG3pLdkItAaLv2hPivpUUmLdHo8ERExopYBsH0GcA3wIUlb2T4V+DZwnqSFOjnA6IzGHFDD7DEX3atViwKtmLMnGaB3DTfoHNGLEhSMrjNYqj78W2DwONvXtvukLOn1ksbX99wRuAW4lrJqeDplh7ux7RxDv7H9I8rK3UodHkpERIwQSROAkyXtAWD7LMpmYjtL2q6W6K1j+x8dHGZ0SFO5Xzae6V3DWhRo5Zw9yQC9J5noEbOWoGB0lW5J1Zc0RtKCwJmUlcHx9f2+CDwC/BSYChxs+952jKGf2b7K9vVZiY2I6BtTgdOANSXtAv8MDjwBrCdpadt/6uQAo+PeQMr9etJwFgVaOWdPMkBPSyZ6xCwkKBhdoxtS9Zvfw/bTwE7A+4HPNZWzXk7ZFXcF2y+0e0z9LCt2ERG9qRHQkbSGpEnAROBGSmDwg5L2krQiMA441vaUjg02Oirlfn1hjhcFWjlnTzJAb0smesQrU86h0U0knQqsAGwALAzsACwOfNP2H9r83o3t6dcFtgEeogQm7wLOAm4DHgO2BLa3fV87xxMREdFrJM1je1r9+sOU7JtTgS2A71EuvucGjqQsXn/L9iWdGW10UtO8bHtgXeBy2+dJ2hHYDfiM7Vs6O8oYCtWdhCWtASxHCbjdCKwCbA/cClwNHA3sZ/vWAc9vyZy96XXG2J4u6a31Pa8HTrf9RP39mwTsVTe1iVGmLkJNBLYFrrN9Uj1+OfAUsHcWnqKfJSgYHSfp9cBTtp+st48C1gA+DLwG2BmY3K6VOUnjGquHtV/NKcD/p1yUfJbSa+KnlEnKW4FLbF/ajrFERET0KpVdYbelnGNfBI4Dfmr7+/W+PYE/2T5S0lhgvO1HGxfuHRt4dISk19r+c/16EmVueL3tcyXtDuwBrJzsntFjuIsCrZyzJxmgdw036BzRbxIUjI6p/QPnBy6lnMBPbAoMXgIsTVkZntauMl1Jb6dMPLavFx7bAIvaPqbevzLwDcpq9MNNE4hcoERERLxKkpYHzgGOr83dkbQ/ZbfYw2w/LemdwHeADWw/2rnRRqfVcr8zgZ/YPrYe2x74NHCa7bMlLZs+k6PHcBcFWjVnTzJA70omesTQpKdgjLhu6dtXL1BOBa5puvgQZWe7hjuBKcACdbxu/n9ERES8MknLAlcCZ9qeLGmspDWB31F6Bq5Z5wYvUBr6v9SxwUa3yMYzPaTOub8H3G/7qTq3fwh4t6QFbd9PmZNvJmlx2y815uY1sNeSOXsNLF4gafF6aFngVNtn1A0ndgA+A8xr+whKgPHSkehrHsNTA8sHSVpY0jhgc2Cf+nP8BOVnvW4tAV8P2NT2JfnZRiQoGCNsQKr+GZIOAV5HWfldB/iCpN0oq3M7tKt3h6SlgDsoE4HjJY2TtG/NXrhf0o9qk+H3AO8E5mnHOCIiIvrAKsC9wO8kLUAJEL7X9oXAA8DHgR9RggYnN6oGon8oG8/0rOEuCrRqzp5kgN413KBz50Ye0R0SFIwRUVdsGqt9awMnADdQTrxfp5QJTwKeB94NHNnO3h22HwFuATauh86llCtje0vgUeBsSmnDV2zf2a6xRERE9LhLKK1CNqbs+Hiv7aMBamnogcB+wDa2L0zmRv+QNA9A7f/1Ycp8bCngq8DngMcp5ZwTgZMprWbS/2t0GdaiQCvm7EkG6F3JRI8YvvQUjLbrtr59qjuM1a9/TEkh/4btLw943ELA3LanpodgRETEnGs6p4+h9HXaFDgP+GHOq/1tuD3mOjbwmCP1b38SsBLwIcrPeI+m+5eiBPmes31f88+3lXN2Sb8AHrX9CUkXAlNs71bvmwwsDCwBHG77shb/M0SbSNoU2A44hhI8vhi4yvbRkvYA3kGpSlsUOKIGoyOiSYKC0VY1nft04Ae2j6/HtgV2t/3eensMpbH419uZHThgXM2TjIuB+W2vX2/Pa/vFkRhHREREr9PMnSDnovTrWoGStfN92893dnTRCcrGM32hFYsCw52zJxmgtw0n6BwRRcqHo226OVXf9nRJc9evNynD1U/q7QQEIyIiWqQGBOe2PYOyo+ydwOrAFikV7j8p9+sfNSA4Vw3KnQdcRdlccDtJ873K1xjWnL0+f0z9en1KK4OVG/dLmrfe9w/bUxvjnoNvMzqkBvimA2cBvwZ+D9zYfF6x/Yjt3zQST/Kzjfh3CQpG23R73z7bLzf1svkvYFwtLYiIiIghaFyMSVpV0nslrQ7/POc2ggOTgduAX+cCrS9l45k+0opFgeHO2ZMM0JtaEXSOiJQPR5t0U6p+U+nCWsCKlN2ofm77mUHGuqrtW1o9hoiIiH4haSJwKGXh7zPAfravrPfNVYMD0adS7te7mubcqwIzgHls31Tva7QRGEP5XPil7Xtn8fy2zNklzWN7Wv36RmCG7bWG911Hp9Wg88v1d2tbYDXKplZn5bMjYvaSKRht0U2p+nVysR7wbcoududSVpDmahprY/UwAcGIiIghkjQB+ALwEeAp4Fng1qZzbgKCfSzlfr2tzrknAqcAawCnSPpovW9GI6vL9mkDA4JNzx/WnL0pW3ktSbtI+mjNSMX2tKbrkw8AX2rtv0C0UzLRI9ojQcFom25I1Zc0pk4ENq//PQA8CFzUfGFi++WRGE9ERESvqhdsz1ICPROB7YFJLptE/LfKjrLRx1Lu19uGsyjQqjl7kgF613CDzhExuAQFo6061bevsZJUTwzPAHcBewEnApvYfkTSVpI+2O6xRERE9KqmzI3VgHVcdhOeDzgW2Nr27yV9APgqMHfnRhrdohU95qL7DHVRoJVz9iQD9LZkoke0R4KC0RLdlKrf1I9kA0lH1MMvUnqT7Gv7fyWtBOxP/gYiIiKGrHG+Bb4LTKuH96f0EzxL0m6Ui/tDGuWg0T9S7tfbhrso0Ko5e5IBel8y0SPaJwGRaIluStWvY9kQOBy4sR4+DfgxsLWky4HvAF+2fV07xxIREdHLJC1L2VRkE9s31Av41euxc4CpwB62L0sWWP9JuV9vG+6iQCvm7EkG6F3JRI8YGfnjiWGrWYDzMTNVf146mKovaSywEbAd8KCk9Sm7251BmQwsAjxl+97GRGIkxhUREdFrbP9J0s3AXpKeAJYDXgDeafugAY/N+bbPDCj3+whN5X62Z6Tcb3QbsChwdw2+LVePTaR8Fuxh+/rB5tytmLM3BRYPpQT+oAQW30gJLO5J2c06yQCjTFPQ+VjKjtVQfsbPUoLOFwGfBQ5MJnrE0CnzsxiqgSdnSbsDqwDLA5vXlbmtgL/Yvn6kxlKzE88EFgbmAe4A3gM8YntSO8cRERHRy5qyct4ALGT7TknvB7YGLgBuBtYH1rb9hQ4ONTqsZvmMA46ilAdPArav2T0bAPfbvr+DQ4wWkHQCsCDQvChwz8BFgabHt3TOXgOLJwPHUZISVifJAD2hBp0vopQJNwedb2Bm0Pkvswo6R8Srk0zBGJLmVH1gTdv7MjNV/0sDUvU/3+7x1LGsCSxK6SPyOWAzyqTk9tpn4gRJi9feExERETGH6vn2o5RAzzRJ1wO72f4VlN7CwEH1v+gzTfPD1YD5bV+nsqvwscAKth9qKvfbuqODjTk22KIA8D3Kz/JSmhYFZvUarZizDwgAvUy5pj2EmYHFdwH7DQwsJmg0uiQTPWJkJFMwhqw5Vd/2lXW173BgCWACJVX/ENuXtXEMjcnJKpQMhV8B04HrbJ9ZH/MJysXJgbYvbddYIiIiep2k5YEjgX0oO3v+GLi73l4GOBj4oe1LkrnRn5rL/WqfyWWA/YC3U7J+GuV+bZsfRvs0LwoA11MWBRqZf2sBxwAH2b5iwPNaOmcfEFh8mEECi8A2SQYYPZKJHtEZCQrGkHRTqr6kdYGPA6fVicCGwMbAbbZPkvRV4CbbV+UCJSIiYmgkLUoJ+q1BafJ+r6SFKRdrfwD2BsbanprzbX9KuV9vG+6iwHDn7EkG6H1DDTpHxNClfDhetS5O1V8J2Bn4EXA7ZeJpYCtJz9s+cJDxR0RExGw0nzttPy7p25T+YR+T9JLtP0jaHLgMeF2j2XvOt/0p5X69qy4KfB5YFhhje5qkTSjBuW9RFgV2n82iwLDm7DUg2AgsbtwcWJQ0n+2T6nt8OckAo08NOn8O2JCZQedjJTWCzjsAh9q+Ij/biNZJUDBetW7p29e0SrgMMMX2UZJeBCZLWtX2/ZJuBMZQshj/Of52jSkiIqLXSBpje7qkj1F2jp2P0jbkFGBzYBNJl7psHLGO7emdHG+MvFb0mIvuNdxFgTbN2ZMM0INaFHSOiCFI+XDMVjem6kuaCOxJKVl4wvYhdRVpd2C9WtI0t+2X2z2WiIiIXiJpMeBp2y/UrJzDKUGe04B/2N5Q0ocogcGHKP3jXrA9o2ODjo5JuV9veoVFgSUof/uPAI1FgTGzWhQY7px9kMCiJe0KHAY0AouLUALPD9q+o5X/DtE+A4N7kt4B/D/gPuDCGnQeTwk679gIOkdEa83V6QFE92tK1Z9ESdX/FCU4uKakXerDGqn6l0pSq8cg6XWSlq5fr0SZCGwLzA+sLmkB20cCJwK/lPQfQC5OIiIi5oCktwIXUso+Af4T+CJlk4h5gD3q8Z8BZ1GCAs8lINifBpT7rUz5PTlW0nyS3sKAcr8ODjVeJUmLSRpXA4LrAgcARwNvBI61fTNwBfBmYFNJ81My9RrPb+mcvV6HTATOBo6W9BXbJwJfB66X9HbbTwBXJCA4etRAsiV9TNJJks4EnqFkoi9ByUR/q+0ngXUSEIxonwQF49VqpOq/rt6+AbgYWEvSp20f2K7eHZLeCNwCjK+HxgHnAssD7wR2sf2MpBVsHw68x/azuUCJiIh49SSNoWQEXgz8oWZ5/Qdl59jPU3byfFDSZpQNBX5t+95OjTc6a7ByP2ATSiD5W8BfKeV+2Yl6lBjuokCr5uxJBuhdww06R0TrJSgYg2qs5kpapk7kjgJ2o/QAWa6uyN0InA/8T+N5bQgIjgWWBK4G3ixpb0q5whbAqcBGth+QtAHwlZpi/uCsXi8iIiIGV8v/rqFk4NwP/JbSH255yo6gD9RA4aHArxLk6T/N2X62Hwe+DdxJ6TH3FttPUUpLV6T0mJtaH5vflS433EWBVs3ZkwzQu5KJHtGdstFIDKopVX9P4G5JjR4gC1BS9Rs9QK5oV98+SW8DtgG+DyxGSSffx2Vnux9SshbXk/QX4AhKP8Mn2zGWiIiIXlcDPncCU4AJwLK276nN3k+X9HpKNseXbP+4g0ONDniFHnPZeKYH1J/tNcBPKX3d3kbZAXYH4HsDFgX2HNALriVz9kECixMpCQhbUMrU17T9txpYnCRpB5IMMCrMJug8ln8NOq8IHJzFhIiRkUzB+KduStWXtBBl9flS4I/AS5QNTsbXRsOnUyYtWwBbAgfYviz9aiIiIuZM07lzPtv/oJRtbQXcVIM7dwEbULKFtrB9Zc63/SPlfv1hwKLAwpRFgT9TSsLXl3Q25drgXxYFWjVnr4HFg4HnmBlYnGL7T8APgZ9QAovrUAKL59h+MoGj0SGZ6BHdK7sPB/DPVP1fAevWDMD3AWsBt1FOvJ+qH9Yr1KyBN9l+oM1j+i6wILAoZQX69ZQJxaPAZNt/ljQXM7etT7+aiIiIIZC0EeUc+wJwvu0fS/o08E1gM9s/6+gAoyNqud/pwK6271LZ9fV2Sibp3sDWNbtHwPsou1Onz+Qo0pg/S5rf9nN1bj0ROIdS8vuz2j/yJWBB21MGzrmHO2evgcUrgS8B91A2FZkB/JySWfYS5brk05Sg5eW2L8/cf/SonxELAndQPj9Wq9eU76B8xvyOstBwpO0rOzfSiP6ToGA0UvXfQ0nLv5hSLnB+/XpBBqTqU8oInmr3SVjSJykrSFfY3qge+y9gPcruVN+zfX87xxAREdHrJK1GqQL4KOVi/HnKYuBztTzvaGAZRuDcH92jlvt9BXiCkrW1CrAasDal3G/HumCccr9RbriLAq2YsycZoDe1IugcEe2V8uE+102p+pLeJGlXSdtKWp+SubgZMEPSyQC2rwGuAxYhu4xFRES0wtuBYylN/Bei9At7TtIE298Glk+ZXv9JuV9/qIsCBwFfAJYGdq4BnDMp/d6ukDS+udy3TXP2K4CPAVNtP1LL0q+qz99eZaPDGS67XGfzmlGiBgQ3As6QdCawnu3LKJuKXFBbVDxu+2nbUxrP6eSYI/pNMgX7WDel6kt6O3BZHc9LlEa0p1ICkUtS0srvs717ffyiLrveRURExKsk6bWU6oBxlIvvayWtR9kBcgIlK+h/JW0OrA/sDEyv/eSSvdFHUu7XHyR9BngZ+CtwCLBl/QyYYPvvkl5bews2Ht+SObukN1E2rHka+BtwLyUbdRvgr7Z3ro/7COWz6Hjbf2zHv0G0TzLRI7pfgoJ9rhtS9SUtDFwOnFlXJRsXLWcAv7G9X719PnC37Z1yYRIRETFnJP0ncAFwEzCesvB3EnAacAJlk4FLKRuMnQrsa/uKjgw2Oiblfr1ruIsClEziYc/ZkwzQP+Y06BwRIy9BwT7XDX37JI2jXJDsZPtZlR3uXpD0OsqFy162z6u3l7J9SzvHExER0WvqRfgp/OvF/Fso5X3HAZOBvSiZX2OB09pVHRDdb7g95qL7tGJRoBVz9iQD9K5kokeMTnN3egAxsgZJ1W/0ANlG0sm2d7Z9TW0uvT4j07dvPsoJ5IPAlXVyMdb2w5JOAF4LYPth4OERGE9ERETPUNlQ7HLgrqaL8Hlt/0HSusDNwK3APoCBRWxPzUVaf2rqMdco99tZ0g22z5Q0D6XHXMr9RpGmRYGjBlkUeI4SnNkLOICyKLCf7SsG+QxoxZz9ReAh4Ad1HONqZdJngZsk3VUDi1sCS9XXy+9Zlxss6CypEXR+jtIzcryk9wMHUoLOLzWen59xROckKNhHBknVP5KZqfq/AU6XdJzt3W1fLemWkUjVt/2EpGOBTSX9xfbtwPTG3ZQVS3JxEhERMedsvyRpC+BKSTvZPsX2i/Vi/n5JPwDeYfvn9SlT6/Nyzu1PAzee2dFNG89Iusr2kx0dYbxqrVwUaNGcPckAPaaFQeeI6IDsPtwnaqr+KcDXbO9hey9KM9/Vga/Yfoiyoci7JZ1SnzZ1BId4EfAIsJOkdWsa+fuBnYBfQC5OIiIihsr2rcAGwBGSdqqHGxfzT1Eu3KLPSHqtpI0kfbKW+UEJxGwJfI2Z/b82B46sAaZH6nM1+KtGN6nZWFsA72/87TcvClAy9t7hsrOvbc9uUWBYc3bbT1CCzptKelc9PGhgccjfdIyYpqDz1IFBZ2BdYF/gbZSg82bApLSmiOguCQr2j0FT9YHPAttK2rLe3hL4DoxsEM72Y5SeRvcCJ0k6Bzge2DN9ayIiIobP9m2UnsFHSNqlXsyvAWwE3NPZ0cVIq+V+V1PKhDcFvivpIOBuBi/3u9j2S7anQxZrR5NWLgq0aM6eZIAe0Yagc0SMsGw00ickLQL8ktIA+Mp6bGwtKfoypcnrNzs6yErSkvXLcXV1OitJERERLSLpvcBVlP5PKwFH2r68s6OKkZSNZ/pT/du/Ftjf9kl1UeB0SvbWr4fwekOes0taAvgksCulfPltwKG2L53TcUTnNf1u7Wv7FEljarD368DvbX+nw0OMiFlIULCPSNoReB9wnO3bmz6s96GczA/JZC8iIqL3SVqFEgDaxvYlOf/3j1rudx+lx9zG9di8NbtnOUqPuY8DN5CNZ3pOty0KJBmgd7Q66BwRIyNBwT4iaTFgT2BR4ALbP62p+ucCn0mZbkRERP+QtIDtZ3IR3n9qUPhK4CDbp9RjjQqSk4F7bJ/Q0UFG22RRINql24LOETF72X24j9h+TNJxlFT9kyQ1UvXTty8iIqL/PNvpAURn2L5V0gbAtZKogcFsPNMn6s9/qSwKRKvZvk3SR5kZdE7bgYgul0zBPpVU/YiIiIj+lnK//tWY++caINohmegRo0eCghERERERfSrlfhHRagk6R4weCQpGRERERPSx9JiLiIjoTwkKRkRERET0uZT7RURE9J+5Oj2AiIiIiIjouGw8ExER0WeSKRgREREREREREdFnkikYERERERERERHRZxIUjIiIiIiIiIiI6DMJCkZERERERERERPSZBAUjIiIi+oCkD0r6c6fHERERERHdIUHBiIiIiFFE0qck3SbpGUmPSLpa0gc6Pa45IcmS7pI0V9OxwySd1cFhRURERPSVBAUjIiIiRglJXwSOAQ4HlgCWBU4CNurgsIZqaWCLTg8iIiIiol8lKBgRERExCkhaGDgU2NX2RbaftT3N9uW296qPmVfSMZKm1P+OkTTvLF7Pkt7SdPssSYfVrz8o6c+S9pb0aM1I3FjSBpJ+L2mqpP2annuwpB9ImizpaUn3SHrvbL6lbwCHSJp7FuO7QNJfJT0l6ReSVhgw1pNqluQzkn4pacn6/T4h6XeSVm56/NKSLpT0mKQHJe0++3/xiIiIiN6WoGBERETE6LA6MA64+BUesz+wGvAuYCVgVeCAIb7fkvX9lgEOAk4DtgbeA6wJHCjpjU2P3xA4HxgPXAacMJvXvwj4BzBpFvdfDSwHLA78D3DugPs3p3xvE4AXgZvq4yYAPwSOAqglypcDd9TvZV1gT0nrz2Z8ERERET0tQcGIiIiI0WFR4O+2X36Fx2wFHGr7UduPAYcA2wzx/aYBX7M9jRLsmwAca/tp2/cA91ICjw032r7K9nTguwPuG4yBAynBxbH/dqf9nfpeLwIHAyvVbMmGi23/xvYLlEDpC7Yn1/f/PtDIFFwFWMz2obZfsv0AJcCZ0uWIiIjoa4OWa0RERERE13kcmCBp7lcIDC4NPNR0+6F6bEjvVwNsAM/X//+t6f7ngQWabv+16evngHGzGSu2r6o7Iu/YfFzSGOBrwGbAYsCMetcE4KlZjGVWY3s9sLSkJ5vuHwPcMKtxRURERPSDZApGREREjA43UcpkN36Fx0yhBMEalq3HBvMcMH/T7SWHM7hh2B/Yb8BYPkXZPOXDwMLAG+pxDeH1HwYetD2+6b8FbW8wjDFHREREjHoJCkZERESMArafovT2O7Fu+jG/pHkkfUTSN+rDzgMOkLSYpAn18efM4iVvBz4laYyk/wbWbvf3MBjb1wN3A9s1HV6QEgB9nBIsPHwYb3EL8LSkfSTNV7/fFSWtMozXjIiIiBj1EhSMiIiIGCVsfwv4ImWDjccoWXCfBy6pDzkMuA24E7iLsvHGYbN4uT2AjwFPUnoRXjKLx42EA4DXNN2eTCl9/guld+HNQ33hWgI9kbL5yoPA34HTKRmIEREREX1Ltjs9hoiIiIiIiIiIiBhByRSMiIiIiIiIiIjoMwkKRkRERERERERE9JkEBSMiIiIiIiIiIvpMgoIRERERERERERF9JkHBiIiIiIiIiIiIPpOgYERERERERERERJ9JUDAiIiIiIiIiIqLPJCgYERERERERERHRZxIUjIiIiIiIiIiI6DP/B9Rs6FnYskNFAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1584x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_per_season_nan_new_era = df_detail_nan[(df_detail_nan['season'] >= YEAR_3P) & (df_detail_nan['Nan_Count'] > 0)]\n",
    "df_per_season_nan_new_era = df_per_season_nan_new_era[['Col_Name','Nan_Count']].groupby(\"Col_Name\").sum().reset_index()\n",
    "df_per_season_nan_new_era = df_per_season_nan_new_era.sort_values(by=['Nan_Count'], ascending=True)\n",
    "\n",
    "df_per_season_nan_old_era = df_detail_nan[(df_detail_nan['season'] < YEAR_3P) & (df_detail_nan['Nan_Count'] > 0)]\n",
    "df_per_season_nan_old_era = df_per_season_nan_old_era[['Col_Name','Nan_Count']].groupby(\"Col_Name\").sum().reset_index()\n",
    "df_per_season_nan_old_era = df_per_season_nan_old_era.sort_values(by=['Nan_Count'], ascending=True)\n",
    "\n",
    "fig = plt.figure(figsize = (10, 4))\n",
    "sns.barplot(data=df_per_season_nan_new_era, x=\"Col_Name\", y=\"Nan_Count\")\n",
    "plt.ylabel('Nan Count', fontsize=12)\n",
    "plt.xticks(rotation=45,horizontalalignment='right',fontweight='light', fontsize=10)\n",
    "plt.xlabel('Column Name', fontsize=12)\n",
    "plt.title(f\"From {df_detail_nan['season'].iloc[0]} until {YEAR_3P}\", fontsize=12)\n",
    "plt.show()\n",
    "\n",
    "fig = plt.figure(figsize = (22, 4))\n",
    "sns.barplot(data=df_per_season_nan_old_era, x=\"Col_Name\", y=\"Nan_Count\")\n",
    "plt.ylabel('Nan Count', fontsize=12)\n",
    "plt.xticks(rotation=45,horizontalalignment='right',fontweight='light', fontsize=10)\n",
    "plt.xlabel('Column Name', fontsize=12)\n",
    "plt.title(f\"From {YEAR_3P-1} until {df_detail_nan['season'].iloc[-1]}\", fontsize=12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 4 Machine Learning Process "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "try_col = ['W', 'L', 'PW', 'PL', 'Pre', 'Post', 'Playoff', 'Rk_Season', 'Overall', 'Rk_Conference', 'Home', 'Road', 'First_4_Months', 'Last_4_Months', 'Champion_Percent']\n",
    "df.drop(try_col, axis=\"columns\", inplace=True)\n",
    "df = df[df['season'] >= YEAR_3P]\n",
    "df.sort_values(by=['season'], ascending=False, inplace=True)\n",
    "\n",
    "df_last = df[df['season'] > (MAX_SEASON - LAST_N_SEASONS)] \n",
    "df = df[df['season'] <= (MAX_SEASON - LAST_N_SEASONS)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_seasons = np.arange(YEAR_3P, (MAX_SEASON - LAST_N_SEASONS) + 1, 1)\n",
    "random.shuffle(all_seasons)\n",
    "\n",
    "split_idx = round(all_seasons.shape[0] * 0.8)\n",
    "train_seasons = all_seasons[:split_idx] \n",
    "test_seasons = all_seasons[split_idx:]\n",
    "\n",
    "df_train = df[df['season'].isin(train_seasons)]\n",
    "df_test = df[df['season'].isin(test_seasons)]\n",
    "\n",
    "extra_col = ['name', 'season', 'Champion_Win_Share']\n",
    "df_train_extra = df_train[extra_col]\n",
    "df_test_extra = df_test[extra_col]\n",
    "df_last_extra = df_last[extra_col]\n",
    "\n",
    "train_labels = df_train_extra['Champion_Win_Share'].values\n",
    "test_labels = df_test_extra['Champion_Win_Share'].values\n",
    "\n",
    "for col in extra_col:\n",
    "    del df_train[col]\n",
    "    del df_test[col]\n",
    "    del df_last[col]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "numeric_col = [col for col in df_train.columns if col not in [\"Top_3_Conference\"]]\n",
    "numeric_pipe = Pipeline(steps=[('imp_median', SimpleImputer(missing_values=np.nan, strategy='median')),\n",
    "                               ('scaler', StandardScaler())])\n",
    "\n",
    "preprocessor = ColumnTransformer(transformers=[('cat', OneHotEncoder(sparse=False), ['Top_3_Conference']),\n",
    "                                               ('num', numeric_pipe, numeric_col)])\n",
    "\n",
    "train_features = preprocessor.fit_transform(df_train)\n",
    "test_features = preprocessor.transform(df_test)\n",
    "last_features = preprocessor.transform(df_last)\n",
    "\n",
    "header_names = [col.split(\"__\")[1] for col in preprocessor.get_feature_names_out()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test_extra.reset_index(drop=True, inplace=True)\n",
    "df_test = pd.concat([pd.DataFrame(data=test_features, columns=header_names), df_test_extra], axis=1)\n",
    "\n",
    "df_last_extra.reset_index(drop=True, inplace=True)\n",
    "df_last = pd.concat([pd.DataFrame(data=last_features, columns=header_names), df_last_extra], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_and_evaluate(clf, param) -> list:\n",
    "    clf.set_params(**param)\n",
    "    clf.fit(train_features, train_labels)\n",
    "                            \n",
    "    test_predict = clf.predict(test_features)\n",
    "    r2 = r2_score(test_labels, test_predict)\n",
    "    mae = mean_absolute_error(test_labels, test_predict)\n",
    "    mse = mean_squared_error(test_labels, test_predict)\n",
    "    rmse = mean_squared_error(test_labels, test_predict, squared=False)\n",
    "    \n",
    "    ndcg = []\n",
    "    for season in df_test['season'].unique():\n",
    "        df_ndcg = df_test[df_test['season'] == season].copy()\n",
    "        df_ndcg.sort_values(by=['Champion_Win_Share'], ascending=False, inplace=True)\n",
    "        test_labels_ndcg = df_ndcg.pop('Champion_Win_Share')\n",
    "        del df_ndcg['name']\n",
    "        del df_ndcg['season']\n",
    "        \n",
    "        test_features_ndcg = df_ndcg.to_numpy()\n",
    "        test_predict_ndcg = clf.predict(test_features_ndcg)\n",
    "        \n",
    "        ndcg_score_ = ndcg_score(y_true=[test_labels_ndcg], y_score=[test_predict_ndcg], k=5) \n",
    "        ndcg.append(ndcg_score_)                \n",
    "        \n",
    "    return [clf.__class__.__name__, r2, mae, mse, rmse, np.mean(ndcg), param.keys(), param.values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomForestRegressor\n",
      "max_depth: 15/15...XGBRegressor\n",
      "max_depth: 10/10..."
     ]
    }
   ],
   "source": [
    "list_grid = []\n",
    "\n",
    "\n",
    "clf = RandomForestRegressor(random_state=RANDOM_SEED, n_jobs=-3)\n",
    "print(clf.__class__.__name__)\n",
    "for max_depth in np.arange(3, 16, 1):\n",
    "        sys.stdout.write(f\"\\rmax_depth: {max_depth}/15...\")\n",
    "        for n_estimators in np.arange(5, 20, 1):\n",
    "                param = {\"max_depth\": max_depth,\n",
    "                        \"n_estimators\": n_estimators}\n",
    "                list_grid.append(fit_and_evaluate(clf, param))\n",
    "\n",
    "                \n",
    "clf = XGBRegressor(random_state=RANDOM_SEED, n_jobs=-3, verbosity=0)\n",
    "print(clf.__class__.__name__)\n",
    "for max_depth in np.arange(3, 11, 1):\n",
    "        sys.stdout.write(f\"\\rmax_depth: {max_depth}/10...\")\n",
    "        for n_estimators in [10, 20, 50, 100]:\n",
    "                for learning_rate in [0.1, 0.2, 0.3]:\n",
    "                        for subsample in np.arange(0.4, 1.01, 0.1):\n",
    "                                for colsample_bytree in np.arange(0.4, 1.01, 0.1): \n",
    "                                        param = {\"max_depth\": max_depth,\n",
    "                                                \"n_estimators\": n_estimators,\n",
    "                                                \"learning_rate\": learning_rate,\n",
    "                                                \"subsample\": subsample, \n",
    "                                                \"colsample_bytree\": colsample_bytree}\n",
    "                                        list_grid.append(fit_and_evaluate(clf, param))              "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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>clf</th>\n",
       "      <th>R2</th>\n",
       "      <th>MAE</th>\n",
       "      <th>MSE</th>\n",
       "      <th>RMSE</th>\n",
       "      <th>NDCG</th>\n",
       "      <th>param.keys</th>\n",
       "      <th>param.values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.698278</td>\n",
       "      <td>0.086047</td>\n",
       "      <td>0.022318</td>\n",
       "      <td>0.149392</td>\n",
       "      <td>0.884393</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(4, 14)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.702807</td>\n",
       "      <td>0.085914</td>\n",
       "      <td>0.021983</td>\n",
       "      <td>0.148266</td>\n",
       "      <td>0.884176</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(4, 13)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.698614</td>\n",
       "      <td>0.086600</td>\n",
       "      <td>0.022293</td>\n",
       "      <td>0.149308</td>\n",
       "      <td>0.882505</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(4, 11)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.701889</td>\n",
       "      <td>0.086386</td>\n",
       "      <td>0.022051</td>\n",
       "      <td>0.148495</td>\n",
       "      <td>0.881897</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(4, 12)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.686288</td>\n",
       "      <td>0.087965</td>\n",
       "      <td>0.023205</td>\n",
       "      <td>0.152331</td>\n",
       "      <td>0.876541</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(3, 14)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.687181</td>\n",
       "      <td>0.087656</td>\n",
       "      <td>0.023139</td>\n",
       "      <td>0.152114</td>\n",
       "      <td>0.875630</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(3, 12)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.693776</td>\n",
       "      <td>0.086242</td>\n",
       "      <td>0.022651</td>\n",
       "      <td>0.150502</td>\n",
       "      <td>0.872856</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(4, 15)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.681960</td>\n",
       "      <td>0.088180</td>\n",
       "      <td>0.023525</td>\n",
       "      <td>0.153378</td>\n",
       "      <td>0.870021</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(3, 8)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.681403</td>\n",
       "      <td>0.088136</td>\n",
       "      <td>0.023566</td>\n",
       "      <td>0.153512</td>\n",
       "      <td>0.868170</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(3, 11)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>RandomForestRegressor</td>\n",
       "      <td>0.688988</td>\n",
       "      <td>0.086383</td>\n",
       "      <td>0.023005</td>\n",
       "      <td>0.151674</td>\n",
       "      <td>0.867441</td>\n",
       "      <td>(max_depth, n_estimators)</td>\n",
       "      <td>(4, 16)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      clf        R2       MAE       MSE      RMSE      NDCG  \\\n",
       "24  RandomForestRegressor  0.698278  0.086047  0.022318  0.149392  0.884393   \n",
       "23  RandomForestRegressor  0.702807  0.085914  0.021983  0.148266  0.884176   \n",
       "21  RandomForestRegressor  0.698614  0.086600  0.022293  0.149308  0.882505   \n",
       "22  RandomForestRegressor  0.701889  0.086386  0.022051  0.148495  0.881897   \n",
       "9   RandomForestRegressor  0.686288  0.087965  0.023205  0.152331  0.876541   \n",
       "7   RandomForestRegressor  0.687181  0.087656  0.023139  0.152114  0.875630   \n",
       "25  RandomForestRegressor  0.693776  0.086242  0.022651  0.150502  0.872856   \n",
       "3   RandomForestRegressor  0.681960  0.088180  0.023525  0.153378  0.870021   \n",
       "6   RandomForestRegressor  0.681403  0.088136  0.023566  0.153512  0.868170   \n",
       "26  RandomForestRegressor  0.688988  0.086383  0.023005  0.151674  0.867441   \n",
       "\n",
       "                   param.keys param.values  \n",
       "24  (max_depth, n_estimators)      (4, 14)  \n",
       "23  (max_depth, n_estimators)      (4, 13)  \n",
       "21  (max_depth, n_estimators)      (4, 11)  \n",
       "22  (max_depth, n_estimators)      (4, 12)  \n",
       "9   (max_depth, n_estimators)      (3, 14)  \n",
       "7   (max_depth, n_estimators)      (3, 12)  \n",
       "25  (max_depth, n_estimators)      (4, 15)  \n",
       "3   (max_depth, n_estimators)       (3, 8)  \n",
       "6   (max_depth, n_estimators)      (3, 11)  \n",
       "26  (max_depth, n_estimators)      (4, 16)  "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(data=list_grid, columns=[\"clf\", \"R2\", \"MAE\", \"MSE\", \"RMSE\", \"NDCG\", \"param.keys\", \"param.values\"], index=None)\n",
    "df.sort_values(by=[\"NDCG\"], ascending=False, inplace=True)\n",
    "df[df['clf'] == \"RandomForestRegressor\"].head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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>clf</th>\n",
       "      <th>R2</th>\n",
       "      <th>MAE</th>\n",
       "      <th>MSE</th>\n",
       "      <th>RMSE</th>\n",
       "      <th>NDCG</th>\n",
       "      <th>param.keys</th>\n",
       "      <th>param.values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>933</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.661721</td>\n",
       "      <td>0.120074</td>\n",
       "      <td>0.025022</td>\n",
       "      <td>0.158183</td>\n",
       "      <td>0.899378</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(4, 20, 0.1, 0.4, 0.7)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1228</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.691447</td>\n",
       "      <td>0.090967</td>\n",
       "      <td>0.022823</td>\n",
       "      <td>0.151074</td>\n",
       "      <td>0.897767</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(4, 100, 0.1, 0.4, 0.7999999999999999)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>854</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.657434</td>\n",
       "      <td>0.116019</td>\n",
       "      <td>0.025339</td>\n",
       "      <td>0.159183</td>\n",
       "      <td>0.896934</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(4, 10, 0.2, 0.7, 0.5)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>934</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.650986</td>\n",
       "      <td>0.122272</td>\n",
       "      <td>0.025816</td>\n",
       "      <td>0.160674</td>\n",
       "      <td>0.891118</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(4, 20, 0.1, 0.4, 0.7999999999999999)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>327</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.687019</td>\n",
       "      <td>0.094967</td>\n",
       "      <td>0.023151</td>\n",
       "      <td>0.152154</td>\n",
       "      <td>0.890318</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(3, 10, 0.3, 0.7999999999999999, 0.99999999999...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3579</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.689430</td>\n",
       "      <td>0.091616</td>\n",
       "      <td>0.022972</td>\n",
       "      <td>0.151567</td>\n",
       "      <td>0.889791</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(8, 100, 0.1, 0.4, 0.7)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3432</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.699774</td>\n",
       "      <td>0.090650</td>\n",
       "      <td>0.022207</td>\n",
       "      <td>0.149021</td>\n",
       "      <td>0.888876</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(8, 50, 0.1, 0.4, 0.7)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2118</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.633953</td>\n",
       "      <td>0.123208</td>\n",
       "      <td>0.027076</td>\n",
       "      <td>0.164548</td>\n",
       "      <td>0.887060</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(6, 20, 0.1, 0.5, 0.8999999999999999)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>787</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.423915</td>\n",
       "      <td>0.186863</td>\n",
       "      <td>0.042612</td>\n",
       "      <td>0.206427</td>\n",
       "      <td>0.885645</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(4, 10, 0.1, 0.4, 0.7999999999999999)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1888</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.683711</td>\n",
       "      <td>0.091730</td>\n",
       "      <td>0.023395</td>\n",
       "      <td>0.152955</td>\n",
       "      <td>0.884700</td>\n",
       "      <td>(max_depth, n_estimators, learning_rate, subsa...</td>\n",
       "      <td>(5, 100, 0.2, 0.7, 0.9999999999999999)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               clf        R2       MAE       MSE      RMSE      NDCG  \\\n",
       "933   XGBRegressor  0.661721  0.120074  0.025022  0.158183  0.899378   \n",
       "1228  XGBRegressor  0.691447  0.090967  0.022823  0.151074  0.897767   \n",
       "854   XGBRegressor  0.657434  0.116019  0.025339  0.159183  0.896934   \n",
       "934   XGBRegressor  0.650986  0.122272  0.025816  0.160674  0.891118   \n",
       "327   XGBRegressor  0.687019  0.094967  0.023151  0.152154  0.890318   \n",
       "3579  XGBRegressor  0.689430  0.091616  0.022972  0.151567  0.889791   \n",
       "3432  XGBRegressor  0.699774  0.090650  0.022207  0.149021  0.888876   \n",
       "2118  XGBRegressor  0.633953  0.123208  0.027076  0.164548  0.887060   \n",
       "787   XGBRegressor  0.423915  0.186863  0.042612  0.206427  0.885645   \n",
       "1888  XGBRegressor  0.683711  0.091730  0.023395  0.152955  0.884700   \n",
       "\n",
       "                                             param.keys  \\\n",
       "933   (max_depth, n_estimators, learning_rate, subsa...   \n",
       "1228  (max_depth, n_estimators, learning_rate, subsa...   \n",
       "854   (max_depth, n_estimators, learning_rate, subsa...   \n",
       "934   (max_depth, n_estimators, learning_rate, subsa...   \n",
       "327   (max_depth, n_estimators, learning_rate, subsa...   \n",
       "3579  (max_depth, n_estimators, learning_rate, subsa...   \n",
       "3432  (max_depth, n_estimators, learning_rate, subsa...   \n",
       "2118  (max_depth, n_estimators, learning_rate, subsa...   \n",
       "787   (max_depth, n_estimators, learning_rate, subsa...   \n",
       "1888  (max_depth, n_estimators, learning_rate, subsa...   \n",
       "\n",
       "                                           param.values  \n",
       "933                              (4, 20, 0.1, 0.4, 0.7)  \n",
       "1228             (4, 100, 0.1, 0.4, 0.7999999999999999)  \n",
       "854                              (4, 10, 0.2, 0.7, 0.5)  \n",
       "934               (4, 20, 0.1, 0.4, 0.7999999999999999)  \n",
       "327   (3, 10, 0.3, 0.7999999999999999, 0.99999999999...  \n",
       "3579                            (8, 100, 0.1, 0.4, 0.7)  \n",
       "3432                             (8, 50, 0.1, 0.4, 0.7)  \n",
       "2118              (6, 20, 0.1, 0.5, 0.8999999999999999)  \n",
       "787               (4, 10, 0.1, 0.4, 0.7999999999999999)  \n",
       "1888             (5, 100, 0.2, 0.7, 0.9999999999999999)  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df['clf'] == \"XGBRegressor\"].head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022\n",
      "                   Teams  Champion_Shares_in_%\n",
      "0  Golden State Warriors             70.451911\n",
      "1           Phoenix Suns             68.304955\n",
      "2        Milwaukee Bucks             62.962042\n",
      "3         Boston Celtics             53.264830\n",
      "4      Memphis Grizzlies             46.490610\n",
      "=============================================================================\n",
      "============================================================================\n",
      "\n",
      "2021\n",
      "                Teams  Champion_Shares_in_%\n",
      "0     Milwaukee Bucks             64.819111\n",
      "1  Philadelphia 76ers             59.436355\n",
      "2        Phoenix Suns             56.969202\n",
      "3           Utah Jazz             56.710852\n",
      "4       Brooklyn Nets             53.716982\n",
      "=============================================================================\n",
      "============================================================================\n",
      "\n",
      "2020\n",
      "                  Teams  Champion_Shares_in_%\n",
      "0    Los Angeles Lakers             71.545239\n",
      "1       Milwaukee Bucks             70.775909\n",
      "2  Los Angeles Clippers             66.627403\n",
      "3       Toronto Raptors             59.817270\n",
      "4        Boston Celtics             46.339440\n",
      "=============================================================================\n",
      "============================================================================\n",
      "\n",
      "NDCG-Score: 0.857603451638539\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestRegressor(random_state=RANDOM_SEED, n_jobs=-3, max_depth=4, n_estimators=14)\n",
    "clf.fit(train_features, train_labels) \n",
    "\n",
    "df_n_victory_list = []\n",
    "ndcg = [] \n",
    "for season_n in df_last['season'].unique():\n",
    "        df_n = df_last[df_last['season'] == season_n].copy()\n",
    "        names_n = df_n[\"name\"].values\n",
    "        df_n.drop(['season', 'name'], axis=\"columns\", inplace=True)\n",
    "        y_true = df_n.pop('Champion_Win_Share')\n",
    "        feature_n = df_n.to_numpy()\n",
    "        del df_n\n",
    "\n",
    "        prediction = clf.predict(feature_n)\n",
    "        ndcg_score_ = ndcg_score(y_true=[y_true], y_score=[prediction], k=5) \n",
    "        ndcg.append(ndcg_score_)\n",
    "        \n",
    "        df_n_victory = pd.DataFrame(data=feature_n, index=None, columns=header_names)\n",
    "        df_n_victory['season'] = season_n\n",
    "        df_n_victory['Teams'] = names_n\n",
    "        df_n_victory['Champion_Shares_in_%'] = prediction * 100\n",
    "        df_n_victory.sort_values(by=['Champion_Shares_in_%'], ascending=False, ignore_index=True, inplace=True)\n",
    "        df_n_victory_list.append(df_n_victory)\n",
    "        \n",
    "        print(season_n)\n",
    "        print(df_n_victory[['Teams', 'Champion_Shares_in_%']].head(5))\n",
    "        print(\"=============================================================================\")\n",
    "        print(\"============================================================================\\n\")\n",
    "\n",
    "print(\"NDCG-Score:\", np.mean(ndcg))\n",
    "df_n_victory_list = pd.concat(df_n_victory_list, ignore_index=True)\n",
    "df_n_victory_list.to_csv(\"champ_predict.csv\", index=False, encoding=\"utf-8-sig\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "explainer = shap.TreeExplainer(clf)\n",
    "shap_values = explainer.shap_values(test_features)\n",
    "\n",
    "shap.summary_plot(shap_values, test_features, plot_type=\"bar\", feature_names=header_names, \n",
    "                    show=False, max_display=15, class_inds=\"original\")\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(10, 6)\n",
    "plt.title(\"Shap Importance\", fontsize=14, loc=\"center\")   \n",
    "plt.tight_layout()\n",
    "fig.savefig(\"pngs/shap_importance.png\")\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = \"Champion Share Score will be higher if the feature have a high value on the x-axis --> Model prediction will be higher!\"\n",
    "shap.summary_plot(shap_values, test_features, feature_names=header_names, show=False, max_display=15, plot_type=\"dot\")\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(10, 8)\n",
    "plt.title(title, fontsize=14, loc=\"center\")   \n",
    "plt.tight_layout()\n",
    "fig.savefig(\"pngs/fi_impact.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](pngs/fi_impact_edit.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 5 PowerBi Charts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 2022\n",
    "![](pngs/nba_heat_table_2022.PNG)\n",
    "<br><br>\n",
    "![](pngs/nba_compare_2022.PNG)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 2021\n",
    "![](pngs/nba_heat_table_2021.PNG)\n",
    "<br><br>\n",
    "![](pngs/nba_compare_2021.PNG)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ➤ 2020\n",
    "![](pngs/nba_heat_table_2020.PNG)\n",
    "<br><br>\n",
    "![](pngs/nba_compare_2020.PNG)\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "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.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "aa6708a3e9a8fadf3ed03c473ecc2d2a3bf5cea3ad7526930f095379c19fd7a0"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}