Auto_LinearRegression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a6adfd99",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import re\n",
    "\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf\n",
    "from statsmodels.stats.outliers_influence import variance_inflation_factor\n",
    "from patsy import dmatrices\n",
    "import scipy.stats as st\n",
    "import scipy\n",
    "\n",
    "\n",
    "from sklearn.utils import resample\n",
    "from sklearn.metrics import *\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3e9f5e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Data:\n",
    "    \"\"\"\n",
    "    Load the data categorize the columns to categorical and numerical\n",
    "    \"\"\"\n",
    "    def __init__(self, filepath: str = None, targetcol: str = None):\n",
    "        self.data = pd.read_csv(filepath)\n",
    "        self.targetcol = targetcol\n",
    "\n",
    "    def get_numericals(self):\n",
    "        self.num_cols = list(self.data.dtypes[\n",
    "            (self.data.dtypes == 'int64') | (self.data.dtypes == 'float64')| \n",
    "            (self.data.dtypes == 'int32') | (self.data.dtypes == 'float32')|\n",
    "            (self.data.dtypes == 'int16') | (self.data.dtypes == 'float16')|\n",
    "            (self.data.dtypes == 'int8')].keys())\n",
    "        if self.targetcol in self.num_cols:\n",
    "            self.num_cols.remove(self.targetcol)\n",
    "        self.cat_cols = list(set(self.data.columns).difference(self.num_cols))\n",
    "        if self.targetcol in self.cat_cols:\n",
    "            self.cat_cols.remove(self.targetcol)\n",
    "        return self.num_cols, self.cat_cols\n",
    "\n",
    "    def get_inputs(self):\n",
    "        num_cols, cat_cols = self.get_numericals()\n",
    "        return num_cols, self.targetcol, self.data, cat_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f91f9ba9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def vif(targetcol, data, num_cols, cat_cols):\n",
    "    \"\"\"\n",
    "    Calculate the VIF and get the columns having multicollinear features (high VIF).\n",
    "    args:\n",
    "        targetcol: target column name\n",
    "        data: whole cleaned dataframe\n",
    "        num_cols: List of numerical column names\n",
    "        cat_cols: List of categorical column names.\n",
    "    return:\n",
    "        vif_high: list of features having high VIF>10\n",
    "    \"\"\"\n",
    "    y, X = dmatrices(targetcol+'~'+'+'.join(num_cols+cat_cols), data=data, return_type='dataframe')\n",
    "    vif = pd.DataFrame()\n",
    "    vif[\"VIF Factor\"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]\n",
    "    vif[\"features\"] = X.columns\n",
    "    vif_high = list(vif[vif['VIF Factor']>10]['features'])\n",
    "    if 'Intercept' in vif_high:\n",
    "        vif_high.remove('Intercept')\n",
    "    vif_high = list(set([re.sub(r'\\[.*', '', s) for s in vif_high]))\n",
    "    return vif_high\n",
    "\n",
    "\n",
    "def removal_on_vif(targetcol:str=None, data:pd.DataFrame=None, num_cols:list=None, cat_cols:list=None):\n",
    "    \"\"\"\n",
    "    Remove all the features having high VIF.\n",
    "    args:\n",
    "        targetcol: target column name\n",
    "        data: whole cleaned dataframe\n",
    "        num_cols: List of numerical column names\n",
    "        cat_cols: List of categorical column names\n",
    "    return: \n",
    "        num_cols: list containing numerical column names after removal based on VIF\n",
    "        cat_cols: list containing categorical column names after removal based on VIF\n",
    "    \"\"\"\n",
    "    vif_first = vif(targetcol, data, num_cols, cat_cols)\n",
    "    print(\"vif first run on all the columns together:\",len(vif_first))\n",
    "    feat_removal=[]\n",
    "    for i in vif_first:\n",
    "        cols = list(set(num_cols).difference(vif_first))\n",
    "        cols.append(i)\n",
    "        cols1 = list(set(cat_cols).difference(vif_first))\n",
    "        ans = vif(targetcol,data[cols+cols1+[targetcol]],cols,list(set(cat_cols).difference(vif_first)))\n",
    "        for j in ans:\n",
    "            if j in vif_first:\n",
    "                feat_removal.append(j)\n",
    "    feat_removal = list(set([re.sub(r'\\[.*', '', s) for s in feat_removal]))\n",
    "    num_cols = list(set(num_cols).difference(feat_removal))\n",
    "    cat_cols = list(set(cat_cols).difference(feat_removal))\n",
    "    print(f\"Columns Removed on basis of VIF: {feat_removal}\")\n",
    "    return num_cols, cat_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bec1e811",
   "metadata": {},
   "outputs": [],
   "source": [
    "def removal_on_pvalue(targetcol: str = None, num_cols: list = None, cat_cols: list = None, data:pd.DataFrame=None):\n",
    "    \"\"\"\n",
    "        Fit model and remove the columns based on pvalue test on each feature.\n",
    "    args:\n",
    "        targetcol: target column name\n",
    "        data: whole cleaned dataframe\n",
    "        num_cols: List of numerical column names\n",
    "        cat_cols: List of categorical column names\n",
    "    \"\"\"\n",
    "    model = smf.ols(targetcol+'~'+'+'.join(num_cols+cat_cols),data=data).fit()\n",
    "    pvalue_removal = list(model.pvalues[model.pvalues>0.05].keys())\n",
    "    if 'Intercept' in pvalue_removal:\n",
    "        pvalue_removal.remove(\"Intercept\")\n",
    "    pvalue_removal = list(set([re.sub(r'\\[.*', '', s) for s in pvalue_removal]))\n",
    "    num_cols = list(set(num_cols).difference(pvalue_removal))\n",
    "    cat_cols = list(set(cat_cols).difference(pvalue_removal))\n",
    "    print(\"Columns removed on basis of Pvalue:\", pvalue_removal)\n",
    "    return num_cols, cat_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "41882c81",
   "metadata": {},
   "outputs": [],
   "source": [
    "def anovatyp1_removal(targetcol: str = None, num_cols: list = None, cat_cols: list = None, data:pd.DataFrame=None):\n",
    "    \"\"\"\n",
    "        Fit anova test and remove the columns failing the anova type 1 test.\n",
    "    args:\n",
    "        targetcol: target column name\n",
    "        data: whole cleaned dataframe\n",
    "        num_cols: List of numerical column names\n",
    "        cat_cols: List of categorical column names\n",
    "        \"\"\"\n",
    "    model = smf.ols(targetcol+'~'+'+'.join(num_cols+cat_cols),data=data).fit()\n",
    "    anova_typ1 = sm.stats.anova_lm(model, typ=1)\n",
    "    m = anova_typ1['PR(>F)']\n",
    "    anovatyp1_removal = list(m[m>0.05].index)\n",
    "    print(\"columns removed on basis of anova typ1:\",anovatyp1_removal)\n",
    "    num_cols = list(set(num_cols).difference(anovatyp1_removal))\n",
    "    cat_cols = list(set(cat_cols).difference(anovatyp1_removal))\n",
    "    return num_cols, cat_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "11408a5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def finalmodel(targetcol: str = None, num_cols: list = None, cat_cols: list = None, data:pd.DataFrame=None):\n",
    "    \"\"\"\n",
    "    Fit final OLS model on data and also get explainability based on tstat values.\n",
    "    args:\n",
    "        targetcol: target column name\n",
    "        data: whole cleaned dataframe\n",
    "        num_cols: List of numerical column names\n",
    "        cat_cols: List of categorical column names\n",
    "    \"\"\"\n",
    "    print(f\"Final Model:{targetcol}+'~'+{'+'.join(num_cols+cat_cols)}\")\n",
    "    num_cols, cat_cols = removal_on_pvalue(targetcol, num_cols, cat_cols, data)\n",
    "    model = smf.ols(targetcol+'~'+'+'.join(num_cols+cat_cols),data=data).fit()\n",
    "    explanation = np.abs(model.tvalues).sort_values(ascending=False)\n",
    "    print(explanation)\n",
    "    explanation = explanation[explanation.index != \"Intercept\"]\n",
    "    sns.regplot(x = data[targetcol], y = model.fittedvalues)\n",
    "    plt.xlabel(\"True Price values\")\n",
    "    plt.ylabel(\"Predicted Price values\")\n",
    "    \n",
    "    return model, explanation, num_cols, cat_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fcb55ec3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def adjusted_r2(predictions:list=None, data:str=pd.DataFrame, targetcol:str=None):\n",
    "    \"\"\"\n",
    "    Calculate adjusted R2.\n",
    "    args:\n",
    "        predictions: list of all the fitted model prediction values.\n",
    "        data: DataFrame of initial dataset containing all columns.\n",
    "        targetcol: target column name.\n",
    "    \"\"\"\n",
    "#     try:\n",
    "    r2 = r2_score(predictions,data[targetcol])\n",
    "    adjr2 = 1-(1-r2)*(len(data)-1)/(len(data)-len(data.columns)-1)\n",
    "    return adjr2\n",
    "#     except:\n",
    "#         print(\"Unable to calculate adjusted R2, please check predictions list.\")\n",
    "    \n",
    "\n",
    "def bootstrap_confidence(n_iterations, targetcol, num_cols, cat_cols, data):\n",
    "    \"\"\"\n",
    "    get confidence score of the model using bootstrapping.\n",
    "    args:\n",
    "        targetcol: target column name\n",
    "        data: whole cleaned dataframe\n",
    "        num_cols: List of numerical column names\n",
    "        cat_cols: List of categorical column names\n",
    "        n_iterations: number of iteration to run bootstrapping\n",
    "    return:\n",
    "        Confidence interval: Lower and upper quantile.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        stats = list()\n",
    "        for i in range(n_iterations):\n",
    "            # prepare train and test sets\n",
    "            train, test, y_train, y_test = train_test_split(data[num_cols+cat_cols], data[targetcol], test_size=0.2)    \n",
    "            train[targetcol] = y_train\n",
    "            test[targetcol] = y_test\n",
    "            # fit model\n",
    "            model = smf.ols(targetcol+'~'+'+'.join(num_cols+cat_cols),data=train).fit()\n",
    "            # evaluate model\n",
    "            predictions = model.predict(test[num_cols+cat_cols])\n",
    "            score = adjusted_r2(predictions,test, targetcol)\n",
    "            if i%100 == 0:\n",
    "                print(f\"Adj R2 for iter {i}: {np.round(score,3)*100}%\")\n",
    "            stats.append(score)\n",
    "        alpha = 0.95\n",
    "        p = ((1.0-alpha)/2.0) * 100\n",
    "        lower = max(0.0, np.percentile(stats, p))\n",
    "        p = (alpha+((1.0-alpha)/2.0)) * 100\n",
    "        upper = min(1.0, np.percentile(stats, p))\n",
    "        print('%.1f%% confidence interval %.1f%% and %.1f%%'%(alpha*100, lower*100, upper*100))\n",
    "        return lower*100, upper*100\n",
    "    except:\n",
    "        print(\"not enough resampled data\")\n",
    "        return 0,0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f63b410d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ci_pi(targetcol, num_cols, cat_cols, data):\n",
    "    \"\"\"\n",
    "    Calculate Confidence Interval and Prediction Interval for a given Sample\n",
    "    args:\n",
    "        targetcol: target column name.\n",
    "        num_cols: list of numerical columns.\n",
    "        cat_cols: list of categorical columns.\n",
    "        data: DataFrame of whole initial dataset. \n",
    "    return:\n",
    "        2 tuples Confidence Interval and Prediction Interval\n",
    "    \"\"\"\n",
    "    y, X = dmatrices(targetcol+'~'+'+'.join(num_cols+cat_cols), data=data, return_type='dataframe')\n",
    "    stderr = np.sqrt(mse*np.dot(X.iloc[0].values,np.dot(np.linalg.inv(np.dot(X.T,X)),X.iloc[0].values.T)))\n",
    "    t_conf = st.t.ppf(0.025,len(X)-len(X.columns))\n",
    "    y_hat = model.predict(pd.DataFrame(data[num_cols+cat_cols].iloc[0:3]))[1]\n",
    "    conf_interval = y_hat-(np.abs(t_conf)*stderr), y_hat+(np.abs(t_conf)*stderr)\n",
    "    pred_interval = y_hat-(np.abs(t_conf)*np.sqrt((stderr**2)+mse)), y_hat+(np.abs(t_conf)*np.sqrt((stderr**2)+mse))\n",
    "    return conf_interval, pred_interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5f4ee43f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def influential_points(targetcol:str=None, num_cols:list=None, cat_cols:list=None, data:pd.DataFrame=None):\n",
    "    \"\"\"\n",
    "    Calculate cooks distance and studentized residual test.\n",
    "    Common elements in both cook's and studentized are removed.\n",
    "    args:\n",
    "        targetcol: target column name\n",
    "        data: whole cleaned dataframe\n",
    "        num_cols: List of numerical column names\n",
    "        cat_cols: List of categorical column names\n",
    "        n_iterations: number of iteration to run bootstrapping\n",
    "    return:\n",
    "        Confidence interval: Lower and upper quantile.\n",
    "    \"\"\"\n",
    "    n=len(data)\n",
    "    p=len(num_cols+cat_cols)+1\n",
    "\n",
    "    model = smf.ols(targetcol+'~'+'+'.join(num_cols+cat_cols),data=data).fit()\n",
    "    infl = model.get_influence()\n",
    "    inflsum=infl.summary_frame()\n",
    "    reg_cook=inflsum.cooks_d\n",
    "    atyp_cook = np.abs(reg_cook) >= 4/len(data)\n",
    "    cook_infl_points = list(data.index[atyp_cook])\n",
    "    \n",
    "    seuil_stud = scipy.stats.t.ppf(0.975,df=n-p-1)\n",
    "    #detection - absolute value > threshold\n",
    "    reg_studs=infl.resid_studentized_external\n",
    "    atyp_stud = np.abs(reg_studs) > seuil_stud\n",
    "    #which ones?\n",
    "    student_inflpoints = list(data.index[atyp_stud])\n",
    "    outliers = [i for i in student_inflpoints if i in cook_infl_points]\n",
    "    print(\"Index of influential points detected by Cooks and Studentized:\", outliers)\n",
    "    return outliers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d9a59ef8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def residuals_plot(fittedvalues, resid):\n",
    "    fig, ax = plt.subplots(figsize=(7,5))\n",
    "    ax.scatter(fittedvalues,resid)\n",
    "    ax.set_xlabel(\"Fitted Values\")\n",
    "    ax.set_ylabel(\"Residual\")\n",
    "    ax.axhline(0,linestyle= 'dashed',color='red')\n",
    "    ax.set_title(\"Fitted Values vs. Residuals\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "85d8f598",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adj R2 of old model: 0.953335747540716\n",
      "Adj R2 of old model: 0.953335747540716\n",
      "vif first run on all the columns together: 68\n",
      "Columns Removed on basis of VIF: []\n",
      "Index of influential points detected by Cooks and Studentized: [15, 29, 71, 134, 151, 163, 198]\n",
      "length of data after removing outliers: 194\n",
      "Columns removed on basis of Pvalue: ['stroke', 'make_chevrolet', 'make_mercedes_benz', 'make_mercury', 'engine_size', 'symboling', 'make_renault', 'peak_rpm', 'make_toyota', 'num_of_cylinders_twelve', 'num_of_cylinders_five', 'fuel_system_mfi', 'make_volvo', 'num_of_cylinders_four', 'fuel_system_1bbl', 'horsepower', 'engine_type_ohcv', 'compression_ratio', 'fuel_system_4bbl', 'num_of_cylinders_six']\n",
      "columns removed on basis of anova typ1: ['fuel_system_spfi', 'engine_type_dohc', 'aspiration_std', 'make_nissan', 'body_style_sedan', 'engine_type_l', 'engine_type_ohc', 'num_of_cylinders_two', 'engine_location_front', 'volume', 'fuel_system_idi', 'body_style_hatchback', 'make_honda', 'body_style_hardtop', 'fuel_type_gas']\n",
      "Final Model:price+'~'+make_mitsubishi+make_plymouth+engine_type_ohcf+make_volkswagen+city_mpg+fuel_system_spdi+fuel_system_2bbl+highway_mpg+make_subaru+curb_weight+num_of_doors_four+num_of_cylinders_eight+make_porsche+body_style_convertible+make_dodge+num_of_doors_two+drive_wheels_fwd+engine_type_rotor+body_style_wagon+drive_wheels_4wd+make_isuzu+engine_location_rear+aspiration_turbo+bore+drive_wheels_rwd+fuel_type_diesel+make_audi+make_bmw+make_alfa_romero+num_of_cylinders_three+make_jaguar+make_mazda+wheel_base+make_peugot+make_saab+fuel_system_mpfi\n",
      "Columns removed on basis of Pvalue: ['num_of_cylinders_three', 'make_jaguar', 'make_dodge', 'wheel_base', 'bore', 'make_volkswagen', 'fuel_type_diesel', 'fuel_system_mpfi', 'fuel_system_spdi', 'engine_type_rotor', 'fuel_system_2bbl', 'make_alfa_romero']\n",
      "num_of_doors_two          57.698072\n",
      "Intercept                 55.441845\n",
      "num_of_doors_four         50.674511\n",
      "drive_wheels_fwd          44.888168\n",
      "drive_wheels_rwd          38.816280\n",
      "drive_wheels_4wd          32.312263\n",
      "curb_weight               19.969357\n",
      "make_bmw                   9.233226\n",
      "make_audi                  6.786564\n",
      "make_peugot                6.346320\n",
      "aspiration_turbo           5.040708\n",
      "make_porsche               3.900351\n",
      "make_isuzu                 3.881851\n",
      "body_style_convertible     3.828038\n",
      "body_style_wagon           3.680784\n",
      "make_mitsubishi            3.543141\n",
      "engine_location_rear       3.125802\n",
      "num_of_cylinders_eight     3.037186\n",
      "engine_type_ohcf           2.813207\n",
      "make_subaru                2.799107\n",
      "make_plymouth              2.795968\n",
      "make_saab                  2.768756\n",
      "city_mpg                   2.744494\n",
      "make_mazda                 2.573140\n",
      "highway_mpg                1.738452\n",
      "dtype: float64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 261,
       "width": 391
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 302,
       "width": 698
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                  price   R-squared:                       0.958\n",
      "Model:                            OLS   Adj. R-squared:                  0.953\n",
      "Method:                 Least Squares   F-statistic:                     186.9\n",
      "Date:                Sat, 15 Oct 2022   Prob (F-statistic):          9.56e-107\n",
      "Time:                        13:58:11   Log-Likelihood:                 173.18\n",
      "No. Observations:                 194   AIC:                            -302.4\n",
      "Df Residuals:                     172   BIC:                            -230.5\n",
      "Df Model:                          21                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==========================================================================================\n",
      "                             coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------------------\n",
      "Intercept                  4.1776      0.075     55.442      0.000       4.029       4.326\n",
      "make_mitsubishi           -0.1220      0.034     -3.543      0.001      -0.190      -0.054\n",
      "engine_type_ohcf           0.1214      0.043      2.813      0.005       0.036       0.207\n",
      "make_plymouth             -0.1170      0.042     -2.796      0.006      -0.200      -0.034\n",
      "city_mpg                  -0.0167      0.006     -2.744      0.007      -0.029      -0.005\n",
      "highway_mpg                0.0106      0.006      1.738      0.084      -0.001       0.023\n",
      "make_subaru               -0.1375      0.049     -2.799      0.006      -0.235      -0.041\n",
      "curb_weight                0.0007   3.39e-05     19.969      0.000       0.001       0.001\n",
      "num_of_doors_four          2.1054      0.042     50.675      0.000       2.023       2.187\n",
      "num_of_cylinders_eight     0.2148      0.071      3.037      0.003       0.075       0.354\n",
      "make_porsche               0.4231      0.108      3.900      0.000       0.209       0.637\n",
      "body_style_convertible     0.1826      0.048      3.828      0.000       0.088       0.277\n",
      "num_of_doors_two           2.0721      0.036     57.698      0.000       2.001       2.143\n",
      "drive_wheels_fwd           1.3651      0.030     44.888      0.000       1.305       1.425\n",
      "body_style_wagon          -0.0947      0.026     -3.681      0.000      -0.146      -0.044\n",
      "drive_wheels_4wd           1.3356      0.041     32.312      0.000       1.254       1.417\n",
      "make_isuzu                -0.3004      0.077     -3.882      0.000      -0.453      -0.148\n",
      "engine_location_rear       0.2589      0.083      3.126      0.002       0.095       0.422\n",
      "aspiration_turbo           0.1177      0.023      5.041      0.000       0.072       0.164\n",
      "drive_wheels_rwd           1.4768      0.038     38.816      0.000       1.402       1.552\n",
      "make_audi                  0.3292      0.049      6.787      0.000       0.233       0.425\n",
      "make_bmw                   0.4115      0.045      9.233      0.000       0.324       0.499\n",
      "make_mazda                 0.0740      0.029      2.573      0.011       0.017       0.131\n",
      "make_peugot               -0.2402      0.038     -6.346      0.000      -0.315      -0.165\n",
      "make_saab                  0.1355      0.049      2.769      0.006       0.039       0.232\n",
      "==============================================================================\n",
      "Omnibus:                        1.386   Durbin-Watson:                   1.375\n",
      "Prob(Omnibus):                  0.500   Jarque-Bera (JB):                1.253\n",
      "Skew:                           0.038   Prob(JB):                        0.534\n",
      "Kurtosis:                       2.614   Cond. No.                     1.72e+19\n",
      "==============================================================================\n",
      "\n",
      "Notes:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
      "[2] The smallest eigenvalue is 4.44e-30. This might indicate that there are\n",
      "strong multicollinearity problems or that the design matrix is singular.\n",
      "R2 of the Final Model 0.9528849442471473\n",
      "Adj R2 for iter 0: 81.3%\n",
      "Adj R2 for iter 100: 88.2%\n",
      "Adj R2 for iter 200: 84.5%\n",
      "Adj R2 for iter 300: 86.7%\n",
      "Adj R2 for iter 400: 86.2%\n",
      "Adj R2 for iter 500: 83.5%\n",
      "Adj R2 for iter 600: 78.0%\n",
      "Adj R2 for iter 700: 77.4%\n",
      "Adj R2 for iter 800: 88.7%\n",
      "Adj R2 for iter 900: 86.6%\n",
      "95.0% confidence interval 69.2% and 90.0%\n",
      "Confidence Interval for a given sample is: (9.449054311180346, 9.690836394368537)\n",
      "prediction Interval for given sample is: (9.329560074239259, 9.810330631309624)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4MAAAKXCAYAAAA4p5/DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAABYlAAAWJQFJUiTwAACAT0lEQVR4nO3de5xcdX3/8fcn3HIFsgQCTQgsZAOIIIJhxbWIrqI/vGFQQisR0tRabSXeWvDSAmor1rZA0LaoMWi0NQh4rfcVRFZcImhBuWSDGwIoqyFclkuAkO/vj3PGTCZzOefMuZ/X8/HYxyQz55z57uyZme/nfD/fz9eccwIAAAAAVMukrBsAAAAAAEgfwSAAAAAAVBDBIAAAAABUEMEgAAAAAFQQwSAAAAAAVBDBIAAAAABUEMEgAAAAAFQQwSAAAAAAVBDBIAAAAABUEMEgAAAAAFQQwSAAAAAAVBDBIAAAAABUEMEgAAAAAFQQwSAApMzMrjAzZ2YXZN2WqMzsAv93uCLrtnRiZgf7bXVZtwXF0c371MxO8vfdEH/LojGzDX6bTsq6LQDyg2AQALpU12ns9POuAMe6wP/Zu802J/nbnBrjr5EoM3tp3etwfMB9ZprZU/4+f510G5G8uiCp8ecpM7vfzL5pZm/Kup0AUBW7Zt0AACiRZyRtbvP44/7t7yTdJWlTk23O92+vkPRwi+Oc5G/3eUlfC9fEzFwn6R5JB0l6i6SbAuxzhqTdJT0laU1iLUNWNkl61v/3DEl/4v+8xsyuknSGc+7ZVjunoN37FABKgZFBAIjPT51z+7f5+YwkOefe75w73Dn3yawbnBbnnJP0Bf+/Z5jZbgF2e4t/+w3n3EPJtAwZWlj33pgm6VBJX/Efe6Okt2XXtGq+TwFUD8EgACAttWBwH0mntNvQzPokvdD/7+eTbBTywTn3G0lvlnS7f9db2mwOAIgBwSAApKxZYYrafXWbjTXMqbqiVghF21NJz2oy9+rgJs/3WjP7upk9YGZPm9nv/blZr+zQzsPM7H/87Z80szvN7Hwz2yPK7+2cWy9p2P9vp45+7fFxSd/z23OAmb3dzP7XzEbN7Akze9TMfmFmF7abZ9mKmV3nv25nt9mmbeENM5tuZh8ws7Vm9oiZbfHbt8LMDmyxzyQzO9vMrjWzB83sGTP7g5n92sw+Z2avCvE7jPrt+9sO233P3+7fG+5/npl9wf89nzKzCTP7jZl918zeZWZTg7alW865ZyRd6//3Oa22M7MXm9mXzew+v80PmtkPzezPzMxa7NNrZv9pZuv88/kJM7vHPwfeb2azGrZvW0DGzPYys381szH/b36vmX3GzOa2+x3bvVf9x1sWPPLPtTeZ2ZfM7Fdm9rD/u6w3s0/7F1FCy9M5ACBdzBkEgHx4RF7gM9v/f/18qtrjz/rbTJc0TdIW//56f9zHvFTMVfJGW2oelbSvpNfIm5v1Cefc3zc2xsxOlPQdSVPr9uuVdIGkV8qbAxjF5yUN+M89s1n6p9+ZP9P/75ecc1v9f18m6bS6TR+WtKekY/yfN5vZSc65+yK2LTQzO0Le63SQf9dWeXMc50t6p6Qzzey1zrnhhl1XS/rzuv8/Iu93mSUvCHqOpO8GbMb/SPoH/3hNUxrNbD9Jg/5//7vu/lPkzTutpe0+JWmbvL91r7y/9Xcl3RmwLXGoBXO7NH3Q7OOS6s/ZCUl7y/v9BiW9zsze7JzbVrfPsfLO2Rn+Xc/Im8M7z/95iaRfKOBrbmYHSLpe3t9Z8t6Le0v6S0mvl/T+IMeJ4Gx574OaCXkX9g/1f/7czE51zv0w6AFzeg4ASAkjgwCQA8655c65/evuWtgw33C5c+5ef5t/9bdZ02Re4r11x/gXeYHgBnmBwgzn3F7yOsRvkxfg/Z2Z/Vl9W8xspry5W1Ml3SLpGH+/6ZLOkvQ8Se+I+KteKa/jvLukxS22OVHSwf6/v1B3/6ikD0k6UtIU59xMSZPlFdRZK68zfHnEdoVmZntJ+ra8QPBrko712zVdXid6taSZkq6uH7X0A+0/l9fhfrekPZ1ze8v7Xf5EXof/hhBN+ZJ/e0Kr0SZJb5IXXI06535ed/9l8oKAb0k6zDk32f9b7yXv7/AZeX+vVPgXMF7q//c3TR5fLi8Q/IO8c3Cmc25PeRdHTpdX9OUMSec27Pqv8s77EUnHOud298+faZIWSrpEO19Yaefz8gLBTfKCv2nOuRnyXrNHJf1biGOF8aC8v9mLJO3t/+6TJR0h7zyYJum/zWxaiGPm6hwAkDLnHD/88MMPP138yKv86SQ9LemBFj+rmmx/QZNjOf/n4DbPd4G/zRVttumTN0r4kKRDWmxzun+cXzXc/w/+/ZskzWqy35l17WzZhjZt+x9/35+2eHyl//gvQhyzR9Lv/f16Gx47uNbeJvtd5z92dptjb/C3Oanh/o/6939NkrXY93/9bd5Xd9/f+/d9J8Zz8Bb/mO9v8fgNjeecpP3q/o6z435ftGjHSa3OcUmHyLtYUHv83IbH95Y3EvaMpONbHP+F8oLszZJ2r7v/Cf+Y/SHa2vR9KulP69r40ib7zZcXPDlJG5o83vY93u587dBek/QDf9+zgpzHWZwD/PDDT75+GBkEgPjsJi/Ns9nPzJTb8hZ52R9fc15hjmaukZcSdqSf9lbzRv/2M865ZmX1vyRvmYioagVhTjCz+fUPmNmUuucPXDjGObdZ0k9rx+2ibWGc5d9e7JxrtaD9//i3r6i771H/dj8zi+t7uJb6+WeND5jZPHkjSfXbSV5gVUulPEDpW2vePNYHzOxxSXfLG8GUvHmilzZsf5q80ekbnHNNlyZxzv1M3ojiTEnH1T1Ue83j+D1r5+fPnHPXNj7ovLmxqS+F4p+D/+v/dyDgblmfAwAyRjAIAPH5sXPOWvycmnJbap3/N9Z1uHf4kXSfts8TOlCSzGx3eWmYkvTjZgf2O53Xd9G2H0j6rf/vJQ2PnSpv7txW7Ri4yG/f8X6BlTvN7LG6YhxOXrqe5KVaJsovDFMrFPKVNq/xCn+b+kIyP5Q3inyspOvM7Ewz67bN/yOvU3+UmT234bE/kzdqdLNzbl3tTufck9r+N/6emX3IzI4xs6Zz9RIwS9svltQXKLlQ0inOucbUxNo53d/q9fZf83n+dvWv+bf92y+Y2UVm9kILtrxJM8f6t03fHwEe64qZzTWzj5vZzX4BmWfr3gMX+5sFOp9ycA4AyBjBIACUU+0q/3S1Hq2cre3fA7XOeI+2F+6oBWzN3B+1Yc5bSPyL/n+XNFR/rFUR/a5z7vf1+5nZ+yT9TNJSSYfJmyv1kLyiOuPaPq8pzHypqOpHUfZV5xHhPwY7/sjR2yU9KS/lcLWk+/2qlP9pZs8P2xjn3P2SfuL/t3F0sPb/nYJreQVP7pCXLvgReUVUHjavYuuZZpZkoble55zJOwfnyJs/+aS84ivNqqnWXvMpan9O14K8+gDz7+SNHM+QN5/wRkmPmtmPzKtQOyVEu/f1bxN5f7RjZi+R9/f6e3lB6V7yRvdq74HaCGiY90CW5wCAjBEMAkA51T7fl7cZraz/uS7k8ZuW7w+hlgLaK+nFkmRm+2t7OuUOKaJmdqSkj/vP+0l5o5d7OOd6nF88R9JVMbUtiPrvz70CvL4H1+/snPucvN/9XZK+Lq8wyMGS/lrSzWb2gQht2ilV1K92+jx5o4ZfbtzBTyE+WtIbJH1aXlAwXd46kKsljZjZ9AhtCcx5fuucu0ReYLK7pC+a2ZyGTWuv+cUBz+kr6p7jQXnn2Svkjdb+wn+el0r6D0m/6rQkREixn4P+SOYX5f19fiivuMsU59zede+B94R9/jycAwCyQzAIAOU07t+2XKuthc3avjxFu1SzruYXOedul1SrallLFX2zvFHJhyR9s2GX0+R9Z33POfdO59zt/ghjvdkKr7ZsxeQ22+zV5L7xun+HfY0lSc65cefcpX4K8b6Sjpf0VXkd+Y+Y2dEhD/kVeemnvWb2Qv++WmD4Y+dc05Es59xW59zXnHNvc849R97f9u/kjbQeq+3rWibOOfff8kY4Z8or0FMv6jldO7Zzzv3QeZV5j5WXpvo2eef8IdqeYtnJH/zbqO+P2nnb6pxrdr5J3lzYufLa+3rn3E+apNJGeQ/k6hwAkC6CQQDIl1ohknZX9rcF2OZG//a1YeZGOeeelvRr/78nNtvGT+ts+lhItdG/081ssraniH7ZOfdUw7a1UZtftGjTNHmVJMN6uOH4jcedL6+K5Q6cc2PaHpwsivC8jcdzzrm18gqo3Cfv+/nFIY/xkLzCK9L2NQzP8G+bpYi2Os4Dzrl/lbfcguStwZemj/i3bzGzBXX3187pl5jZPt0+iXPuIefcpyXVRmGD/p63+Lft3gPtjvWwf9tqJHJhi/tr269zzj3RYpuXt3newHJwDgBICcEgAORLbc7P3l1u83l5QeOfqMMC2P66gvW+4t++1cx6muxyhravA9iN/5E3krWXvPUDayNhzaqI1taAO6rFsT6o7QuKh3Gbf/u6Fo+f12bfK/zbd/jpmE2ZZ6+6/+/ealt/tPMZ/797tHnuVmpB3+n+6GCfvNf46ibt2q1hvmajJ7toR2TOuR9I+qW8Pkp9uuxX5C0UP1nSJ9odo/6cNrNJHea9hf09a++PE/w1Ixuf+xC1XkNT2n7Ovb7xATPbQ17qcDO190Cff/Gkcd+TtX2NxkDyeg4ASA/BIADkS21U7i1tKvrVtnmxmfU128A5d4e2X9W/0Mw+5XdSJUlmNt3MXmFmq7W9c1vzKXlr9s2SV2HwaH+f3czsTHmLUIdZoLspfx5XrRR+LWC9yzk30mTzH/i3rzazD5jZVL9N+5rZJ/z9H4zQjKvkjcYeZWaXmr84vJntZ2Yr5KWwthqFuUjeMgbTJP3YzM6qn1tlZgea2Vsl3SxvPlbNP5vZVWZ2an2wbWaz/efs9dv0A4X3DUmPyUsX/JR/33f8UcNGR8qbK/cuM1tQCwr8v/Np2j7/7Hv1O5nZ2ba9iuvBEdoYxL/6t282s17pj+dL7TxZamZX1ldONbPJZvZiM/uUpOG6Y+0pab2ZfdDMjqq9r/wgcVDSP/nb7fB7tuKcu0Hb/zZXmdlrzF8ixMwGJH1X3pItrVzp377VzJb6AWBtXuy31Tr9dFjeubiPvKqoB/j7TTGzv5AX8Id9D0Q6BwCUiMvBYof88MMPP0X+0fbFqa8Luf0FTR5bqu2LQD8pbz2/DZL+tW6b3SSt97fZJi9w2+D/zK3bbhd5xTFc3c+j8ubkbau779om7XiJti/U7eSlttUW0v6ppI8p4qLzDc/z+ob2NV003d/26rrtaguL136Pla1eV3VYxFvSvze0ofb6bJV0tlosOu/vO1/S7XX7PiuvQ/5EwzHPqtvnkobHHvH/LvX3faCL1/SLDcc6vcV2xzRst8Vv+7N1962VtGfDfmfXPX5wyLadFGRfSbvWve6XNzz2oYbz93Ftn+tau2+sbvu9G37Pp/3fc2vdfXer7r0T4H16gKTRuv2fkFfV08l7Py5T60Xnd5NXFbe27zP+OeD8dv3xPdFk33MafpeH/f2dvBTqd6rFZ5GaLzof6Rzghx9+yvPDyCAA5IhzbpWkt0q6SV5n9UBJB8kbpatt84ykQflLEsgrtnGQ/7Nr3XbPOufeIW/u2RflBZa7yyvNv1FesZKz5K3t19iOH0t6vrzFs/8gL01sg6QLJL1M7Uc+wvi2thfk2KbtS040s1he2uYd8jrAJm+05Czn3LIu2vBeSe+Q9H/aHvB+T9LLXF1Fymact0zE8/39r5UXlNTWSbxV0mXyAuvVdbtdLK9T/3VJ6/zfYw9J98p7vU90zv1zF7/Pl+r+/Zh2LsZTc4e8BdT/S/5yAn7bH5V0g7zAYsA592iL/RPjnNuq7QVdzq6v9Omc+6i8CqmflheQmbzR2d9J+o68ZTv66w73qKTXyAvCb5J3vs2QF0SulZdifIxz7r4Q7fudvLl9/y7vfbWLvIBupbyCK3e32fcZeVVNPyHvPbXNb8sVko6Tdx622neFvDmqtVHCXSXdKa/Ay4vkBaRh5PYcAJAOc85l3QYAAAAAQMoYGQQAAACACiIYBAAAAIAKIhgEAAAAgAoiGAQAAACACiIYBAAAAIAKIhgEAAAAgAoiGAQAAACACiIYBAAAAIAKIhgEAAAAgAoiGAQAAACACto16wagNTMbk7SnpA0ZNwUAAABAPh0s6VHnXG/YHQkG823PKVOm9BxxxBE9WTcEAAAAQP7ccccdevLJJyPtSzCYbxuOOOKInptvvjnrdgAAAADIoeOOO0633HLLhij7MmcQAAAAACqIYBAAAAAAKohgEAAAAAAqiGAQAAAAACqIYBAAAAAAKohgEAAAAAAqiGAQAAAAACqIYBAAAAAAKohgEAAAAAAqiGAQAAAAACqIYBAAAAAAKohgEAAAAAAqiGAQAAAAACqIYBAAAAAAKohgEAAAAAAqiGAQAAAAACpo16wbAAAAsrFufELD6zfpsS1bNX3yrhqYP0sLZs/IulkAgJQQDAIAUDHD6zfp0qFR3TS2eafHju/t0fLBPg3Mn5VBywAAaSJNFACAClmzdqOWrBxpGghK0k1jm7Vk5YiuXHtvyi0DAKSNYBAAgIoYXr9J77/mNm1z7bfb5qTzrrlVw+s3pdMwAEAmSBMFAETGnLNiuXRotGMgWLPNSSuGRkkXBYASIxgEAITGnLPiWTc+0TI1tJWRsc1aNz5BgA8AJUWaKAAgFOacFVPUlE9SRQGgvAgGAQCBMeesuB7bsjXV/QAA+UcwCAAILMqcM+TD9MnRZoZE3Q8AkH8EgwCAQLqZc4bsRZ3DydxPACgvgkEAQCDMOSu2BbNn6PjenlD79Pf2UDwGAEqMYBAAEAhzzopv+WCfJlmwbSeZdM5gX7INAgBkimAQABAIc86Kb2D+LH1s0VEdA8JJJl206GhSRAGg5PiGBgAEwpyzcli8cJ7mzpyqFUOjGmkyB7S/t0fnsE4kAFQCwSAAIJDanLMwRWSYc5ZPA/NnaWD+LK0bn9Dw+k16bMtWTZ+8qwbmz+LvBQAVQjAIAAhs+WCflqwcCbS8BHPO8m/B7BkEfwBQYcwZBAAExpwzAADKg5FBAEAozDkDAKAcCAYBAKEx5wwAgOIjGAQARMacMwAAios5gwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQbtm3QAAQHGsG5/Q8PpNemzLVk2fvKsG5s/Sgtkzsm4WAACIgGAQANDR8PpNunRoVDeNbd7pseN7e7R8sE8D82dl0DIAABAVaaIAgLbWrN2oJStHmgaCknTT2GYtWTmiK9fem3LLAABANwgGAQAtDa/fpPdfc5u2ufbbbXPSedfcquH1m9JpGAAA6BrBIACgpUuHRjsGgjXbnLRiaDTZBgEAgNgQDAIAmlo3PtEyNbSVkbHNWjc+kVCLAABAnAgGAQBNRU35JFUUAIBiIBgEADT12Jatqe4HAADSRTAIAGhq+uRoqw9F3Q8AAKSLYBAA0FTUdQNZbxAAgGIgGAQANLVg9gwd39sTap/+3h4tmD0joRYBAIA4EQwCAFpaPtinSRZs20kmnTPYl2yDAABAbAgGAQAtDcyfpY8tOqpjQDjJpIsWHU2KKAAABcIsfwBAW4sXztPcmVO1YmhUI03WHezv7dE5g30EggAAFAzBIACgo4H5szQwf5bWjU9oeP0mPbZlq6ZP3lUD82cxR7DiOCcAoLgIBgEAgS2YPYOOPiRJw+s36dKhUd3UZLT4+N4eLWe0GAByjzmDAAAglDVrN2rJypGmgaAk3TS2WUtWjujKtfem3DIAQBiVDQbNbK6Zfc7MfmtmT5nZBjO7xMxmBtx/HzP7SzP7qpmtN7MnzewRM7vBzJaZWWVfWwBAeQ2v36T3X3Obtrn2221z0nnX3Krh9ZvSaRgAILRKBixmdqikmyUtlXSTpIsl/UbSckk3mtk+AQ7zJkmfkdQvaUTSJZKulvRcSZ+VdKWZBSzIDgBAMVw6NNoxEKzZ5qQVQ6PJNggAEFklg0FJ/yFpP0nnOOdOdc6d55x7mbyg8DBJ/xTgGOskvU7SXOfcm51z73fO/YWkwyXdK+k0SYuSaT4AAOlbNz7RMjW0lZGxzVo3PpFQiwAA3ahcMGhmh0g6WdIGSZ9qePh8SY9LWmJm09odxzn3I+fcN51z2xruf0DSf/n/PSmONgMAkAdRUz5JFQWAfKpcMCjpZf7t95sEchOShiVNlfTCLp7jGf92axfHAAAgVx7bEu1rLep+AIBkVXFpicP823UtHh+VN3K4QNJQ2IOb2a6S3uL/97sB97m5xUOHh31+AACSMn1ytG5D1P0AAMmq4sjgXv7tIy0er92/d8TjXySviMy3nXPfi3gMAAByJ+q6gaw3CAD5xKW6ndUqgAaslVa3o9k5kt4r6U5JS4Lu55w7rsXxbpZ0bNh2AACQhAWzZ+j43p5QRWT6e3u0YPaMBFsFAIiqiiODtZG/vVo8vmfDdoGY2d9IulTS7ZJe6pwLV24NAIACWD7Yp0kBF06aZNI5g33JNggAEFkVg8G7/NsFLR6vfWu1mlO4EzN7l6RPSvqVvEDwgcitAwAgxwbmz9LHFh3VMSCcZNJFi44mRRQAcqyKaaLX+rcnm9mk+oqiZjZD0oCkJyX9LMjBzOxcefMEfynpFc456mcDAEpt8cJ5mjtzqlYMjWqkScpof2+PzhnsIxAEgJyrXDDonLvbzL4vr2Lo30i6rO7hCyVNk3S5c+5xSTKz3SQdKukZ59zd9ccys3+Q9GFJN0s6mdRQAEA31o1PaHj9Jj22ZaumT95VA/Nn5Xa+3cD8WRqYP6tQbQYA7KhywaDvHZJ+KmmFmQ1KukNSv6SXyksP/WDdtnP8x++RdHDtTjM7S14g+Kykn0g6x2ynnJkNzrkrEvkNAAClMbx+ky4dGm1amOX43h4tz/Eo24LZMwj+AKCgKhkM+qODL5AXzL1K0imSfidphaQLA47w9fq3u0h6V4ttfizpiq4aCwAotTVrN+r919ymbS1qWN80tllLVo7ookVH6/SFB6bbOABAqVUyGJQk59y9kpYG2G6Dti83UX//BZIuiLtdAIDqGF6/qW0gWLPNSeddc6vmzJyS2xFCAEDxVLGaKAAAuXDp0GjHQLBmm5NWDI0m2yAAQKVUdmQQAOJGIQ2EsW58ItTi7ZI0MrZZ68YnOK8AALEgGASALhW5+AeyM7w+2kpEw+s3EQwCAGJBmigAdGHN2o1asnKk5QhPrfjHlWvvTbllyLvHtmxNdT8AABoxMgggNNIhPRT/QDemT472FRxlP96zAIBmCAYBBEY65I6iFP+o0uuD9qKeC2H24z0LAGiHNFEAgZAOuaNuin8AkrdY+/G9PaH26e/tCTyix3sWANAJwSCAjsKmQ0YtjFEk3RT/AGqWD/Zp0k4r2TY3yaRzBvsCbct7FgAQBMEggI5YC21nFP9AHAbmz9LHFh3VMSCcZNJFi44OnNLJexYAEATBIIC2SIdsLs3iHyi3xQvnafWyfvW3SBnt7+3R6mX9On3hgYGOx3sWABAUvRIAbbEWWnNpFP9AdQzMn6WB+bNiqfrJexYAEBTBIIC2SIdsrlb8I8wITJjiH6imBbNndH2O8J4FAARFMAigLdIhW1s+2KclK0cCzc0KU/wD6SrbGny8ZwEAQfHJD6At0iFbqxX/6FS1MWzxD6SjrGvw8Z4FAARFARkAbSW9FlrRxV38A+ko8xp8vGcBAEExMgigozjSIcuWilcvzuIfSF7YNfjmzJxSuFEzUpgBAEEQDALoqJt0yLKm4jUTR/EPJC/KGnxFO0dJYQYABEGaKIBAoqRDljkVD8VUpTX4SGEGAHTCyCCAwMKkQ1YhFS8ppJsmp2pr8JHCDABoh2AQQGhB0iGrkIoXtyql1GalqmvwkcIMAGiGNFEAsatSKl5cSKlNB2vwAQCwHcEggNh1k4pXRWFTaqv6OsWBNfgAANiOYBBA7KqaihdVlJRaRMMafAAAbEcwCCB2pOIFR0pt+pYP9mmSBduWNfgAAGVGMAggdqTiBUdKbfpqa/B1CghZgw8AUHYEgwBiRypecKTUZoM1+AAAYGkJAAlZPtinJStHAs2Fq3IqHim12WENPgBA1dGbAJCIWipepyqZVU/FI6U2e6zBBwCoKtJEASSGVLzOSKkFAABZYWQQQKJIxeuMlFoAAJAFgkEAqSAVrzVSagEAQBYIBgEgBxYvnKe5M6dqxdCoRpqsO9jf26NzBvsIBAEAQGwIBgEgJ0ipBQAAaSIYBICcIaUWAACkgWqiAAAAAFBBBIMAAAAAUEGkiaIj5i8BAAAA5UMwiJaG12/SpUOjuqlJZcPje3u0nMqGAAAAQGERDKKpNWs3tl3z7KaxzVqyckQXLTpapy88MN3GAUCCyIYAAFQFwSB2Mrx+U8fFryVpm5POu+ZWzZk5hRFCAIVHNgQAoGoIBrGTS4dGOwaCNductGJolA4SSotRomogGwIAUEUEg9jBuvGJplfF2xkZ26x14xN0kFEqjBJVB9kQAICqYmkJ7GB4/aZU9wPyaM3ajVqycqTlhZHaKNGVa+9NuWVIQpRsCAAAyoCRQezgsS1bU90PyBtGiaqFbIgdkRYNANVCMIgdTJ8c7ZSIuh+QN8yZrZZusiHKFCSRFg0A1USaKHYQ9cueTgLKoJtRIhQT2RCkRQNAlTGcgx0smD1Dx/f2hOoQ9/f2lOoKOaqLUaLqqXo2BGnRKAtSnIFoyvFthlgtH+zTkpUjgVLlJpl0zmBf8o0CUsAoUfVUPRsibFr0B665TZ856wV0spEbpDgD3SFNFDsZmD9LH1t0lCZZ++0mmXTRoqP5kEVpVH2UqIpq2RBhlCUbIkpa9D2bn9DJF1+v0y+/kSrSyBwpzkD3CAbR1OKF87R6Wb/6W3SS+nt7tHpZP4svo1SqPkpUVcsH+zpe/KopUzZEN8EcnWxkLWyKMxcvgOa4nI2WBubP0sD8WeThozKYM1tNtWyITh3LsmVDdJvezDxCZInKz0A8CAbR0YLZM+jsojKYM1tNixfO09yZU7ViaFQjTS4G9Pf26JySzT2KI72ZTjaywPqgQHwIBgGgTlVHiVC9bIi4zl062UgblZ+B+BAMAkCDKo4SYbuqZENESYtuhU420kTlZyA+BIMA0ETVRolQTWHSotuhk400UfkZiA/vCgBooyqjRHEjiC6GoGnRndDJTl+V32NUfgbiw6c3ACCwTh1QFoAunk5p0UHwN00P7zEqPwNxIhgEADRVH/j9fmKLfnnvI7rt/kd22q7WAb3voSfajjDV1qa7aNHRrFGaM/Vp0W/9/M91z+YnAu9LJzs9a9Zu5D3mo/Jzcqo86lxFBIMAAEnbOwC//u2jumlsszYGDAhuGtusMz87Iknq1C9jbbp8WzB7hv550VF0snMo7CLrZX+PUfk5fow6VxPBIABUXLsOQFBhppuxNl2+0cnOJxZZ3xmVn+PDqHN1EQwCQIV16gAkhbXp8o1Odr6wyHprVH7uHqPO1UYwCAAVFbQDkOTz01nLLzrZ+cEi651R+Tk6Rp2rjWAQACoqTAcgCaxNVwx0srPHIutICqPOmJR1AwAA6YvSAYgba9MBwbDIOpLSzagzyoFPCQAoqG7S9/LwRU6aERAMi6wjKYw6g2AQAAomjvLfWX+RszYdEByLrCMpjDqDNFEAKJA1azdqycqRlp3CWvnvK9fe2/Y4WX6RszYdEN7ywT5NsmDb8h5DUIw6g2AQAAoibPnvdqmgSXyRmyTr0FllbTogmtr6j50CQt5jCKM26hwGo87lQjAIAAURpfx3K1E6AO1MMunjpx2tLy7rV3+L4/b39mj1sn4WLAYiWrxwnlbzHkPMGHWuNhJ+AaAAkij/vXywT0tWjnS9vETjAuSsTZc/cf49+Ntmi/UfEbfaqHOnzBNGncuJYBAACiCJRaeDdgDqHTVnTx1z4EztN2OPth1Q1qbLhziKDSVxLHSP9xjitHjhPM2dOVUrhkY10uQ93njRD+VBMAgABZBU+e9OHYCD9pmqhQf16Mg5ezLyUDBr1m5sG+jXig1dtOjojmmFcR4L8WOUEHFg1LmaCAYB7IQvgvxJsvw3HYDyCVtsaM7MKS2v+Md5LMSL0VokgVHnaiEYBPBHdCzyK43y33QAyiNKsaFW50qcx0J8GK0FEAeqiQKQFN/6dUgG5b8RVDfFhpI8FuIT5zIzAKqNkUGgghrTAafuvgtpYAUQpvon5b/jU7T02TiLDSVRuAjdY7QWQFwIBoEKaZcGGhQdi+xQ/jtdRU2bjrPYUFKFixBdEsvMAKgu0kSBiuiUBhoGaWDZYdHpdBQ5bTrOYkNJFi5CNN2M1gJAIz6tgQoIOr8k7DG5ypwNqn8mq+jVM+MsNpRG4SKEw2gtgDgRDAIVEGZ+SVAbNj0e7wERGtU/k1H0+Vi1YkNhsgBaFRuK81iIB6O1AOJEmihQclHmlwTx+Rvv0emX30jqEUqlLNUzlw/2aZIF27ZTsaE4j4XuMVoLIE4Eg0DJJRms5XneFBBFWeZj1YoNdQrighQbivNY6B7LzACIEzkDQMk0ziPb8GCy6Zx5nTcFRFGm+ViLF87T3JlTtWJoVCNNRjv7e3t0TsCKqHEeC91jmRkAcSEYBEoijmUjosrjvCkgirLNx4qz2BCFi/KDZWYAxCWf314pMLO5kj4s6VWS9pH0O0lfk3Shc+6hgMd4o6SXSDpG0vMkzZD0JefcmQk0GWhpzdqNsVcLDSvKOlZ0KrvD6xe/ss7HirPYEIWL8oHRWgBxqGQwaGaHSvqppP0kfV3SnZKOl7Rc0qvMbMA592CAQ31IXhD4mKT7JB2eTIuB1pJYNqKbtgTpJBZ1Me+84PVLDtUzUSSM1gLoVlULyPyHvEDwHOfcqc6585xzL5N0saTDJP1TwOO8W9ICSXtKensiLQU6iHvZiEkmnfyc2ZH2DTJvqsiLeecBr1/yqJ6Jolkwe4aWDvTqnYN9WjrQSyAIILDKBYNmdoikkyVtkPSphofPl/S4pCVmNq3TsZxz1zrnRp1zORiTQRXFvWxEbX7JCYfuE2n/TvOmwi7mnbcKjVnj9UsH1TOLZ934hFYNj+myoVGtGh7L3VIfAJBXVUwTfZl/+33n3Lb6B5xzE2Y2LC9YfKGkobQbB4QRZ2e/fn5J1I5Up05x0RfzzhqvX3qYj1UMpEwDQHeqGAwe5t+ua/H4qLxgcIFSCgbN7OYWDzEHEW1FLWd/1gkH6eBZ01rOL0li3lQ3i3mT8sTrlwXmY+Vbp8JZtZTpixYdrdMXHphu4wCgIKoYDO7l3z7S4vHa/Xsn3xSgO1HL2R88a5qWDvS23Sbuday6WcybjjevX5aonpk/YVOmWQcVAJqr3JzBAGqzRFKbB+icO67Zj7wqp0BLSZbBj3veVJkW884Crx+wXZSUaQDAzqo4Mlgb+durxeN7NmwH5FbSZfDjnDdVtsW808brh6JIOq2WlGkAiE8Vewl3+bcLWjxey3VrNacQyJW40zkbxTVvqqyLeaeF1w95l1YxF1KmASA+VQwGr/VvTzazSfUVRc1shqQBSU9K+lkWjQPCqqVzdpo/020Z/G7nTbGYd3d4/RBWmoVv0izmQso0AMSncsGgc+5uM/u+vIqhfyPpsrqHL5Q0TdLlzrnHJcnMdpN0qKRnnHN3p91eIIiilMFPehSz7Hj9EETayy2kXcyFlGkAiE9VPxnfIemnklaY2aCkOyT1S3qpvPTQD9ZtO8d//B5JB9cfxMxOlXSq/9/9/dsTzOwK/9+bnHPvi731QBNFKIOf1ihmWVXp9cvzeZxnWSy3kPb6l6RMA0B8KhkM+qODL5D0YUmvknSKpN9JWiHpQudc0DysYySd1XDfIf6P5AWQBINIVd7L4BdlFDOv4nj98hxosYh4dFkst5BFMRdSpgEgPpUMBiXJOXevpKUBttug7ctNND52gaQL4mwXUBTdBBRFGMXMs1av35y9p+j+h5/ULfc8pHXjEzu9nnkPtFhEvDtpj9BJ2RVzIWUaAOJR2WAQQDRxBhR5H8XMu9rrF+Rvct9DT+Q60GIR8e5ktdxCVsVcqpQyDQBJIhgEEBgjN/kT5G9y5soRyUmdBlGyDLSyGNUqk6xG6LIs5kLKOQB0j2AQQCCM3ORP0L+JCxhkSdkEWiwi3r0sR+jS3K/ZcUg5B4DoCAYBBMLITf6E+ZuEkXagxSLi3ctqhC4vxVxIOQeAaCZl3QAA+dfNyA2SEeVvEkbUAC0KFhHvXpYjdMsH+zSpaZm1nVHMBQDyhWAQQEfdjNwgGUm/tmkGWiwi3r0/TDwVep+4RuhqxVw6BYRpF3NZNz6hVcNjumxoVKuGx7g4BQBN8E0KoCNGbvIn6dc2zUAr63lnZXDp0GjofeIcoctTMZe8L6ECAHlCMAigI0Zu8ifp1zbNznJe5p0VVdSU4X1n7BFrO/JQzIWKxwAQDj01AB0xcpM/Sb62WQRaLCIeXd4K8GRVzIWKxwAQHnMGAXRUG7kJg5GbZEX5mwSRVaCV13lnRUAatydKxWMAqDqCQQCBUDEwf8L8Tcz/aSfrQGvxwnlavaxf/S2C3P7eHq1e1k96XwPSuKl4DABRleebAECi9p2xh1599AH61v/9Tu0uvmcdUFRJbTStU2pc7W8yZ+aUXBT4aCcP886KhjTu/KXKAkBREAwCaKtdZb5GeQkoqiRsFceiBFosIh4cBXikG+9+MNJ+ZUuVBYCwCAaBEoqrs9+pMp/kpR6+9nl/or992fxSdS6LJOxoGoFW+VS5AM/w+k36we3jkfYtU6osAETBpyBQInGurxW0Mp+T9K1bf6vFCw8kwMgYQV51hU0ZLtPo/aVDo21T19sp0+sAAFEQDAIlEff6WlEq89GxArKTp4Xf0xJ1jUWpfKmyAKIpwtSJJBEMAiUQ9/pa3VTmq9IHKJA3VSvAE7VwjKlcqbIAwoszm6rICAaBEoh7FI/KfIiiKgFIEVQlZThqAZhXPGd2JTp5AJqLO5uqyAgGgYJLYhSPRawRBldX40dgHUzUAjAnHLpPzC0BUBRxZ1MVHcEgUHBJjOIlvYg1Hd3y4OpqvAisw2GNRQBhURNhRwSDQMElMYqXVAeLjm65cHU1XgTW4bHGIoAwqImws0lZNwBAd5IYxat1sMLo1MFas3ajlqwcafkhXOvoXrn23lDPi+xEubqK5sIG1lEzAspo+WCfJlmwbcu2xiKAcLrJpiorgkGg4JIaxYuzg0VHt3y6ubqKnRFYR1dbY7HT51UZ11gEEA41EXZGMAgUXBKjeFK8HSw6uuXD1dX4EFjvaN34hFYNj+myoVGtGh4L9HsuXjhPq5f1q7/FZ2F/b49WL+snvRaouKRrIhRReX8zoEKWD/ZpycqRQAFXmDSpOBaxJj+/nLi6Gh+WcvF0O6e4amssAgiPolM7IxgESqA2itcpFTNKmlS3HSw6uuUzvH6TvnLzfZH2bXV1tcodeALreIvnVGWNRQDhUXRqZwSDQEnEMYrXTtQOFh3dcunUae+k8fyjwixpS1SlBfKtbBfrksqmKqpyfJMAkJTPNKmoHdZbNj6kVcNjmX/p5Om1jEM3v0/QTnsrjVdXWUrBU/W0Jdb8AvKprBfrksymKiKCQaCE8pQmFfVD9Nq7/qBr7/qDpGy+dMr2JRjH7xOm096o8eoqo0HbVTltiTnFQD6V/WJd0tlURUIwCCBRUTq6jdL+0inbl2Acv0+UTntNs6urjAbtqKppS8wpBvKnKhfr8phNlQWWlgCQuDBrFraS1hqEa9Zu1HlXl2dNxLjWeIz6ex60z9SdSvqzlMLOqrpWHnOKgfyp2nJQC2bP0NKBXr1zsE9LB3orFQhKBIMAUhC0o9tJkl86w+s36fTLb9S5V9+moJmQRfgSjOtLPWrn+43Hzm1aNCaKvAfe3Yp7rbwo6/WlrerFc4C84WJd9fBpCiAVnfLzg0pivlA3FTK7bU+S6SlxzseKs9POaFBrcaQtJT3fNc5zduruu0Tarywjo0DekLpdPQSDAFLT2NG9ft32IjFhxPml022FzKjtSaNATZxf6nFWvGQ0qLOoRaCSnO8a9zlba2tYZSmeA+QRF+uqhzRRAKmr5ecfO29mpP3j/NLppkJmTdj2rFm7UUtWjrQctat12K9ce2+q7Wq3X60QUBitOu1VX0ohKXHND20m7nM26kWYMhXPAfKIi3XVQzAIIDNZf+l0UyGzXpj2hOmw//3Vt+r1n7xBS1fdpI9/947QczLifn3DFAJq12mPM7DEdkkVfUgiyIxyEaZsxXOAPOJiXfUQDALITNZfOnEVJAnTnrCd4P+77xFde9cf9J/X/UYnX3y9XnnJ9Tu1u1WhkLhf3zgrXsYVWMKTZNGHuIPMqBdhPrboqEIs5QIUGRfrqocxXQCZyXqx7TjSTcO0J46RyLsemNCZnx3Rx087WnNmTuk4hyvu1zeuhXprgWWnESdGg4JJquhDEovCR23rE08/G2k/AOFUdd3TqiIYBCoqL4usZvml0226adj2xDUS6eSlkJpJrkOhkGUv7tXPN2yO9fWNa6HeuAJLJFf0IYkgkwIVQL5xsa5aCAaBikmjimUYWX7pdHOsKO2JuzPbKhCs2eaklTeMadmLe7XyhrHYX9+oFS/rxRVYVl1S82+TCNyyniscFecoqoSLddVBMAhUSJJl57uR1ZdOlDTVbtqTRWd2m5Nuve8RrV7Wn+sv9TgCyypLav5tEoFb1nOFw8rbBTQgLVysqwaCQaBgon4oh60IOGfmlNRHCLP40gmTpmqSLjrtKC1eOC/Sc2XVYRwZ26x9Z+yhNW87gS/1kkpq/m0SgVvWc4XDyOsFNCBNXKwrN4JBoCC6vTodpSJgFsFL2l86YdNUu+nwRR2JjENtDhdf6uWVxPzbP0w8pRmTd9VEiHTRIIFbEQpU5P0CGgDEgaUlgALodsHnJMvOl8HihfO0elm/+luU0+7v7dHqZf2xXPkPs6RCnCi+UX5xLv0hbf/cCRMIhilCFGdbk5DUuo0AkCddjQya2Y8i7uqcc4PdPDdQFXFcnU6q7HyZpJWmGnQkMm5ZF99AOuKafxv0c6de2MAtzwUqklhSAwDyqNvewUkR90uxCwQUWxzpnZRyDy6NNMpOneAkBOlQM5+wHOK4sBHmc0eSZkzeVf915nGhA7e8FqjgAhqAqugqGHTOkWYKJCiuq9NFLeXeKG8dxm40doJ/ff+juuqW+xJ5rk5zuKiWWE5RL2xE+dyZ2LJV+87YI/Rz1eRtLisX0ABURb56egB2ENfV6aKVcm9U5mClvhO8sHemzrv6tkCpE6ZgKRad5nBRLRGNkhwVK8oFnbJcQAOATvjUAnJqeP0mrfzJWKR9G69OF6mUe6MqBSu19NGPfut23fFA8+I9h+8/Q//wmufovoeeCFwBtVWgTLVENJPEqFjRLugU/QIaAASVWDBoZnMlzZHUNG/EOXd9Us8NFF2nAKiTZleni1DKvVEVg5WB+bP0nXedqHXjE/rqL+7Xnb97VJJ0+AEz9Ibnz90hQO+2+EZRlhtBuuIeFSviBZ0iX0ADgDBiDwbN7GRJF0s6vMOmu8T93EAZRKni16hZhz3senp56PRXOVhZMHuGzn1V+4/RbopvUC0RrcQ5KlbkCzpFvIAGNFOU9GxkI9Zg0Mz6JX1L0h8kfVLSOyX9WNJdkv5U0hGSviHpF3E+L1AmYav4NWp3dTrPpdwbEawEF6X4BtUS0Uqco2JFvqBTxAtoQL2ipWcjG3GPDH5A0hZJC51zvzWzd0q61jn3YTMzSRdIeq+kD8b8vEApRAmA6gW5Op3XUu6NCFaSRbVEtBPHqFgZLugU6QJaTd4/25GOIqZnIxtxB4MnSPqGc+63dfdNkrxV5iWdb2anSLpQ0htjfm6g8KIGQFL4q9N5K+XeiGAlWVRLRDtxjIqV5YJOkS6gMQoEqdjp2Uhf3N/qe0naWPf/pyVNa9hmWNKfx/y8QClEDWTm7j1FH39juDSlvHdsCFaSRbVEdNLtqFjZLujk+QIao0D5k+V3bJHTs5G+uHtNv5c0s+H/hzZss5ukKTE/L1AKUQOZZX/aG/iDvChXjwlWkkW1RATRzagYF3TSwShQvmT9HVuG9Gyka1LMx1unHYO/n0l6hZktkCQz21/SaZJGY35eoBSSDoDWrN2oJStHWn5R1K4eX7n23kjtiFMtWAmDYCWc5YN9mmTBtqVaYrUtmD1DSwd69c7BPi0d6A30PuOCTjqijAIhGXn4ju0mPRvVFHcw+F1JLzGzWg/uUnmjgL8ws7WS7pS0r6RLYn5eoBSSDIDCXj1O84th3fiEVg2P6bKhUa0aHtO6cW/B9SoFK61egyTV5oV1eo2plogouKCTvG5GgRCvvHzHli09G8mLOxfjcknXS3pGkpxzw2b2JkkfkfRcSRsk/b1z7gsxPy9QGkmtbZXHOQRB0mnKXto965SiIlZLRHGwVl+yylKkpwzy8h1LejbCivUv75x7VNJIw31flfTVOJ8HKLMk1rbK4xyCMAUPVi/rDxys5L0wTr28FH0oSrVEFA9r9SWLUaB8yNN3LOnZCIvLAEAOxT1ak7erx2HTaVYv69eat53QNljJeoQtrDwWfchztUQUV7efZ1ykaI1RoHzI03csxcEQFp8GQE7FOVqTt6vHUdNpWgUreRlhCyMvKUVAGqJ8nhXtAk8WGAXKh7x9x5KejTBiDQbN7DcBN3XOucYlJwA0EcdoTZ6uHsedTpPHEbZO8pRSBKQp6OdZES/wZIFRoHzI03esRHo2won7LJwkqdlpt5ekvf1//1Z+gRkA6cjT1eO402mKOMKWp5QiIG+iXuBJM500T6mrjAJlL0/fsTUUB0NQcReQObjVY2Y2X9IKSdMkvTLO5wXQXp6uHseZTlPUEba8pRQBeRL2As9HvnW79pyyWyrppHlMXWUUKHt5+o6tR3EwBBH3OoMtOefWS1okaY6k89N6XgCevKzZF2c6TVEX181bShGQF1Eu8Nz5QOt94lzkOw8LireyeOE8rV7Wr/4W6zr29/Zo9bL+SqfUJi0v37HNLJg9Q0sHevXOwT4tHeglEMQOUu1ZOOe2mNkPJP2ZpPen+dxA1eXl6nGc6TRFHWHLY0oRkAdJXKiJY75wEVJXGQXKVl6+Y4GwsrjMvFXS/hk8L1B5eZhDEGc6TVFH2PKaUgRkLakLNd3OFw6buvrRb92uGSmlrjZiiZjs5OE7Fggr1R6Rmc2S9AZJ6edQAJCUj6vHcRU8KPIIG0UfgJ0leaEm6nzhKKmrdzww0fIxKqGWWx6+Y4Ew4l5a4h/bPM+Bkl4vr7IoKaJAxjpdPU7yiyyudJoij7CRUgTsLOnzPEpF3rymriLfGKGNjkA6XXFfgrugw+OPSvqoc+5fYn5eADFJq1peXOk0RR5hI6UI2FGUCzxhRElDzWvqKlA2eazWWwVxB4MvbXH/NkkPSbrTOUdtdJRCGa9cpb3QcxzpNEUfYSOlCNhRmAs8YUVJQ81j6iqQpjS+n9Luf2C7uNcZ/HGcxwPyqKxXrqJWy4tDt+k0UUfY8hSAkVIEeIJe4IliIsIoXx5TV4E0pNXfybL/gWyqiQKFVeYrV2Gr5eUtvSnMCFtZA3qgLIJc4HnkyWd0Z5tCLc1c8sN1Ou6gmaHe33lMXQWSlmZ/p+j9j6LrKhg0s3lR93XObezmuYG0lfnKVZRqeXlNb+o0wlbmgB4ok04XeIbXbwqdThq1I5m31FUgqCgZMEn0d1q1I87+R56yfYqk20+gDZKifDS6GJ4bSFWZr1xFrZZXtPSmMF9w5159q5ycFi+MfM0LBURnIn9aXeAZmD9Ly1/ep4t/MBrqeFEuZCWZulqU7wkUSzcZMHH2dzq147DZ04M9UZPj1t7DZPt0p9uA7AvaORjslXSipEck/VLSA/IWmT9G3rIS10sa6/J5gVSVaeSsmahpSkVLbwrzBecknXv1bbr6lvv5IqkAOhPFtOfk3SLtF+VCVpDU1YeffEZ3hUhdzctSNyiXbjJg4uzvBGnH2ojp17X+B9k+3esqGHTOnV3/fzM7TNKNki6WdKFz7tG6x/aUdKGkt0j6q26eF0hb2UfOoqYpFSm9KcoXnFTeLxJGwLajM1FcaV/IijN1NW9L3aAcuk3xjKu/E7QdUQfap0/etdTTd9IUd0/uIkm3Oefe2/iAHxi+28yO87dbFPNzA4kp+8hZ1A/HIn2odrNwdJm+SBgB2xGdiWLL6kJWu9TVIi91g+LrNsUzrv5OmHZEMTB/lj70tV+VdvpOmibFfLwTJd3QYZsbJL0k5ucFElX2kbNatbwwipbe1G1gXvsiKYp14xNaNTymy4ZGtWp4TOvGJ7Rm7UYtWTnScoS0NgJ25dp7U25tdqJ0nJAfebyQtXjhPK1e1q/+Fp+p/b09Wr2sn1FmxK6bFM+aOPo7UTNxgqq9t7r9XeGJu6e6h7z5ge0c4G8HFEYeOxxxC1Mtr4jpTXEE5kWYB9pu5C+IKo2AlX0ucBVEWfYhjQtZYZa6AeISR4pnHP2dbjJxOqn1P8o+fSdNcY8M/kLSGWb2/GYP+imiiyXdEvPzAomqwshZLb1pkrXfrqjpTXG1N8kvuW51GvkLqugjYM1GRZvppjOB/Fg+2Nfxc6sm7QtZC2bP0NKBXr1zsE9LB3oL9Z2A4okjxTOO/k7UdnR6G9f3P8o+fSdNcY8MXijpu5J+ZmZfklc5dFzSbHmpoX8uLwC9MObnBRJX9pEzKVi1vHMKOqcsroWj8/pFEnTuW1BFHAELOx+SzkQ5ME8P8MQ1paXb/k7Udpz5woO0bnwiUP+j7NN30hTrK+Kc+6GZnSHpcklnSzqr7mGT9JCkv3LODcX5vEAaqtLhKHN6UxwLR2f5RdLub5LEZP0ipdNEqQhKZ6I8ynwhK6/K+B1RdHFNaem2vxO1HUtOOOiPC9F3OreqMH0nLbF/oznnrjKz70h6vaRj5a0t+Ii81NCvO+cej/s5ozCzuZI+LOlVkvaR9DtJX5O3JMZDaR8HxVClDkeranlFFsfC0Vn8bTuNeJ127JxEJusXZQQsakVQOhPlEuVCFgFNeFQkzq8459B209/pth1B+h95nS9cRIlc3vQDvv/2f3LHzA6V9FNJ+0n6uqQ7JR0vabmkV5nZgHPuwbSOg2Ip88hZFXT6gmsniy+SJBft7aQoI2BRS6nTmSinIB1JAppoWJMz/+Kc0tJNfyeNqTVVmL6ThmJ808fvP+QFcOc45y6r3Wlm/y7p3ZL+SdJfp3gcFFAZR87ilOdgufYFt2btRp139W2BFr3N4osk6UV7OylCZ7jbiqB0JqqHgCYa1uQshiSmtETp76QxtaYq03eS1lUwaGZv8f/5VefcRN3/O3LOfaGb547KzA6RdLKkDZI+1fDw+ZL+StISM3tvu5TWuI4D5FXUYK5IV9wXL5wnSbn9Ikl60d52ijIC1m15cToT1UJAE123i5kjPXmZ0pJGO/LyuxZZtyODV8i7KP0zSRN1/2/H/G0yCQYlvcy//b5zblv9A35AOywvyHuhpHaFbuI6DpAr3QRzRbzintcvkqQX7W2nSCNgcVQEzes5gPh9+Fu3E9BEwJqcxZOXKS1ptCMvv2thOeci/2h7xdAZ/v/PCvrTzfN22eZPyAtG39vi8U/6j789jeP4297c4ufxYw84wDkp2M9b3+p28ta3Bt///PN33v81rwm+/+WX77z/sccG3/8b39h5/zC//89/vvP+QfeVnLv//h33vf/+cPs3+vnPg+97wAE77/+NbwTf/9hjd97/8suD7/+a1zjnnPvyTfe43vO+5Q4691vu4oE/C3Xu3TD6hz/ue9C533Jfet4rC3fu3fXAo+5zN/zGrfjhOvf4PvsV5tyrvea1n1efdUngfR+Y3rPT/u9f+k+pn3s7OP/8wPvf+dozdmp/N+feXQ886u550ctSP/d2wOdeKufeDw5duNO5E/ZzbycV+s599VmX7PT6ce4F3L/Lz72qn3t87jW4/HJ3rOQk3exc+Nioq5FB59wVDf//fDfHS8le/u0jLR6v3b93SscBcqHbdeqyTGmMyw7zInbfJdvGZGj80S1ZNyGw2XtNjvV4C2bPkHqmxnpMAPm2bnxCG28f18uzbgiQgaoWkGnH/Ntuu7WBj+OcO67pAcxulrc8B5C4boK5h598JrOURuzIOm9SKntP2S10RVAAkHacFjG4fiPBICrJnIvvUr6ZzZR0gKS7nXNP1d2/VNKpkh6XdKlzbiS2Jw3JzD4h6X2S3uec+7cmj39S0t9Ieodz7j+TPk6Htt587LHHHnvzzTdH2R0IbN34hE6++PrQ+33/3SdqwewZWjU8pgu/eXvo/c9/7XO0dKA39H5VEPVv8vHTjtI1t9zfcu7bI08+ozsfmAh8vP7eHq152wmh25Gm4fWbQlUEXb2sn3lgFRL1vVTD51T33xF51GmOu7S9cFRe5rgDrRx33HG65ZZbbmk1wNRO3COD/yzpTHnLLUiSzOydki7R9gvWp5rZC5xz4XuO8bjLv13Q4vFa1YR1KR0HyNxXf3F/pP1qFRnjKOKBHUVdA2/xwnlavHBe04n0kkJ36IpQBIKKoGgnasXZGs6X8i3wTVVZYLu4g8EBSUPOuSfr7nufpPsl/bmk/eVVEX2PpL+M+bmDuta/PdnMJrm6SqBmNkPe7/CkvAqpaRwHSEWz4OAPE0+1rBwaRC2Yi7o4eVEWNc9KN2vgNVsXatXwWKR21IL+PKMiKFrp5qJTngOatJVpTU6WyQC2i7snNkd1yyiY2XMkHSjpXOfcDf59b5J0YszPG5hz7m4z+768ZR/+RtJldQ9fKGmapMudvzagme0m6VBJzzjn7o56HCAr7ZaK6FYtmIv6JcmXa3txj3iVfQSX8uJoJupFJ1O+A5q0lWUEnmUygB3FHQxOkVRfhm5AXgGVH9bdd7ek18T8vGG9Q9JPJa0ws0FJd0jql/RSeWmdH6zbdo7/+D2SDu7iOEDqgsyJ6Ebty75sKUR5EueIV1VGcJuNiqK6ogYl737FgtwGNFkpwwh81LThImRIAFHE/Q1/v6TD6/7/SkmPSvq/uvtmykufzIw/qvcCSR+W9CpJp0j6naQVki50zgXq0cZ1HCAJ3S4V0UljMFemFKK8iWvEixFcVFGUi1VH7D+Dz6gWij4CX/YMCSCsuIPBayWdZWZ/K2+E8HWSrq6fTydpvqR7Y37e0Jxz90paGmC7DWpTrT3ocYC0JbnuX7NgriwpRHnW7YgXI7ioqrAXqz70muck36iCK+oIfFUyJICg4j6zPybpNEmXygugHpN0Qe1BM9tP0kskfSbm5wVSU4SroVHmRATVLpgrQwpR2RV1BLcI7zvkFxerUEOGBLCjWINB59yYmR0p6Y3+Xd9wzm2s2+QgSZ+S9N9xPi+QhnaFWI7v7dHyHAU53ZZSbyVIMFf0FKKyK1qnuEjvO+QbF6sgkSEBNIp10XnEi0Xn86Noi9NeNjSqf/tBvEtcvv2kQ3Tuq46I9ZjIzvD6TbnvFBftfYfi4GJVtQ2v3xQqQ2L1sv7MPw+BdvK06Pwfmdk0eQuyT3fO/SSp5wGSVsTFaZOY2/CG58+N/ZhJqEonL45iMnkewS3i+w7FUdT5bohH0TIkgCTF3mM0s7ny5gy+VtIu8paW2NV/7MWSPi3pHc656+J+biAJRVycNu7nL0KKTFXSCeP+PfPaKS7i+w6IQ14v0JQNacOAJ9Zg0MwOkDQiabakb0jaT9IJdZuM+PctlnRdnM8NJKGoi9NGmRPRSp6KiLTSKZ3wprHNWrJypPDphFX5PYv6vgO6UZULWnmS9wwJIA1xjwyeLy/Ye7lz7jozO191waBz7hkz+4m8xeiB3Cvy4rRhqka2UoQUmaqkE1bl95SK/b6Lis5otVXlQk9e5TVDAkhD3MHgKfIqiF7XZpuNkv405ucFElHkxWmDzolopSgpMlVJJ6zK7ykV+30XFqNBqNKFHgD5E3cwOFvSaIdtnpE0LebnBRJR9MVpg86J2HfGHoUclahKOmFZf89Wo2FFf98FxWgQpGpd6AGQP3F/c26W1Okba4GkB2J+XiARZVicNuiciDwHDa1UJZ2wSL9nkHTHTqNhpx07J9Jz5+l91wmjQfFIO7027ucr64UeAMURdzA4LOl1Zra/c26ngM/M+iS9StIXY35eIBFlWpy2jHMiqpJOWITfM2i6Y5DRsJ9v2KzeWdM0tunxwM+f1/ddK4wGdSft9Nqknq9IF3oAlNOkmI/3CUmTJf3YzP6fpKmSt+ag//9vStom6d9ifl4gMcsH+zTJgm1bhMqbZVKVdMK8/55r1m7UkpUjLS+a1NId/+l/bw88GrZh0+Oykr7vuhkNQvDz7cq19+b++YpwoQdAucUaDDrnRiT9laSDJX1L0vv8hx71/98raZlz7tdxPi+QpFohlk4BYREqb5ZNFmm868YntGp4TJcNjWrV8FgqHfQ8pyuHSXf8zE/GAo+GOUkH7zOtlO+7bkaDqi5sem23r1nSz5f3Cz0Ayi/2TxPn3Cozu0HSOyS9UNI+kh6R9DNJn3TO3RX3cwJJY3HafEozjTfLqo95TlcOk+4Y1timx/Xx047SNbfcX6r3HaNB0aWdXpv08+X5Qg+Aakjk0pJzblTSu1s9bmb7Ouf+kMRzA0lhcdp8CrOeYtR0wjxUfUzj9wwrSrpjWE88/azWvO2EUr3vGA2KJu1iK2k8X54v9ACohlS/WcxsL0nnSvpbSXum+dxAXMpYiKXIgq6nGDWdMC9VH5P+PaNII22xNhpWpvcdo0HRpF1sJa3ny+OFHgDVEVswaGYHSTpO3jqCNznnxusemyxvpPB9kmZKeiKu5wWAuNN460ehrrr5vtxUfQzze6YxkpZG2mIZR8MYDYom7fTatPbL44WeVvI+Qp/39gF5FMu3rJmtkDdHsDbV/2kze69z7j/M7CRJn5c0V9JTki6V9LE4nhcAauJI4203LzCopNcA6/R7Dq/fpNMvvzGVuY1pBGplHQ1jNCi8tNNr09wv7/PSs5wzHUTe2wfkWdff5GZ2lry0z22S7pAXEB4maYWZPS7pckm7+Lcfdc79ttvnBIBWoqYTdpoXGEYaa4A1+z3TntuYdOeqzKNhRRoNyou002uz2C+P89LzMGe6nby3D8i7OC7rni3paUkvdc7dKElmdqKkH0haKek+Sa91zt0Ww3MBQOyCzgsMKouqj1nMbYyS7hhUFUbD8j4alDdpp9dmlc7b7oJW2oFiXuZMt5L39gFFEEcweLSkr9YCQUlyzl1vZl+T9EZJf0EgCCDP4l4e4de/fSTRVNFm0i65XxM23XHZi3u18ob26w1WaTQsr6NBeZV2em1e0nmzSoPM6nMlqLy3DyiCOBad30vS+ib3j/q3NzZ5DAByIYnlEb7763GdfPH1Ov3yG1OpuNlNCfxu1dIdgy4O/8FXP0erl/Wrv7en6Xb9vT1avay/culcC2bP0NKBXr1zsE9LB3oJBFsIe7512/FP+/maWbN2o5asHGn5Hq+lQV659t5YnzfLz5Ug8t4+oCjiGBmcJK+CaKNnJMk592QMzwEAiUgyWEtrrkraJfcbhU13ZDQM3Ug7vTbLdN4s0yCz/lwJ8jxR9+NzBtgurlJwMSZYAaiKPAQDSc/vS2OuStql85uJEuCVae1ApCvtCwpZXcDIMg0yD58rSTxPFnO6gTyLKxi8wMwuaPaAmT3b5G7nnCvf4lEAAslTGfA0lkdIeq5K2qXz2yHAQ5q6Od+iBHZpnt/dpEHG0cY8fa7E+TxlXLsU6EZc74gO2fRdbw+gJPJSBrzWEdzw4OOJPUe9JNcfTLsEPlBkeboY1U5caZBRRzPz/rmS9/YBRdF1MOici6MIDYAKyEMZ8DgWlu/muZMIBrMqgQ8UTV4uRgXRbRpkt0Fv3j9X8t4+oCgI5ACkJsr8lzh1qsqXtCTnqiwf7OtY8bCmCmv4AY3CXoxKoxJwO92kQcZVgTTvnyt5bx9QBASDAFKRdRnwuBeWj6LWuVs3PqFVw2O6bGhUq4bHMlnigVQpVE3WF6PCivoenbr7LrEFvXn/XMl7+4AiYBYtgFRkXQY87oXlo5i6+y46/fIbE5urlGUJfCDPsi7GEkXUNMirb7k/1gqkef9cyXv7gLwjGASQiizLgCexsHxYvbOmpTJXiTX8gJ1lfTEqquWDfVqyciRQcDfJpEXHztG5V98W6jmCBL15/1zJe/uAPCMYBJCKLMuAZz33xyRtePBxuRQL57DEA7BdUdekq6VBdkr7rKVBPv50tPYGDXrz/rmS9/YBecScQQCpyLIMeJYdukkmHTxrWsdAsCYPc5WAsinymnSLF87T6mX96u/tafp4f2+PVi/r1+kLDyxs0AsgO9l/ygGohCzLgGfVoevv7UksbQtAcEVfky5oGmSRg14A2eDdDyA1Yee/xFUGPMkOXS0965h5ezftpK0aHot03GZpW8yHAaIpy5p0ndIgix70AkgfwSCA1ISd/xJXByVKRzCIxip1zTppcaRtdbt4NIDsLkalqSxBL4D0MGcQQKrCzH+JU5jFiYN4+0mHaM3bTugYhHWbthXX4tFA1VVlTToWYgcQBiODAFKXRRnwoKOSQb3h+XOb3t/4O83Ze0qk4w/Mn6Xh9ZtCLR4dRxVSoMyqsCZdVhkYAIqJYBBAZtIuA96pIxhUs7SqdqmcMybvqokQ6aK143/oa7+KdfFoANVYk64KQS+AeBAMAqiUZh3B3088pS/+7B4FibuapVWtWbux7VX4MIFg7fjrxidCz3GkCikQXNnXpKtC0AugewSDACqpsSP43Dl7RkqrWrN2o867+rZAgWQn9cePswopgOoqe9ALoDsEgwCg8GlV7dJC22mVMtp4fBaPBgAASSMYBABf0LSqTmmh7Uxs2apPLzlO9z/8ZNu0LRaPBgAASaPXAAAN2qVVBa3w2c79Dz+ppQO9bbdh8WhkgfllAFAtBIMAEMKlQ6NdL00RJJWTxaORpnZpz8f39mg5lScBoJQIBgEgoCgVPpsJmsq5fLBPS1aOBAo+WTwaUXVKe75pbLOWrBzRRYuO1ukLD0y3cSXDyGtx8LdCVRAMAkBAw+s3xXKcoCMsLB6NpAVNe97mpPOuuVVzZk7hPIuAkdfi4G+FqpmUdQMAoCjiqNQZNpVz8cJ5Wr2sX/29PS2Pt3pZPyM2iCRM2vM2J60YGk22QSW0Zu1GLVk50jKroDbyeuXae1NuGRrxt0IVMTIIAAF1W6lzkkmLjp2jVcNjoVKPWDwaSYiS9jwytlnrxic47wJi5LU4+FuhqggGASCgbr74TdJB+0zTuVffttNj9alH7QI+Fo9GnKKmPQ+v38R5GFCUkVcCjGzwt0JVEQwCQEBRKnxKUu+sadrw4OMa2/R408dvGtusM1eO6OB9pjXdhnkqSELUtOc40qWrgJHX4uBvhSpjziCAUlk3PqFVw2O6bGhUq4bHtG58ItbjLx/s0yQLtq1Jeuuf9uqeBx+X63DF2Tm1DRaZp4K4RU177jZduiq6GXltJunPtiqL+28FFAmf6ABKIa0KcGErfF51y31dr0soMU8F8Yt6HnH+BRPXyCvVLZPHKDmqjJFBAIWXdgW4oBU+j5m3dyzrEtbkqZojoxTFV0t7DiNsNdwqizqC+vuJp/74b6pbpoNRclQZZzGAQgtTAe7cq2+Vk9PihfO6ft4gFT5XDY91/TyNsp6nwihFuSwf7NOSlSOBRq8nmXTOYF/yjSqJqO+DL/7sHh01Zy/NmTmF6pYpYZQcYZWpujfBIIBcCfsBG6YCnJN07tW36epb7o8taGlX4TOpFKKsqjmuWbuxbee0Nkpx0aKjC7vuYZm+4IMIm/Zc1M5vFn/XqAWnnLzgbsHsGVS3TEmUvxWj5NVUxguiBIMAciHKB2yUCnBSekFLUilEWcxTKfsaXGX8gg9q8cJ5mjtzqlYMjWqkye/f39ujcwr6+2f9dw0z8lpvm5PufCBc6nXWWQNFxyg5OinrBVGCQQCZi/oB200ltzSClqSOm8U8lTKvwVXWL/gwgqQ9F00e/q61kdfzrrmtY0XhOLAGZHRVGSVHNGW+IEowCGSsTJ2vKLr5gO12hCzpoCVqmlgnaX/BlHkNrjJ/wUfRLu25SPL0d128cJ5+df8jWv2zjYkcvx7VLbtT5lFydKfMF0QJBoGMhE1fKmvQ2M0HbBwjZEkHLVHTxFrJYp5KN2tw5f0cLfMXfJXl7e+634zJiR27HtUtu1fGUXJ0p8wXRCWCQSATYdKX5sycUtq5TN1+wMb1eycZtARNPQoiq3kqZV2Dq+xf8FWVx79rWkFaUb8L8qgso+ToXpkviEoEg0Dqwi6FIHnV5Zop+lymbj9g40rDTDpo6ZR6NHnXSdqydVvbY2Q5T6Wsa3CV/Qu+qvL4d03jfUt1SyC4MCO/Zb0gWpPvb2qghMIuhdBJkecyxfEBG0caZhpBS7PUo9HfT+ib//e7joFg76xp+uuXHKLHn96qy4ZGU09ZKusaXGX/gq+qPP5do1y4Onz/GVo3PkF1SyBGUSoMl/WCaM2krBsAVEnUpRA6qc15KZo4PmBraZiTLHo70gxaFsyeoaUDvTr2oJn61q2/CxTwj216XOdefZsu/Obt+rcfrNOF37xdJ198vU6//MauKqqGafPxvT2h9inCKEXZv+CrKq9/1+WDfYE/pyaZ9A+veU6gzzaqWwLBrFm7UUtWjrTsh9Wyra5ce+8O95f1gmgNwSCQoiQ77rU5L0US1wfs4oXztHpZv/pDBixSdkFLmBHiVlp9cSUhbEe2CKMUZf+Cr6q8/l2DXriqD+46fbb19/Zo9bL+Qk4TANIUtsJwfX+trBdEa7i8CaQo6fSyos1lipI61eoDtpaGuWbtRp139W2BRtyyClriHCFOK024jGtwxXn+IT/y/HeNsnQB1S2B7nVbYTjMlJSiXBCtIRgEUpR0GlIR5zLF/QG7eOE8Scp10BL3CHFaSx6UcQ2uMn/BV1me/65RgzuqW6Iq4r7wEUeF4TJeEK0hGARSlPSHQxHnMiXxAZv3oCWJoD2tJQ/KNkpR5i/4KivC35XgDthRlOIuQY8btT3179G89y2iKl7PESiwuJZCaKVoH0A1SXzA5jloSSpoTzNNuEwd2bJ+wVcdf1egOMKsvxx2jmycFYbz3LeIimAQSFkcSyE0U/S5TEl9wAYJWtL+UJ+z95REjlvENOG8KOMXPPi7AkUQtrhL2DnySVQYLtMFUYJBIGVB05fMJLlgaw2WaS5Tmh+wSaWkdHL/w0/GfkypmGnCeVOmL3hsx98VyK9ui7t0ktcKw3nB0hJABoKUC//isn5ddBprTCUl6npDcUhqBI9zAABQJN0Udwmq7EtDdIvLyEBGgqYvMeclfkmnpHSSxAhelb64AADlEFdxl07yXGE4awSDQMY6pS8x5yV+SaekdBJ38F61Ly4AQDnEWdylnSJUGM4KwSBQEMx5iUcc6w11K86qskl/cXERAgCQlCSKu7RCheHmCAYBVEpaKSmt1IKreT1TtXZsc6ACQa0k+cWVVXEdAEB1pF3chWyrnREMAqiUtFJSGrULrtqpjfwdM2/v1L64klzvCQCAmiiZMnHMkSfbajuCQQCVkmZKSk2n4KqVxpG/NL64si6uAwCoFoq7ZItgEEClpJ2SEjS4kiSTdNqxc3XknD0zS1nJurgOAKBaKO6SLdYZBFApaa83FCa4cpLufegJLR3ozSQQTGO9JwAAGgVZf3n1sn6mJiSAkUEAlZNWSkoeKpeGkXVxHQBAdVHcJRsEgwAqJ62UlKIFV1kV1wEAoIbiLukiGARQSWmsN1S04CqL4joAACA7fIMDqKykU1KKFlylXVwHAABkq5LBoJm9SNKHJL1Q0mRJ6yV9TtJlzrlnAx5jN0nvkHSMpOdLeo6k3SS91Tn32QSaDSAhSaWkFC24ymq9JwAAkI3KVRM1s9dLul7SiZK+KulTknaXdLGkL4c41DRJl0g6W9L+kh6Is50Aii/tyqVxWD7Yp0kWbFvWewIAoNgqFQya2Z6SPiPpWUknOeeWOef+Tt7o3o2S3mhmZwQ83BOSTpH0J865/eWNLALADooWXNWK63RqM+s9lde68QmtGh7TZUOjWjU8xtIhAFBiVUsTfaOkfSV9wTn389qdzrktZvYhSUOS3q4AI4TOuaclfSephgKIV1alqou4mG4axXWQP8PrN+nSodGmacLH9/ZoOX9zACidqgWDL/Nvv9vksevljfa9yMz2cM49lV6zACQlDx3cIgZXrPdULWvWbmx7weKmsc1asnJEFy06mkWfAaBEqhYMHubfrmt8wDm31czGJB0p6RBJd6TVKDO7ucVDh6fVBqCM8tTBLWpwxXpP5Te8flPHkWtJ2uak8665VXNmTsnVhQsAQHRVCwb38m8fafF47f69k28KgCTltYNb1eCqaEFwlVw6NNrxfVKzzUkrhkYJBgGgJAoXDJrZBkkHhdjlS865M4Me3r8N+LUYD+fccc3u90cMj02zLUBZ0MHNhzyk6aK1deMToZYSkaSRsc1aNz5BMA8AJVC4YFDS3ZK2hNj+t3X/ro387dVsQ0l7NmwHoIDK1sEt6qhantJ00dzw+k2R9yvCOQgAaK9wwaBzbrCL3e+S9AJJCyTtME/PzHaV1Ctpq6TfdPEcADJWlg5ukUfV8pqmix09tmVrqvsBAPKlUusMSvqRf/uqJo+dKGmqpJ9SSRQotjJ0cNes3aglK0dajnDWRtWuXHtvyi0LJkqaLtI3fXK0a8JR9wMA5EvVgsGrJG2SdIaZvaB2p5lNlvRR/7//Wb+Dme1lZoeb2QHpNRNAN4rewQ07qhZ1JLQm7kXGu0nTRbqijsYyigsA5ZCPnk9KnHOPmtlb5QWF15nZlyVtlvQ6ectOXCVpTcNub5C0StLnJZ1d/4CZnaftyz8c498uNbMX+/++wTn32Zh/DQAdFL2Dm1bxm6TSUMuSplsFC2bP0PG9PaGC9/7eHv5OAFASVRsZlHPua5JeIm+R+dMkvVPSM5LeI+kM51yYSqKvknSW//M8/74X1d334hb7AUhQrYMbRl46uGmNqiWZhlqGNN0qWT7Yp0nWeTtJmmTSOYN9yTYIAJCaSo0M1jjnhiWdEnDbKyRd0eKxk2JrFICu1VfdPGz2dK3dsFlBLu/kqYObxqha0sVdip6mWzUD82fpY4uO6nhOTDLpokVH52YEHQDQPb55ARReu3THTvLWwU1jVC3pNNSip+nmWVLLjCxeOE9zZ07ViqFRjTR5H/X39uicHFevBQBEQzAIoNA6rWXXTh47uEmPqqWxBiPz0OLX7oLHQT1T9Y6XHqrFC+d19RwD82dpYP6swq5rCQAIj2AQQGEFTXeUJJN05gsP0n4z9sh1BzfpUbW0irssH+zTkpUjgf42eUrTzaNOFzzu2fyEzr36Nv3Xj3+jj5763Fxd3AAA5BvBIIDCCpPu6OSNin3k1Ocm2qZuJT2qllZxF+ahxSPMBY+xTY/rzM+O6OOnHa3TFx4Y6bmSqC4LAMgvgkEAhdCYujZn7ymJpztmJclRtTSLuzAPrXthLnhI3kWPTkV/mqWB/mLjQ22Dzlp12YsWRQs0AQD5RDAIINe6KQ7T6nh5DwaTHFWLMw01yNwy5qFFF2V+p9S66E+376Wo1WUBAPlFMAggt7opDtNKUdayS2pULY401CjphAtmzyD4Cynq/E5p51HwuN5LUarLAgDyi2AQQC6FmSsVRpHWsktqVK2bNNROQQXphPHp9sJFbRQ87vdSUdKtAQCdFadXBKBSws6VCqqIIxpxj6pFTUNNerF67KjbCxe1YDKJ91IR0q0BAJ1NyroBANAo6lypTljLbrvFC+dp9bJ+9ff2NH28v7dHq5f17zC6F2WxekTXbSA9ffKuib2XipJuDQBoj5FBALnTzVypViaZtOjYOVo1PEYRE1+YNNQ0FqvHjqLM76w3MH9WIu8lqVjp1gCA1vg0B5A7Gx58PNbjmUkH7TNN5159206PsX5asDTUtBarx3brxid02OwZWju2WWGzPGuj4N/71QOJtK3K7xcAKBOCQQCZaRyRmrr7Lrr6lvtjTWs7ZNY0jW16XGObmgeYFDwJJq3F6tH9EhD1RX+SGMELk27NkiIAkG8EgwBSF/fagTWfXnKc7n/4yR2Cy/dfc1vHUZVtTjr36lt12/2PaL8Ze9BpbSLNxeqrrNslIBqL/sQ9gtdYXbaVKMuPAADSx7c0gFQlsXag5I1WnHzk/jvcd/rlNwZ+Hidp9c/u2eE+Oq3bxblYPZrrdgmIZmtPdjvvsF5joNkKy48AQHEQDAJITVJrBzYbrYijiiKd1u3iWKwe7YVdAuKgfabqjcfO7TiSHWZdyVaaBZrNsPwIABQLwSCA1CSx3lmr0Yq4qijSad2um8Xq0V6Uixf3PPiEXvnc/TsG3GHXlTxm3t6R5/lFWX6k6u8rAMgSwSCAVCSx3lm70Yo4C5fQafVEXawenSVdrXXxwnmaO3OqVgyNaqTJ+7DxvRRlRJflRwCgeAgGAaQi7vXOzjrhIF34+ue2fDzuwiV0Wj1hgwq0V6u2+cPbxyPtH+aiR5h1JaNg+REAKB6CQQCpiHuJgYNnTWv7eBLBCJ1WT9JBRRXEVVE3ykWPIOtKRsHyIwBQPASDAFIR90hdp2AvziqKNXRad5RUUFF2cVbUzdMILMuPAEDxTMq6AQCqIc5Oa9AqlcsH+zTJYntaOq3oWpwVdfNWrZXlRwCgeAgGAaSiNlLXrTBVKmsFT+IKCOm0oltxVdTNY7XWKO/xvAW0AFA1BIMAUtPtSF2UKpWLF87T6mX96u8yEKXTim7FVVE3z9Vaw7zH8xjQhrFufEKrhsd02dCoVg2Pad34RNZNAoDQyHkCkJqgSxM0002VymYFT34/sUVfHNkox5p5SEkcFXXzXq21CsuPtCv+c3xvj5bn+O8DAI0IBgGkKsjSBIuOnaMnnn429iqVjQVPnjtnr1J3WpEvUQsQDRy6j17+nNmFqdZa5uVHOhX/uWlss5asHNFFi47W6QsPTLdxABABwSCA1OVlaYIyd1qRP1ELEL38ObO1dKA35tYkKy/v8TgFLf6zzUnnXXOr5sycwmcHgNwjGASQmTwsTVDGTivyqYrVNvPwHo9LmOI/25y0Ymi00H87ANVAMAgAKlenFfkUZe1LChflQ5TiPyNjm7VufIK/H4Bco5oogExQiQ9VVKVqm2UStfhPHEWDACBJjAwCSBWV+FBlVai2WUZRi/9E3Q8A0kIwCCA1VOID8lO4iHmywUUt/hN1PwBIC59SAFJBJT5guywLFzE6H14Vi/8AqAaCQQCpoBIfsLO0CxcxOh8NxX8AlBUFZAAkrptKfADiEXZ0nuInO6L4D4AyIhgEkDgq8QHZizI6j+1qxX86BYQU/wFQJASDABJHJT4gW4zOx2Pxwnlavaxf/b09TR/v7+3R6mX9pNgCKAzmDAJIHJX4gGx1MzrPvLcdZVn8BwDiRk8LQOKoxAdki9H5+KVd/AcAkkAwCFRcGle3qcQHZIvReQBAM3zKAxWV9lpjywf7tGTlSKACFlTiA+LF6DwAoBkKyAAVtGbtRi1ZOdJypK621tiVa++N7TmpxAdkpzY6H0YWo/Prxie0anhMlw2NatXwGAVsACBhjAwCFRN2rbE5M6fEFpgtXjhPc2dO1YqhUY00CUT7e3t0TswjkgA8eR6dTztTAQDgIRgEKibKWmNxdsKoxAdkozY63+liUNqj82vWbmzbplqmwkWLjo60ZAOfNQDQGsEgUCHdrDWWRFEZOmRAuvI2Op9kpgKjjQDQGcEgUCGsNQa0V4VRpDyNzieVqZD0aCMAlAXBIFAhrDUGNFfFUaSsR+eTylTIcl40ABQN1USBCmGtMWBnWVTXRXeZCu1EGW0EgKoiGAQqhLXGgB2FHUWKGsBgZ0lkKnQz2ggAVUQwCFRIUdYaA9LCKFJ2kshUSGq0EQDKimAQqJjlg30dF36vSXutMSBNjCJlK4lMBeZFA0A4BINAxdTWGusUEKa91hiQNkaRspVEpgLzogEgHIJBoIIWL5yn1cv61d+iI9bf26PVy/opuY5SYxQpe3FnKjAvGgDC4VIYUFF5WmsMyAKjSNmrZSp0KuITNFOhNtoYJv2XedEAqoxvNKDisl5rDMgKo0j5sHjhPM2dOVUrhkY10iSI6+/t0Tkh1nlcPtinJStHAhUGYl40gKojGAQAVBKjSPkRZ6ZC3KONAFBmBIMAgMpiFClf4spUiHu0EQDKimAQAFBZjCKVF/OiAaAzgkEAQKUxilRuzIsGgNYIBgEAlccoUjqSen35uwFANASDAAD4GEVKxvD6Tbp0aLRpsZ7je3u0POLIa1LHBYCqYNF5AACQmDVrN2rJypGWVVtvGtusJStHdOXae3NxXACoEoJBAACQiOH1mzoW55GkbU4675pbNbx+U6bHBYCqIRgEAACJuHRoNNCyHZIXuK0YGs30uABQNQSDAAAgduvGJ1qmcLYyMrZZ68YnMjkuAFQRwSAAAIhd1NTMTvsldVwAqCKCQQAAELvHtmyNfb914xO6ft0fUm0PAJQZS0sAAIDYTZ8crYvRbL92S0gk3R4AKDM+GQEAQOyiru/XuN+atRsDVQ5Nqj0AUGakiQIAgNgtmD1Dx/f2hNqnv7dHC2bP+OP/gy4hEfa4AAAPI4MAgMpaNz6h4fWb9NiWrZo+eVcNzJ9F0BCj5YN9WrJyJFAwN8mkcwb7drgvzBISYY4LAPAQDAIAKqfdHLTje3u0fLCPtMIYDMyfpY8tOqrj6N4kky5adPQOr3mUJSSCHBcAsB3BIACgUjrNQbtpbLOWrBzRRYuO1ukLD0y3cSW0eOE8zZ05VSuGRjXSJLjr7+3ROU2C726Xgmh1XADAdgSDAIDKCDoHbZuTzrvmVs2ZOYVgIgYD82dpYP6sUGm5UZeCeOlh++r9pxxBui8ABEAwCACojDBz0LY5acXQKMFgjBbMnhE4SIu6FMSJC/YlEASAgKgmCgCohChz0EbGNmvd+ERCLUI7cS1NAQBojWAQAFAJUeegdTt3DdHEsTQFAKA9gkEAQCVEnYMWdT90b/lgnyZZsG1ZQgIAwiMYBABUQtQ5aFH3Q/dqS1N0CghZQgIAoiEYBABUAnPQiun582bqzf0Hae7eU5o+3t/bo9XL+lkGBAAi4HInAKQkTFl9xK82By1MERnmoGVneP0mXTo02vTvNXfvKXrp4ftqyQkH8/cBgC4QDAJAwtp1ao/v7dFyFsZOzfLBPi1ZORJoeQnmoGVnzdqNbdeDvO/hJ/WlkY06as7eBIMA0AXSRAEgQWvWbtSSlSMtR6NuGtusJStHdOXae1NuWTUxBy3/htdvahsI1mxz0nnX3Eq1VwDoAsEgACSETm0+LV44T6uX9au/xbIFzEHL1qVDo4FGbiXvvbNiaDTZBgFAiVUyTdTMXiTpQ5JeKGmypPWSPifpMufcswGP0SdpkaRXSuqTNFvSQ5J+JukS59y1CTQdQIFE6dQyEpWOgfmzNDB/FvM4c2bd+ESoOZ2SNDK2WevGJ/i7AUAElQsGzez1kq6WtEXSGkmbJb1W0sWSBiS9KeChPiJpsaTbJX3bP85hkl4n6XVmttw5tyLe1gMoCjq1xbBg9gxe7xyJOjo+vH4Tf0cAiKBSwaCZ7SnpM5KelXSSc+7n/v3/IOlHkt5oZmc4574c4HDflfRx59wvGp7jJZJ+IOkTZvYV59zvYv0lgJQwYtIdOrVAeI9t2ZrqfgBQdZUKBiW9UdK+kr5QCwQlyTm3xcw+JGlI0tsldQwGnXNXtLj/x2Z2naRXSHqRvFFIoDCofBkPOrVAeNMnR+uWRN0PAKquagVkXubffrfJY9dLekLSi8xsjy6f5xn/ll4dCoXKl/GhUwuEF/VCExeoACCaqvU6DvNv1zU+4JzbamZjko6UdIikO6I8gZkdJGlQXmB5fcB9bm7x0OFR2gBEEbby5ZyZU+iAtUGnFghvwewZOr63J9R82/7eHlKrASCiqo0M7uXfPtLi8dr9e0c5uD+i+CVJe0i6wDn3UJTjAFmgnHu8ap3aMOjUAtLywb6O60DWTDLpnMG+ZBsEACVWuGDQzDaYmQvx88Uwh/dvA3aJd2jXLpJWy6tIukbSvwbd1zl3XLMfSXeGbQcQRTeVL9EanVogvIH5s/SxRUd1fO9MMumiRUczmg4AXShimujd8paFCOq3df+ujfzt1WxDSXs2bBeIHwh+Ud6yFFdKOtM5FzqgBLJC5ctk1Dq1ndJv6dQCO1q8cJ7mzpyqFUOjGmlyoaq/t0fnUMwKALpWuGDQOTfYxe53SXqBpAWSdpinZ2a7SuqVV/TlN0EP6O/33/ICwf+W9JagC9cDeUHly+TQqQWiGZg/SwPzZ7HMDQAkqHDBYJd+JOnNkl4l6X8aHjtR0lRJ1zvnngpyMDPbXd5I4OslfUHSUufctviaC6SDypfJolPbHK8HglgwewbnBQAkpGo9uaskfVzSGWZ2Wd2i85MlfdTf5j/rdzCzvSQdIOmR+gXk/WIx10g6RdJKSX9FIIiiovJlOujUeljLEgCAfKhUMOice9TM3iovKLzOzL4sabOk18lbduIqecVf6r1B0ipJn5d0dt39/yUvENwk6X5J/2i202z365xz18X7WwDxo5w70rJm7ca2cyhra1letOhonb7wwHQbBwBAxVQqGJQk59zXzOwlkj4o6TRJkyWtl/QeSStCFH7p9W9nSfrHNttdF7GpQKqWD/ZpycqRQMtLUPkSUbCWJQAA+VK5YFCSnHPD8kb1gmx7haQrmtx/UqyNAjJG5UskLcpalpxnAAAkp3DrDAJIzuKF87R6Wb/6WyyW3t/bo9XL+knfQ2isZQkAQP5UcmQQQGtUvkQSWMsSAID8IRgE0BSVLxEn1rIEACB/SBMFACSOtSwBAMgfgkEAQOJYyxIAgPwhGAQAJK62lmUYrGUJAECyCAYBAKlYPtinSRZsW9ayBAAgeQSDAIBU1Nay7BQQspYlAADpYGY+ACA1ixfO09yZU7ViaFQjTdYd7O/t0TmDfQSCAACkgGAQAJAq1rIEACAfCAYBAJlgLUsAALLFnEEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqKBds24AgPxbNz6h4fWb9NiWrZo+eVcNzJ+lBbNnZN0sAAAAdIFgEEBLw+s36dKhUd00tnmnx47v7dHywT4NzJ+VQcsAAADQLdJEATS1Zu1GLVk50jQQlKSbxjZrycoRXbn23pRbBgAAgDgQDALYyfD6TXr/Nbdpm2u/3TYnnXfNrRpevymdhgEAACA2BIMAdnLp0GjHQLBmm5NWDI0m2yAAAADEjmAQwA7WjU+0TA1tZWRss9aNTyTUIgAAACSBYBDADqKmfJIqCgAAUCwEgwB28NiWranuBwAAgGwQDALYwfTJ0VacibofAAAAskEwCGAHUdcNZL1BAACAYiEYBLCDBbNn6PjenlD79Pf2aMHsGQm1CAAAAEkgGASwk+WDfZpkwbadZNI5g33JNggAAACxIxgEsJOB+bP0sUVHdQwIJ5l00aKjSREFAAAoICo+AGhq8cJ5mjtzqlYMjWqkybqD/b09Omewj0AQAACgoAgGAbQ0MH+WBubP0rrxCQ2v36THtmzV9Mm7amD+LOYIAgAAFBzBIICOFsyeQfAHAABQMswZBAAAAIAKIhgEAAAAgAoiGAQAAACACiIYBAAAAIAKIhgEAAAAgAoiGAQAAACACiIYBAAAAIAKIhgEAAAAgAoiGAQAAACACiIYBAAAAIAKIhgEAAAAgAoiGAQAAACACiIYBAAAAIAKIhgEAAAAgAoiGAQAAACACjLnXNZtQAtm9uCUKVN6jjjiiKybAgAAACCH7rjjDj355JObnXP7hN2XYDDHzGxM0p6SNmTclLw43L+9M9NWoOo4D5EHnIfIA85D5EXVz8WDJT3qnOsNuyPBIArDzG6WJOfccVm3BdXFeYg84DxEHnAeIi84F6NjziAAAAAAVBDBIAAAAABUEMEgAAAAAFQQwSAAAAAAVBDBIAAAAABUENVEAQAAAKCCGBkEAAAAgAoiGAQAAACACiIYBAAAAIAKIhgEAAAAgAoiGAQAAACACiIYBAAAAIAKIhgEAAAAgAoiGESmzOzVZvZ9M7vPzJ40s9+Y2VfM7IQQx9hgZq7FzwNJth/FZ56/MLOfmdmEmT1hZr8ws3PMbJeQx5prZp8zs9+a2VP+uXmJmc1Mqv0oh7jOQz4P0YmZvdHMLjOzn5jZo/658cUO+7zIzL5tZpv9c/NWM3tX2M/IuI+F4srqPDSzg9t8Rjoz+3L3v12x7Jp1A1BdZvZxSX8v6UFJX5O0SdJ8Sa+XdJqZvcU51/aDoc4jki5pcv9j3bcUJfd5SUsk/V7SGkmPS3q5pEslnWhmb3LOuU4HMbNDJf1U0n6Svi7pTknHS1ou6VVmNuCcezCZXwElEMt56OPzEO18SNLz5J0P90k6vN3GZvZ6SVdL2iLv3Nws6bWSLpY0IOlNQZ84zmOh8DI7D33/J6/v2ehXIY9TfM45fvhJ/UfS/pKelfSApP0aHnupJCfpNwGPtUHShqx/J36K9yPp1Nq5JmlW3f27Sfqq/9jZAY/1PX/7dzbc/+/+/f+V9e/LTz5/Yj4P+Tzkp+2P/x3bJ8kkneSfX19sse2e8i5QPCXpBXX3T5Z38ctJOiPg88Z2LH6K/5PheXiwv/0VWb8GefkhTRRZOUhemvKIc+739Q84566VNCFp3ywahkpZ5N/+m3NuU+1O59wzkv7B/+87Ox3EzA6RdLK8jvinGh4+X94ozxIzm9Ztg1FKsZyHQBDOuWudc6PO7xl38EZ538Vfds79vO4YW+SN7EjS2wM+dZzHQsFleB6iAWmiyMqopKclHW9ms+o7QGZ2oqQZaj5838oeZnampHnyOt63SrreOfdsfE1GCe3v3/6myWO1+441s72dcw+3Oc7L/NvvO+e21T/gnJsws2F5weILJQ110V6UU1znYQ2fh4hL7bPtu00eu17SE5JeZGZ7OOeeSvFYqJYkzp0/MbO3SdpH3nSlG51zt3bf1OIhGEQmnHObzexceSl0t5vZ1+S9GQ+V9DpJP5D0thCH3F/S6ob7xsxsqXPuxzE0GeVUuwjR2+SxQ+r+fbikn7U5zmH+7boWj4/KCwYXiGAQO4vrPKzh8xBxafnZ5pzbamZjko6Ud57ekeKxUC1JnDuv8H/+yMyuk3SWc25j9KYWD2miyIxz7hJ56VG7SnqrpPPkTQC+V14u9+9b772DVZIG5XWApkk6StLl8vLCv2Nmz4u14SiTb/m37zGzntqdZrarpAvrtutUDXQv//aRFo/X7t87bANRCXGdhxKfh4hXnJ9tfE4iqjjPnSckfUTScfI+U2dKeomka+XNXRyq2pQOgkFkxsz+XtJVkq6QNyI4Td6b8zeSvmRm/xLkOM65C51zP3LOjTvnnnDO/co599fyRh2nSLogifajFL4s6Tvyzr/bzezTZnaJpF9KOkXeiJ7kFTvqhvm3QatBolpiOw/5PETK4vxs43MSUQU+d5xzv3fO/aNz7hbn3MP+z/XysndG5FW1/8sE25o7BIPIhJmdJOnjkr7hnHuPc+43fsflFklvkHS/pPf6hTmi+i//9sSuGovS8uf3vU7S++RVtl0i6S/klbl+sbzUZcmrYtZO7arkXi0e37NhO+CPYjwP2+HzEFHE+dnG5ySiSvzccc5tlfRZ/7+V+pwkGERWXuPfXtv4gHPuCUk3yTs/n9/Fc9Q6TpUa7kc4zrmtzrl/c84d45yb4pzb0zn3Kkm3SzpG0pOSft3hMHf5twtaPN7n37aaU4iKi+k8bIfPQ0TR8rPNT2PulbRVzYsfJXksVEta584f/NtKfU4SDCIre/i3rZaPqN3/dBfPcYJ/yxcLolgibw2jK/0S/+3ULmqcbGY7fK6a2Qx5C+I+qWDFP4B6Yc7Ddvg8RBQ/8m9f1eSxEyVNlfTTgBUc4zwWqiWtc+eF/m2lPicJBpGVn/i3f2Vmc+ofMLP/J6/zvEXeYqIys93M7HAzO7Rh2yPrCy7U3X+QpE/6//1i3I1HeZjZnk3uWyjpIkmPSfpw3f1Nz0Pn3N2Svi+vSMffNBzuQnlXGb/gnHs83tajLOI4D/k8RAKuklft9gwze0HtTjObLOmj/n//s34HM9vLPz8P6PZYgC+289DM+s1s98YnMLOXSXq3/99KfU5asLUegXj5oyffk/RyeQvMf1XeXJkj5KWQmqR3Oecu9bc/WNKYpHuccwfXHecCeVVIr/Ufn5BXhOHV8q6mf1vSG5xz3YwwosTMbETeqN2v5J0/R8or2vGUpEXOue/VbXuwmpyH/mOHyrt4sZ+kr8srb90v6aXy0kNf5Jx7UEATcZyHfB4iCDM7VdKp/n/3l/RKeSMhtYu0m5xz72vY/ip5F2i/LGmzvDmuh/n3n16/cLiZnS2vqu3nnXNnN3nuwMdCeWV1HvrLRxwp6Tp587Il6WhtX8vwH5xztQCzElhnEJlwzm0zs1PkjaKcIa9ozFR5b+5vS1rhnPt+gENdK++D4Pny0qCmSXpY0g3y1tlazRcLOrhK3jl4prxqi7+VN4n8IufchqAHcc7d7V+x/LC8VJZTJP1O0gpJFzrnNsfcbpRLHOchn4cI4hhJZzXcd4i2r2l5j7xiRpIk59zXzOwlkj4o6TR5FxbWS3qPvO/qwOdUnMdC4R2jbM7D1fL6nAsl/T9Ju0kal3SlpE86537SZt9SYmQQAAAAACqIOYMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAAAAAFBBBIMAAAAAUEEEgwAAAABQQQSDAIDSMrODzcyZ2RVZt6UVMzvJb+MFWbelxsw2mNmGrNsBAEgWwSAAoJD8AKrdz9lt9r3C3+bgFo9fZ2YuqbZHYWaTzGyj3+7ndNh2ipk9bGZPm9l+abURAFAsu2bdAAAAunRhi/t/Kel+SUdIeiS11iTEObfNzD4n6XxJfynpPW02P13SXpKucs79Po32AQCKh2AQAFBozrkLOmxyZxrtSMlKSR+StMTMznPOPd1iu7/0bz+dTrMAAEVEmigAoLSazRn00z/P8v87VpdWuqG2vaSX1Lat+7mu4dhzzeyTZvYbM3vKzB40s2+Y2cIWbZltZivNbNzMnjSzX5rZWc22bcU5d6+k70qaJekNLZ7ncEkvljQm6YdmtruZ/a2ZfdvM7vHbutnMfmhm/y/oc5vZBf7rcFKTx1rOzTSzqWb2fv/3fdzMHjOzG83sz5psa2Z2lpn91Mz+YGZbzOxeM/uemS0O2lYAQDCMDAIAquZCSadKep6kSyU97N//sP9zoaSzJR2kHVNQN9T+YWbHSvq+pB5J35N0jbwA7VRJN5jZG5xz367bfh9JP5V0iKQb/J8DJP2Xf5wwPiPp1fJG/9Y0ebw2KvhZ55wzsx7/9/yppB9I+oP/3K+V9G0ze6tz7rMh2xCIme0t6UeSni/pFkmfk3ch+pWS/tvMjnTOfahul3+S9H55geyV8tJ7D5C0UNKb1Pz3BQBERDAIACi0FlU4Nzjnrmi2vXPuAr9wzPMkXeKc29CwyQX+6NdBzVJQzWxXeYHKdEkvdc79uO6xP5G0VtJKMzvYOfeU/9DH5AWClzjn3l23/Scl3djxl9zRtyT9VtKgmfU658bqjre7pLdI2iov8JKkh/zf5b6G32MvScOS/sXMvuScezJkO4K4RF4geK5z7l/qnnuypK9J+oCZXeWc+6X/0NvkzfN8rnPuiYb2zkqgfQBQaaSJAgCK7vwmP2cn+HyvlnSopMvqA0FJcs79VtK/SNpf0qAkmdlukt4saULSBQ3b/1zSl8I8uXPuWXmBnkla1vDw6yXtK+mbzrkH/O2fagwE/fsf8Y8zU97IW6z80dAzJf28PhD0n3uLpHP93+HPG3Z9RtKzTdq7Ke42AkDVMTIIACg055yl/JQn+LcHtRiV7PNvj5D0bUmHS5oq6Sd+ANboOm2fwxjUZyV9QNJSMzvfDxAl6a3+7Q6FY8zsSEl/J+lEeWmXkxuONyfk8wexUNIuklqtobibf3tE3X1fkvROSb82s69I+rGkG1u8bgCALhEMAgAQzj7+7Zs6bDfdv93Lvx1vsd0DYRvgnLvHzH4gb+7dKZK+6ae+vlzSPaqbh2hmL5Q3b29XSUOSviHpUUnbJB0jbzRxj7BtCKD2Oi1U+5HH6XX/frekuyX9haTz/J+tZvZtSe91zq1PoJ0AUFkEgwAAhFMbpXq9c+4bIbaf3eLx/SO249PygsG3SvqmvJRRk7TSObetbrsPSZoib37jdfUHMLP3ywsGg6gds1nfYe8m99V+74udc+3WRPwjf4TzUkmXmtl+8qqiniEv8D7SLzjzVLtjAACCY84gAKCKammVu7R73MyaPf4z//ZPAz7XnZKekHSMX7Sl0UkBj9PoG/JGFU8xswPlzZOszSesN1/S5sZA0PeSEM/3kH97YJPHXtDkvpvkBZBBX6cdOOd+75y7xjl3uryRzUMlPTfKsQAAzREMAgCq6EH/dl6Ex78uL5Xxb8zslGY7m9kJZjZVkpxzz8ibCzdDDQVkzOwF8orLhOac2yrpCnkB7ZckzZX0befc/Q2bbpDUY2ZHNzz3Mnkji0Hd5N8u9Suq1o5zoKR/bNK+3/vteoGZ/UP9PnX7Hmpmvf6/9zCzQTOzhm12k7eEh+QF1QCAmJAmCgCooiF5BVU+Y2ZXSXpM0sPOuU/WPf4mSdf489WelHSPc261c+4ZM1skb33B/zWzn0r6pbxA5UB58+MOkVeopRa8fEBeddF3+QFgbZ3BxfKKzLwu4u/xGXlVOWujb59uss0l8oK+G8ystnbfC+SlYF4l6Y1Bnsg5N2Jm18srQnOTmf1IXurra+W9Fs1GDP9WXkGdD0taYmY3yJs7+SfyCscslPRn8tYVnCLph5I2mNmIvLmPkyW9wt/2G865O4K0FQAQjDnnsm4DAAChmZmT2lcT9YuqjEn6vHPu7IbH3iNvvt0hknaXF+wd7D+2i6SPyJuvdqC8i6c/ds6dVLf/fpLeI+k1/jG2SfqdpP+Tt4bel/3Ru9r2+0v6Z3nB03RJd8kL1DZIulbShc3WNezELyTzckn3STq4rrJo/TavkTd38Eh5qaQ3Sfqo3+5VkpbWr8toZhskqfZ61N2/t6RPyJtnuJekUUkr5BWsafU67y7pr+QtIXGkvABv3N/3m5JWO+ce9EcA3y3ppf52+8lbjuNueSOgn3POPR3y5QEAtEEwCAAAAAAVxJxBAAAAAKgggkEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqCCCQQAAAACoIIJBAAAAAKgggkEAAAAAqKD/DzdxalOxlXTkAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 331,
       "width": 449
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__==\"__main__\":\n",
    "    data_obj = Data(\"cleaned_data_project1.csv\",\"price\")\n",
    "    num_cols, targetcol, data, cat_cols = data_obj.get_inputs()\n",
    "    #There is presence of heteroscedasticity\n",
    "    data['price'] = np.log(data['price'])\n",
    "    #data.info()\n",
    "    model = smf.ols(targetcol+'~'+'+'.join(num_cols+cat_cols),data=data).fit()\n",
    "    #print(model.summary())\n",
    "    print(\"Adj R2 of old model:\",model.rsquared_adj)\n",
    "    print(\"Adj R2 of old model:\",model.rsquared_adj)\n",
    "    sns.regplot(data[targetcol],model.fittedvalues)\n",
    "    num_cols, cat_cols = removal_on_vif(targetcol, data, num_cols, cat_cols)\n",
    "    outliers = influential_points(targetcol, num_cols, cat_cols, data)\n",
    "    data = data.drop(outliers).reset_index()\n",
    "    print(\"length of data after removing outliers:\",len(data))\n",
    "    num_cols, cat_cols = removal_on_pvalue(targetcol, num_cols, cat_cols, data)\n",
    "    num_cols, cat_cols = anovatyp1_removal(targetcol,num_cols,cat_cols,data)\n",
    "    model, explanation, num_cols, cat_cols = finalmodel(targetcol,num_cols, cat_cols, data)\n",
    "    fig, ax = plt.subplots(figsize=(10,5))\n",
    "    sns.barplot(explanation.values,explanation.index)\n",
    "    plt.show()\n",
    "    print(model.summary())\n",
    "    mse = model.mse_resid\n",
    "    msr = model.mse_model\n",
    "    print(\"R2 of the Final Model\", model.rsquared_adj)\n",
    "    n_iterations = 1000\n",
    "    lower, upper = bootstrap_confidence(n_iterations, targetcol, num_cols, cat_cols, data)\n",
    "    conf_interval, pred_interval = ci_pi(targetcol, num_cols, cat_cols,data)\n",
    "    print(\"Confidence Interval for a given sample is:\",conf_interval)\n",
    "    print(\"prediction Interval for given sample is:\",pred_interval)\n",
    "    residuals_plot(model.fittedvalues,model.resid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0adae19a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       9.510075\n",
       "1       9.711116\n",
       "2       9.711116\n",
       "3       9.543235\n",
       "4       9.767095\n",
       "         ...    \n",
       "189     9.849559\n",
       "190     9.731809\n",
       "191     9.854560\n",
       "192    10.019936\n",
       "193    10.026811\n",
       "Name: price, Length: 194, dtype: float64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['price']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b11b593c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "filename = 'finalized_model_LRproject.pkl'\n",
    "pickle.dump(model, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "acd72cc5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"simpletable\">\n",
       "<caption>OLS Regression Results</caption>\n",
       "<tr>\n",
       "  <th>Dep. Variable:</th>          <td>price</td>      <th>  R-squared:         </th> <td>   0.958</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model:</th>                   <td>OLS</td>       <th>  Adj. R-squared:    </th> <td>   0.953</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Method:</th>             <td>Least Squares</td>  <th>  F-statistic:       </th> <td>   186.9</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Date:</th>             <td>Sat, 15 Oct 2022</td> <th>  Prob (F-statistic):</th> <td>9.56e-107</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Time:</th>                 <td>14:03:20</td>     <th>  Log-Likelihood:    </th> <td>  173.18</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>No. Observations:</th>      <td>   194</td>      <th>  AIC:               </th> <td>  -302.4</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Df Residuals:</th>          <td>   172</td>      <th>  BIC:               </th> <td>  -230.5</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Df Model:</th>              <td>    21</td>      <th>                     </th>     <td> </td>    \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Covariance Type:</th>      <td>nonrobust</td>    <th>                     </th>     <td> </td>    \n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "             <td></td>               <th>coef</th>     <th>std err</th>      <th>t</th>      <th>P>|t|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Intercept</th>              <td>    4.1776</td> <td>    0.075</td> <td>   55.442</td> <td> 0.000</td> <td>    4.029</td> <td>    4.326</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_mitsubishi</th>        <td>   -0.1220</td> <td>    0.034</td> <td>   -3.543</td> <td> 0.001</td> <td>   -0.190</td> <td>   -0.054</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>engine_type_ohcf</th>       <td>    0.1214</td> <td>    0.043</td> <td>    2.813</td> <td> 0.005</td> <td>    0.036</td> <td>    0.207</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_plymouth</th>          <td>   -0.1170</td> <td>    0.042</td> <td>   -2.796</td> <td> 0.006</td> <td>   -0.200</td> <td>   -0.034</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>city_mpg</th>               <td>   -0.0167</td> <td>    0.006</td> <td>   -2.744</td> <td> 0.007</td> <td>   -0.029</td> <td>   -0.005</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>highway_mpg</th>            <td>    0.0106</td> <td>    0.006</td> <td>    1.738</td> <td> 0.084</td> <td>   -0.001</td> <td>    0.023</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_subaru</th>            <td>   -0.1375</td> <td>    0.049</td> <td>   -2.799</td> <td> 0.006</td> <td>   -0.235</td> <td>   -0.041</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>curb_weight</th>            <td>    0.0007</td> <td> 3.39e-05</td> <td>   19.969</td> <td> 0.000</td> <td>    0.001</td> <td>    0.001</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>num_of_doors_four</th>      <td>    2.1054</td> <td>    0.042</td> <td>   50.675</td> <td> 0.000</td> <td>    2.023</td> <td>    2.187</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>num_of_cylinders_eight</th> <td>    0.2148</td> <td>    0.071</td> <td>    3.037</td> <td> 0.003</td> <td>    0.075</td> <td>    0.354</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_porsche</th>           <td>    0.4231</td> <td>    0.108</td> <td>    3.900</td> <td> 0.000</td> <td>    0.209</td> <td>    0.637</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>body_style_convertible</th> <td>    0.1826</td> <td>    0.048</td> <td>    3.828</td> <td> 0.000</td> <td>    0.088</td> <td>    0.277</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>num_of_doors_two</th>       <td>    2.0721</td> <td>    0.036</td> <td>   57.698</td> <td> 0.000</td> <td>    2.001</td> <td>    2.143</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>drive_wheels_fwd</th>       <td>    1.3651</td> <td>    0.030</td> <td>   44.888</td> <td> 0.000</td> <td>    1.305</td> <td>    1.425</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>body_style_wagon</th>       <td>   -0.0947</td> <td>    0.026</td> <td>   -3.681</td> <td> 0.000</td> <td>   -0.146</td> <td>   -0.044</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>drive_wheels_4wd</th>       <td>    1.3356</td> <td>    0.041</td> <td>   32.312</td> <td> 0.000</td> <td>    1.254</td> <td>    1.417</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_isuzu</th>             <td>   -0.3004</td> <td>    0.077</td> <td>   -3.882</td> <td> 0.000</td> <td>   -0.453</td> <td>   -0.148</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>engine_location_rear</th>   <td>    0.2589</td> <td>    0.083</td> <td>    3.126</td> <td> 0.002</td> <td>    0.095</td> <td>    0.422</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>aspiration_turbo</th>       <td>    0.1177</td> <td>    0.023</td> <td>    5.041</td> <td> 0.000</td> <td>    0.072</td> <td>    0.164</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>drive_wheels_rwd</th>       <td>    1.4768</td> <td>    0.038</td> <td>   38.816</td> <td> 0.000</td> <td>    1.402</td> <td>    1.552</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_audi</th>              <td>    0.3292</td> <td>    0.049</td> <td>    6.787</td> <td> 0.000</td> <td>    0.233</td> <td>    0.425</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_bmw</th>               <td>    0.4115</td> <td>    0.045</td> <td>    9.233</td> <td> 0.000</td> <td>    0.324</td> <td>    0.499</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_mazda</th>             <td>    0.0740</td> <td>    0.029</td> <td>    2.573</td> <td> 0.011</td> <td>    0.017</td> <td>    0.131</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_peugot</th>            <td>   -0.2402</td> <td>    0.038</td> <td>   -6.346</td> <td> 0.000</td> <td>   -0.315</td> <td>   -0.165</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>make_saab</th>              <td>    0.1355</td> <td>    0.049</td> <td>    2.769</td> <td> 0.006</td> <td>    0.039</td> <td>    0.232</td>\n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "  <th>Omnibus:</th>       <td> 1.386</td> <th>  Durbin-Watson:     </th> <td>   1.375</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Prob(Omnibus):</th> <td> 0.500</td> <th>  Jarque-Bera (JB):  </th> <td>   1.253</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Skew:</th>          <td> 0.038</td> <th>  Prob(JB):          </th> <td>   0.534</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Kurtosis:</th>      <td> 2.614</td> <th>  Cond. No.          </th> <td>1.72e+19</td>\n",
       "</tr>\n",
       "</table><br/><br/>Notes:<br/>[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.<br/>[2] The smallest eigenvalue is 4.44e-30. This might indicate that there are<br/>strong multicollinearity problems or that the design matrix is singular."
      ],
      "text/plain": [
       "<class 'statsmodels.iolib.summary.Summary'>\n",
       "\"\"\"\n",
       "                            OLS Regression Results                            \n",
       "==============================================================================\n",
       "Dep. Variable:                  price   R-squared:                       0.958\n",
       "Model:                            OLS   Adj. R-squared:                  0.953\n",
       "Method:                 Least Squares   F-statistic:                     186.9\n",
       "Date:                Sat, 15 Oct 2022   Prob (F-statistic):          9.56e-107\n",
       "Time:                        14:03:20   Log-Likelihood:                 173.18\n",
       "No. Observations:                 194   AIC:                            -302.4\n",
       "Df Residuals:                     172   BIC:                            -230.5\n",
       "Df Model:                          21                                         \n",
       "Covariance Type:            nonrobust                                         \n",
       "==========================================================================================\n",
       "                             coef    std err          t      P>|t|      [0.025      0.975]\n",
       "------------------------------------------------------------------------------------------\n",
       "Intercept                  4.1776      0.075     55.442      0.000       4.029       4.326\n",
       "make_mitsubishi           -0.1220      0.034     -3.543      0.001      -0.190      -0.054\n",
       "engine_type_ohcf           0.1214      0.043      2.813      0.005       0.036       0.207\n",
       "make_plymouth             -0.1170      0.042     -2.796      0.006      -0.200      -0.034\n",
       "city_mpg                  -0.0167      0.006     -2.744      0.007      -0.029      -0.005\n",
       "highway_mpg                0.0106      0.006      1.738      0.084      -0.001       0.023\n",
       "make_subaru               -0.1375      0.049     -2.799      0.006      -0.235      -0.041\n",
       "curb_weight                0.0007   3.39e-05     19.969      0.000       0.001       0.001\n",
       "num_of_doors_four          2.1054      0.042     50.675      0.000       2.023       2.187\n",
       "num_of_cylinders_eight     0.2148      0.071      3.037      0.003       0.075       0.354\n",
       "make_porsche               0.4231      0.108      3.900      0.000       0.209       0.637\n",
       "body_style_convertible     0.1826      0.048      3.828      0.000       0.088       0.277\n",
       "num_of_doors_two           2.0721      0.036     57.698      0.000       2.001       2.143\n",
       "drive_wheels_fwd           1.3651      0.030     44.888      0.000       1.305       1.425\n",
       "body_style_wagon          -0.0947      0.026     -3.681      0.000      -0.146      -0.044\n",
       "drive_wheels_4wd           1.3356      0.041     32.312      0.000       1.254       1.417\n",
       "make_isuzu                -0.3004      0.077     -3.882      0.000      -0.453      -0.148\n",
       "engine_location_rear       0.2589      0.083      3.126      0.002       0.095       0.422\n",
       "aspiration_turbo           0.1177      0.023      5.041      0.000       0.072       0.164\n",
       "drive_wheels_rwd           1.4768      0.038     38.816      0.000       1.402       1.552\n",
       "make_audi                  0.3292      0.049      6.787      0.000       0.233       0.425\n",
       "make_bmw                   0.4115      0.045      9.233      0.000       0.324       0.499\n",
       "make_mazda                 0.0740      0.029      2.573      0.011       0.017       0.131\n",
       "make_peugot               -0.2402      0.038     -6.346      0.000      -0.315      -0.165\n",
       "make_saab                  0.1355      0.049      2.769      0.006       0.039       0.232\n",
       "==============================================================================\n",
       "Omnibus:                        1.386   Durbin-Watson:                   1.375\n",
       "Prob(Omnibus):                  0.500   Jarque-Bera (JB):                1.253\n",
       "Skew:                           0.038   Prob(JB):                        0.534\n",
       "Kurtosis:                       2.614   Cond. No.                     1.72e+19\n",
       "==============================================================================\n",
       "\n",
       "Notes:\n",
       "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
       "[2] The smallest eigenvalue is 4.44e-30. This might indicate that there are\n",
       "strong multicollinearity problems or that the design matrix is singular.\n",
       "\"\"\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loaded_model = pickle.load(open(filename, 'rb'))\n",
    "loaded_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "216656be",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}