03 CAPSTONE PROJECT - MODEL BUILDING NOTEBOOK.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EMERITUS CAPSTONE PROJECT\n",
    "**_NUVEEN SALES ANALYSIS:_**\n",
    "The aim of the project is to build a machine learning model to predict _next year_ sales based on different explanatory variables which describe _current year_ sales.\n",
    "\n",
    "In the following notebooks, each one of the steps in the Machine Learning model building pipeline are described. There will be a notebook for each one of the Machine Learning Pipeline steps:\n",
    "\n",
    "1. Exploratory Data Analysis\n",
    "2. Feature Engineering\n",
    "3. Feature Selection\n",
    "4. Model Building\n",
    "\n",
    "**This is the notebook for step 3 & 4: Feature Selection and Model Building**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FEATURE SELECTION\n",
    "\n",
    "`Features selection` refers to procedures that will allow us to find the vast subset of features from all the variables present in the dataset, namely it is the process to identify the most predictive features. We start with the entire dataset with all the variables and by the end of the feature selection process we end up with a smaller number of features which are typically the most predictive ones.\n",
    "\n",
    "### Advantages of Feature Selection:\n",
    "\n",
    "- Utilizing less number of features minimizes the risk that we may encounter due to data errors and removing redundacy which means that many features provide the same information, for example we often find variables that take only one value (constant variables) or variables that take the same value for the great majority of the observations (quasi constant variables) these variables tend to be quite useless to make predictions, so we may get rid of them.\n",
    "\n",
    "- We also find variables with different names but identical in all of their values (duplication), so we may remove one of them.\n",
    "\n",
    "- Finally we also find correlation and correlated variables tend to provide the same information about the target that we want to predict, so there is no need to use the two variables if they're correlated including one of them already adds most of the value that can be extracted.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During the Exploratory Data Analysis and Feature Engineering a discrimination of variables were made based on **features characteristics**.\n",
    "\n",
    "The criteria used to _filter_ the features to be used in our model were based on the three points exposed above, namely thru an analysis of the information provided by the variables in regards to the target prediction.\n",
    "\n",
    "The variables discarded from the raw data are:\n",
    "- CONTACT_ID\n",
    "- refresh_date\n",
    "- no_of_Redemption_12M_1\n",
    "- no_of_Redemption_12M_10K\n",
    "- no_of_funds_redeemed_12M_1\n",
    "- no_of_funds_Redemption_12M_10K\n",
    "- no_of_assetclass_redeemed_12M_1\n",
    "- no_of_assetclass_Redemption_12M_10K\n",
    "- redemption_curr\n",
    "- redemption_12M\n",
    "- aum_AC_MONEY\n",
    "- aum_AC_EQUITY\n",
    "- aum_AC_PHYSICAL_COMMODITY\n",
    "- aum_AC_REAL_ESTATE\n",
    "- aum_P_529\n",
    "- aum_P_ALT\n",
    "- aum_P_UCITS\n",
    "- aum_P_ETF\n",
    "- aum_P_UIT\n",
    "- aum_AC_FIXED_INCOME_MUNI\n",
    "- aum_AC_FIXED_INCOME_TAXABLE\n",
    "- aum_AC_MULTIPLE\n",
    "- aum_AC_TARGET\n",
    "- aum_P_CEF\n",
    "- aum_P_MF\n",
    "- aum_P_SMA\n",
    "\n",
    "After a data cleaning process a dataset with the relevant variables was saved (**_Nuveen Dataset_**). This dataset will be used to further processing throughout the `pipeline` processing.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MODEL BUILDING\n",
    "\n",
    "We come to a point where we have our data, We have processed or engineered our variables and we have already selected the features that we want to use, so now it is time to build the Machine Learning Model.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MACHINE LEARNING PIPELINE\n",
    "\n",
    "In a typical machine learning pipeline, we receive our data then we perform most likely affordably an extensive data analysis where we understand the variables and understand what we are trying to predict.\n",
    "\n",
    "Then we perform some feature engineering to leave the variables ready to be consumed by our model, we select the variables and train our machine learning models. Once we are happy with the machine learning model that we build and the performance that it shows we are able to put this model into production.\n",
    "\n",
    "So to this end we would like to build a **Pipeline** which is basically a `sequence of feature engineering steps` that we perform to the data in order to take it from raw to the engineered state and then we can use them to train our machine learning models or to score data with the model that we did.\n",
    "\n",
    "The pipeline has the characteristic that is clear to understand what the pipeline is doing, namely it is concise (small block of code that is reproducible). We can propagated it across our systems and is able to score new data very easily and therefore it is very easy to put into production.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ASSEMBLING A PIPELINE\n",
    "\n",
    "Thru the complete process to obtain a Machine Learning model, we applyed multiple feature engineering steps to tackle many aspects of the viables and next we built machine learning model with the already transformed data.\n",
    "The process as we have done follows more or less these procedure:\n",
    "\n",
    "- Impute the variables.\n",
    "- Encode the variables.\n",
    "- Transform the variables.\n",
    "- Scale the variables.\n",
    "\n",
    "In order to do this, we're going to use a series of **Transformers**\n",
    "\n",
    "Now let's say we want to transform our Train dataset. the data will follow each step to produce a dataset ready to be used by the Machine Learning model. Same case if we want to trasnform our Test dataset or a new dataset and basically we need to repeat these processes again for any data that we want to transform.\n",
    "\n",
    "As we can see the process is not complex but it could be made easier, we can assemble a `Pipeline` that contains all the feature engineering steps and if we want our machine learning model too.\n",
    "\n",
    "A `Pipeline` is an _object_ that allow us to combine all the `Transforming steps` within one block. What we need to do is we instantiate all the feature engineering steps that we performed within the pipeline.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "##IMPORTS SECTION\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
    "from sklearn.decomposition import PCA\n",
    "#REGRESSION MODELS\n",
    "from sklearn.linear_model import Ridge, Lasso, BayesianRidge\n",
    "from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor\n",
    "#CLASSIFICATIONS MODELS\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier\n",
    "#METRICS\n",
    "from sklearn.metrics import mean_squared_error, r2_score, roc_auc_score, classification_report, confusion_matrix\n",
    "\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "##TRANSFORMER: RARE LABEL ENCODER\n",
    "class RareLabelEncoder(BaseEstimator, TransformerMixin):\n",
    "\n",
    "    def __init__(self, threshold=0.05, variables=None):\n",
    "        \n",
    "        self.threshold = threshold\n",
    "        \n",
    "        if not isinstance(variables, list):\n",
    "            self.variables = [variables]\n",
    "        else:\n",
    "            self.variables = variables\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        \n",
    "        self.encoder_dict_ = {}\n",
    "        \n",
    "        for var in self.variables:\n",
    "            temp = pd.Series(X[var].value_counts() / np.float(len(X)))\n",
    "            self.encoder_dict_[var] = list(temp[temp >= self.threshold].index)\n",
    "\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        \n",
    "        X = X.copy()\n",
    "        \n",
    "        for feature in self.variables:\n",
    "            next_cat = self.encoder_dict_[feature][-1] + 1\n",
    "            X[feature] = np.where(X[feature].isin(self.encoder_dict_[feature]), X[feature], next_cat)\n",
    "\n",
    "        return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "##TRANSFORMER: LOGARITMIC TRANSFORMATION\n",
    "class LogaritmicTransformation(BaseEstimator, TransformerMixin):\n",
    "\n",
    "    def __init__(self, variables=None):\n",
    "        \n",
    "        if not isinstance(variables, list):\n",
    "            self.variables = [variables]\n",
    "        else:\n",
    "            self.variables = variables\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        #Method implemented as requirement by sklearn pipeline\n",
    "\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        \n",
    "        X = X.copy()\n",
    "        \n",
    "        for feature in self.variables:\n",
    "            X[feature] = np.log1p(X[feature])\n",
    "\n",
    "        return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "##TRANSFORMER: BINARIZATION\n",
    "class Binarization(BaseEstimator, TransformerMixin):\n",
    "\n",
    "    def __init__(self, bins=10, variables=None):\n",
    "        \n",
    "        self.bins = bins\n",
    "        \n",
    "        if not isinstance(variables, list):\n",
    "            self.variables = [variables]\n",
    "        else:\n",
    "            self.variables = variables\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        #Method implemented as requirement by sklearn pipeline\n",
    "\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        \n",
    "        X = X.copy()\n",
    "        \n",
    "        for feature in self.variables:\n",
    "            X[feature] = pd.qcut(X[feature],q=self.bins,labels=False,duplicates='drop')\n",
    "\n",
    "        return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "##TRANSFORMER: DISCRETIZATION + ENCODER\n",
    "class DiscreteEncoder(BaseEstimator, TransformerMixin):\n",
    "\n",
    "    def __init__(self, variables=None):\n",
    "        \n",
    "        if not isinstance(variables, list):\n",
    "            self.variables = [variables]\n",
    "        else:\n",
    "            self.variables = variables\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        ds = pd.concat([X,y], axis=1)\n",
    "        ds.columns = list(X.columns) + ['target']\n",
    "        self.encoder_dict_ = {}\n",
    "        \n",
    "        for var in self.variables:\n",
    "            temp = ds.groupby([var])['target'].mean().sort_values(ascending=True).index\n",
    "            self.encoder_dict_[var] = {k: i for i,k in enumerate(temp,0)}\n",
    "\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        \n",
    "        X = X.copy()\n",
    "        \n",
    "        for feature in self.variables:\n",
    "            X[feature] = X[feature].map(self.encoder_dict_[feature])\n",
    "\n",
    "        return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "##DATA LOADING\n",
    "df_nuveen = pd.read_csv('./data/Nuveen Dataset.csv')\n",
    "X = df_nuveen.drop(['sales_total','sales_12M','new_Fund_added_12M','sales_2019','Fund_added_2019'], axis=1)\n",
    "yreg = df_nuveen['sales_2019']\n",
    "ycls = df_nuveen['Fund_added_2019'].apply(lambda x: 1 if x > 0 else 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    7484\n",
       "1    2521\n",
       "Name: Fund_added_2019, dtype: int64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ycls.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "cls_0 = ycls.apply(lambda x: x if x==0 else np.nan).dropna()\n",
    "cls_1 = ycls.apply(lambda x: x if x==1 else np.nan).dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(cls_0)\n",
    "plt.hist(cls_1)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "##VARIABLES SELECTED AS PREDICTORS\n",
    "DISCRETE_VARS = ['no_of_sales_12M_1','no_of_sales_12M_10K','no_of_funds_sold_12M_1','no_of_fund_sales_12M_10K',\n",
    "                 'no_of_assetclass_sold_12M_1','no_of_assetclass_sales_12M_10K','No_of_fund_curr','No_of_asset_curr']\n",
    "\n",
    "CONTINUOUS_VARS = ['AUM','sales_curr']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# REGRESSION MODEL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "##SPLIT DATA INTO TRAIN & TEST\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, yreg, test_size=0.1, random_state=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_log_train = np.log1p(y_train)\n",
    "y_log_test = np.log1p(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "##PIPELINE ASSEMBLER\n",
    "regression_pipe = Pipeline(\n",
    "    [\n",
    "        ('rare_label_encoder', RareLabelEncoder(threshold=0.03, variables=DISCRETE_VARS)),\n",
    "        \n",
    "        ('log_transform', LogaritmicTransformation(variables=CONTINUOUS_VARS)),\n",
    "         \n",
    "        ('scaler', StandardScaler()),\n",
    "        \n",
    "        ('reg_model', Ridge(alpha=0.05, random_state=0))\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('rare_label_encoder',\n",
       "                 RareLabelEncoder(threshold=0.03,\n",
       "                                  variables=['no_of_sales_12M_1',\n",
       "                                             'no_of_sales_12M_10K',\n",
       "                                             'no_of_funds_sold_12M_1',\n",
       "                                             'no_of_fund_sales_12M_10K',\n",
       "                                             'no_of_assetclass_sold_12M_1',\n",
       "                                             'no_of_assetclass_sales_12M_10K',\n",
       "                                             'No_of_fund_curr',\n",
       "                                             'No_of_asset_curr'])),\n",
       "                ('log_transform',\n",
       "                 LogaritmicTransformation(variables=['AUM', 'sales_curr'])),\n",
       "                ('scaler', StandardScaler()),\n",
       "                ('reg_model', Ridge(alpha=0.05, random_state=0))])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regression_pipe.fit(X_train, y_log_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "y1_pred = regression_pipe.predict(X_train)\n",
    "y2_pred = regression_pipe.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE for Train:15.07133610703737\n",
      "RMSE for Train:3.882181874543923\n",
      "R2 for Train:0.5130636460879996\n",
      "\n",
      "MSE for Test:13.940477371516423\n",
      "RMSE for Test:3.7336948685606894\n",
      "R2 for Test:0.5519942914988312\n"
     ]
    }
   ],
   "source": [
    "##EVALUATION\n",
    "print('MSE for Train:{}'.format(mean_squared_error(y_log_train,y1_pred)))\n",
    "print('RMSE for Train:{}'.format(np.sqrt(mean_squared_error(y_log_train,y1_pred))))\n",
    "print('R2 for Train:{}'.format(r2_score(y_log_train,y1_pred)))\n",
    "print()\n",
    "print('MSE for Test:{}'.format(mean_squared_error(y_log_test,y2_pred)))\n",
    "print('RMSE for Test:{}'.format(np.sqrt(mean_squared_error(y_log_test,y2_pred))))\n",
    "print('R2 for Test:{}'.format(r2_score(y_log_test,y2_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(y2_pred, y_log_test)\n",
    "plt.xlabel('Prediction (Sales 2019)')\n",
    "plt.ylabel('Test (Sales 2019)')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm4AAAExCAYAAADFmC6sAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABTs0lEQVR4nO3dd3zV9d3//8crmyxIQkgCCVMQUJYg4qh74KhoW61YZwe11bZ2XK3t1V4dV69vra32V1vrqrtVq7UqjjpKHXWggCKyl4yQSQJJIDvn/fvjc4IhhpBAzvl8Tnjeb7dzOzmf+TrHY/LiPV5vc84hIiIiIsEX53cAIiIiItIzStxEREREYoQSNxEREZEYocRNREREJEYocRMRERGJEUrcRERERGJERBM3M5ttZmvMbL2Z3dDF/i+Y2bLw4y0zm7K/c80s28xeNrN14eesSL4HERERkaCIWOJmZvHAbcDZwERgrplN7HTYR8BJzrnJwP8Cd/Xg3BuABc65scCC8GsRERGRfi8hgteeCax3zm0EMLNHgTnAyvYDnHNvdTh+IVDYg3PnACeHj3sAeBX4QXeBDB482I0cOfKg3oyIiIhINCxZsmS7cy63q32RTNyGAVs7vC4Gjunm+C8B/+zBuXnOuVIA51ypmQ3p6mJmNg+YBzB8+HAWL17c6zcgIiIiEm1mtnlf+yI5xs262Nbl+lpmdgpe4tbectbjc/fFOXeXc26Gc25Gbm6XSauIiIhITIlk4lYMFHV4XQiUdD7IzCYDfwbmOOeqenBuuZkVhM8tACr6OG4RERGRQIpk4rYIGGtmo8wsCbgEmN/xADMbDvwDuNw5t7aH584Hrgz/fCXwdATfg4iIiEhgRGyMm3Ou1cyuA14E4oF7nXMrzOya8P47gP8BcoA/mRlAa7h7s8tzw5e+EXjMzL4EbAEuitR7EBEREQkSc65XQ8di0owZM5wmJ4iIiEgsMLMlzrkZXe3TygkiIiIiMUKJm4iIiEiMUOImIiIiEiOUuImIiIjECCVuIjGqsaWN55aVsmRztd+hiIhIlERyySsRiZDGljYuvvNtlhXXAPC9M8dx3aljfY5KREQiTS1uIjHophfWsKy4hpsvmsL5U4Zyy8trWVa80++wREQkwpS4icSYirpG/vLOZj4/o4jPTi/kfy84kuy0ZH7z4hq/QxMRkQhT4iYSY/6ycAstbSGuOXkMAAMHJHLlsSP4z7rtbKjc5XN0IiISSUrcRGKIc45nPijhuDE5jBqctmf73GOGkxBnPL642MfoREQk0pS4icSQVaV1fLR9N+dMKthr++D0ZI4dk8MLy0s5FJaxExE5VClxE4khC1aVA3DWEfmf2Df7yHw2VdWzprwu2mGJiEiUKHETiSELP6piQkEmg9OTP7Hv9Al5ALy+tjLaYYmISJQocROJEU2tbSzZvINZo7O73J+XmcKY3DTeWF8V5chERCRalLiJxIhlxTU0toQ4ZlTOPo85/rDBLPqomubWUBQjExGRaFHiJhIj3tnotaQdM6rrFjeAY0fn0NDSxvKSmmiFJSIiUaTETSRGvLtpB4fnZZCVlrTPY6YNzwJg6ZadUYpKRESiSYmbSAxwzrFiWw2TCwd2e1z+wBTyM1NYunVndAITEZGoUuImEgPKa5uo2t3MkcO6T9wAphYNUuImItJPKXETiQHLt3lj1o4YmrnfY6cOH8SW6nqqdjVFOiwREYkyJW4iMWB5SQ1mMKGgB4lb0SAAPijeGdmgREQk6pS4icSA5dtqGT04jbTkhP0eOyncnbp8W22kwxIRkShT4iYSA1aU1HDE0P2PbwNIS05gRE4qq8uUuImI9DcRTdzMbLaZrTGz9WZ2Qxf7x5vZ22bWZGbf67D9cDNb2uFRa2bXh/f9zMy2ddh3TiTfg4jfahpaKK1pZHxBRo/PmZCfyepSrVkqItLf7L/f5QCZWTxwG3AGUAwsMrP5zrmVHQ6rBr4JXNDxXOfcGmBqh+tsA57scMjvnHO/jVTsIkGyvmIXAGOH9DxxG1+QwYsry2hobmNAUnykQhMRkSiLZIvbTGC9c26jc64ZeBSY0/EA51yFc24R0NLNdU4DNjjnNkcuVJHg2hBO3A4bkt7jc8bnZ+IcrClXq5uISH8SycRtGLC1w+vi8LbeugR4pNO268xsmZnda2ZZBxqgSCxYX7mLpIQ4irIG9PicCeFu1dWlGucmItKfRDJxsy62uV5dwCwJOB94vMPm24ExeF2ppcDN+zh3npktNrPFlZWVvbmtSKCsr9jF6MFpJMT3/H/XoqxUUpPiWV2mFjcRkf4kkolbMVDU4XUhUNLLa5wNvOecK2/f4Jwrd861OedCwN14XbKf4Jy7yzk3wzk3Izc3t5e3FQmO9RW7GNOLblKAuDhjXF4Ga5S4iYj0K5FM3BYBY81sVLjl7BJgfi+vMZdO3aRmVtDh5YXA8oOKUiTAGlva2LqjnrG9TNwAxuSms3H7rghEJSIifonYrFLnXKuZXQe8CMQD9zrnVpjZNeH9d5hZPrAYyARC4ZIfE51ztWaWijcj9audLn2TmU3F63bd1MV+kX5jQ+UunOvdxIR2Y4ak8cR7xdQ1tpCRkhiB6EREJNoilrgBOOeeB57vtO2ODj+X4XWhdnVuPZDTxfbL+zhMkcDatL0egFGD03p97phcL9nbWLmbKeFlsEREJLZp5QSRANtcvRuAETkHnrhtqFR3qYhIf6HETSTAtlTVk5OWRHoP1ijtbEROKglxpsRNRKQfUeImEmCbq+oZkZN6QOcmxscxPDuVjZW7+zgqERHxixI3kQDbUl1/QN2k7UbnpqvFTUSkH1HiJhJQTa1tlNQ0MDz7wFrcwJtZuml7Pa1toT6MTERE/KLETSSgtlY34BwH3FUK3gSF5rYQxTsa+jAyERHxixI3kYDasmdG6cElbqCZpSIi/YUSN5GA2lzl1XA7qDFu4fpvH23XBAURkf5AiZtIQG2uqictKZ6ctKQDvsag1EQyUhL2JIEiIhLblLiJBNSW6nqG56RhZgd8DTNjRE4qm6uVuImI9AdK3EQCalPVbkYcxIzSdiOy09hSpa5SEZH+QImbSACFQo7iHQ0MP4iJCe1G5KRSvKNBJUFERPoBJW4iAVS1u5nm1hDDBg046GuNyEmlNeQorWnsg8hERMRPStxEAmjbTq/uWl8kbsOzvZmlmqAgIhL7lLiJBFBJOHEb2kctbuCNmRMRkdimxE0kgLaFVzoYlnXwiVt+ZgpJCXFs0cxSEZGYp8RNJIC27WwgPTmBzJSEg75WXJxRlDWAzWpxExGJeUrcRAJo284Ghg0acFA13DoamZOmMW4iIv2AEjeRACrZ2cDQQSl9dr3hOalsqa7HOddn1xQRkehT4iYSQCU7G/pkfFu7Edmp1De3sX1Xc59dU0REok+Jm0jA1De3sqO+pU9mlLZrX6he49xERGKbEjeRgCnpwxpu7dpXYNA4NxGR2KbETSRginf0feJWmDUAM7TYvIhIjFPiJhIwJTu9pan6coxbckI8+ZkpFO9Q4iYiEssimriZ2WwzW2Nm683shi72jzezt82sycy+12nfJjP70MyWmtniDtuzzexlM1sXfs6K5HsQibZtO+tJiDOGZPTdrFKAoqzUPa15IiISmyKWuJlZPHAbcDYwEZhrZhM7HVYNfBP47T4uc4pzbqpzbkaHbTcAC5xzY4EF4dci/UbJzkbyB6YQH9c3NdzaFWYNoFhdpSIiMS2SLW4zgfXOuY3OuWbgUWBOxwOccxXOuUVASy+uOwd4IPzzA8AFfRCrSGBs29HQpzNK2xVmDaCstpHm1lCfX1tERKIjkonbMGBrh9fF4W095YCXzGyJmc3rsD3POVcKEH4e0tXJZjbPzBab2eLKyspehi7in/ZVE/paYXYqIQdlNY19fm0REYmOSCZuXfXz9KZs+/HOuaPwulqvNbMTe3Nz59xdzrkZzrkZubm5vTlVxDdtIUdZbWNkErfwZIetmqAgIhKzIpm4FQNFHV4XAiU9Pdk5VxJ+rgCexOt6BSg3swKA8HNFn0QrEgCVdU20hRwFfbjcVbuiLK+Wm2aWiojErkgmbouAsWY2ysySgEuA+T050czSzCyj/WfgTGB5ePd84Mrwz1cCT/dp1CI+Kqv1ujHzM/s+cSsIT3jYWq2ZpSIisSohUhd2zrWa2XXAi0A8cK9zboWZXRPef4eZ5QOLgUwgZGbX481AHQw8aWbtMT7snHshfOkbgcfM7EvAFuCiSL0HkWgrDydueRFI3BLi41TLTUQkxkUscQNwzj0PPN9p2x0dfi7D60LtrBaYso9rVgGn9WGYIoERycQNoCh7gGq5iYjEMK2cIBIgZTWNJMQZOWlJEbl+YVaqJieIiMQwJW4iAVJe28SQjGTi+rj4bruirFTKa5toam2LyPVFRCSylLiJBEh5bSN5AyPTTQoflwRpXw9VRERiixI3kQApq22MyIzSdntquWnpKxGRmKTETSRAymsbIzYxAaAou72WmyYoiIjEIiVuIgFR39xKXWNrRBO3vMwUEuJMExRERGKUEjeRgGhfQzR/YHLE7hEfZwwdpJIgIiKxSombSECU1zYBkJcRuRY3aK/lphY3EZFYpMRNJCD2FN+N4KxSgMJBqVr2SkQkRilxEzkYLY1QWwrOHfSlyiK8akK7ouwBbN/VRGOLarmJiMQaJW4iB6JhBzx9LfxqGNwyHu46Gba+e1CXLK9tJD05gfTkiK5ER2FW+8xSdZeKiMQaJW4ivdVYAw/OgaWPwPSr4IxfQH01PPBp2PDKAV/WKwUSuYkJ7fbUctMEBRGRmKPETaQ3nIOnr4PyFTD3UTj3Zjj+WzDvFcgeDX//ItRsO6BLl9U0kh/h8W2gWm4iIrFMiZtIb6x8ClbNh1N/DOPO/Hh72mC4+CFobYLnv3dAly6vbYr4jFKA3PRkkhLiKNbqCSIiMUeJm0hPtTbDyz+FvElw7Dc+uX/wYXDSf8Ga52Hja726dCjkqKiL7Dql7eLijELVchMRiUlK3ER6aulfYOdmOP2nEL+PCQTHfA0GFsGrv+rVpavrm2lpcxFdp7SjYVmq5SYiEouUuIn0RCgEb98GQ4+Cw07f93GJKXDsdbDl7V7NMm1fNSEakxPAm1mqyQkiIrFHiZtIT2z4N1Sth1lfB7Pujz3qckgZBO/c0ePLV9RFp4Zbu6LsAVTvbmZ3U2tU7iciIn1DiZtITyy5D9KGwMQ5+z82KQ0mXwyrnoWGnT26fFmNt9xVNGaVAhRlaWapiEgsUuImsj/11bD2RZh0ESQk9eycqZdCWxMsf6JHh5fVNmIGg9Oj1VUaruWmmaUiIjFFiZvI/qx8GkItXitaTxVMhSETYenDPTq8oraRwenJJMZH53/J9lpuWzVBQUQkpihxE9mfZY/B4HFQMKXn55h5rW7bFkPVhv0eXlbbGLUZpQA5aUkMSIzXYvMiIjFGiZtId2q2wZa3YNLF+5+U0Fn7eLjVz+330LKa6Cx31c7MKFRJEBGRmBPRxM3MZpvZGjNbb2Y3dLF/vJm9bWZNZva9DtuLzOwVM1tlZivM7Fsd9v3MzLaZ2dLw45xIvgc5xK19wXueeH7vzx00HPIn9yhxq6hritqM0nZF2SoJIiISayKWuJlZPHAbcDYwEZhrZhM7HVYNfBP4baftrcB3nXMTgFnAtZ3O/Z1zbmr48Xxk3oEIXuKWNdLrKj0Q48+Dre/Arop9HtLU2kb17uaodpUCFGUNoLi6HudcVO8rIiIHLpItbjOB9c65jc65ZuBRYK9aCs65CufcIqCl0/ZS59x74Z/rgFXAsAjGKvJJzbu9pavGnd37btJ2488FHKz55z4Pqaj1SoFEu8WtMCuVuqZWahtUy01EJFZEMnEbBmzt8LqYA0i+zGwkMA14p8Pm68xsmZnda2ZZ+zhvnpktNrPFlZWVvb2tiJe0tTXB4bMP/Bp5R3hdpu1drl0orw0X341SDbd2RdnhkiAa5yYiEjMimbh11UTRqz4ZM0sHngCud87VhjffDowBpgKlwM1dneucu8s5N8M5NyM3N7c3txXxrH0BkjNh+HEHfg0zGHMafPQfaGvp8pCycOIW7a7SwnARXtVyExGJHZFM3IqBog6vC4GSnp5sZol4SdtfnXP/aN/unCt3zrU550LA3XhdsiJ9b+OrMOrEnhfd3Zcxp0BzHWxb0uXuaK9T2k613EREYk8kE7dFwFgzG2VmScAlwPyenGhmBtwDrHLO3dJpX0GHlxcCy/soXpGPVX8EOzfDqJMO/lqjTgSLgw2vdLm7oq6J5IQ4Bg5IPPh79cLAAYlkpCRo2SsRkRgSscTNOdcKXAe8iDe54DHn3Aozu8bMrgEws3wzKwa+A/zYzIrNLBM4HrgcOLWLsh83mdmHZrYMOAX4dqTegxzCPnrNex7dB4nbgCwYOs1bqL4LXg23FOxAJ0AchKKsVHWViojEkIRIXjxcquP5Ttvu6PBzGV4Xamdv0PUYOZxzl/dljCJd2vgapOcfeBmQzsacCv+5BRprIGXgXruivWpCR0XZA9hQuduXe4uISO9p5QSRzkIh+Oh1r7Wtr1rBRp0Erg22LPzEroraxqjPKG1XmJVK8Q7VchMRiRVK3EQ6q1wF9dv7Znxbu8IZEJcIm9/aa7NzjrLaRvIyojsxoV1R1gAaW0Js39Xsy/1FRKR3lLiJdLblbe95xEGUAekscYA3zq392mG1Da00toTI96nFTTNLRURiixI3kc62vAPped5SV31pxLGw7T1o+XgWZ3ldeykQ/7pKQbXcRERihRI3kc62LIThs/pufFu74cdBqGWvem4f13DzK3HzVk9QSRARkdigxE2ko5ptULMFimb1/bWHHwPYXuPc/Fo1oV1acgI5aUkUq6tURCQmKHET6WhreNbn8AgkbgOyYMjEvRK3inDiNiTKqyZ0VJidytZqtbiJiMQCJW4iHW1ZCIlpkD85MtcfcRwUL4K2VsBrcRuUmkhKYnxk7tcDhVkD1OImIhIjlLiJdLRlIRROh/gI1aYecSw074LyDwEoq2nyrZu0XVFWKtt2NtAWUi03EZGgU+Im0q6pDsqXw/BjI3ePwqO95+LFAFTUNfo2MaFdUfYAWtoc5eFuWxERCS4lbiLtti0BF4KimZG7x8AiSMv1yoLQvk6pf+PbQCVBRERiiRI3kXbhZIqhR0XuHmYwbAZsW0xrW4jtu4LQVaqSICIisUKJm0i7bUsgezSkZkf2PsOmw/a1VFVtJ+TwbZ3SPeGEEzetniAiEnxK3ETalbzvJVWRVujdo27juwDkZfibuCUnxJOXmaySICIiMUCJmwhAbSnUbotsN2m78D1CW70JCn6tU9rR8OxUjXETEYkBStxEAErC49ui0eI2YBDkjGVAxfuAf8tddTQiJ43N1bv9DkNERPajR4mbmT1hZueamRI96Z+2vQcWD/mTonO/whlk7VxGQhzkpCVF557dGJmTSnltE/XNrX6HIiIi3ehpInY7cCmwzsxuNLPxEYxJJPq2LYG8iZCUGp37DZtOeks1k9LriIvr48XsD8CInDQANlepu1REJMh6lLg55/7lnPsCcBSwCXjZzN4ys6vNLDGSAYpEnHNeV2k0xre1C3fJHpuyOXr37MbIPYmbuktFRIKsx12fZpYDXAV8GXgf+D1eIvdyRCITiZbqjdBYE53xbe3yjqSZRKba+ujdsxsjBnstjZvU4iYiEmg9WpDRzP4BjAceAj7tnCsN7/qbmS2OVHAiUbFtifc8LIotbglJrHIjGde2Nnr37EZmSiI5aUlqcRMRCbierqT9Z+fc8x03mFmyc67JOTcjAnGJRM+29yBhAOROiNotdze1srRtJHMb3oJQCOL8n/czIieVTdvV4iYiEmQ9/Wvxyy62vd2XgYj4puQ9KJgM8T39d8zBK69tZLkbRVLbbtjxUdTu252ROWlqcRMRCbhuEzczyzez6cAAM5tmZkeFHycD+51+Z2azzWyNma03sxu62D/ezN42syYz+15PzjWzbDN72czWhZ+zevpmRT4h1AZly6FgSlRvW1bbyIrQSO9F6dKo3ntfRuSkUVLTSGNLm9+hiIjIPuyvxe0s4LdAIXALcHP48R3gR92daGbxwG3A2cBEYK6ZTex0WDXwzfA9enruDcAC59xYYEH4tciBqd4ILbujnriV1zayzhXi4pKg9IOo3ntfRoYnKGgFBRGR4Oq2b8g59wDwgJl91jn3RC+vPRNY75zbCGBmjwJzgJUdrl8BVJjZub04dw5wcvi4B4BXgR/0MjYRT3vSlD85qrctq2mihQRCQyYQX7I0qvfel/Zabpuq6hmbl+FzNCIi0pVuEzczu8w59xdgpJl9p/N+59wt3Zw+DNja4XUxcEwP4+ru3Lz2Wa3OuVIzG7KP2OcB8wCGDx/ew9vKIadsGcQlQm50a0qX1zaSkZxA/NCpsPJpr5ac+VuId2SO1+KmcW4iIsG1v67StPBzOpDRxaM7Xf0Vcj2M62DO9Q527i7n3Azn3Izc3NzenCqHktJlMGQCJER32amymkbyBqbA0KnQuBN2bonq/bsyKDWJgQMS2aTETUQksPbXVXpn+PnnB3DtYqCow+tCoKQPzi03s4Jwa1sBUHEAsYl4rVxly+Dws6N+69LaRgoGpnw8tq70A8gaEfU4OhupkiAiIoHW00XmbzKzTDNLNLMFZrbdzC7bz2mLgLFmNsrMkoBLgPk9jKu7c+cDV4Z/vhJ4uofXFNlbbQnUV0F+dCcmAJTXNJKXmQJDjvAWtw/MBIU0tbiJiARYT+u4nemcqwXOw2sNGwf8V3cnOOdageuAF4FVwGPOuRVmdo2ZXQN7yo0U481S/bGZFZtZ5r7ODV/6RuAMM1sHnBF+LdJ7Zcu854LoTkxobQtRuauJ/MwUSEzxumqDVBJkZwNNrSoJIiISRD2tONq+kPw5wCPOuWrrwUDq8GoLz3fadkeHn8vwukF7dG54exVwWg/jFtm30mWAQd6RUb3t9l3NtIUc+QNTvA0FU2Dti4GZoBByULyjgTG56b7GIiIin9TTFrdnzGw1MANYYGa5QGPkwhKJgtIPIGcMJEc3QSmr9f7Xyc9sT9ymQv12qCvd90lRMnKwNx/po0p1l4qIBFGPEjfn3A3AscAM51wLsBuvnppI7CpbFvX6beDNKAX2bnGDQIxza29l21C5y+dIRESkK71ZnHECXj23juc82MfxiERHfTXUbIWjvxz1W5fVNAB4kxMA8o8EzEvcfJjh2tHAAYnkZiSzvkKJm4hIEPUocTOzh4AxwFKgfdSyQ4mbxCqfJiYAlNU2kRhv5KSFa8clpcHgcRCQFRTG5KaxXi1uIiKB1NMWtxnAROdcr4rgigRWaThx86MUSG0jQzJSiIvrMBGhYApsfjPqsXTlsCHpPL20BOccPZmEJCIi0dPTyQnLgfxIBiISVWXLIHMYpOVE/9Y1jR+Pb2tXMBlqt8Hu7VGPp7PDctOpa2ylcleT36GIiEgnPU3cBgMrzexFM5vf/ohkYCIRVerPxATwZpV+MnELzgSFw4Z4q9lpnJuISPD0tKv0Z5EMQiSqmuuhah0ccUHUb+2co6ymkVPHD9l7R/4k77n0AzjM3zKFhw0Jzyyt2MVxYwb7GouIiOytR4mbc+41MxsBjHXO/cvMUoH4yIYmEiHlK8CFfGlxq21spaGl7eMabu0GZMGgER9PmvBRXmYy6ckJanETEQmgnq5V+hXg78Cd4U3DgKciFJNIZJWFuyP9mFHauYZbRwWTA9FVamaMyU1jg4rwiogETk/HuF0LHA/UAjjn1gFDuj1DJKhKl0HKIBhYFPVb71k1ocvEbQpUb4TG2ihH9UljhqSrxU1EJIB6mrg1Oeea21+Ei/CqNIjEprJlXpLkQ6mL8ppOy1111F6apOzDKEbUtcOGpFNW20hdY4vfoYiISAc9TdxeM7MfAQPM7AzgceCZyIUlEiFtLVC+0pduUoDScOI2JDP5kzvbYwrAOLfD9ix9pe5SEZEg6WnidgNQCXwIfBV4HvhxpIISiZjKNdDW5EvhXfC6SnPSkkhO6GJuT0Y+pOd9XBzYR+0zS9eV1/kciYiIdNTTWaUhM3sKeMo5VxnZkEQiqL0b0qcWt/Laxo/XKO1KfjAmKIzISSM5IY41ZUrcRESCpNsWN/P8zMy2A6uBNWZWaWb/E53wRPpY2TJIGAA5h/ly+9KaRgq6mpjQrmAKVK6GlsboBdWF+Djj8PwMVitxExEJlP11lV6PN5v0aOdcjnMuGzgGON7Mvh3p4ET6XNmHkHcExPlThrC8tpG8bhO3yeDaoGJF9ILah/H5Gawu83+Gq4iIfGx/idsVwFzn3EftG5xzG4HLwvtEYodz4Rml/nSTNra0Ub27uesZpe32LH3l/zi3CQWZbN/VTEWdv61/IiLysf0lbonOuU+seh0e55YYmZBEImTnZmis+Xh5qSirqPUWbe+yhlu7QSMgZWAgxrmNz88EYHWpuktFRIJif4lb8wHuEwme9okJPs4ohX3UcGtn5k1QCEBJkPH53mLz6i4VEQmO/c0qnWJmXf3WNqCbvz4iAVS6DCwOhkzw5fbdrprQUcEUWPRnaGuF+B5N/I6IrLQk8jNTWKUWNxGRwOj2r4JzTgvJS/9R9iEMHgdJqb7cvnRnA9CDxC1/MrQ2wva1kDcxCpHt24SCDFaVqsVNRCQoelqAVyT2lS3zkiKflOxsICMlgcyU/QwPbZ+gEITu0oJMNlTuork15HcoIiKCEjc5VOyugtptvk1MANi2s5Fhgwbs/8DBY71acwGYoHDE0Exa2hxrtYKCiEggRDRxM7PZZrbGzNab2Q1d7DczuzW8f5mZHRXefriZLe3wqDWz68P7fmZm2zrsOyeS70H6ifbWK59KgYDX4ja0J4lbXDzkHxmIkiCThw0C4IPinb7GISIinoglbmYWD9wGnA1MBOaaWecBO2cDY8OPecDtAM65Nc65qc65qcB0oB54ssN5v2vf75x7PlLvQfqR9sTNz67SmgaGDurhnJ72maUhf7soi7IHkJWayLKtNb7GISIinki2uM0E1jvnNjrnmoFHgTmdjpkDPOg8C4FBZlbQ6ZjTgA3Ouc0RjFX6u7IPIbMQUrN9uX19cys761t61uIG3ji3plrYuSmice2PmTGpcJBa3EREAiKSidswYGuH18Xhbb095hLgkU7brgt3rd5rZlld3dzM5pnZYjNbXFlZ2fvopX8pXebr+LaSnV4pkB6NcYOPu3QDMM5tSuFA1lXsoqG5ze9QREQOeZFM3KyLba43x5hZEnA+8HiH/bcDY4CpQClwc1c3d87d5Zyb4ZybkZub24uwpd9proeqdb6PbwMoGNjDxG3IRIhLCMY4t8JBtIUcK0rUXSoi4rdIJm7FQFGH14VASS+PORt4zzlX3r7BOVfunGtzzoWAu/G6ZEX2rWIluJDvpUCAno9xS0iG3AmBaXED+KBYiZuIiN8imbgtAsaa2ahwy9klwPxOx8wHrgjPLp0F1DjnSjvsn0unbtJOY+AuBJb3fejSr7QnP752lTYQZ5DX3XJXnRVM8SYouM4N1dE1JDOF/MwUlmmcm4iI7yK2no5zrtXMrgNeBOKBe51zK8zsmvD+O4DngXOA9XgzR69uP9/MUoEzgK92uvRNZjYVr0t1Uxf7RfZW9qG3cPug4b6FsG1nI3mZKSTG9+LfSgWTYelfoK4MMjvP2YmuKUUDeW/LDl9jEBGRCCZuAOFSHc932nZHh58dcO0+zq0HcrrYfnkfhyn9XfuKCdbVkMro6HENt47yO0xQ8DlxmzkqhxdXlFNa09DzcXoiItLntHKC9G9trVC+wtfxbdBew623iduRgAVi6auZI70yKu9+VO1zJIc457zJNo013rOIHHIi2uIm4ruq9d6C7T6ObwuFHKU7G5l9ZC/GtwEkZ0DOmEBMUJhQkEF6cgLvflTNnKmdK/ZIxFSsho2vwtZ3vH+A7NwCrQ0f70/KgEFFMHQaFM2EcWdDRp5v4YpI5Clxk/6t7EPv2cdSIFW7m2luC/W8hltHBVNg66K+D6qXEuLjmD4ii0Wb1OIWcbu3w5L7YdljsH2Nt21gkfddOOx0SM+FuERoa4ZdFVC9Ada+CEv/ClwPI0+Ao78M48+DeP2KF+lv9H+19G9lH0B8Mgwe51sIe0qBHMjYsPzJsPwJqK/2bdWHdjNHZfObF9dQvbuZ7LQkX2Ppl6o2wH9ugQ8fh7YmGHECzPwKjJvttap1xzmv7M2qZ2Dpw/D4ld5knFN/Akd+DuI0Kkakv1DiJv1b6TIYMgHiE30L4eMabgfY4gbeOLfRJ/ddUAdg5igvcVy0qZqzjsj3NZZ+pa4MXvs1vPeg15I27TKYOQ+GjO/5Ncwg7wjvceJ/wZrn4bWb4B9fgbdvg0//HoZOjdhbEJHo0T/DpP9yzkt4fOwmBdjW2+K7HbUnbgEY5za5cCApiXG8tX6736H0D6E2ePdu+MMML2mbfhV86wM475beJW2dxcXDhE/DvNfgwru8xPDuU+FfP4fW5j4LX0T8oRY36b92boaGHd7AbR8V72ggLSmegQMOoNUvNdsb3xSApa+SE+I5dnQOr67V2r8HrXwlPPNNKF7ktaSee4s3EaUvxcXBlM/DuDPhxR/DG7fApjfgovthoCaYiMQqtbhJ/1XyvvdcMNXXMIp31FOUnYodaB25/MmBKAkCcPLhQ9hcVc9H23f7HUpscg4W3g53nQTVG70Wscuf6vukraMBWXDBbfC5e71xcHd+Cja+Frn7iUhEKXGT/qtkqTdmKO8IX8PYWt1AYVbqgV+gYDJsXwdNu/ouqAN08uG5ALy6psLnSGLQrkp4+GJ44QYYcypc+67XIhatwtBHfha+8gqk5cJfPgMf/C069xWRPqXETfqvkve9pC0h2bcQnHNsqa5nePbBJG5TAOfV8fLZiJw0Rg9O49U16i7tla3vwh0neC1d5/wW5j4KaYOjH0fuOPjSSzD8WHhyHvznZt/XwhWR3lHiJv2Tc16Lm8/j26p2N9PQ0kZR9kEsE9Vx6asAOOnwXBZurKKhuc3vUGLDkvvhvnMgMQW+8m+vxIePy6+RMhAuewImXQQLfuE9lLyJxAwlbtI/VW+EphrfSyBsrfaWJSo6mK7SzKGQOtirSRcAp43Po6k1xOvr1OrWrdZmeOZb3mPUiV43Zf6RfkflSUj2xtdNv9qbtKDkTSRmaFap9E+lS71nn1vctu7wSoEUHUxXqZk3zi0gLW6zRmeTlZrIc8tKVc9tXxp2wN8uh03/gRO+7RXCjYv3O6q9xcV5s1nBS94ATvsff1sDRWS/lLhJ/1TyvrdiQu4EX8PY0+J2MF2l4M2MfetWaGmAxIO81kFKiI9j9pEFPL10G40tbaQkBiwh8duOTfDXi7znz9wNky/2O6J965y8JaV6BXxFJLDUVSr9U8nS8MQEf5dm2lpdz+D0JFKTDvLfSIUzINQaiHpuAJ+eXEB9cxuvrNbs0r0UL4E/n+6tIXr5k8FO2tq1J2+TLoZ//9IrBiwigaXETfqfUMjrVvS5mxRg6476gysF0m7YdO952+KDv1YfOGZ0DnmZyTy+pNjvUIJj9XNw/7mQmApfetlb7D1WxMXBnNu8MiXPfAvW/NPviERkH9RVKv1P9UZoqg1G4lbdwJSiQQd/oYx8yCyEbUsO/lp9ID7OuGh6EX96dT2lNQ0UDPS3+7avNTS38d6WHawtr2Nj5W5qGlpoam0jOSGewenJjMtLZ0rRIMbnZ3iFlZc8AM9e733n5v4N0nP9fgu9l5AEFz8ED5wHj18FVz3ntfSKSKAocZP+p33FBJ8Tt9a2ECU7G/j0lIK+uWDhdCgORosbwOePLuKPr6znsUXFfOv0sX6Hc9Aq65qY/0EJL68s473NO2luCwGQkZJATloSyQnxNLa2UVnXRH24FMqwQQP439x/cerW2+Cw0+HiByEpzc+3cXCS0+HSx+Ge0+HRS73yJQML/Y5KRDpQ4ib9T8n7kJACuQexUHcfKK1ppDXkDq4USEfDZsDKp2H3dn+Kt3ZSlJ3Kp8YO5q/vbOaak0eTnBB7kxRCIceC1RU88u4WXltbSVvIMT4/g6uOH8mxY3I4cuhABqcn7bVcWSjk2Lqjnnc2VJHxxi85devfeKbtWN5K+iHfboxniL/DKg9eeq7XanjPGfDIJfDFF2M7GRXpZ5S4Sf9TuhTyJ0G8v1/vrTvaZ5T2VeIWHudWvBgOn9031zxIXz1xDJfd8w5PvreNS2YO9zucHmtobuPv7xVz7xsf8dH23eRnpjDvxNF8ZtowxuZldHtuXJwxIiuFEWW/gdq/sWvylSxN+Ap/f2crTy9/le+cMY4vHj+KuLgYLqsxZLy3tunDF8M/5nldqHEaEi0SBPo/UfqXUFsgVkwAKK4O13Drqxa3oVPB4gMzzg3g+MNyOGJoJne9vpHWcNdikG3f1cTNL63huBsX8JOnlpORksCtc6fxxg9O4Qezx+83aQOgtQn+frU3+/LE/yL9wt/zk/Mn8a/vnMSxo3P45XOr+MKf36FkZ0Pk31AkjT0Dzvw/WP0svPJLv6MRkTC1uEn/UrESWnZD4dF+R8LWHfXExxkFg1L65oJJaTBkYmBmlgKYGd84dSzX/GUJjy8pZm5AW922Vtfz5/9s5NFFW2luC3H6hDy+fMIoZo7K3qsbdL+adsHfLoONr8BZ/w+OvXbPrhE5afz5yhk8tngrP39mJZ/+wxvccfl0jh6ZHYF3FCWzvgaVq7w1TYdOgwmf9jsikUOeEjfpX4oXec8BmA23pbqegoEpJMb3YcP2sKNg5VNeyZOAdF2ddUQeM0ZkccvLazl/ylDSkoPza2VteR13vLqBpz8oIc7gwmnDmHfiGA4bkt77i9VXe4V1S96HC26HqZd+4hAz4/NHD2fGyGy+/MBiLr17If934SQunlHUB+/GB2Zwzm+hbDk8+TWvoPXgw/yOSuSQFtHf/GY228zWmNl6M7uhi/1mZreG9y8zs6M67NtkZh+a2VIzW9xhe7aZvWxm68LPWZF8DxJjihd763pmjfI7Ej7avptRg/t4UHfhDGisgeoNfXvdg2Bm/OjcCWzf1cRNL6z2OxyccyzaVM2XH1jMmb97nRdWlHHVcSN5/funcNPnphxY0lZX7tVoK/sQPv9Ql0lbR2Ny03nq68dzzKgcvv/3Zfz5PxsP8N0EQEKyN1s2PtFrbWze7XdEIoe0iCVuZhYP3AacDUwE5prZxE6HnQ2MDT/mAbd32n+Kc26qc65j88kNwALn3FhgQfi1iGfru143qc/rLTrnIpO4DQv/rxCgsiAARw3P4spjR/LA25t5a/12X2JoaG7j0Xe3cM6tb3DRHW+zeHM1158+ljd/cCo/OW/igdea27kF7psNOzbDFx6D8ef26LSBqYnce9XRnDupgF8+t4rfvbwWF6sLuQ8q8iYrbF8D87+pBelFfBTJPo2ZwHrn3EYAM3sUmAOs7HDMHOBB5/02W2hmg8yswDlX2s115wAnh39+AHgV+EEfxy6xqL4aqtbBlEv8joSq3c3UNbYyMqePE7fcwyE5E7a+A1Pn9u21D9L3Zx/O6+sq+cYj7/P0dcf3zYoRPbCqtJa/Lynm70uKqWloYXx+Bjd+ZhJzpg5jQNJBliip2gAPnA9NdXDFU1A0s1enJyXEcevcaaQmxfP7BetoCzm+d9bhBxeTX8acAqf+GBb8wvvH0axr/I5I5JAUycRtGLC1w+ti4JgeHDMMKAUc8JKZOeBO59xd4WPy2hM751ypmQ3p6uZmNg+vFY/hw4M5YFr62Lb3vOde/nGNhE3bve6kUbl9nLjFxXvvb8vCvr1uH0hNSuDuK2ZwwW1vcvV9i/jrV45hSEYfTczopKKukflLS3jivW2sKq0lMd44Y2IeVx47svcTDvalfCU8OAdcG1z1DBRMOaDLxMcZv/7sZBLijT++sp7U5Hi+fnKMjhM7/tveeqwv/bc3y3n4LL8jEjnkRDJx6+o3Z+f29e6OOd45VxJOzF42s9XOudd7evNwoncXwIwZM9SufygoXgQWF4hSIBvDidvovu4qBe+P5b9/6bUwpgZrxuKY3HTuvmIGX7x/EZfcuZC7rpjOYUN6UGKjBzZX7ealFeW8tLKMxZt34BxMKRrEL+YcwXmTh5Kd1oeVb7e9B3/5jFfI+YpnvZbOgxAXZ/zygknUN7dx0wtrSEtK4MrjRvZNrNEUFwcX3g53ngR//yJc80bgvoMi/V0kE7dioONUqkKgpKfHOOfanyvM7Em8rtfXgfL27lQzKwAqIhS/xJrid71yGcl9kygcjE3bd5MQZwwbFIE1PIcf6z1vfTcwhXg7mjU6hwe/OJOvPrSE8//4Jt8983CuOHZEr2fX7mpqZdFH1by1YTuvr93OmvI6ACYUZPKNU8dy/pShBzbRYH82vwV/vRhSs+CK+ZDdNxNd4uOM3140hfrmNn46fwUDkuJjc7ZpykC46H5vZYUnr4G5jwZmhrPIoSCSidsiYKyZjQK2AZcAnadizQeuC49/OwaoCSdkaUCcc64u/POZwC86nHMlcGP4+ekIvgeJFaGQ14Vz5Gf8jgTwZpQOz0kloS9LgbQbNh3iEmHLW4FM3ABmjMzmuW9+iu8/sYz/fXYld7y2gYumF3Ly4UOYXDiQlMSPx54559hZ30LxjgZWldayvKSGZcU1fLithraQIykhjunDs/jJeRM5c2Je361E0ZX1C+DRL3jrc17xNAwc1qeXT4yP44+XTuPLDyzmhieWMXBAImcdkd+n94iKoVO94rz//C94+49w/Df9jkjkkBGxxM0512pm1wEvAvHAvc65FWZ2TXj/HcDzwDnAeqAeuDp8eh7wZHicSgLwsHPuhfC+G4HHzOxLwBbgoki9B4khVeugqSYQhXchXAqkrycmtEsc4HUHB3CcW0f5A1N44OqjeX3ddh54axN3vLaBP73qlTHJSk1kQGI8bc5R29BKQ0vbnvPSkuI5YuhAvnbSGI4bk8NRI7L2SvQiZtWz3ooIgw+Hy5/01uyMgOSEeO64bDpf+PM7fOOR93ng6pkcOyYnIveKqJlfgU2vw4Kfe63ARcH4f0+kv7OYnZ7eCzNmzHCLFwerfIL0sfcegvnXwbWLIHecr6GEQo6JP32By44ZwY/P61wBp4+89BNYeDv8cKuXyMWA6t3NLNm8g1WltVTUNdLYEiIhzkhLTmDooAEMG5TCuLwMRuakRX+dz2WPed1+Q6fBZX+HAZEvD7ljdzMX3fk2ZTWNPDpvFkcOGxjxe/a5hp1w54ngQvDV1zXeTaSPmNmSTqXQ9ghOiXORg7FlIQzIhhz/Z+uV1XpJychITExoN/xYeOtWr4r/iOMid58+lJ2WxBkT8zhjYp7foext8X3w7Ldh5Akw95GojZHMSkvioS/N5HO3v82V977L49ccy+jcCIzZi6QBg+Ci++Ces+Dpa+GSh32voSjS32lEqfQPm9/0EpgADJLeFMkZpe3ayzBsfity9zgUvPVHePZ6b0H1Lzwe9YktBQMH8NCXZuKAy+95l7Kaxqjev08Mmw5n/ALWPO+1AotIRPn/V07kYNWWwo6PAtPytL5yF0BkW09SsyF3fODHuQWWc/DqjV49sokXwOf/6luX8+jcdB64eiY765u5/J532Fnf7EscB2XW1+Dwc+Hl/4FtS/yORqRfU+ImsW9LuNWpvUyGz9aV7yIjJYG8zOTI3mj4LG8FhVDb/o+VjzkHL/0YXv0VTP0CfPYeSOjDGnAHYFLhQO6+cgabq+q5+v5F1De3+hpPr5nBnD9CRj48fpU39k1EIkKJm8S+zW9BUjrkT/Y7EgDWltcxLi+jb6r3d2fkp6CpFkqXRvY+/Uko5I1ne/uPMHMenP9HiA/GUN/jxgzm1rnT+GDrTq75y3s0t4b8Dql3UrPhc/dBbYk3UegQmPgm4gclbhL7Nr8FRccE5g/wuopdjI1EYdjORp3oPW98LfL36g/aWuGpa2DJfXDCt+HsmwIxJrKj2Ufm86vPTOL1tZV89/EPCIViLPkpOhpO+ymsegbevWv/x4tIrwXrt5ZIb9VXQ8VKGBGMbtKqXU1U725mbF4UBrmnD/FWivhIidt+tTbB41fCsr/BqT+B038W2NmPnz96ODecPZ5nPijhZ8+sIOZKNh17HYybDS/+t8a7iUSAEjeJbe2D80cc728cYWvLvYkJUWlxAxh1kvcZtMTgbMRoaa6HRy6B1c/C7F/Did/zO6L9uuakMcw7cTQPvr2ZG/+5OraSt7g4uOB2jXcTiRAlbhLbNr0B8ckw9Ci/IwFgXYW3nua4aLS4AYw+GVobvUkK8kmNtfCXz8KGV7zxbLOu8TuiHvvh2eO5fNYI7nx9Iz96cjltsdRt2nG829PXarybSB9S4iaxbeOrXjdpYorfkQDhGaXJUZhR2m7EcWDx6i7tSn01PDgHit+Fz90DR13ud0S9Ymb8Ys4RfP3kMTzy7ha++ej7NLbE0AzioqPh9J97LZ3v3OF3NCL9hhI3iV115VCxwmt1Coi15XWMzUuP/IzSdimZXgFUTVDYW1053H8ulK+Az/8Fjvys3xEdEDPj+7PH86NzxvPcslI+f9dCymtjqFv82Gvh8HO8JdqKNd5NpC8ocZPY9dHr3nOAErd1Fbui103abvTJUPIeNOyI7n2DaudWuO9s2LEZvvAYHH623xEdtHknjuGOy6azrryOT//hDZZsjpH/1mYw5zbIKAiPd4uRuEUCTImbxK6Nr3qLgQekfltFXWP0ZpR2NPYMb5Hv9Quie98gqtrgJW27t8PlTwYqqT9Ys4/M5x9fP47kxDguvvNtbnl5LS1tMVDrLTXbW8+0rhSe0ng3kYOlxE1ik3Ne4jbyUxAX73c0AKwoqQXgiKGZ0b3xsOmQmgPrXorufYOmfKWXtLXUw5XzYfgxfkfU58bnZ/LcNz/FnKlDuXXBOs7/45u8s7HK77D2r3BGeD3T52Dhn/yORiSmKXGT2FS1AWqLA9WisjKcuE2MduIWFw+HnQ7rXj50l7/a9h7cfw5gcNXzMHSq3xFFTGZKIrdcPJU7LjuKmvpmPn/XQq55aAkfFtf4HVr3Zn0Nxp/nrWdavNjvaERilhI3iU0bX/GeA5S4rSipYXh2KpkpidG/+dgzoaH60Cx4uvlteOB8SM6AL74AQ8b7HVFUzD6ygAXfPZnrTx/Lm+u38+k/vsHcuxbyxJJidjcFcK3T9vVMM4d6493qq/2OSCQmKXGT2LTuZRg0ArJH+x3JHitKajlyWJRb29oddppXFmTti/7c3y8b/g0PXegVe736Bcge5XdEUTUgKZ7rTx/Hmz88lR/MHs/WHfV89/EPmPa/L3Pp3Qv5w4J1/GtlOVur64OxfNaALLjofqgrgyev8daOFZFeCcbijiK90Vzv1S2bflVgli2qbWxhc1U9F88o8ieAAVneeq1rX4TTfuJPDNG26ln4+9Uw+HBvIkJ6rt8R+SYzJZGvnTyGr544miVbdvDC8jLeXL+dm19eu+eYOIOs1CSy05JITU4gIc6Ij7M9z3H28XP7tvg4Iys1kcHpyeRmJDNycBpjh6STk34QdQqHTYfZv4Lnvwev/RpO+WEffAIihw4lbhJ7PnrdWy1g3Fl+R7KHb+PbOhp3Fvzrp7BzCwwa7l8c0bDscXjyqzB0Glz2dy9xFeLijKNHZnP0yGwAahpaWF9Rx9ryXZTubKBqdzPVu5upb26jLeRoDYVobg3R5hyhkKPNOVrbHCHnwvsdO3Y3U9u4d9drXmYyM0flcMyobE4dP4Shgwb0LtCjv+yNS3ztRm88Yj8o2SISLUrcJPasexGS0gOzPin4OKO0o4nne4nbyqfhuG/4F0ekLb4Pnv02jDwB5j7ijW2TLg0ckMj0EdlMH5F9UNdpam2joraJjdt3s668jmXFNbzzURXPfFACwLThg/j05KF8dnohAwf0YIynGZx3i1dA+x/zYN6rkDPmoGIUOVQocZPY4pzXHTjmFEiI0rJSPbCipIbcjGSGZPi49Fb2aCiYAiue7L+J21t/hJf+Gw47Az7/ECT2sqVHDkhyQjxF2akUZady0jivS9o5x8btu3lheRnPLSvlF8+u5DcvruGCaUP58qdGMyY3vfuLJg7wVrW48yR49FL48gJI3s85IqLJCRJjypdD7TYYN9vvSPbywdadTB420O8w4IgLvZmlOzb7HUnfcg5e/bWXtE2cA5c8rKTNZ2bGmNx0rj3lMJ7/1qd49hsncP6UofzjvW2ccctrfOexpWyu2t39RQYNh8/dC9vXwtNfV3FekR5Q4iaxZc0L3vPYM/2No4Od9c1sqNzNUSMCMM5q4gXe88qnfQ2jTzkHL/8EXv1/MOVS+Oy9kJDkd1TSyZHDBvLrz03mzRtO5YvHj+K5ZaWcevNr/Gz+CmoaWvZ94phT4LRwF/+b/1/U4hWJVRFN3MxstpmtMbP1ZnZDF/vNzG4N719mZkeFtxeZ2StmtsrMVpjZtzqc8zMz22ZmS8OPcyL5HiRgVj4NhTMhfYjfkezx/padAEwPQuKWPcobsL/iSb8j6RuhEDz3HXjrD3D0V7x1L+M1wiPIBqcn8+PzJvKf75/CJUcX8cDbmzjt5ld5Ykkxbl8tasd/y2st/tfPYfXz0Q1YJMZELHEzs3jgNuBsYCIw18wmdjrsbGBs+DEPuD28vRX4rnNuAjALuLbTub9zzk0NP/R/+aFi+zoo/xCO/IzfkexlyeYdxMcZkwsD0FUK3h/Akve81SViWVsrPPU1WHwvHH89nPMbiFMnQawYkpnC/104iWeuO4Gi7FS++/gHXH7Pu2zb2fDJg81gzp+8GaZPfBnKPox6vCKxIpK/BWcC651zG51zzcCjwJxOx8wBHnSehcAgMytwzpU6594DcM7VAauAYRGMVWLBiqe854mdv0b+WrJ5BxMLMklNCkhL0KSLweLg/Yf8juTAtTbB41fCskfh1J/AGT8PTM0+6Z0jhw3kiWuO4/8uPJL3tuxg9u9e57FFWz/Z+paUCpc8AikD4eFLoK7cn4BFAi6SidswYGuH18V8Mvna7zFmNhKYBrzTYfN14a7Ve82sy/4pM5tnZovNbHFlZeUBvgUJlBVPwvBjvSVzAqK1LcQHxTuD0U3aLrMAxp4FSx/2Wq1iTfNuePjzsPpZmH0jnPg9vyOSgxQXZ3zhmBG8eP2JTByayfefWMZXHlzCjt3Nex+YWQCXPuot3/boXGjponVO5BAXycStq38edx7g0O0xZpYOPAFc75yrDW++HRgDTAVKgZu7urlz7i7n3Azn3Izc3EO3onq/UbnGq/l0xIV+R7KX1WV11De3MW34IL9D2dtRl8Ouclj3kt+R9E7DTm8Jq49e87rOZn3N74ikDxVlp/LIV2bxk/Mm8vraSs699T8s2dxpzdKCKfCZu70CvU9ppqlIZ5FM3IqBjuv/FAIlPT3GzBLxkra/Ouf+0X6Ac67cOdfmnAsBd+N1yUp/t+JJwGDC+X5HspfFm7w/OoFqcQNv1m3akNjqLt1VCfef5/3Bvuh+mPYFvyOSCIiLM750wiie+NpxJMTHcfGdC7njtQ17r6U64Tw4/aew4h+w4Of+BSsSQJFM3BYBY81slJklAZcA8zsdMx+4Ijy7dBZQ45wrNTMD7gFWOedu6XiCmRV0eHkhsDxyb0ECIRSCpX+FUZ/yulIC5K0NVRRmDaAwK9XvUPYWnwhTL/WKFdds8zua/du5Fe6bDVXrva6ygI1jlL43qXAgz37zBM46Io8b/7maLz2wiJr6DmVDjr8epl8Nb/wOFt6+z+uIHGoilrg551qB64AX8SYXPOacW2Fm15jZNeHDngc2AuvxWs++Ht5+PHA5cGoXZT9uMrMPzWwZcArw7Ui9BwmITf/x1t+cdoXfkeylLeR4e2MVJxw22O9QujbjasDBu3f6HUn3tq+He2fDrgq44ik47HS/I5IoyUxJ5LZLj+IXc47gjfXbOf+2N1hTVuftNINzb4bx58ELN8CHf/c3WJGAiOg0uHCpjuc7bbujw88OuLaL896g6/FvOOcu7+MwJejefwiSB3rdJwHy4bYa6hpbOS6oiVvWSK9refH9cOJ/BXNNz7IPvTFtzsFVz3rjm+SQYmZccexIjhiayTV/eY8L//Qmv71oCudMKoC4ePjsPfCXz8CT10BqjlewV+QQpqJIEmwNO2DlfJh8UeCWOHpz/XYAjhuT43Mk3TjuG9BUA+8FcKzbR6/DfedAfBJc/U8lbYe46SOyefYbJ3B4fgZf/+t73PTCatpCDhJTvCXOBo+Dv13mLekmcghT4ibB9uHfoa0JpgWvofU/6yoZn5/B4PTgLHb/CYUzYMTx8Obvg1VaYfkT8JfPeqVdvvgi5I7zOyIJgLzMFB6dN4u5M4v406sb+OL94XFvAwbBZU9AarbXQlv6gd+hivhGiZsEl3Ow6M9eS8zQqX5Hs5ea+hYWbdrBqeODs/TWPp3y37CrDBbd43cknrf+CH//IgybAV98AQYV7f8cOWQkJ8Tzq89M5v9dOIm3Nnjj3taW13kTk658FpIy4MELoHyF36GK+EKJmwTXhn9D5WqY9fX9Hxtlr66toC3kOG1Cnt+h7N/I42H0KfDGLdBYu//jIyUUghd+BC/9tzdr9PInYUDAyqhIYFx6zHAenTeL+uY2LrztTV5YXgZZI+CqZyAhGR6c49V3FDnEKHGT4Fr4J0jPC1zRXYB/rapgcHoSU4sG+R1Kz5z2P1BfDa/92p/7N9V545MW3gbHXAOfu88buyTSjekjsnnmuhM4LC+Da/6yhFteXkto0Ci48hlvWbf7z1PLmxxylLhJMJWvhPX/ghlf8v51HSBNrW28uqaCUw4fQnxcjKyfOewoOOoKrx5Wxaro3nvHJrjnTFj7Asz+tbeMVVx8dGOQmJU/MIW/zZvF56YXcuuCdcx7aAl16SO9btO4BG+Cy9ZFfocpEjVK3CSYXr8JktJh5lf8juQTXltTSV1jK+dODlYx4P067aeQkgnzvxm9NUw3vQF3nQK1Jd7g8lnXaLF46bWUxHh+87nJ/PTTE3llTQUX/uktNjLUGyM5IMvrNt3wit9hikSFEjcJnorVsOIpmDnPm0UWMPM/KCEnLYnjg1q/bV/ScuCc30Lxu/D6byJ7r1AI/nMzPHA+pA2Gr/xb9bfkoJgZVx8/ioe+NJOqXU3Mue1NXikf4CVvWSPh4Yu93xsi/ZwSNwmeV38Fialw7HV+R/IJu5pa+deqcs6ZVEBifAz+7zPpczD5Eq9Fc8O/I3OPXRXw18/Cgl/AERfAlxdAzpjI3EsOOceNGcz8606gKCuVLz6wiD8t2YW76lkYOg0ev9L7B4MWppd+LAb/8ki/tuUdWPkUHHed10IUMM9+UEJjS4gLpg31O5QDd+5vIXcCPHZl3493W/k03H48bH4LPv17r+p9Smbf3kMOeUXZqTzxteM4d1IBN72whuue2kT93H/AkZ/z/sHw1NehtcnvMEUiQombBEcoBC/+ENLz4fhv+R3NJzjneGjhZsbnZ3DU8BguY5GcAZf+zVuJ4sE5fTMrr64MHrvCe2QWeF2j06/SeDaJmAFJ8fxh7jR+MHs8z39Yymfueo+tp9wKJ/8IPnjY+27XlfkdpkifU+ImwfH+Q95yNqf9DySl+R3NJyzdupMVJbV8YdYILNYTkkFFH5dUuO8cbwbvgWjaBa/8Cm6dBmte8CZAfPnfkHdE38Yr0gUz42snj+G+q45m284Gzr/tTd4s/JLX0luyFO74lLe0mkg/osRNgqGuDF76CYw4AabM9TuaLv35jY9IT07gwmnD/A6lb+Qe7g3szhzqLT/1/Pe9Wm89sXs7vPpruHUqvHYjjDsLrl0In/oOxCdENGyRzk4+fAjzrzuBnPRkLrvnHW4pm0zblxd4S2U9OAdeuwlCbX6HKdIn9BtW/OccPHO9tybp+bdCXPD+PbG+YhfPf1jK104aQ3pyP/rfJmuk16358v/Aorvhg0dg0kUw8XwYetTH49PaWrxVLIoXw+rnYOOrEGqBsWfCif8FRTP9fBcijBqcxtPXHs9PnlrOrQvWsXBjNn/4/AvkvX4DvPJ/sO4luOAOGHyY36GKHBRzh8DsmxkzZrjFixf7HYbsy8I74IUfwFm/gmODt7wVwLf/tpR/Li/lzR+cSk6QF5U/GBWrvBl5q56B1kZvW1K6Vyy3sRYI/64YNMJL7KZd7rXaiQTME0uK+cnTy0lOiOPmiyZzausb8Nx3ve/1aT+FY76qItASaGa2xDk3o8t9StzEV1vf9cZYjT0DLnk4kIPZP9i6kzm3vclXTxrND8+e4Hc4kddY69V6K/0Adld5LWspg7wkrWCqV9ojgP+dRDraULmL6x5+n1WltVxydBH/feIgMl76rtfyVjDFq2molmIJKCVuStyCqfoj+PNpkDLQq/UVwGK7oZDjojvfZnPVbl753slkpCT6HZKI9FBjSxu/+9da7n59I3mZKdz4mUmc1Pw6vPRjqCuFqZfBKT+Cgf1k3Kr0G90lbsEbTCSHhppt8NCF4EJw6eOBTNoA7n9rE0s27+D7s8craROJMSmJ8fzw7Ak88bXjSEtO4Mr7FvG91WPZfvWbXsmhZX/zZkS/8CPYVel3uCI9osRNom/HJrj/XKiv8pK2gA4WXlVay40vrOa08UO4aHqh3+GIyAGaNjyLZ79xAl8/eQxPvb+NU36/mD+nXEXz1xd7k3HeuR1+PwX++QPv95NIgKmrVKJryzvw6KXeuKkvPAFFR/sdUZcq65q44LY3aQ2FePYbnyI3o59OSBA5xGyo3MX/PruSV9dUMjo3je+deTiz8+qIe+NmWP53rxdg/HleAenRJ2sSg/hCY9yUuPmvrdWbsfjar2HQcPjC4zB4rN9RdalqVxNf+PM7bKrazeNfPY5JhQP9DklE+ti/V5fzf8+tYkPlbsbnZ/DN08ZyVlGI+MV3w+L7oHEnZAyFKZfA5M97k3M0KUeiRImbEjd/bXoDXvxvKF0Kky6Gc37jFcYMoPUVu5j30GK27Wjg7itmcOK4XL9DEpEIaQs5nl1Wwu8XrGNj5W4KswZw2awRXDw1l+ziBbD0YW9VEReC7DFw+Nkw/lwoPBriNeZVIkeJmxK36HMONr4Cb/8J1r8MmcPgzF/CkZ/xO7IutbaFeGjhZn774hpSEuO5/bLpzBwVzAkTItK32kKOF1eU8eDbm1i4sZqkhDhOHpfLeVOGcnpRiNQNL8Dq573ls0ItkJjqlRIZcTyMOM4rk5Oc7vfbkH7Et8TNzGYDvwfigT87527stN/C+88B6oGrnHPvdXeumWUDfwNGApuAi51zO7qLQ4lblIRCUPq+V8B15dNQvRHScmHW12HW17xFzQOmsaWN55aVcufrG1hbvotPjR3Mrz87maGDgheriETemrI6Hnl3C89/WEpFXRPJCXHMHJXNCYcN5lPDkxm3ewkJW96EzW9B+XK8wtQG2aMhfxLkHwmDD/deZ48K5LrLEny+JG5mFg+sBc4AioFFwFzn3MoOx5wDfAMvcTsG+L1z7pjuzjWzm4Bq59yNZnYDkOWc+0F3sShxi4CmXVC9Abavg6r13lJIxe9CYw1YPIz6FEy+xGthSwjOwP6WthBry+tYvq2G/6zbziurK9jd3Mbhed4Yl3Mm5cf+AvIictDaQo5Fm6p5YXkZb6zfzvqKXQAkJcQxoSCTI4dmckRWiCPaVlHYtI5BNauJr1j+yVmp6Xne0nLpeZCR3+E5H9JyvDqWKYMgOVPr/Moe3SVukfyWzATWO+c2hoN4FJgDrOxwzBzgQedljwvNbJCZFeC1pu3r3DnAyeHzHwBeBbpN3CKueqO3XNCeJDj83KPXnffRzbEH+No5Kuoaqaxr2rPNObDOx7oQcW1NxIWaiG9rJK610XtuayShdRfJTdUkNVaR1LyDpJbavcKtzRhDdd6ZVOVMpyzvRFqSBuGcgw8r93pre26157Xb6/VebyH8Q+dz9t72yWOaWtqob25jd1Mru8KPsppGSmoaKKtppKXNOzgnLYnzpw7l3ElDOf6wHCVsIrJHfJwxa3QOs0bnAFBW08g7H1WxfFsNH26rYf7SEv7a1ApkAEcBR5GRkkBhaisTkrYzNrGC4ZSR11bK4J2lZFR+QHrLApLbdu/zni3xqbQmZdKSmE4oPmXPoy0+mVBcMm3xKYTik71HXBIhi8fFJeAsDmcfPxMXh7N47xEXfrY4oP13nO2ZaOHC2yz87Pb6PRj+2WzPcR23ffzcad8ByBiQwJjBMdLdPHQqZA717faRTNyGAVs7vC7Ga1Xb3zHD9nNunnOuFMA5V2pmQ7q6uZnNA+YBDB8+/ADfQg+teQFe/GFk73GQhoQfPdXmjAaSaSSJRpKodSlUuUyqKGC7G0+lG8RGV8BHLp9NLp+mxiTYU79yU5/HfyCSE+JIS04gPTmBvMxkphVlMXTSACYUZDC5cBAjslOJi1OyJiL7lz8whTlThzFnqrfKgnOO7bua2VJdT/GOerZU1VO1u5nq3c1U1g9mze7R7Kxvoam1jYbmNhpa2gg5SKGJXNvJEHaSZbvIZDeZVk8m9WS27iazqZ5MqyeFZpKpJ8V2kkIzSbSQYs2k0UwyLSTTQjwh4qz/j1MPnM/d5+t47Ugmbl39Rez8DdvXMT05t1vOubuAu8DrKu3Nub026SIYeXz4Rad/jfTkdY+PZT/79/26clczVbuawezjfyh1vHf7c0IKoYQULC6p07GQG358HI59Irw9dzbr9LrjMZ887xPH7ON86/DV6Bhbxx+S4+NJTY4nMV71pUUkMsyM3IxkcjOSmT4ia7/HO+doaXM0trbR1BLCOUebc4Sct7ReyDnaQuHX4Z/36kkIP2o+ceEQuDYs1AauDVzrnp8t1AouhIVaMRdiz9U69dC093zYPnuB9t5mdDi/c2/PAUpNjI+dscVZI3y9fSQTt2KgqMPrQqCkh8ckdXNuuZkVhFvbCoCKPo36QKTneo8Ayx3oJV0iIhJ9ZkZSgpGUEAcpfkcjsSySTRKLgLFmNsrMkoBLgPmdjpkPXGGeWUBNuBu0u3PnA1eGf74SeDqC70FEREQkMCLW4uacazWz64AX8Up63OucW2Fm14T33wE8jzejdD1eOZCruzs3fOkbgcfM7EvAFuCiSL0HERERkSBRAV4RERGRAOmuHIhGb4uIiIjECCVuIiIiIjFCiZuIiIhIjFDiJiIiIhIjlLiJiIiIxAglbiIiIiIxQombiIiISIw4JOq4mVklsHk/hw0GtkchnFikz6Z7+ny6p89n3/TZdE+fT/f0+exbrH82I5xzXa5UeUgkbj1hZov3VezuUKfPpnv6fLqnz2ff9Nl0T59P9/T57Ft//mzUVSoiIiISI5S4iYiIiMQIJW4fu8vvAAJMn0339Pl0T5/Pvumz6Z4+n+7p89m3fvvZaIybiIiISIxQi5uIiIhIjFDiJiIiIhIjDunEzcwuMrMVZhYysxmd9v3QzNab2RozO8uvGIPCzH5mZtvMbGn4cY7fMQWBmc0Of0fWm9kNfscTJGa2ycw+DH9fFvsdj9/M7F4zqzCz5R22ZZvZy2a2Lvyc5WeMftrH56PfO4CZFZnZK2a2Kvw361vh7fr+0O3n0y+/P4f0GDczmwCEgDuB7znnFoe3TwQeAWYCQ4F/AeOcc21+xeo3M/sZsMs591u/YwkKM4sH1gJnAMXAImCuc26lr4EFhJltAmY452K5CGafMbMTgV3Ag865I8PbbgKqnXM3hhP/LOfcD/yM0y/7+Hx+hn7vYGYFQIFz7j0zywCWABcAV6HvT3efz8X0w+/PId3i5pxb5Zxb08WuOcCjzrkm59xHwHq8JE6ko5nAeufcRudcM/Ao3ndH5BOcc68D1Z02zwEeCP/8AN4fm0PSPj4fAZxzpc6598I/1wGrgGHo+wN0+/n0S4d04taNYcDWDq+L6cdfgl64zsyWhbs0Dskm+U70PemeA14ysyVmNs/vYAIqzzlXCt4fH2CIz/EEkX7vdGBmI4FpwDvo+/MJnT4f6Iffn36fuJnZv8xseReP7lpGrItt/b5PeT+f1e3AGGAqUArc7GesAXFIfk964Xjn3FHA2cC14a4wkd7Q750OzCwdeAK43jlX63c8QdPF59Mvvz8JfgcQac650w/gtGKgqMPrQqCkbyIKrp5+VmZ2N/BshMOJBYfk96SnnHMl4ecKM3sSr2v5dX+jCpxyMytwzpWGx+lU+B1QkDjnytt/PtR/75hZIl5S8lfn3D/Cm/X9Cevq8+mv359+3+J2gOYDl5hZspmNAsYC7/ock6/CvxTaXQgs39exh5BFwFgzG2VmScAleN+dQ56ZpYUHCWNmacCZ6DvTlfnAleGfrwSe9jGWwNHvHY+ZGXAPsMo5d0uHXfr+sO/Pp79+fw71WaUXAn8AcoGdwFLn3Fnhff8NfBFoxWt2/adfcQaBmT2E19zsgE3AV9vHVhzKwtPL/z8gHrjXOfd//kYUDGY2Gngy/DIBePhQ/2zM7BHgZGAwUA78FHgKeAwYDmwBLnLOHZID9Pfx+ZyMfu9gZicA/wE+xKuEAPAjvHFch/z3p5vPZy798PtzSCduIiIiIrFEXaUiIiIiMUKJm4iIiEiMUOImIiIiEiOUuImIiIjECCVuIiIiIjFCiZuIiIhIjFDiJiIiIhIj/n+BT9tlZu+KNQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sales_pred = pd.Series(y2_pred, index=y_test.index)\n",
    "\n",
    "fig, ax = plt.subplots(1,1,figsize=(10,5))\n",
    "sales_pred.plot(kind='kde', ax=ax)\n",
    "y_log_test.plot(kind='kde', ax=ax)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "resid = (y_log_test - sales_pred)\n",
    "fig, ax = plt.subplots(1,2,figsize=(15,5))\n",
    "resid.hist(bins=30, ax=ax[0])\n",
    "resid.plot.box(ax=ax[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CLASSIFICATION MODEL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "##SPLIT DATA INTO TRAIN & TEST\n",
    "Xc_train, Xc_test, yc_train, yc_test = train_test_split(X, ycls, test_size=0.1, random_state=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "##PIPELINE ASSEMBLER\n",
    "classification_pipe = Pipeline(\n",
    "    [\n",
    "        ('rare_label_encoder', RareLabelEncoder(threshold=0.03, variables=DISCRETE_VARS)),\n",
    "        \n",
    "#         ('binarization', Binarization(bins=20, variables=CONTINUOUS_VARS)),\n",
    "        \n",
    "#         ('discrete_encoder', DiscreteEncoder(variables=CONTINUOUS_VARS)),\n",
    "         \n",
    "        ('scaler', StandardScaler()),\n",
    "        \n",
    "        ('pca', PCA(n_components=0.95, svd_solver='full')),\n",
    "        \n",
    "        ('class_model', RandomForestClassifier(n_estimators=100, max_depth=5, class_weight='balanced',random_state=0))\n",
    "\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('rare_label_encoder',\n",
       "                 RareLabelEncoder(threshold=0.03,\n",
       "                                  variables=['no_of_sales_12M_1',\n",
       "                                             'no_of_sales_12M_10K',\n",
       "                                             'no_of_funds_sold_12M_1',\n",
       "                                             'no_of_fund_sales_12M_10K',\n",
       "                                             'no_of_assetclass_sold_12M_1',\n",
       "                                             'no_of_assetclass_sales_12M_10K',\n",
       "                                             'No_of_fund_curr',\n",
       "                                             'No_of_asset_curr'])),\n",
       "                ('scaler', StandardScaler()),\n",
       "                ('pca', PCA(n_components=0.95, svd_solver='full')),\n",
       "                ('class_model',\n",
       "                 RandomForestClassifier(class_weight='balanced', max_depth=5,\n",
       "                                        random_state=0))])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classification_pipe.fit(Xc_train, yc_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "y1_prob = classification_pipe.predict_proba(X_train)[:,1]\n",
    "y2_prob = classification_pipe.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train ROC-AUC:0.7400890270210688\n",
      "Test ROC-AUC:0.7168530599565083\n"
     ]
    }
   ],
   "source": [
    "##EVALUATION\n",
    "print('Train ROC-AUC:{}'.format(roc_auc_score(yc_train,y1_prob)))\n",
    "print('Test ROC-AUC:{}'.format(roc_auc_score(yc_test,y2_prob)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _CLASSIFICATION REPORT_\n",
    "\n",
    "The classification report is a key metrics in a classification problem. It shows:for each class you're trying to find.\n",
    "\n",
    "- Precision which means `how many of all predictions were correctly classified` **_Precision = TP/(TP+FP)_**\n",
    "- Recall which means `how many of this class were correctly classified` **_Recall = TP/(TP+FN)_**\n",
    "- F1-score which is the `harmonic mean between precision & recall` **_F1 = 2*Precision*Recall/Precision+Recall_**\n",
    "\n",
    "The support is the number of occurence of the given class in the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1_pred = classification_pipe.predict(X_train)\n",
    "x2_pred = classification_pipe.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Dataset Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.88      0.60      0.71      6744\n",
      "           1       0.39      0.76      0.51      2260\n",
      "\n",
      "    accuracy                           0.64      9004\n",
      "   macro avg       0.63      0.68      0.61      9004\n",
      "weighted avg       0.76      0.64      0.66      9004\n",
      "\n",
      "Test Dataset Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.88      0.58      0.70       740\n",
      "           1       0.39      0.77      0.52       261\n",
      "\n",
      "    accuracy                           0.63      1001\n",
      "   macro avg       0.64      0.68      0.61      1001\n",
      "weighted avg       0.75      0.63      0.65      1001\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('Train Dataset Report:')\n",
    "print(classification_report(yc_train,x1_pred))\n",
    "print('Test Dataset Report:')\n",
    "print(classification_report(yc_test,x2_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TN:4042 FP:2702 N:6744\n",
      "TP:1712 FN:548 P:2260\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[4042, 2702],\n",
       "       [ 548, 1712]], dtype=int64)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tn,fp,fn,tp = confusion_matrix(yc_train,x1_pred).ravel()\n",
    "print('TN:{0} FP:{1} N:{2}'.format(tn,fp,(tn+fp)))\n",
    "print('TP:{0} FN:{1} P:{2}'.format(tp,fn,(tp+fn)))\n",
    "confusion_matrix(yc_train,x1_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TN:432 FP:308 N:740\n",
      "TP:201 FN:60 P:261\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[432, 308],\n",
       "       [ 60, 201]], dtype=int64)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tn,fp,fn,tp = confusion_matrix(yc_test,x2_pred).ravel()\n",
    "print('TN:{0} FP:{1} N:{2}'.format(tn,fp,(tn+fp)))\n",
    "print('TP:{0} FN:{1} P:{2}'.format(tp,fn,(tp+fn)))\n",
    "confusion_matrix(yc_test,x2_pred)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}