Model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "75aea66f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import libraries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "import statsmodels.api as sm\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "bdfbee4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\leowe\\anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3166: DtypeWarning: Columns (0,19,49,59,118,129,130,131,134,135,136,139,145,146,147) have mixed types.Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv('lendingclub/accepted_2007_to_2018Q4.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "40fa3729",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "id                             0\n",
       "member_id                2260701\n",
       "loan_amnt                     33\n",
       "funded_amnt                   33\n",
       "funded_amnt_inv               33\n",
       "                          ...   \n",
       "settlement_status        2226455\n",
       "settlement_date          2226455\n",
       "settlement_amount        2226455\n",
       "settlement_percentage    2226455\n",
       "settlement_term          2226455\n",
       "Length: 151, dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Observe the missing values of each column\n",
    "data.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9c9717b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# columns to remove\n",
    "remove_col = [\"id\", \"member_id\", \"funded_amnt\", \"funded_amnt_inv\", \"installment\", \"url\", \"desc\", \"emp_title\", \"pymnt_plan\", \"title\", \n",
    "              \"zip_code\", \"initial_list_status\", \"out_prncp\", \"out_prncp_inv\", \"total_pymnt\", \"total_pymnt_inv\", \"total_rec_prncp\", \"total_rec_int\",\n",
    "              \"total_rec_late_fee\", \"recoveries\", \"collection_recovery_fee\", \"last_pymnt_d\", \"last_pymnt_amnt\", \"next_pymnt_d\", \"last_credit_pull_d\", \n",
    "              \"last_fico_range_high\", \"last_fico_range_low\", \"mths_since_last_major_derog\", \"policy_code\", \"num_tl_120dpd_2m\", \"num_tl_30dpd\", \"hardship_flag\", \n",
    "              \"hardship_type\", \"hardship_reason\", \"hardship_status\", \"deferral_term\", \"hardship_amount\", \"hardship_start_date\", \"hardship_end_date\", \n",
    "              \"payment_plan_start_date\", \"hardship_length\", \"hardship_dpd\", \"hardship_loan_status\", \"orig_projected_additional_accrued_interest\", \n",
    "              \"hardship_payoff_balance_amount\", \"hardship_last_payment_amount\", \"disbursement_method\", \"debt_settlement_flag\", \"debt_settlement_flag_date\",\n",
    "              \"settlement_status\", \"settlement_date\", \"settlement_amount\", \"settlement_percentage\", \"settlement_term\", \"sub_grade\", \"grade\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "ded25675",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove them\n",
    "data = data.drop(remove_col,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "5b5c9155",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter for only fully paid and charged off loans\n",
    "data = data[data['loan_status'].isin(['Fully Paid','Charged Off'])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "f688007e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate missing value percentage for each column\n",
    "missperc = (data.isna().sum() / data.shape[0]).reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "562d1f2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter for columns with less than 50% missing values\n",
    "cols = missperc[missperc[0] < 0.5]['index']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "0db01955",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter the dataframe based on those columns\n",
    "data = data[cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "6ffc8c7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert loan status to a dummy variable\n",
    "data[\"loan_status\"] = data[\"loan_status\"].map({\"Fully Paid\": 1., \"Charged Off\": 0.})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "8e4bbf50",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\leowe\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: FutureWarning: The default value of regex will change from True to False in a future version.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "data['emp_length'] = data['emp_length'].str.replace(r'\\D', '').astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "bba5761e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fill the NA values\n",
    "data = data.fillna(data.median())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5759b234",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Total missing values\n",
    "data.isna().sum().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "c0d61042",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['fico_range_high', 'total_rev_hi_lim', 'avg_cur_bal', 'bc_util', 'num_actv_rev_tl', 'num_bc_sats', 'num_op_rev_tl', 'num_rev_accts', 'num_rev_tl_bal_gt_0', 'num_sats', 'percent_bc_gt_75', 'tot_hi_cred_lim', 'total_bc_limit', 'total_il_high_credit_limit']\n"
     ]
    }
   ],
   "source": [
    "# Create correlation matrix\n",
    "corr_matrix = data.corr().abs()\n",
    "\n",
    "# Select upper triangle of correlation matrix\n",
    "upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(np.bool))\n",
    "\n",
    "# Find features with correlation greater than 0.8\n",
    "to_drop = [column for column in upper.columns if any(upper[column] >= 0.8)]\n",
    "print(to_drop)\n",
    "\n",
    "# Drop them\n",
    "data = data.drop(to_drop, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "bcca8fd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['loan_amnt', 'term', 'int_rate', 'emp_length', 'home_ownership',\n",
       "       'annual_inc', 'verification_status', 'issue_d', 'loan_status',\n",
       "       'purpose', 'addr_state', 'dti', 'delinq_2yrs', 'earliest_cr_line',\n",
       "       'fico_range_low', 'inq_last_6mths', 'open_acc', 'pub_rec', 'revol_bal',\n",
       "       'revol_util', 'total_acc', 'collections_12_mths_ex_med',\n",
       "       'application_type', 'acc_now_delinq', 'tot_coll_amt', 'tot_cur_bal',\n",
       "       'acc_open_past_24mths', 'bc_open_to_buy', 'chargeoff_within_12_mths',\n",
       "       'delinq_amnt', 'mo_sin_old_il_acct', 'mo_sin_old_rev_tl_op',\n",
       "       'mo_sin_rcnt_rev_tl_op', 'mo_sin_rcnt_tl', 'mort_acc',\n",
       "       'mths_since_recent_bc', 'mths_since_recent_inq',\n",
       "       'num_accts_ever_120_pd', 'num_actv_bc_tl', 'num_bc_tl', 'num_il_tl',\n",
       "       'num_tl_90g_dpd_24m', 'num_tl_op_past_12m', 'pct_tl_nvr_dlq',\n",
       "       'pub_rec_bankruptcies', 'tax_liens', 'total_bal_ex_mort'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "f94dc467",
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert terms from months to years\n",
    "data[\"term\"] = (data[\"term\"].str.extract('(\\d+)').astype(float))/12\n",
    "\n",
    "# transform earliest_cr_line to the number of days before the loan is issued\n",
    "data[\"earliest_cr_line\"] = data[\"issue_d\"].str.extract('(\\d+)').astype(float) - data[\"earliest_cr_line\"].str.extract('(\\d+)').astype(float)\n",
    "data = data.drop([\"issue_d\",'addr_state'], axis=1)\n",
    "\n",
    "# create dummy variables\n",
    "data[\"application_type\"] = data[\"application_type\"].map({\"Individual\": 1., \"Joint App\": 0.})\n",
    "data = data[data[\"home_ownership\"].isin([\"MORTGAGE\", \"RENT\", \"OWN\"])]\n",
    "data = pd.get_dummies(data, columns=[\"home_ownership\", \"verification_status\",'purpose'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "ae28ed6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Oversample to balance it\n",
    "ros = RandomOverSampler(random_state=42)\n",
    "X_res, y_res = ros.fit_resample(data.drop(columns=['loan_status']), data['loan_status'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "800e8d26",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data into the test and train dataset\n",
    "xtrain, xtest, ytrain, ytest = train_test_split(X_res, y_res, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "946fd7a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 0.677904\n",
      "         Iterations 5\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table class=\"simpletable\">\n",
       "<caption>Logit Regression Results</caption>\n",
       "<tr>\n",
       "  <th>Dep. Variable:</th>      <td>loan_status</td>   <th>  No. Observations:  </th>   <td>1722801</td>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model:</th>                 <td>Logit</td>      <th>  Df Residuals:      </th>   <td>1722799</td>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Method:</th>                 <td>MLE</td>       <th>  Df Model:          </th>   <td>     1</td>   \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Date:</th>            <td>Tue, 05 Oct 2021</td> <th>  Pseudo R-squ.:     </th>   <td>0.02199</td>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Time:</th>                <td>16:01:18</td>     <th>  Log-Likelihood:    </th> <td>-1.1679e+06</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>converged:</th>             <td>True</td>       <th>  LL-Null:           </th> <td>-1.1942e+06</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Covariance Type:</th>     <td>nonrobust</td>    <th>  LLR p-value:       </th>   <td> 0.000</td>   \n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "         <td></td>           <th>coef</th>     <th>std err</th>      <th>z</th>      <th>P>|z|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>const</th>          <td>   -8.3654</td> <td>    0.038</td> <td> -221.007</td> <td> 0.000</td> <td>   -8.440</td> <td>   -8.291</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>fico_range_low</th> <td>    0.0121</td> <td> 5.47e-05</td> <td>  220.931</td> <td> 0.000</td> <td>    0.012</td> <td>    0.012</td>\n",
       "</tr>\n",
       "</table>"
      ],
      "text/plain": [
       "<class 'statsmodels.iolib.summary.Summary'>\n",
       "\"\"\"\n",
       "                           Logit Regression Results                           \n",
       "==============================================================================\n",
       "Dep. Variable:            loan_status   No. Observations:              1722801\n",
       "Model:                          Logit   Df Residuals:                  1722799\n",
       "Method:                           MLE   Df Model:                            1\n",
       "Date:                Tue, 05 Oct 2021   Pseudo R-squ.:                 0.02199\n",
       "Time:                        16:01:18   Log-Likelihood:            -1.1679e+06\n",
       "converged:                       True   LL-Null:                   -1.1942e+06\n",
       "Covariance Type:            nonrobust   LLR p-value:                     0.000\n",
       "==================================================================================\n",
       "                     coef    std err          z      P>|z|      [0.025      0.975]\n",
       "----------------------------------------------------------------------------------\n",
       "const             -8.3654      0.038   -221.007      0.000      -8.440      -8.291\n",
       "fico_range_low     0.0121   5.47e-05    220.931      0.000       0.012       0.012\n",
       "==================================================================================\n",
       "\"\"\""
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Logistic regression\n",
    "logit = sm.Logit(ytrain, sm.add_constant(xtrain['fico_range_low'])).fit(maxiter=1000)\n",
    "logit.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "683ba45e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Logistic Regression from sklearn\n",
    "LR_base = LogisticRegression().fit(xtrain['fico_range_low'].values.reshape(-1, 1), ytrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "de7925b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make predictions on testing data\n",
    "ypred_base = LR_base.predict_proba(xtest['fico_range_low'].values.reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "dfb2a2ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plots the ROC curve and computes AUC\n",
    "def plot_AUC(y_pred, y_test, model_name):\n",
    "    plt.rcParams[\"figure.figsize\"] = (8,6)\n",
    "    fpr, tpr, thresholds = roc_curve(y_test, y_pred)\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    label = 'AUC:' + ' {0:.2f}'.format(roc_auc)\n",
    "    plt.plot(fpr, tpr, c = 'g', label = label, linewidth = 2);\n",
    "    plt.xlabel('False Positive Rate', fontsize = 10);\n",
    "    plt.ylabel('True Positive Rate', fontsize = 10);\n",
    "    plt.title('ROC Curve: '+ model_name, fontsize = 12);\n",
    "    plt.legend(loc = 'lower right', fontsize = 10);\n",
    "    plt.grid(linewidth=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "cd31b7d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_AUC(ypred_base[:,1], ytest, \"LR baseline model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "f00f88e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function that plots and computes the Cumulative Accuracy Profile\n",
    "def plot_CAP(y_pred, model_name, N=10):\n",
    "    \n",
    "    # our model\n",
    "    idx = np.argsort(-y_pred)\n",
    "    y_pred = -np.sort(-y_pred)\n",
    "    deciles = np.array_split(y_pred, N)\n",
    "    deciles_idx = np.array_split(idx, N)\n",
    "    \n",
    "    # number of borrowers (observations) in each decile\n",
    "    nB = len(deciles[0])\n",
    "    \n",
    "    # number of default loans in each decile\n",
    "    y = np.array(ytest)\n",
    "    nD = np.array([sum(y[id] == 0) for id in deciles_idx])\n",
    "    \n",
    "    # total number of default loans\n",
    "    totD = np.sum(nD)\n",
    "    \n",
    "    # cumulative Number of default loans in each decile\n",
    "    cumD = np.cumsum(nD)\n",
    "    \n",
    "    # percentage of default loans in each decile\n",
    "    pD = (nD/totD) * 100\n",
    "    \n",
    "    # cumulative percentage of default loans in each decile\n",
    "    cumP = np.insert(np.cumsum(pD), 0, 0)\n",
    "\n",
    "    # The perfect model\n",
    "    \n",
    "    # number of default loans\n",
    "    perf_nD = np.zeros(N)\n",
    "    ids = round(totD/nB)\n",
    "    \n",
    "    # Number of default loans in each decile\n",
    "    perf_nD[:int(ids)] = np.repeat(nB, ids)\n",
    "    \n",
    "    # cumulative Number of default loans in each decile\n",
    "    perf_cumD = np.cumsum(perf_nD)\n",
    "    \n",
    "    # cumulative percentage of default loans in each decile\n",
    "    perf_cumP = np.insert(np.cumsum((perf_nD/totD) * 100), 0, 0)\n",
    "\n",
    "    # A random model\n",
    "    rand_cumP = np.insert(np.array(range(10,110,N)), 0, 0)\n",
    "\n",
    "    # Compute Accuracy Ratio\n",
    "    \n",
    "    # Area under Random Model\n",
    "    a = auc(rand_cumP, rand_cumP)\n",
    "    \n",
    "    # Area between Perfect and Random Model\n",
    "    aP = auc(rand_cumP, perf_cumP) - a\n",
    "    \n",
    "    # Area between our and Random Model\n",
    "    aR = auc(rand_cumP, cumP) - a\n",
    "    AR = aR / aP\n",
    "\n",
    "    plt.plot(rand_cumP, cumP, c = 'b', linewidth = 1, label=model_name)\n",
    "    plt.plot(rand_cumP, perf_cumP, c = 'grey', linewidth = 1, label=\"Perfect model\")\n",
    "    plt.plot(rand_cumP, rand_cumP, c = 'r', linestyle = '--', label=\"Random model\")\n",
    "    plt.plot([], [], ' ', label=\"Accuracy Ratio = \"+ str(round(AR, 3)))\n",
    "    plt.ylabel(\"% of default loans\")\n",
    "    plt.xlabel(\"% of loans\")\n",
    "    plt.title(\"Cumulative Accuracy Profile\")\n",
    "    plt.legend(loc=\"lower right\")\n",
    "    plt.grid(linewidth=0.5)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "43852a9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the CAP and compute AR\n",
    "plot_CAP(ypred_base[:,0], \"LR baseline model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "03d1319a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\leowe\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:765: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n"
     ]
    }
   ],
   "source": [
    "# Use all features to compare to the baseline model\n",
    "LR_all = LogisticRegression().fit(xtrain, ytrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "f082edf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make predictions on testing data\n",
    "ypred_all = LR_all.predict_proba(xtest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "2d584870",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfEAAAGDCAYAAAA72Cm3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABElElEQVR4nO3deZyV8//G8dd7pmlPpQ3t2kibpEIRlRYliRZJkZIoWyjbL6EIfSVLQkVapE0UISoKbdp3tEyL9mVM28z5/P44p4wxzZyaOXPPmbmej8c8Ouc+9zn3NZ+mrrl3c84hIiIi4SfC6wAiIiJyblTiIiIiYUolLiIiEqZU4iIiImFKJS4iIhKmVOIiIiJhSiUuIhmOmY02sxcDjxuYWbRHOeaY2b1BzuvMrHyoM4kkpBIXAcxss5kdNbMYM9sVKJG8iea52sy+N7MjZnbIzL4ws8qJ5jnPzN4ws62Bz9oUeF74DMs1M+ttZqvM7G8zizazz8ysaii/33ORsFiTeM0F8seY2XYzG2JmkUF85hwzO2BmOdI+sUjmpxIX+UdL51xeoAZwOdDv1AtmdhXwDfA5cBFQFlgOzDeziwPzZAdmA5cBTYHzgKuBfUDtMyxzKPAQ0Bs4H6gITANuOtvwZpbtbN+TxqoHxu86oB1wT3Izm1kZoD7ggJtDnk4kE1KJiyTinNsFzMJf5qcMBj52zg11zh1xzu13zj0D/AL0D8xzF1AKaO2cW+Oc8znndjvnXnDOzUy8HDOrADwAdHDOfe+cO+6ci3XOjXXOvRyY51+bc82si5n9lOC5M7MHzGwjsNHMhpvZa4mW87mZPRp4fJGZTTazPWb2p5n1Tu14Jeac2wTM59/jl5S78I/faKDzuS4vMAY9zWxjYCvJC2ZWzsx+NrPDZjYx8AvWqfm7BbaQ7Dez6WZ2UYLXGpvZusCWlrcAS7Sse8xsbWDrwSwzK32uuUXSgkpcJBEzKwE0AzYFnufGv0b9WRKzTwQaBx43Ar52zsUEuaiGQLRzbmHqEnMLUAeoDIwD2pmZAZhZQeBGYIKZRQBf4N+CUDyw/IfNrElg3npmdjCVWTCzS/CvYW9KYda7gLGBryZmViwVi20KXAHUBZ4ARgAdgZJAFaBDINsNwCCgLXAhsAWYEHitMDAZeAYoDPwOXJPg+7oFeAq4FSgC/AiMT0VmkVRTiYv8Y5qZHQG2AbuB/wtMPx//v5WdSbxnJ/7/8AEKnWGeMznb+c9kUGDLwFH8xeLwlyjAbcDPzrkdwJVAEefcAOfcCefcH8D7QHsA59xPzrkCqcix1Mz+BtYCc4B3zjSjmdUDSgMTnXNL8BfmHalY9ivOucPOudXAKuAb59wfzrlDwFf4d4+Av9hHOueWOueO499lclVg035zYI1zbpJz7iTwBrArwTLuwz/Wa51zccBAoIbWxsVLKnGRf9zinMsHNAAu4Z9yPgD48K+5JXYhsDfweN8Z5jmTs53/TLadeuD8dzSaQGDNE38xjg08Lg1cZGYHT33hX7NMzRpwQjWBvPj3h9cB8iQzb2f8RXtq7MaRik3qwF8JHh9N4vmpgxQvwr/2DUBgq8k+/FsmLuK/Y7ntn4+hNDA0wdjtx7+5vXgqcoukikpcJBHn3Fz8+2lfCzz/G/gZuD2J2dviP5gN4Dv8m4WTK6+EZgMlzKxWMvP8DeRO8PyCpCInej4euC2whlgH/yZi8BfSn865Agm+8jnnmgeZN0XObyL+8XouqXnMLBf+cbsucCbALuARoLqZVU+rLGewA38Zn8qSB/8Wke34t4qUTPCaJXyOf/zuSzR+uZxzC0KcWeSMVOIiSXsDaGxmNQLP+wKdA6eD5TOzgoHTra4Cng/MMwb/f/STzewSM4sws0Jm9pSZ/aconXMb8W9yHm/+c6Gzm1lOM2tvZn0Dsy0DbjWz3OY/B7lrSsGdc78Be4APgFnOuYOBlxYCh83sSTPLZWaRZlbFzK48i3GJDGQ89ZX9DPO9DHQ3s6R+6bgFiMe/D79G4OtS/LsC7jqLLOdiHHC3mdUInNY2EPjVObcZmAFcZma3Bo70782/f2kaDvQzs8sAzCy/mSX1i51IulGJiyTBObcH+Bh4NvD8J6AJ/oOaduLfJHs5UC9QxgT2sTYC1gHfAofxF2dh4NczLKo38BbwNnAQ/77h1vgPQAP4H3AC/+bhj/hn03hKxgeyjEvwPcUDLfGX5p/4dwN8AOQHMLP6ZpbSQXl98W+ePvX1fVIzOedWAnOBx5N4uTMwyjm31Tm369QX/nHoGMpT5Zxzs/H/nU7G//dYjn+OCdiLf2vLy/g3sVfAf5T9qfdOBV7Bf5DgYfz73puFKqtIMMy/20dERETCjdbERUREwpRKXEREJEypxEVERMKUSlxERCRMqcRFRETClNd3PTprhQsXdmXKlEmTz/L5fABEROh3mdTQOKaexjD1NIappzFMvVCN4ZIlS/Y654oknh52JV6mTBkWL16cJp8VE+M/JTZv3rwpzCnJ0TimnsYw9TSGqacxTL1QjaGZbUlqun7dEhERCVMqcRERkTClEhcREQlTKnEREZEwpRIXEREJUypxERGRMKUSFxERCVMqcRERkTClEhcREQlTIStxMxtpZrvNbNUZXjcze9PMNpnZCjOrGaosIiIimVEo18RHA02Teb0ZUCHw1R14N4RZREREMp2QXTvdOTfPzMokM0sr4GPnnAN+MbMCZnahc25ncp/r8/lOX5s2tWJjY9Pkc7I6jWPqaQxTT2OYehrD1Dlw7ABfbfiKbzZ/w+uNX6dQrkIhX6aXN0ApDmxL8Dw6MO0/JW5m3fGvrVOyZMl0CSciIpIc5xyr9qzi6z+/5qvfv2LJriX4nP8uZk3KN6FD5Q4hz+BliVsS01xSMzrnRgAjAGrVquXS+u4wumNP2tA4pp7GMPU0hqmnMTyzY3HH+OHPH/h8/efM2DiD6MPRp1+Lioji6uJX0/TipjSp1CRdxtHLEo8GEq5WlwB2eJRFREQkSSfjTzJn8xwmrp7IZ2s+49DxQ6dfK5K7CK0qtaJ5heY0LtcYTvinp9cvQl6W+HTgQTObANQBDqW0P1xERCS9LN+1nJG/jWT8qvHsid1zenr1YtW55ZJbuLnSzdS4oAYR9s8x4jEn0uaYrWCFrMTNbDzQAChsZtHA/wFRAM654cBMoDmwCYgF7g5VFhERkWDsjd3LhFUT+Hj5xyzasej09IqFKtK2clvaVWlHlaJVPEz4b6E8Oj3ZPfqBo9IfCNXyRUREguGc46etP/Hu4neZtGYSJ30nAciXPR+dqnXinsvvoeaFNTFL6lAub3m5OV1ERMQz+2L3MXzxcMasGMP6fesBiLAImpVvRseqHWl9aWtyR+X2OGXyVOIiIpJlnIg/wTe/f8O4leOYum4qx+KOAXBB3gu4u8bd9KjVg1L5S3mcMngqcRERydSccyzYtoDRy0Yzee1kDhw7cPq1ZuWb8cCVD9CkfBOyRYRfJYZfYhERkSDs+XsPn635jOGLh7Ny98rT06sUrUL7y9pzR9U7KFuwrIcJU08lLiIimUacL45Zm2bxwW8f8OWGL4nzxQFQNE9RulTvQqfqnbisyGUZ8iC1c6ESFxGRsLf10FbeW/weI5eNZFfMLsB/kFqTck3oXL0zt156Kzmy5fA4ZdpTiYuISFjyOR9T1k7h3cXv8sOfP+ACV+6uVKgSd1W/iy41unBRvos8ThlaKnEREQkru//ezUfLPuL9pe+zcf9GAHJE5qD1pa2574r7uK70dZlmc3lKVOIiIhIWNu7byJCfhzBq2SiOxx8HoOR5JXnimie4s9qdFMhZwNuAHlCJi4hIhhXni2P6+umMWjaKGRtmnN5k3qJiC+69/F5uqnhTWJ4allay7ncuIiIZ1v6j+xmxZATvLXmPzQc3A5A9Mjsdq3akz9V9qFyksrcBMwiVuIiIZAjOOWb/OZt3F7/L9PXTT58eVq5gOXrU6kHn6p0pkqeIxykzFpW4iIh46vDxw4z6bRTvL32f1XtWA/7Tw24sdyO9a/emafmmREZEepwyY1KJi4iIJ3Yc2cHrC15n+JLhxJ6MBfwXZXnwygfpWrNrpj89LC2oxEVEJF2t/GslwxcPZ+SykadvQNKgTAN61e5Fi4otyB6Z3eOE4UMlLiIiIedzPr7/83temf8K3/3x3enpt1xyC89e+yw1L6zpYbrwpRIXEZGQOR53nFHLRjH016Gs27sOgDxReehcvTPdr+hO9Quqe5wwvKnERUQkzW05uIWPln/EO4ve4a+//wL89+zuWasnD9Z+kIK5CnqcMHNQiYuISJpZtH0RA38ayPT10/E5HwBVi1alb72+tL2sbZa+MEsoaDRFRCRVfM7HVxu/4pX5r/Dj1h8BiLRI2l3Wjm41u3FD2RuyzLXM05tKXEREzsnRk0f5aPlHDFs4jDV71gBwXo7zuO+K+3ik7iNcmO9CjxNmfipxERE5K3tj9/LOonf+tb+7eL7i9Krdi55X9iRfjnweJ8w6VOIiIhKURdsX8fait/l09aenz+++/ILLefzqx7mt8m1ERUZ5nDDrUYmLiMgZxfni+HrT17z+8+vM2Tzn9PTmFZrzaN1Htb/bYypxERH5j4PHDvLB0g/43y//Y8eRHYB/f3e3mt24v9b9lDu/nMcJBVTiIiKSwKo9qxj+3XAmrp7I0bijAFQsVJGul3flvivuI3/O/B4nlIRU4iIiWZxzji83fMlr819j3rZ5p6c3KNOAx69+nGblm2mTeQalEhcRyaLifHGMXTGWQT8NYv2+9QDkzpabe2veS+86vbXJPAyoxEVEspi9sXt5d9G7vLP4HXbF7ALgwrwX0uuKXnSq0okShUt4nFCCpRIXEcki1u9dz/9++R8fLf/o9ClilQpVol+9fnSs1pFjscc8TihnSyUuIpLJ/Rr9KwPmDWDmxpmnp91Y7kYeu+oxGl/cWPu7w5hKXEQkE3LOMW/LPF5d8CozNs4AIFe2XHSs2pFHr3qUS4tc6nFCSQsqcRGRTMTnfExcPZHB8wfz267fAMgdlZvetXvzyFWPUDRPUY8TSlpSiYuIZALH444zYdUEBv40kA37NgBQIGcBHqrzED2v7KnyzqRU4iIiYexY3DE+XPohA38aePrKaqXyl6JfvX50qdGFnNlyepxQQkklLiISho4cP8LwxcN549c3Tpd31aJVebjuw3Sq1kk3I8kiVOIiImFkV8wuBswdwLiV4zh0/BAA1YtV59lrn6X1pa2JsAiPE0p6UomLiISBfbH7GPjjQN5d/O7pa5pfU/Ia+tbry00VbtJpYlmUSlxEJAPbcnAL7y5+l/eWvMfBYwcBuLnSzbxw/QtUK1bN23DiOZW4iEgGtHr3al5d8CpjVozB53wANLq4EYMbDebyCy/3OJ1kFCpxEZEMZN3edQyYO4AJqybgcERaJO2rtKdX7V5cXfJqr+NJBqMSFxHJAJbsWMLQX4fyyYpPcDiiIqK45/J7ePzqx3U3MTkjlbiIiIcW71jM83Of58sNXwIQaZF0qdGF5657jlL5S3mcTjI6lbiIiAfmb53Psz88yw+bfwAgZ7ac3F/rfh648gGteUvQVOIiIulo/d719Jvdj6nrpgJwXo7z6FazG09c84QujSpnTSUuIpIOft//O4N+GsRHyz8izhdHrmy5eKTuIzx+zeMUyFnA63gSplTiIiIh9NvO3xj669DTp4pFWiT3Xn4v/Rv0p/h5xb2OJ2FOJS4iEgJLdizhuTnPMXPjTAAiLILO1TvTr14/KhWu5HE6ySxU4iIiaWjlXyt5Yd4LfLbmMwDyROXhnsvv4aE6D+mANUlzKnERkTSwZMcSXvv5NT5d9SkOR/bI7Dx45YM8cc0TFMtbzOt4kkmFtMTNrCkwFIgEPnDOvZzo9fzAJ0CpQJbXnHOjQplJRCQtrfhrBf3n9D99tHlURBT3XXEfT1zzBCXzl/Q4nWR2IStxM4sE3gYaA9HAIjOb7pxbk2C2B4A1zrmWZlYEWG9mY51zJ0KVS0QkLSzftZyXfnyJSWsm4XCnz/N+qM5DlC5Q2ut4kkWEck28NrDJOfcHgJlNAFoBCUvcAfnMfw+9vMB+IC6EmUREUmX17tU888MzTFs3DYDskdnpVrMbT9V/iovyXeRtOMlyQlnixYFtCZ5HA3USzfMWMB3YAeQD2jkXuF3PGfh8PmJiYtIkYGxsbJp8TlancUw9jWHqhXoMDx8/zMCfB/LOkndOr3nfXfVuHrryIYrn858qllb/N3lFP4epl95jGMoST+oO9S7R8ybAMuAGoBzwrZn96Jw7/K8PMusOdAcoWVL7mEQk/cSejOWjlR/x6q+vsid2D5EWSeeqnXnq6qcolkcHrIm3Qlni0UDCxi2Bf407obuBl51zDthkZn8ClwALE87knBsBjACoVauWy5s3b5oGTevPy6o0jqmnMUy9tBrDk/EneXfxuwyeP5jtR7YDUKd4Hd5s9ia1i9dOk2VkVPo5TL30GsNQlvgioIKZlQW2A+2BOxLNsxVoCPxoZsWASsAfIcwkIpKirzd9Te+verNx/0YAqherTv8G/WlVqRX+Q3hEMoaQlbhzLs7MHgRm4T/FbKRzbrWZ9Qi8Phx4ARhtZivxb35/0jm3N1SZRESSs2r3KvrN7nf6tqDlzy/PwBsG0qZyGyIswuN0Iv8V0vPEnXMzgZmJpg1P8HgHcGMoM4iIpGTjvo30nd2XqWun4nDkypaL/g3680jdR4iKjPI6nsgZ6YptIpJlrdmzhhfnvcinqz/F53xkj8xO18u78n/X/Z+usiZhQSUuIlnOHwf+4MV5LzJ62WgcjqiIKLpU78KA6wfozmISVlTiIpJl7I3dy/Nznue9Je9x0neSSIukW81u9Kvfj1L5S3kdT+SsqcRFJNM7GX+Stxe9zQvzXmD/0f0Yxp3V7uS5a5+jQqEKXscTOWcqcRHJ1L75/Rv6fNOHlbtXAnBD2Rt4o8kbVC1W1eNkIqmnEheRTGnjvo30+bYP09dPB6B0/tK82exNWlZsqXO9JdNQiYtIpnLw2EEGzB3A0F+H4nM+8kTl4Zlrn+GhOg+RKyqX1/FE0pRKXEQyhWNxx3h7ydsMWTSEw8f9t1+4s9qdvNb4NZ0uJpmWSlxEwprP+Zi8ZjL9Zvfj9wO/A9CgTANea/waV1x0hcfpREJLJS4iYck5x+frP+fZH55l1e5VAFxS6BKGNBlCswrNPE4nkj5U4iISdtbuWUuPGT2Yt2UeABflu4gn6jxBpyqdOD//+R6nE0k/KnERCRsHjx3khbkv8ObCN4nzxVE4d2Geqf8M99W6j7hjcV7HE0l3KnERyfBOxp9k1LJR9J/Tn50xO4mwCO69/F5eafwK5+fyr3nHEONxSpH0pxIXkQzt520/02NGD1b8tQKAuiXqMqzZMGpdVMvjZCLeU4mLSIa0+eBmnv7+acatHAdAuYLlePGGF2l7WVvd21skQCUuIhnK4eOHGTB3AMMWDuNE/AmyR2bnkbqP8Nx1z5E7KrfX8UQyFJW4iGQIR08eZdjCYbz+8+vs/ns3AHdUvYMBDQZQ7vxyHqcTyZhU4iLiuS/Wf8EDMx9g2+FtANQpXodhzYZxZfErPU4mkrGpxEXEM9sObeOBmQ/wxYYvAKhWrBovN3yZpuWb6iYlIkFQiYtIuvv7xN8Mnj+YVxe8ytG4o2SPzM7gRoN5sPaDREZEeh1PJGyoxEUk3TjnmLBqAn2+7cOOIzsAaHNpG95u/rZuUiJyDlTiIpIu/jjwBw/MfICvN30NQI0LajCs2TDqlarncTKR8KUSF5GQOhZ3jFd+eoXBCwYTezKW/Dny82rjV+las6vO9xZJJZW4iITMgm0LuGvqXadvEdr2srYMazaMonmKepxMJHNQiYtImjtw9ADPfP8M7yx+B4BLCl/Cey3e49rS13qcTCRzUYmLSJqJ98Xz8fKPefzbx9l3dN/pq60NuH4A2SOzex1PJNNRiYtImvg1+le6Tu/K6j2rAbi29LUMbTqUGhfU8DaYSCamEheRVDkZf5IX573ISz++RLyLp3T+0gy4fgCdqnXSBVtEQkwlLiLnbMVfK7hzyp2s3L0Sw3i4zsMMajSInNlyeh1NJEtQiYvIWfM5H28vfJvHv32c4/HHKVOgDO+3fJ9GFzfyOppIlqISF5GzsmHfBu778j7mbJ4DQNfLu/Jmszd1m1ARD6jERSQocb44Bv44kJd+fIkT8Sc4P9f5DL9pOLdfdrvX0USyLJW4iKRo7Z613DXtLhbvWAxA5+qdef3G1ymUu5DHyUSyNpW4iJzRyfiT/O+X//F/c/6PY3HHKHleSUa2Gql93yIZhEpcRJL0287f6DilI2v3rgWgS40uDG06lPNynOdxMhE5RSUuIv9y9ORRXpn/Ci/Oe5F4F0/ZAmV5u/nbNKvQzOtoIpKISlxETluyYwntJ7dn0/5NAPSs1ZMhTYaQI1sOj5OJSFJU4iJC7MlY/vfz/3jxxxc5FneMykUq83bzt2lQpoHX0UQkGSpxkSxu9h+z6Tq9K1sObQH8+76H3zRca98iYUAlLpJFHTl+hD7f9GHE0hEA1LigBoMbDaZxucYeJxORYKnERbKgGRtmcN+X97H9yHayR2bn6fpP069eP6Iio7yOJiJnIegSN7M8zrm/QxlGRELrwNEDPPrNo4xeNhqAmhfWZOTNI6l+QXVvg4nIOYlIaQYzu9rM1gBrA8+rm9k7IU8mImlqwbYF1HivBqOXjSZ7ZHZeafQKC+9dqAIXCWPBrIn/D2gCTAdwzi03s2tDmkpE0ozP+Rj04yCem/McPuejdvHajGk9hoqFKnodTURSKajN6c65bWaWcFJ8aOKISFr648AfdJraiQXbFgDw2FWPMajhIO37FskkginxbWZ2NeDMLDvQm8CmdRHJmJxzTFoziXu/uJfDxw9TOHdhPmn9CU3KN/E6moikoWBKvAcwFCgORAPfAD1DGUpEzt2OIzt4+OuH+WzNZwC0qtSKD2/+UHccE8mEginxSs65jgknmNk1wPzQRBKRc+GcY/yq8fSc0ZNDxw+ROyo3gxsNpueVPUm0O0xEMolgSnwYUDOIaSLikZ1HdtLrq15MXjsZgOYVmvN287cpU6CMt8FEJKTOWOJmdhVwNVDEzB5N8NJ5QGSog4lIyk7t++45syd7Y/eSOyo3bzR5g3tr3qu1b5EsILk18exA3sA8+RJMPwzcFspQIpKyI8eP0HlaZ6aumwpAw7IN+fDmDyldoLTHyUQkvZyxxJ1zc4G5ZjbaObflXD7czJriPyguEvjAOfdyEvM0AN4AooC9zrnrzmVZIlnJ15u+pueMnvx58E/yROXh5UYv88CVD2jtWySLCWafeKyZvQpcBuQ8NdE5d0NybzKzSOBtoDH+o9oXmdl059yaBPMUAN4BmjrntppZ0bP/FkSyjuNxx3lq9lP875f/4XDUuKAGk26fRLnzy3kdTUQ8EEyJjwU+BVrgP92sM7AniPfVBjY55/4AMLMJQCtgTYJ57gCmOOe2Ajjndqf0oT6fj5iYmCAWn7LY2Ng0+ZysTuOYesGM4Zq9a+j0RSc27N9ApEXyeJ3HeaLuE0RFRqXZv4lwpp/D1NMYpl56j2GK104HCjnnPgROOufmOufuAeoG8b7iwLYEz6MD0xKqCBQ0szlmtsTM7krqg8ysu5ktNrPFe/fuDWLRIpmHz/l47dfXuPaTa9mwfwPlC5Zn9h2zefqap3XlNZEsLpg18ZOBP3ea2U3ADqBEEO9LauecS2L5VwANgVzAz2b2i3Nuw7/e5NwIYARArVq1XN68eYNYfPDS+vOyKo1j6iUew9/3/86dU+/kl+hfAOhSowvvNH+HXFG5vIgXFvRzmHoaw9RLrzEMpsRfNLP8wGP4zw8/D3g4iPdFAyUTPC+B/xeAxPPsDdzi9G8zmwdUBzYgksV9velr7ph8BweOHaBYnmKMvmU0Tcs39TqWiGQgKW5Od8596Zw75Jxb5Zy73jl3BbA/iM9eBFQws7KBa663J3AntAQ+B+qbWTYzyw3UQddllywu9mQsvb/qTbOxzThw7AAtK7Zk/YPrVeAi8h/JXewlEmiLfz/21865VWbWAngK/6bvy5P7YOdcnJk9CMzCf4rZSOfcajPrEXh9uHNurZl9DawAfPhPQ1uVFt+YSDhauH0hd39+N2v2rCFbRDb6X9effvX7EWHBHL4iIllNcpvTP8S/OXwh8KaZbQGuAvo656YF8+HOuZnAzETThid6/irw6llkFsl04n3xDFk0hIELBhLni6P8+eUZ32Y8tS6q5XU0EcnAkivxWkA155zPzHICe4Hyzrld6RNNJGv4ff/vdJrSiZ+3/wxA79q9eaXxK+TMljOFd4pIVpdciZ9wzvkAnHPHzGyDClwkbU1cPZHuX3Tn0PFDFM1dlE9u/YTG5Rp7HUtEwkRyJX6Jma0IPDagXOC5Ac45Vy3k6UQyqSPHj3D/jPsZu3IsAC3Kt2BY42GUKVrG22AiElaSK/FL0y2FSBbyze/f0O2Lbmw9tJVc2XLx+o2vc+cld+q65yJy1pK7Aco53fRERJJ2PO44/ef057WfXyPOF0fNC2sy9taxXFL4El02VUTOSTAXexGRVNq4byPtJrXjt12/AfB8g+d5qv5TZIvQP0EROXf6H0QkxCaunsg9n9/D3yf/pnT+0nzc+mOuLX2t17FEJBMIqsTNLBdQyjm3PsR5RDKNmBMx9PqqF6OXjQagzaVt+PDmD8mfM7+3wUQk00jxMlBm1hJYBnwdeF7DzBJfPlVEEli4fSG136/N6GWjyZktJ281e4vPbv9MBS4iaSqYNfH++O8NPgfAObfMzMqELpJI+HLO8dbCt3hk1iPEu3gqFqrIpNsnUbVYVa+jiUgmFEyJxznnDun0F5HkxZyIoeeMnoxZMQbwX3nt5UYv67ahIhIywZT4KjO7A4g0swpAb2BBaGOJhJeN+zZyy6e3sGbPGnJE5mBUq1F0qNrB61gikskFc2ukXsBlwHFgHHCI4O4nLpLpOecYsWQENd6rwZo9a7ik8CUsvW+pClxE0kUwa+KVnHNPA0+HOoxIODl8/DA9vuzB+FXjAehQpQPv3vSuDl4TkXQTTIkPMbMLgc+ACc651SHOJJLhrdq9itaftmbT/k3kjsrNW83e4u7L7/Y6lohkMSmWuHPuejO7AGgLjDCz84BPnXMvhjydSAY0YdUEuk7vSuzJWKoWrcqktpOoWKii17FEJAsKZp84zrldzrk3gR74zxl/LpShRDKiOF8cj856lA6TOxB7MpZO1Trxy72/qMBFxDMpromb2aVAO+A2YB8wAXgsxLlEMpQDRw/QfnJ7vvn9GyItklcbv8rDdR/WncdExFPB7BMfBYwHbnTO7QhxHpEMZ/mu5bSf3J51e9dRKFchJrWdRIMyDbyOJSIS1D7xuukRRCQjGrN8DN2+6Mbx+ONUKVqFLzt8SekCpb2OJSICJFPiZjbROdfWzFYCLuFLgHPOVQt5OhGPnIg/wZPfPsnQX4ficNxT4x7eaPoG+XLk8zqaiMhpya2JPxT4s0V6BBHJKLYf3k7bSW1ZsG0BERbBG03eoFftXtr/LSIZzhlL3Dm3M/Cwp3PuyYSvmdkrwJP/fZdIeFuyYwktxrdgV8wuiucrzme3f8ZVJa/yOpaISJKCOcWscRLTmqV1EBGvfbD0A6768Cp2xezi2tLXsvS+pSpwEcnQktsnfj/QE7jYzFYkeCkfMD/UwUTSS5wvjqdnP83gBYMB6HFFD95o+gY5suXwOJmISPKS2yc+DvgKGAT0TTD9iHNuf0hTiaST6MPRdJnWhdl/ziZbRDbeaf4O3a7o5nUsEZGgJFfizjm32cweSPyCmZ2vIpdwt3jHYhp+3JDDxw9TNE9Rxt46lkYXN/I6lohI0FJaE28BLMF/ilnCQ3MdcHEIc4mE1OQ1k+k0tRNH445St0RdPrv9M0qcV8LrWCIiZyW5o9NbBP4sm35xRELrRPwJ+nzTh2ELhwHQuXpn3mvxnvZ/i0hYSvHodDO7xszyBB7faWZDzKxU6KOJpK3NBzdz/UfXM2zhMCItktdvfJ1RrUapwEUkbAVzitm7QKyZVQeeALYAY0KaSiSN/bT1J6768CoWbFvAhXkvZP4983n0qkd1ARcRCWvBlHicc84BrYChzrmh+E8zEwkLn6z4hBs+uoFdMbu4sdyNLO+xnDol6ngdS0Qk1YIp8SNm1g/oBMwws0ggKrSxRFIvzhdHn2/60GlqJ076TtK9Zndm3DGDInmKeB1NRCRNBFPi7YDjwD3OuV1AceDVkKYSSaXth7fTcnxLXv/5dbJFZGNo06EMbzGcbBHB3H1XRCQ8BHMr0l1mNha40sxaAAudcx+HPprIuflp60+0/awtO2N2UiBnAaa0ncL1Za/3OpaISJoL5uj0tsBC4HagLfCrmd0W6mAiZ8s5x1sL36LRx43YGbOTa0pew5qea1TgIpJpBbNt8WngSufcbgAzKwJ8B0wKZTCRs3E87jg9ZvRg9LLRADxc52EGNx5MVKQO3xCRzCuYEo84VeAB+whuX7pIujhw9AAtx7dk/rb55M+Rn7ebv03Hah29jiUiEnLBlPjXZjYLGB943g6YGbpIIsHbFbOLm8bdxNKdS7kg7wVMbz+dK4tf6XUsEZF0EcyBbY+b2a1APfzXTx/hnJsa8mQiKVi1exUtx7dk88HNVDi/At/d9R2l8utigiKSdSR3P/EKwGtAOWAl0Mc5tz29gokkZ+LqiXSe1pljcce44sIrmHXnLArlLuR1LBGRdJXcvu2RwJdAG/x3MhuWLolEUvDSvJdoN6kdx+KO0alaJ+Z0maMCF5EsKbnN6fmcc+8HHq83s6XpEUjkTE7En6DXzF6MWDoCwxjYcCB96/X1OpaIiGeSK/GcZnY5/9xHPFfC5845lbqkm/1H99NyfEsWbFtA9sjsjG41mg5VO3gdS0TEU8mV+E5gSILnuxI8d8ANoQolktDaPWtpNrYZWw5tocR5JZjSdoqOQBcRIZkSd87pMlfiubmb53LzhJs5fPwwtS6qxZS2UyiZv6TXsUREMgRdtEUyrDHLx9Dw44YcPn6YlhVbMrfLXBW4iEgCKnHJcHzOR9/v+nLXtLuId/H0qt2Lqe2mkjsqt9fRREQyFN2XUTKU2JOxdPuiG+NWjiPSInmz2Zv0vLKn17FERDKkFEvczAzoCFzsnBtgZqWAC5xzC0OeTrKU7Ye3c+vEW1m4fSE5InPwefvPaVK+idexREQyrGA2p78DXAWcOp/nCPB2MB9uZk3NbL2ZbTKzM57Qa2ZXmlm8bnGadW3ct5FrRl7Dwu0LKZ6vOIu7L1aBi4ikIJgSr+OcewA4BuCcOwBkT+lNZhaJv+ybAZWBDmZW+QzzvQLMOovckoms/Gsl142+ji2HtnB1yatZ0n0JVYpW8TqWiEiGF8w+8ZOBonVw+n7iviDeVxvY5Jz7I/C+CUArYE2i+XoBk4GgTvz1+XzExMQEM2uKYmNj0+RzsrrUjOOC6AXcPvV2Dp84zNXFr2bSLZPIQ540+zsOF/pZTD2NYeppDFMvvccwmDXxN4GpQFEzewn4CRgYxPuKA9sSPI8OTDvNzIoDrYHhyX2QmXU3s8Vmtnjv3r1BLFrCwezNs7ll8i0cPnGYVhVaMa3NNPJlz+d1LBGRsBHMrUjHmtkSoCH+S67e4pxbG8RnWxLTXKLnbwBPOufi/cfPnTHDCGAEQK1atVzevHmDWHzw0vrzsqqzGcehvwzl4VkPA9ChSgfGtB5DZERkiJKFD/0spp7GMPU0hqmXXmMYzNHppYBY4IuE05xzW1N4azSQ8MocJYAdieapBUwIFHhhoLmZxTnnpqUcXcKRc47n5z7P83OfB+CZ+s/w/PXPE2G6ZIGIyNkKZp/4DPxr0AbkBMoC64HLUnjfIqCCmZUFtgPtgTsSzuCcK3vqsZmNBr5UgWdecb44en/Vm3cXv4thfHjzh9x9+d1exxIRCVvBbE6vmvC5mdUE7gvifXFm9iD+o84jgZHOudVm1iPwerL7wSVz+fvE37Sb1I4ZG2eQIzIHY28dS5vKbbyOJSIS1s76im3OuaVmFtSR5M65mcDMRNOSLG/nXJezzSLhYVfMLhqPacyq3avIEZmD7+76jnql6nkdS0Qk7AWzT/zRBE8jgJrAnpAlkkxlV8wubhxzI6t2r6L8+eWZdecsLi54sdexREQyhWDWxBOe8xOHfx/55NDEkczkr5i/uHHMjazcvZLKRSrz/V3fUyxvMa9jiYhkGsmWeOAiL3mdc4+nUx7JJDYf3EyLcS1YvWc15QqWY/Zds1XgIiJp7IwlbmbZAgen1UzPQBL+Nh/cTP1R9Yk+HE2lQpWY22WuClxEJASSWxNfiH//9zIzmw58Bvx96kXn3JQQZ5Mw9Pv+32nwUQOiD0dzTclr+KLDFxTMVdDrWCIimVIw+8TPB/YBN/DP+eIOUInLvyzduZQmnzRhb+xeal1Ui5kdZ3JejvO8jiUikmklV+JFA0emr+Kf8j4l8eVTJYv7ctOX3DPjHo7GHeXGcjcy8baJKnARkRBLrsQjgbwEdw10ycLGrR7H/bPux+d8dKrWifdbvk+ObDm8jiUikuklV+I7nXMD0i2JhKX3Fr9Hj697AP7roA+4fgDJ3cxGRETSTnIlrv+JJVmjl43m/hn3A/DSdS/xVIOnPE4kIpK1JFfiDdMthYSdcSvHcffn/puXPF//eXrX6u1xIhGRrOeM9390zu1PzyASPj5a9hGdpnYCoP91/Xm09qMpvENEREJBN3GWszLqt1Hc/fnd+JyPZ699lueue87rSCIiWdZZ38VMsq5PV33KfV/eh8PxcsOXebLek15HEhHJ0lTiEpTxK8fTcUpHHI5nr31WBS4ikgGoxCVF3/7+LZ2mdsLhGHjDQPrV7+d1JBERQfvEJQXzt87n1om3Eu/i6V27twpcRCQDUYnLGS3esZimY5sScyKG9lXaM6TJEK8jiYhIAipxSdJvO3+j0ceNiDkRQ7vL2vFJ60+IjIj0OpaIiCSgEpf/WLtnLU3HNuXQ8UO0rNiSMa3HqMBFRDIglbj8y6/Rv1JvVD12/73bfzey2ycSFRnldSwREUmCSlxOW7ZrGc3HNWf/0f3cVOEmprSdQs5sOb2OJSIiZ6BTzASArYe20ujjRuw/up+bK93M5LaTyRahHw8RkYxMa+LC6t2ruXbUtew7uo/mFZrz6W2fqsBFRMKA/qfO4v448Ac3fHwDu//ezWVFLmN8m/HahC4iEia0Jp6FbT20lQajG7D7793cUPYGFnVbxHk5zvM6loiIBEklnkVtPriZ+qPqs+3wNuqWqMuUtlPIFZXL61giInIWVOJZUPThaBqMbsDWQ1u58qIrmXHHDPLnzO91LBEROUsq8Sxm66GtNPy4IVsObaFMgTLMunMW5+c63+tYIiJyDlTiWchfMX/ReExjNuzbQLVi1VjSfQkFcxX0OpaIiJwjlXgWceDoAZqNbcaGfRuoXKQy39/1vdbARUTCnE4xywIOHD1A/VH1Wb1nNRcXvJgfOv9AodyFvI4lIiKppDXxTO7oyaPcNO4mVu9ZTbE8xZjbZS5F8xT1OpaIiKQBlXgmFu+L544pd/Bz9M+UOK8EC7stpMR5JbyOJSIiaUQlnkk553jyuyeZtm4aBXIW4OuOX1MqfymvY4mISBpSiWdSg+cP5vWfXyfCIph420QuK3qZ15FERCSNqcQzobErxtJ3dl8APmn9CY3LNfY4kYiIhIJKPJOZsnYKXT7vAsDrN75Oh6odvA0kIiIho1PMMpFJaybRblI7fM7Hk9c8ySN1H/E6koiIhJDWxDOJ6eun03FKR3zOx+NXP86ghoMwM69jiYhICGlNPBOYu3kurSa0AqB37d680ugVFbiISBagNfEwt27vOm759BYAHqn7CG80fUMFLiKSRajEw9ihY4e4adxNHDx2kJsr3czgxoNV4CIiWYhKPEzF+eJo/Wlr/jjwB9WLVWfcrePIFqG9IyIiWYlKPAw55+jzTR9+2PwDRXIXYVr7aeTJnsfrWCIiks5U4mFo4I8DGfrrULJHZmdy28mUKVDG60giIuIBlXiYGfnbSJ754RkAPrz5Q+qXru9xIhER8YpKPIxMWzeN7l90B2BEixHcWe1OjxOJiIiXVOJhYtamWdz+2e3Eu3j61etHtyu6eR1JREQ8phIPA8t3Lef2z24nzhdHr9q9eOmGl7yOJCIiGUBIS9zMmprZejPbZGZ9k3i9o5mtCHwtMLPqocwTjv488CeNxjTiyIkjdKjSQRdzERGR00JW4mYWCbwNNAMqAx3MrHKi2f4ErnPOVQNeAEaEKk84ij0Zyy2f3sLe2L00KNOAka1GEmHaeCIiIn6hbITawCbn3B/OuRPABKBVwhmccwuccwcCT38BSoQwT1hxztFhcgdW/LWCi/JdxMTbJpIzW06vY4mISAYSykt8FQe2JXgeDdRJZv6uwFcpfajP5yMmJiaV0fxiY2PT5HNC4ckfnmT6+unkypaLsS3HksvlSrPvO61l5HEMFxrD1NMYpp7GMPXSewxDWeJJ7bh1Sc5odj3+Eq93hte7A90BSpYsmVb5Mqxxq8fxztJ3yBaRjVE3jaLWhbW8jiQiIhlQKEs8GkjYuCWAHYlnMrNqwAdAM+fcvqQ+yDk3gsD+8lq1arm8efOmadC0/rzUWLpzKY/MfgSAQQ0H0a5GO48TBS8jjWO40himnsYw9TSGqZdeYxjKfeKLgApmVtbMsgPtgekJZzCzUsAUoJNzbkMIs4SF6MPRtBzfktiTsbSs2JLHrnrM60giIpKBhWxN3DkXZ2YPArOASGCkc261mfUIvD4ceA4oBLwTOG0qzjmXJbcdx56MpcW4Fuw4soNrSl7Dp7d9qlPJREQkWSG9d6VzbiYwM9G04Qke3wvcG8oM4cA5R7cvurH8r+WUK1iOz9t/Tq6oXF7HEhGRDE4nHWcAL//0MuNWjiN3VG6mtZ9GodyFvI4kIiJhQCXusa82fvWvu5JVKVrF40QiIhIuVOIeWr93Pe0nt8fnfDxc52HaV2nvdSQREQkjKnGP7D+6n+bjmnP4+GFaX9Ka15u87nUkEREJMypxDxyPO06zsc3448AfVC9WnTGtx+ia6CIictbUHOnMOce9X9zLwu0LKZqnKNPaTyNP9jxexxIRkTCkEk9nb/zyBp+s+ITcUbn5ssOXlClQxutIIiISplTi6eirjV/R59s+AIxqNYori1/pcSIREQlnKvF0svngZm6deCs+5+P5Bs/T9rK2XkcSEZEwpxJPBz7no/sX3TkWd4xGFzfi2Wuf9TqSiIhkAirxdPDagtf49o9vARjRYoSuiS4iImlCJR5i87fOp+93fQGY0nYKZQuW9TiRiIhkFirxEDp47CB3Tr0Th6PPVX1ofWlrryOJiEgmohIPEecc93x+D5sPbuaKC6/ghRte8DqSiIhkMirxEBny8xCmrptK3ux5mXj7RHJmy+l1JBERyWRU4iGwZs8anvr+KcB/Z7KLC17scSIREcmMVOJpLPZkLLd/djsn4k/Q5tI2Oh9cRERCRiWexu6fcT9r9qyhUqFKjGo1yus4IiKSianE09CwX4fx8fKPARjXZhz5cuTzOJGIiGRmKvE0snTnUp747gkAPmj5ATUvrOlxIhERyexU4mkg9mQsHad05FjcMdpc2oauNbt6HUlERLIAlXga6DilI+v2rqPkeSW1H1xERNKNSjyVPl/3OdPWTQNgWvtp2g8uIiLpRiWeCsfjjtN2kv8Usseuekz7wUVEJF2pxFPh2R+e5UT8CUqeV5JBDQd5HUdERLIYlfg5WrV7FUN/HQrAq41fJSoyyuNEIiKS1ajEz4Fzjl5f9eJE/AlaVGxBuyrtvI4kIiJZkEr8HAxfPJw5m+cA8H7L970NIyIiWZZK/Cyt2bOGx755DIBPb/uUC/Je4HEiERHJqlTiZ+F43HHaftaWo3FH6Vi1o25uIiIinlKJn4VXF7zK6j2rKX9+eYa3GO51HBERyeJU4kFa+ddKnv3hWQBGtBhB3ux5PU4kIiJZnUo8SL2+6gVA+yrtub7s9R6nERERUYkH5Zvfv2HulrkADLxhoMdpRERE/FTiKTh68ig9Z/QEoHft3pQtWNbjRCIiIn4q8RQ8MusRfj/wO5WLVOblRi97HUdEROQ0lXgy1u1dx3tL3gP8F3XJFZXL40QiIiL/UIkn4//m/B8AV5e8mqtLXu1xGhERkX9TiZ/BL9G/MHH1RABGtxrtbRgREZEkqMST4Jyjx5c9AOh7TV8qFKrgcSIREZH/UoknYdKaSSz/azlFchehb72+XscRERFJkko8kRPxJ3jyuycB6H5Fd/LnzO9xIhERkaSpxBMZMHcAfx78k0sKX0L/Bv29jiMiInJGKvEEdv+9myE/DwH8p5Rli8jmcSIREZEzU4kn8M6idzgad5Rm5ZtRr1Q9r+OIiIgkSyUecPTkUQbMHQDAY1c95nEaERGRlGl7ccDI30bicFQvVp2GFzf0Oo6ISIZ38uRJoqOjOXbsmNdRMgyfzwdARMS5rSPnzJmTEiVKEBUVFdT8KnHA53z0n9sfgG41u3kbRkQkTERHR5MvXz7KlCmDmXkdJ0OIj48HIDIy8qzf65xj3759REdHU7ZscDfb0uZ0YMraKeyN3Uv2yOz0qNXD6zgiImHh2LFjFCpUSAWeRsyMQoUKndWWjSxf4s45Bv00CIAhNw4hMuLsf3sSEcmqVOBp62zHM8uX+Pzo+SzduZTCuQtzz+X3eB1HRETO0tSpUzEz1q1bd3ranDlzaNGixb/m69KlC5MmTQL8+/P79u1LhQoVqFKlCrVr1+arr75KdjnHjx+nXbt2lC9fnjp16rB58+Yk5ztx4gTdu3enYsWKXHLJJUyePBmAIUOGULlyZapVq0bDhg3ZsmVLKr5rv5CWuJk1NbP1ZrbJzP5z/VLzezPw+gozqxnKPEn5YPkHAPS4ooduNSoiEobGjx9PvXr1mDBhQtDvefbZZ9m5cyerVq1i1apVfPHFFxw5ciTZ93z44YcULFiQTZs28cgjj/Dkk08mOd/AgQMpWrQoGzZsYM2aNVx33XUAXH755SxevJgVK1Zw22238cQTTwT/TZ5ByErczCKBt4FmQGWgg5lVTjRbM6BC4Ks78G6o8iTl0PFDzPh9BgD31rw3PRctIiJpICYmhvnz5/Phhx8GXeKxsbG8//77DBs2jBw5cgBQrFgx2rZtm+z7Pv/8czp37gzAbbfdxuzZs3HO/We+0aNH069fP8B/lHrhwoUBuP7668mdOzcAdevWJTo6OrhvMhmhPDq9NrDJOfcHgJlNAFoBaxLM0wr42PlH4RczK2BmFzrndp7pQ30+HzExMWkS8ONlH3Ms7hj1S9anULZCafa5WU1sbKzXEcKexjD1NIapd7Zj6PP5Th+Nne3F0NRJ3DNxyb4+ZcoUmjRpQrly5ShYsCCLFi2iZs2axMfH45w7nQ/8x0D5fD7Wr19PqVKlyJMnz79eP6V79+50796dWrVq/Wv69u3bueiii4iPj8fMyJ8/P7t37z5d0gD79+8H4Omnn2bevHlcfPHFvPnmmxQrVuxfn/XBBx/QpEmTJJd/Nj0Xys3pxYFtCZ5HB6ad7TyYWXczW2xmi/fu3ZtmAQ+dOES2iGx0q67TykREwtGECRNOr0G3a9fu9Nr4mQ4QC+bAsREjRvynwIEk17oTf15cXBzR0dFcc801LFq0iLp16/5ns/nYsWNZvHgxffr0STFLSkK5Jp7USCUegWDmwTk3AhgBUKtWLZc3b97UpwOeqf8Md1S9g6rFq+oIyzSQVn8vWZnGMPU0hqkX7BhGREScPh/a/d9/Cy7U9u3bxw8//MDq1asxs9NryK+99hpFixbl4MGD/zpf+8CBAxQtWpRKlSqxdetWYmNjyZcvX9DLK1GiBDt27KB06dLExcVx6NAhihQp8q/+KFKkCLlz56ZNmzZERETQrl07Ro0adTrHd999x6BBg5g7d+7pTeuJRUREBP93EHT6sxcNlEzwvASw4xzmCamLC1ysAhcRCUOTJk3irrvuYsuWLWzevJlt27ZRtmxZfvrpJypUqMCOHTtYu3YtAFu2bGH58uXUqFGD3Llz07VrV3r37s2JEycA2LlzJ5988kmyy7v55pv56KOPTi/7hhtu+E9/mBktWrRgzpw5AMyePZvKlf2Hg/3222/cd999TJ8+naJFi6bJGISyxBcBFcysrJllB9oD0xPNMx24K3CUel3gUHL7w0VERE4ZP348rVu3/te0Nm3aMG7cOHLkyMEnn3zC3XffTY0aNbjtttv44IMPyJ8/PwAvvvgiRYoUoXLlylSpUoVbbrmFIkWKAHDvvfeyePHi/yyva9eu7Nu3j/LlyzNkyBBefvnl06/VqFHj9ONBgwbRv39/qlWrxpgxY3j99dcBePzxx4mJieH222+nRo0a3HzzzakeA0tqG39aMbPmwBtAJDDSOfeSmfUAcM4NN/+vMG8BTYFY4G7n3H9HLoFatWq5pAb3XJw6cECb31JH45h6GsPU0xim3tmO4dq1a7n00ktDGSnspOayq6ckNa5mtsQ5958d9SG9drpzbiYwM9G04QkeO+CBUGYQERHJrLL8FdtERETClUpcREQkTKnERUTknIXyuKqs6GzHUyUuIiLnJGfOnOzbt09FnkZO3U88Z86cQb8npAe2iYhI5lWiRAmio6PZs2eP11EyDJ/PB/gv2HIucubMSYkSJYKeXyUuIiLnJCoqirJly3odI0NJ71MdtTldREQkTKnERUREwpRKXEREJEyF9LKroWBme4AtafiRhYG0u79p1qVxTD2NYeppDFNPY5h6oRjD0s65Ioknhl2JpzUzW5zU9Wjl7GgcU09jmHoaw9TTGKZeeo6hNqeLiIiEKZW4iIhImFKJwwivA2QSGsfU0ximnsYw9TSGqZduY5jl94mLiIiEK62Ji4iIhKksU+Jm1tTM1pvZJjPrm8TrZmZvBl5fYWY1vciZkQUxhh0DY7fCzBaYWXUvcmZkKY1hgvmuNLN4M7stPfOFi2DG0cwamNkyM1ttZnPTO2NGF8S/5/xm9oWZLQ+M4d1e5MyozGykme02s1VneD19OsU5l+m/gEjgd+BiIDuwHKicaJ7mwFeAAXWBX73OnZG+ghzDq4GCgcfNNIZnP4YJ5vsemAnc5nXujPYV5M9iAWANUCrwvKjXuTPSV5Bj+BTwSuBxEWA/kN3r7BnlC7gWqAmsOsPr6dIpWWVNvDawyTn3h3PuBDABaJVonlbAx87vF6CAmV2Y3kEzsBTH0Dm3wDl3IPD0FyD4W/FkDcH8HAL0AiYDu9MzXBgJZhzvAKY457YCOOc0lv8WzBg6IJ+ZGZAXf4nHpW/MjMs5Nw//mJxJunRKVinx4sC2BM+jA9POdp6s7GzHpyv+30LlHymOoZkVB1oDw9MxV7gJ5mexIlDQzOaY2RIzuyvd0oWHYMbwLeBSYAewEnjIOedLn3iZQrp0Sla5FaklMS3xYfnBzJOVBT0+ZnY9/hKvF9JE4SeYMXwDeNI5F+9fAZIkBDOO2YArgIZALuBnM/vFObch1OHCRDBj2ARYBtwAlAO+NbMfnXOHQ5wts0iXTskqJR4NlEzwvAT+3y7Pdp6sLKjxMbNqwAdAM+fcvnTKFi6CGcNawIRAgRcGmptZnHNuWrokDA/B/nve65z7G/jbzOYB1QGVuF8wY3g38LLz7+DdZGZ/ApcAC9MnYthLl07JKpvTFwEVzKysmWUH2gPTE80zHbgrcERhXeCQc25negfNwFIcQzMrBUwBOmmNJ0kpjqFzrqxzroxzrgwwCeipAv+PYP49fw7UN7NsZpYbqAOsTeecGVkwY7gV/5YMzKwYUAn4I11Thrd06ZQssSbunIszsweBWfiPyhzpnFttZj0Crw/HfyRwc2ATEIv/t1AJCHIMnwMKAe8E1iTjnG6kcFqQYygpCGYcnXNrzexrYAXgAz5wziV5KlBWFOTP4gvAaDNbiX/T8JPOOd3dLMDMxgMNgMJmFg38HxAF6dspumKbiIhImMoqm9NFREQyHZW4iIhImFKJi4iIhCmVuIiISJhSiYuIiIQplbiIBwJ3KFuW4KtMMvPGpMHyRpvZn4FlLTWzq87hMz4ws8qBx08lem1BajMGPufUuKwK3EGrQArz1zCz5mmxbJFwpFPMRDxgZjHOubxpPW8ynzEa+NI5N8nMbgRec85VS8XnpTpTSp9rZh8BG5xzLyUzfxeglnPuwbTOIhIOtCYukgGYWV4zmx1YS15pZv+5u5mZXWhm8xKsqdYPTL/RzH4OvPczM0upXOcB5QPvfTTwWavM7OHAtDxmNiNwH+lVZtYuMH2OmdUys5eBXIEcYwOvxQT+/DThmnFgC0AbM4s0s1fNbJH57618XxDD8jOBG0aYWW3z36P+t8CflQJXGhsAtAtkaRfIPjKwnN+SGkeRzCRLXLFNJAPKZWbLAo//BG4HWjvnDptZYeAXM5vu/r2p7A5glnPuJTOLBHIH5n0GaOSc+9vMngQexV9uZ9ISWGlmV+C/ilQd/Ffk+tXM5uK/x/QO59xNAGaWP+GbnXN9zexB51yNJD57AtAOmBko2YbA/fhviHPIOXelmeUA5pvZN865P5MKGPj+GgIfBiatA64NXGmsETDQOdfGzJ4jwZq4mQ0EvnfO3RPYFL/QzL4LXENdJNNRiYt442jCEjSzKGCgmV2L/zKhxYFiwK4E71kEjAzMO805t8zMrgMq4y9FgOz412CT8qqZPQPswV+qDYGppwrOzKYA9YGvgdfM7BX8m+B/PIvv6yvgzUBRNwXmOeeOBjbhVzOz2wLz5Qcq4P8FJqFTv9yUAZYA3yaY/yMzq4D/TlBRZ1j+jcDNZtYn8DwnUApdN10yKZW4SMbQESgCXOGcO2lmm/EX0GnOuXmBkr8JGGNmrwIHgG+dcx2CWMbjzrlJp54E1mj/wzm3IbCW3hwYFFhjTm7NPuF7j5nZHPy3sWwHjD+1OKCXc25WCh9x1DlXI7D2/yXwAPAm/ut4/+Ccax04CHDOGd5vQBvn3Ppg8oqEO+0TF8kY8gO7AwV+PVA68QxmVjowz/v4NzPXBH4BrjGzU/u4c5tZxSCXOQ+4JfCePEBr4EczuwiIdc59ArwWWE5iJwNbBJIyAf9m+vr4b7BB4M/7T73HzCoGlpkk59whoDfQJ/Ce/MD2wMtdEsx6BMiX4PksoJcFNkuY2eVnWoZIZqASF8kYxgK1zGwx/rXydUnM0wBYZma/AW2Aoc65PfhLbbyZrcBf6pcEs0Dn3FJgNP77Q/+K/05fvwFV8e9LXgY8DbyYxNtHACtOHdiWyDfAtcB3zrkTgWkfAGuApWa2CniPFLYEBrIsx3+bzMH4twrMx3/XrVN+ACqfOrAN/xp7VCDbqsBzkUxLp5iJiIiEKa2Ji4iIhCmVuIiISJhSiYuIiIQplbiIiEiYUomLiIiEKZW4iIhImFKJi4iIhCmVuIiISJj6f3edbNyQOW+nAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_AUC(ypred_all[:,1], ytest, \"LR All model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "acf5b513",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the CAP and compute AR\n",
    "plot_CAP(ypred_all[:,0], \"LR All model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "557a46b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random Forest Classifier\n",
    "rf = RandomForestClassifier(max_depth=15, random_state = 42)\n",
    "rf.fit(xtrain, ytrain)\n",
    "ypred_rf = rf.predict_proba(xtest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "69c72841",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# AUC for RF\n",
    "plot_AUC(ypred_rf[:,1], ytest, \"RF All model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "79fed67e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the CAP and compute AR for RF\n",
    "plot_CAP(ypred_rf[:,0], \"RF All model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe34e31b",
   "metadata": {},
   "source": [
    "# Analyze subgroup performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "52f152a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\leowe\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  after removing the cwd from sys.path.\n",
      "C:\\Users\\leowe\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \"\"\"\n",
      "C:\\Users\\leowe\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:6: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n",
      "C:\\Users\\leowe\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  import sys\n",
      "C:\\Users\\leowe\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:8: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "# Combine data and the predictions into one dataframe\n",
    "rfpred= rf.predict(xtest)\n",
    "lrpred= LR_all.predict(xtest)\n",
    "xtest['rfpredict'] = rfpred\n",
    "xtest['lrpredict'] = lrpred\n",
    "xtest['y'] = ytest\n",
    "xtest['rfcorrect'] = (xtest['rfpredict'] == xtest['y']).astype(int)\n",
    "xtest['lrcorrect'] = (xtest['lrpredict'] == xtest['y']).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "492242fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the random forest in the lower 25th percentile of the average FICO Score is 0.708604517047795\n",
      "Accuracy of the logistic regression in the lower 25th percentile of the average FICO Score is 0.5892876057763602\n",
      "Accuracy of the random forest in the upper 90th percentile of the average FICO Score is 0.8126487859069988\n",
      "Accuracy of the logistic regression in the upper 90th percentile of the average FICO Score is 0.6712426598952547\n"
     ]
    }
   ],
   "source": [
    "# By the lower 25th percentile of the average FICO Score\n",
    "fico1q = xtest['fico_range_low'].quantile(0.25)\n",
    "df_lowfico = xtest[xtest['fico_range_low'] < fico1q]\n",
    "print(\"Accuracy of the random forest in the lower 25th percentile of the average FICO Score is\", df_lowfico['rfcorrect'].sum()/df_lowfico.shape[0])\n",
    "print(\"Accuracy of the logistic regression in the lower 25th percentile of the average FICO Score is\", df_lowfico['lrcorrect'].sum()/df_lowfico.shape[0])\n",
    "\n",
    "# By the upper 10th percentile of average FICO Score\n",
    "fico90 = xtest['fico_range_low'].quantile(0.9)\n",
    "df_highfico = xtest[xtest['fico_range_low'] > fico90]\n",
    "print(\"Accuracy of the random forest in the upper 90th percentile of the average FICO Score is\", df_highfico['rfcorrect'].sum()/df_highfico.shape[0])\n",
    "print(\"Accuracy of the logistic regression in the upper 90th percentile of the average FICO Score is\", df_highfico['lrcorrect'].sum()/df_highfico.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "2ba1427a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the random forest for those who own their house is 0.7196969696969697\n",
      "Accuracy of the logistic regression for those who own their house is 0.5728927934810287\n",
      "Accuracy of the random forest for those paying rent for their house is 0.7136937016477028\n",
      "Accuracy of the logistic regression for those paying rent for their house is 0.583405988235424\n",
      "Accuracy of the random forest for those getting loans for a car is 0.7405002405002405\n",
      "Accuracy of the logistic regression for those getting loans for a car is 0.645983645983646\n"
     ]
    }
   ],
   "source": [
    "# By homeownership\n",
    "ownhome = xtest[xtest['home_ownership_OWN'] == 1]\n",
    "print(\"Accuracy of the random forest for those who own their house is\", ownhome['rfcorrect'].sum()/ownhome.shape[0])\n",
    "print(\"Accuracy of the logistic regression for those who own their house is\", ownhome['lrcorrect'].sum()/ownhome.shape[0])\n",
    "\n",
    "# By currently their house or not\n",
    "renthome = xtest[xtest['home_ownership_RENT'] == 1]\n",
    "print(\"Accuracy of the random forest for those paying rent for their house is\", renthome['rfcorrect'].sum()/renthome.shape[0])\n",
    "print(\"Accuracy of the logistic regression for those paying rent for their house is\", renthome['lrcorrect'].sum()/renthome.shape[0])\n",
    "\n",
    "# By the purpose of car loans\n",
    "car = xtest[xtest['purpose_car'] == 1]\n",
    "print(\"Accuracy of the random forest for those getting loans for a car is\", car['rfcorrect'].sum()/car.shape[0])\n",
    "print(\"Accuracy of the logistic regression for those getting loans for a car is\", car['lrcorrect'].sum()/car.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b5e0657",
   "metadata": {},
   "source": [
    "On average the random forest classifier does 10% better than the logistic regressor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e75c4bdf",
   "metadata": {},
   "source": [
    "# Economic insight by feature importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "f68df26b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardize the data\n",
    "xtrainnorm = (xtrain - np.mean(xtrain)) / np.std(xtrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "b95335f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Logistic regression on the standardized data\n",
    "lr = LogisticRegression().fit(xtrainnorm,ytrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "1d397684",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Collect the standardized coefficients\n",
    "coefs_lr = pd.DataFrame([xtrain.columns,lr.coef_[0]]).T\n",
    "coefs_lr['abs_coef'] = abs(coefs_lr[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "6ea88126",
   "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>Variable</th>\n",
       "      <th>Standardized Coefficient</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>int_rate</td>\n",
       "      <td>-0.362526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>term</td>\n",
       "      <td>-0.275132</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dti</td>\n",
       "      <td>-0.192408</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>acc_open_past_24mths</td>\n",
       "      <td>-0.172457</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>fico_range_low</td>\n",
       "      <td>0.153511</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>earliest_cr_line</td>\n",
       "      <td>-0.147458</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>loan_amnt</td>\n",
       "      <td>-0.137666</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>mo_sin_old_rev_tl_op</td>\n",
       "      <td>0.115808</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>total_acc</td>\n",
       "      <td>0.108137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>annual_inc</td>\n",
       "      <td>0.084245</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               Variable Standardized Coefficient\n",
       "0              int_rate                -0.362526\n",
       "1                  term                -0.275132\n",
       "2                   dti                -0.192408\n",
       "3  acc_open_past_24mths                -0.172457\n",
       "4        fico_range_low                 0.153511\n",
       "5      earliest_cr_line                -0.147458\n",
       "6             loan_amnt                -0.137666\n",
       "7  mo_sin_old_rev_tl_op                 0.115808\n",
       "8             total_acc                 0.108137\n",
       "9            annual_inc                 0.084245"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rank by the absolute value\n",
    "coefs_lr = coefs_lr.sort_values('abs_coef',ascending=False)[:10].reset_index(drop=True)\n",
    "coefs_lr['Variable'] = coefs_lr[0]\n",
    "coefs_lr['Standardized Coefficient'] = coefs_lr[1]\n",
    "coefs_lr = coefs_lr.drop(columns=[0,1,'abs_coef'])\n",
    "coefs_lr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "e041700b",
   "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>Variable</th>\n",
       "      <th>Feature Importance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>int_rate</td>\n",
       "      <td>0.221361</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>term</td>\n",
       "      <td>0.105709</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>fico_range_low</td>\n",
       "      <td>0.060954</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>dti</td>\n",
       "      <td>0.052049</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>loan_amnt</td>\n",
       "      <td>0.03677</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>bc_open_to_buy</td>\n",
       "      <td>0.034229</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>tot_cur_bal</td>\n",
       "      <td>0.032639</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>annual_inc</td>\n",
       "      <td>0.030565</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>acc_open_past_24mths</td>\n",
       "      <td>0.028917</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>mo_sin_old_rev_tl_op</td>\n",
       "      <td>0.02342</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               Variable Feature Importance\n",
       "0              int_rate           0.221361\n",
       "1                  term           0.105709\n",
       "2        fico_range_low           0.060954\n",
       "3                   dti           0.052049\n",
       "4             loan_amnt            0.03677\n",
       "5        bc_open_to_buy           0.034229\n",
       "6           tot_cur_bal           0.032639\n",
       "7            annual_inc           0.030565\n",
       "8  acc_open_past_24mths           0.028917\n",
       "9  mo_sin_old_rev_tl_op            0.02342"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Feature importance from the random forest\n",
    "coefs_rf = pd.DataFrame([xtrain.columns,rf.feature_importances_]).T\n",
    "\n",
    "# Ranked by feature importance\n",
    "coefs_rf = coefs_rf.sort_values(1,ascending=False)[:10].reset_index(drop=True)\n",
    "coefs_rf['Variable'] = coefs_rf[0]\n",
    "coefs_rf['Feature Importance'] = coefs_rf[1]\n",
    "coefs_rf = coefs_rf.drop(columns=[0,1])\n",
    "coefs_rf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "757002aa",
   "metadata": {},
   "source": [
    "By comparing the 2 tables and seeing a majority of overlapping variables, we have a good idea of the most important factors to credit risk and by their ranks we know how much more important 1 variable is over another. The sign of the standardized coefficients means the direction of the impact and we can compare with current literature and common sense to analyze the consistency."
   ]
  }
 ],
 "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}