Analysis_07MAY2019_new.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Data-sets\" data-toc-modified-id=\"Data-sets-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Data sets</a></span><ul class=\"toc-item\"><li><span><a href=\"#Synthetic-data-with-unobservables\" data-toc-modified-id=\"Synthetic-data-with-unobservables-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Synthetic data with unobservables</a></span></li><li><span><a href=\"#Data-without-unobservables\" data-toc-modified-id=\"Data-without-unobservables-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Data without unobservables</a></span></li></ul></li><li><span><a href=\"#Algorithms\" data-toc-modified-id=\"Algorithms-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Algorithms</a></span><ul class=\"toc-item\"><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Contraction algorithm</a></span></li><li><span><a href=\"#Causal-approach---metrics\" data-toc-modified-id=\"Causal-approach---metrics-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Causal approach - metrics</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>With unobservables in the data</a></span></li><li><span><a href=\"#Without-unobservables\" data-toc-modified-id=\"Without-unobservables-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Without unobservables</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- ##  Causal model\n",
    "\n",
    "Our model is defined by the probabilistic expression \n",
    "\n",
    "\\begin{equation} \\label{model_disc}\n",
    "P(Y=0 | \\text{do}(R=r)) = \\sum_x \\underbrace{P(Y=0|X=x, T=1)}_\\text{1} \n",
    "\\overbrace{P(T=1|R=r, X=x)}^\\text{2} \n",
    "\\underbrace{P(X=x)}_\\text{3}\n",
    "\\end{equation}\n",
    "\n",
    "which is equal to \n",
    "\n",
    "\\begin{equation}\\label{model_cont}\n",
    "P(Y=0 | \\text{do}(R=r)) = \\int_x P(Y=0|X=x, T=1)P(T=1|R=r, X=x)P(X=x)\n",
    "\\end{equation}\n",
    "\n",
    "for continuous $x$. In the model Z is a latent, unobserved variable, and can be excluded from the expression with do-calculus by showing that $X$ is admissible for adjustment. Model as a graph:\n",
    "\n",
    "![Model as picture](../figures/intervention_model.png \"Intervention model\")\n",
    "\n",
    "For predicting the probability of negative outcome the following should hold because by Pearl $P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0 | R=r, X=x)$ when $X$ is an admissible set:\n",
    "\n",
    "\\begin{equation} \\label{model_pred}\n",
    "P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0|X=x, T=1)P(T=1|R=r, X=x).\n",
    "\\end{equation}\n",
    "\n",
    "Still it should be noted that this prediction takes into account the probability of the individual to be given a positive decision ($T=1$), see second term in \\ref{model_pred}.\n",
    "\n",
    "----\n",
    "\n",
    "### Notes\n",
    "\n",
    "* Equations \\ref{model_disc} and \\ref{model_cont} describe the whole causal effect in the population (the causal effect of changing $r$ over all strata $X$).\n",
    "* Prediction should be possible with \\ref{model_pred}. Both terms can be learned from the data. NB: the probability $P(Y=0 | \\text{do}(R=r), X=x)$ is lowest when the individual $x$ is the most dangerous or the least dangerous. How could we infer/predict the counterfactual \"what is the probability of $Y=0$ if we were to let this individual go?\" has yet to be calculated.\n",
    "* Is the effect of R learned/estimated correctly if it is just plugged in to a predictive model (e.g. logistic regression)? **NO**\n",
    "* $P(Y=0 | do(R=0)) = 0$ only in this application. <!-- My predictive models say that when $r=0$ the probability $P(Y=0) \\approx 0.027$ which would be a natural estimate in another application/scenario (e.g. in medicine the probability of an adverse event when a stronger medicine is distributed to everyone. Then the probability will be close to zero but not exactly zero.) -->\n",
    "\n",
    "Imports and settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "# Imports\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as scs\n",
    "import scipy.integrate as si\n",
    "import seaborn as sns\n",
    "import numpy.random as npr\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Settings\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "plt.rcParams.update({'font.size': 16})\n",
    "plt.rcParams.update({'figure.figsize': (14, 7)})\n",
    "\n",
    "# Suppress deprecation warnings.\n",
    "\n",
    "import warnings\n",
    "\n",
    "\n",
    "def fxn():\n",
    "    warnings.warn(\"deprecated\", DeprecationWarning)\n",
    "\n",
    "\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\")\n",
    "    fxn()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data sets\n",
    "\n",
    "### Synthetic data with unobservables\n",
    "\n",
    "In the chunk below, we generate the synthetic data as described by Lakkaraju et al. The default values and definitions of $Y$ and $T$ values follow their description.\n",
    "\n",
    "**Parameters**\n",
    "\n",
    "* M = `nJudges_M`, number of judges\n",
    "* N = `nSubjects_N`, number of subjects assigned to each judge\n",
    "* betas $\\beta_i$ = `beta_i`, where $i \\in \\{X, Z, W\\}$ are coefficients for the respected variables\n",
    "\n",
    "**Columns of the data:**\n",
    "\n",
    "* `judgeID_J` = judge IDs as running numbering from 0 to `nJudges_M - 1`\n",
    "* R = `acceptanceRate_R`, acceptance rates\n",
    "* X = `X`, invidual's features observable to all (models and judges)\n",
    "* Z = `Z`, information observable for judges only\n",
    "* W = `W`, unobservable / inaccessible information\n",
    "* T = `decision_T`, bail-or-jail decisions where $T=0$ represents jail decision and $T=1$ bail decision.\n",
    "* Y = `result_Y`, result variable, if $Y=0$ person will or would recidivate and if $Y=1$ person will or would not commit a crime.\n",
    "\n",
    "The generated data will have M\\*N rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    '''Return value of sigmoid function (inverse of logit) at x.'''\n",
    "\n",
    "    return 1 / (1 + np.exp(-1*x))\n",
    "\n",
    "\n",
    "def dataWithUnobservables(nJudges_M=100,\n",
    "                          nSubjects_N=500,\n",
    "                          beta_X=1.0,\n",
    "                          beta_Z=1.0,\n",
    "                          beta_W=0.2):\n",
    "\n",
    "    df = pd.DataFrame()\n",
    "\n",
    "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
    "    df = df.assign(judgeID_J=np.repeat(range(0, nJudges_M), nSubjects_N))\n",
    "\n",
    "    # Sample acceptance rates uniformly from a closed interval\n",
    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
    "    acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
    "\n",
    "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
    "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
    "\n",
    "    # Sample the variables from standard Gaussian distributions.\n",
    "    df = df.assign(X=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "    df = df.assign(Z=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "    df = df.assign(W=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "\n",
    "    # Calculate P(Y=0|X, Z, W)\n",
    "    probabilities_Y = sigmoid(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
    "\n",
    "    df = df.assign(probabilities_Y=probabilities_Y)\n",
    "\n",
    "    # Result is 0 if P(Y = 0| X = x; Z = z; W = w) >= 0.5 , 1 otherwise\n",
    "    df = df.assign(result_Y=np.where(df.probabilities_Y >= 0.5, 0, 1))\n",
    "\n",
    "    # For the conditional probabilities of T we add noise ~ N(0, 0.1)\n",
    "    probabilities_T = sigmoid(beta_X * df.X + beta_Z * df.Z)\n",
    "    probabilities_T += np.sqrt(0.1) * npr.normal(size=nJudges_M * nSubjects_N)\n",
    "\n",
    "    df = df.assign(probabilities_T=probabilities_T)\n",
    "\n",
    "    # Sort by judges then probabilities in decreasing order\n",
    "    # Most dangerous for each judge are at the top.\n",
    "    df.sort_values(by=[\"judgeID_J\", \"probabilities_T\"],\n",
    "                   ascending=False,\n",
    "                   inplace=True)\n",
    "\n",
    "    # Iterate over the data. Subject will be given a negative decision\n",
    "    # if they are in the top (1-r)*100% of the individuals the judge will judge.\n",
    "    # I.e. if their within-judge-index is under 1 - acceptance threshold times\n",
    "    # the number of subjects assigned to each judge they will receive a\n",
    "    # negative decision.\n",
    "    df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    df['decision_T'] = np.where((df.index.values % nSubjects_N) <\n",
    "                                ((1 - df['acceptanceRate_R']) * nSubjects_N),\n",
    "                                0, 1)\n",
    "\n",
    "    # Halve the data set to test and train\n",
    "    train, test = train_test_split(df, test_size=0.5)\n",
    "\n",
    "    train_labeled = train.copy()\n",
    "    test_labeled = test.copy()\n",
    "\n",
    "    # Set results as NA if decision is negative.\n",
    "    train_labeled.loc[train_labeled.decision_T == 0, 'result_Y'] = np.nan\n",
    "    test_labeled.loc[test_labeled.decision_T == 0, 'result_Y'] = np.nan\n",
    "\n",
    "    return train_labeled, train, test_labeled, test, df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data without unobservables\n",
    "\n",
    "In the chunk below, we generate a simplified data. The default values and definitions of $Y$ and $T$ values follow the previous description.\n",
    "\n",
    "**Parameters**\n",
    "\n",
    "* M = `nJudges_M`, number of judges\n",
    "* N = `nSubjects_N`, number of subjects assigned to each judge\n",
    "* $\\beta_X$ = `beta_X`, coefficient for $X$\n",
    "\n",
    "**Columns of the data:**\n",
    "\n",
    "* `judgeID_J` = judge IDs as running numbering from 0 to `nJudges_M - 1`\n",
    "* R = `acceptanceRate_R`, acceptance rates\n",
    "* X = `X`, invidual's features observable to all (models and judges), now $X \\sim \\mathcal{N}(0, 1)$\n",
    "* T = `decision_T`, bail-or-jail decisions where $T=0$ represents jail decision and $T=1$ bail decision.\n",
    "* $p_y$ = `probabilities_Y`, variable where $p_y = P(Y=0)$\n",
    "* Y = `result_Y`, result variable, if $Y=0$ person will or would recidivate and if $Y=1$ person will or would not commit a crime. Here $Y \\sim \\text{Bernoulli}(\\frac{1}{1+exp\\{-\\beta_X \\cdot X\\}})$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dataWithoutUnobservables(nJudges_M=100,\n",
    "                             nSubjects_N=500,\n",
    "                             sigma=0.0):\n",
    "\n",
    "    df = pd.DataFrame()\n",
    "\n",
    "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
    "    df = df.assign(judgeID_J=np.repeat(range(0, nJudges_M), nSubjects_N))\n",
    "\n",
    "    # Sample acceptance rates uniformly from a closed interval\n",
    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
    "    acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
    "\n",
    "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
    "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
    "\n",
    "    # Sample feature X from standard Gaussian distribution, N(0, 1).\n",
    "    df = df.assign(X=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "\n",
    "    # Calculate P(Y=1|X=x) = 1 / (1 + exp(-beta_X * x)) = sigmoid(beta_X * x)\n",
    "    df = df.assign(probabilities_Y=sigmoid(df.X))\n",
    "\n",
    "    # Draw Y ~ Bernoulli(sigmoid(beta_X * x)) = Bin(1, p)\n",
    "    results = npr.binomial(n=1, p=df.probabilities_Y,\n",
    "                           size=nJudges_M * nSubjects_N)\n",
    "\n",
    "    df = df.assign(result_Y=results)\n",
    "\n",
    "    # Invert the probabilities. P(Y=0 | X) = 1 - P(Y=1 | X)\n",
    "    df.probabilities_Y = 1 - df.probabilities_Y\n",
    "\n",
    "    # Assign the prediction probabilities and add some Gaussian noise\n",
    "    # if sigma is set to != 0.\n",
    "    df = df.assign(probabilities_T=df.probabilities_Y)\n",
    "\n",
    "    df.probabilities_T += npr.normal(size=nJudges_M * nSubjects_N) * sigma\n",
    "\n",
    "    # Sort by judges then probabilities in decreasing order\n",
    "    # I.e. the most dangerous for each judge are first.\n",
    "    df.sort_values(by=[\"judgeID_J\", \"probabilities_T\"],\n",
    "                   ascending=False,\n",
    "                   inplace=True)\n",
    "\n",
    "    # Iterate over the data. Subject is in the top (1-r)*100% if\n",
    "    # his within-judge-index is over acceptance threshold times\n",
    "    # the number of subjects assigned to each judge. If subject\n",
    "    # is over the limit they are assigned a zero, else one.\n",
    "    df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    df['decision_T'] = np.where((df.index.values % nSubjects_N) <\n",
    "                                ((1 - df['acceptanceRate_R']) * nSubjects_N),\n",
    "                                0, 1)\n",
    "\n",
    "    # Halve the data set to test and train\n",
    "    train, test = train_test_split(df, test_size=0.5)\n",
    "\n",
    "    train_labeled = train.copy()\n",
    "    test_labeled = test.copy()\n",
    "\n",
    "    # Set results as NA if decision is negative.\n",
    "    train_labeled.loc[train_labeled.decision_T == 0, 'result_Y'] = np.nan\n",
    "    test_labeled.loc[test_labeled.decision_T == 0, 'result_Y'] = np.nan\n",
    "\n",
    "    return train_labeled, train, test_labeled, test, df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algorithms\n",
    "\n",
    "### Contraction algorithm\n",
    "\n",
    "Below is an implementation of Lakkaraju's team's algorithm presented in [their paper](https://helka.finna.fi/PrimoRecord/pci.acm3098066). Relevant parameters to be passed to the function are presented in the description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contraction(df, judgeIDJ_col, decisionT_col, resultY_col, modelProbS_col,\n",
    "                accRateR_col, r):\n",
    "    '''\n",
    "    This is an implementation of the algorithm presented by Lakkaraju\n",
    "    et al. in their paper \"The Selective Labels Problem: Evaluating \n",
    "    Algorithmic Predictions in the Presence of Unobservables\" (2017).\n",
    "\n",
    "    Arguments:\n",
    "    -----------\n",
    "    df -- The (Pandas) data frame containing the data, judge decisions,\n",
    "        judge IDs, results and probability scores.\n",
    "    judgeIDJ_col -- String, the name of the column containing the judges' IDs\n",
    "        in df.\n",
    "    decisionT_col -- String, the name of the column containing the judges' decisions\n",
    "    resultY_col -- String, the name of the column containing the realization\n",
    "    modelProbS_col -- String, the name of the column containing the probability\n",
    "        scores from the black-box model B.\n",
    "    accRateR_col -- String, the name of the column containing the judges' \n",
    "        acceptance rates\n",
    "    r -- Float between 0 and 1, the given acceptance rate.\n",
    "\n",
    "    Returns:\n",
    "    --------\n",
    "    (1) The estimated failure rate at acceptance rate r.\n",
    "    '''\n",
    "    # Get ID of the most lenient judge.\n",
    "    most_lenient_ID_q = df[judgeIDJ_col].loc[df[accRateR_col].idxmax()]\n",
    "\n",
    "    # Subset. \"D_q is the set of all observations judged by q.\"\n",
    "    D_q = df[df[judgeIDJ_col] == most_lenient_ID_q].copy()\n",
    "\n",
    "    # All observations of R_q have observed outcome labels.\n",
    "    # \"R_q is the set of observations in D_q with observed outcome labels.\"\n",
    "    R_q = D_q[D_q[decisionT_col] == 1].copy()\n",
    "\n",
    "    # Sort observations in R_q in descending order of confidence scores S and\n",
    "    # assign to R_sort_q.\n",
    "    # \"Observations deemed as high risk by B are at the top of this list\"\n",
    "    R_sort_q = R_q.sort_values(by=modelProbS_col, ascending=False)\n",
    "\n",
    "    number_to_remove = int(\n",
    "        round((1.0 - r) * D_q.shape[0] - (D_q.shape[0] - R_q.shape[0])))\n",
    "\n",
    "    # \"R_B is the list of observations assigned to t = 1 by B\"\n",
    "    R_B = R_sort_q[number_to_remove:R_sort_q.shape[0]]\n",
    "\n",
    "    return np.sum(R_B[resultY_col] == 0) / D_q.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Causal approach - metrics\n",
    "\n",
    "Generalized performance:\n",
    "\n",
    "$$\n",
    "\\mathbf{gp} = \\sum_{x\\in\\mathcal{X}}  f(x) ~ \\delta(F(x) < r)P(X=x)\n",
    "$$\n",
    "\n",
    "and empirical performance:\n",
    "\n",
    "$$\n",
    "\\mathbf{ep} = \\dfrac{1}{n} \\sum_{(x, y) \\in \\mathcal{D}_{test}} f(x) ~ \\delta(F(x) < r)\n",
    "$$\n",
    "\n",
    "where\n",
    "\n",
    "$$\n",
    "f(x) = P(Y=0|T=1, X=x)\n",
    "$$\n",
    "\n",
    "is a predictive model trained on the labeled data and\n",
    "\n",
    "$$\n",
    "F(x_0) = \\int P(x)~\\delta(P(Y=0|T=1, X=x) > P(Y=0|T=1, X=x_0)) ~ dx = \\int P(x)~\\delta(f(x) > f(x_0)) ~ dx.\n",
    "$$\n",
    "\n",
    "NB: in code the direction of inequality was changed. CDF changed to `bailIndicator` algorithm.\n",
    "\n",
    "**Rationale for `bailIndicator`:**\n",
    "\n",
    "* Bail decision is based on prediction $P(Y=0|T=1, X=x)$.\n",
    "    * Uniform over all judges\n",
    "* Judges rationing: \"If this defendant is in the top 10% of 'dangerousness rank' and my $r = 0.85$, I will jail him.\"\n",
    "* Overall: this kind of defendant $(X=x)$ is usually in the $z^{th}$ percentile in dangerousness (sd $\\pm~u$ percentiles). Now, what is the probability that this defendant has $z \\leq 1-r$?\n",
    "\n",
    "\n",
    "<!--- **Proposal**\n",
    "\n",
    "1. Train model for $P(Y=0|T=1, X=x)$\n",
    "* Estimate quantile function for $P(T=1|R=r, X=x)$\n",
    "* Calculate $P(Y=0|do(r'), do(x'))=P(Y=0|T=1, X=x') \\cdot P(T=1|R=r', X=x')$ for all instances of the training data\n",
    "* Order in ascending order based on the probabilities obtained from previous step\n",
    "* Calculate $$\\dfrac{\\sum_{i=0}^{r\\cdot |\\mathcal{D}_{all}|}}{|\\mathcal{D}_{all}|}$$--->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getProbabilityForClass(x, model, class_value):\n",
    "    '''\n",
    "    Function (wrapper) for obtaining the probability of a class given x and a \n",
    "    predictive model.\n",
    "\n",
    "    Arguments:\n",
    "    -----------\n",
    "    x -- individual features, an array of shape (observations, features)\n",
    "    model -- a trained sklearn model. Predicts probabilities for given x. \n",
    "        Should accept input of shape (observations, features)\n",
    "    class_value -- the resulting class to predict (usually 0 or 1).\n",
    "\n",
    "    Returns:\n",
    "    --------\n",
    "    (1) The probabilities of given class label for each x.\n",
    "    '''\n",
    "    if x.ndim == 1:\n",
    "        # if x is vector, transform to column matrix.\n",
    "        f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n",
    "    else:\n",
    "        f_values = model.predict_proba(x)\n",
    "\n",
    "    # Get correct column of predicted class, remove extra dimensions and return.\n",
    "    return f_values[:, model.classes_ == class_value].flatten()\n",
    "\n",
    "\n",
    "def cdf(x_0, model, class_value):\n",
    "    '''\n",
    "    Cumulative distribution function as described above. Integral is \n",
    "    approximated using Simpson's rule for efficiency.\n",
    "    \n",
    "    Arguments:\n",
    "    ----------\n",
    "    \n",
    "    x_0 -- private features of an instance for which the value of cdf is to be\n",
    "        calculated.\n",
    "    model -- a trained sklearn model. Predicts probabilities for given x. \n",
    "        Should accept input of shape (observations, features)\n",
    "    class_value -- the resulting class to predict (usually 0 or 1).\n",
    "\n",
    "    '''\n",
    "    def prediction(x): return getProbabilityForClass(\n",
    "        np.array([x]).reshape(-1, 1), model, class_value)\n",
    "\n",
    "    prediction_x_0 = prediction(x_0)\n",
    "\n",
    "    x_values = np.linspace(-10, 10, 40000)\n",
    "\n",
    "    x_preds = prediction(x_values)\n",
    "\n",
    "    y_values = scs.norm.pdf(x_values)\n",
    "\n",
    "    results = np.zeros(x_0.shape[0])\n",
    "\n",
    "    for i in range(x_0.shape[0]):\n",
    "\n",
    "        y_copy = y_values.copy()\n",
    "\n",
    "        y_copy[x_preds > prediction_x_0[i]] = 0\n",
    "\n",
    "        results[i] = si.simps(y_copy, x=x_values)\n",
    "\n",
    "    return results\n",
    "\n",
    "\n",
    "def bailIndicator(r, y_model, x_train, x_test):\n",
    "    '''\n",
    "    Indicator function for whether a judge will bail or jail a suspect.\n",
    "    Rationale explained above.\n",
    "\n",
    "    Algorithm:\n",
    "    ----------\n",
    "\n",
    "    (1) Calculate recidivism probabilities from training set with a trained \n",
    "        model and assign them to predictions_train.\n",
    "\n",
    "    (2) Calculate recidivism probabilities from test set with the trained \n",
    "        model and assign them to predictions_test.\n",
    "\n",
    "    (3) Construct a quantile function of the probabilities in\n",
    "        in predictions_train.\n",
    "\n",
    "    (4)\n",
    "    For pred in predictions_test:\n",
    "\n",
    "        if pred belongs to a percentile (computed from step (3)) lower than r\n",
    "            return True\n",
    "        else\n",
    "            return False\n",
    "\n",
    "    Arguments:\n",
    "    ----------\n",
    "\n",
    "    r -- float, acceptance rate, between 0 and 1\n",
    "    y_model -- a trained sklearn predictive model to predict the outcome\n",
    "    x_train -- private features of the training instances\n",
    "    x_test -- private features of the test instances\n",
    "\n",
    "    Returns:\n",
    "    --------\n",
    "    (1) Boolean list indicating a bail decision (bail = True) for each \n",
    "        instance in x_test.\n",
    "    '''\n",
    "\n",
    "    predictions_train = getProbabilityForClass(x_train, y_model, 0)\n",
    "\n",
    "    predictions_test = getProbabilityForClass(x_test, y_model, 0)\n",
    "\n",
    "    return [\n",
    "        scs.percentileofscore(predictions_train, pred, kind='weak') < r\n",
    "        for pred in predictions_test\n",
    "    ]\n",
    "\n",
    "\n",
    "def estimatePercentiles(x_train, y_model, N_bootstraps=2000, N_sample=100):\n",
    "    '''\n",
    "    Estimate percentiles based on bootstrapped samples of original data.\n",
    "    Bootstrapping is done N_bootstraps times and size of the sample is\n",
    "    N_sample.\n",
    "\n",
    "\n",
    "    '''\n",
    "\n",
    "    res = np.zeros((N_bootstraps, 101))\n",
    "\n",
    "    percs = np.arange(101)\n",
    "\n",
    "    for i in range(N_bootstraps):\n",
    "\n",
    "        sample = npr.choice(x_train, size=N_sample)\n",
    "\n",
    "        predictions_sample = getProbabilityForClass(sample, y_model, 0)\n",
    "\n",
    "        res[i, :] = np.percentile(predictions_sample, percs)\n",
    "\n",
    "    return res\n",
    "\n",
    "\n",
    "def calcReleaseProbabilities(r,\n",
    "                             x_train,\n",
    "                             x_test,\n",
    "                             y_model,\n",
    "                             N_bootstraps=2000,\n",
    "                             N_sample=100,\n",
    "                             percentileMatrix=None):\n",
    "    '''\n",
    "    Similar to bailIndicator, but calculates probabilities for bail decisions\n",
    "    by bootstrapping the data set.\n",
    "\n",
    "    Returns:\n",
    "    --------\n",
    "    (1) Probabilities for positive bail decisions.\n",
    "    '''\n",
    "\n",
    "    if percentileMatrix is None:\n",
    "        percentileMatrix = estimatePercentiles(x_train, y_model, N_bootstraps,\n",
    "                                               N_sample)\n",
    "\n",
    "    probs = np.zeros(len(x_test))\n",
    "\n",
    "    for i in range(len(x_test)):\n",
    "\n",
    "        if np.isnan(x_test[i]):\n",
    "\n",
    "            probs[i] = np.nan\n",
    "\n",
    "        else:\n",
    "\n",
    "            pred = getProbabilityForClass(x_test[i], y_model, 0)\n",
    "\n",
    "            probs[i] = np.mean(pred < percentileMatrix[:, r])\n",
    "\n",
    "    return probs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance comparison\n",
    "\n",
    "Below we try to replicate the results obtained by Lakkaraju and compare their model's performance to the one of ours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitLogisticRegression(x_train, y_train, x_test, class_value):\n",
    "    '''\n",
    "    Fit logistic regression model with given training instances and return \n",
    "    probabilities for test instances to obtain a given class label.\n",
    "    \n",
    "    Arguments:\n",
    "    ----------\n",
    "    \n",
    "    x_train -- x values of training instances\n",
    "    y_train -- y values of training instances\n",
    "    x_test -- x values of test instances\n",
    "    class_value -- class label for which the probabilities are counted for.\n",
    "    \n",
    "    Returns:\n",
    "    --------\n",
    "    (1) Trained LogisticRegression model\n",
    "    (2) Probabilities for given test inputs for given class.\n",
    "    '''\n",
    "\n",
    "    # Instantiate the model (using the default parameters)\n",
    "    logreg = LogisticRegression(solver='lbfgs')\n",
    "\n",
    "    # Check shape and fit the model.\n",
    "    if x_train.ndim == 1:\n",
    "        logreg = logreg.fit(x_train.values.reshape(-1, 1), y_train)\n",
    "    else:\n",
    "        logreg = logreg.fit(x_train, y_train)\n",
    "\n",
    "    label_probs_logreg = getProbabilityForClass(x_test, logreg, class_value)\n",
    "    \n",
    "    return logreg, label_probs_logreg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With unobservables in the data\n",
    "\n",
    "Lakkaraju says that they used logistic regression. We train the predictive models using only *observed observations*, i.e. observations for which labels are available. We then predict the probability of negative outcome for all observations in the test data and attach it to our data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 0 1 2 3 4 [2] 0 1 2 3 4 [3] 0 1 2 3 4 [4] 0 1 2 3 4 [5] 0 1 2 3 4 [6] 0 1 2 3 4 [7] 0 1 2 3 4 [8] 0 1 2 3 4 "
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAHwCAYAAACYFJ/XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XmcTuX/x/HXNYt9bAmhspTKMsaYsSUzjFCWqERkDVHylRbyK8k3JUlSohRKWSK79C0ytsg6KUSqyb6baSyDmbl+f5x7pjFmlXvmNt7Px2Me7vuc61znc851T92fuZZjrLWIiIiIiIjIP7xyOgARERERERFPo0RJREREREQkBSVKIiIiIiIiKShREhERERERSUGJkoiIiIiISApKlERERERERFJQoiQi1wRjzMfGmCGu102MMZE5HJJItjHGVDTGnE5nv48xxhpjymdfVJ4bR3oyitEY09MYE56tQYmIR1KiJCLZyhgTaYw5Z4w5neynTEbHWWt7Wmtfz44Y/y1jzGvGmKk5HUdqXEmmNcYMzOE4bjPGXPMP8suuxMBa+4e1tlCy864xxnRz5zlFRK53SpREJCe0stYWSvZzMLtObIzxycnjPUBX4KTrX8lALmjvXMkY453TMYhI7qdESUQ8gjHGyxgzxxhz2BgTZYwJN8bclWz/58aYYakcd9lf9JOXTRymZ4wZYow5DExybW9tjPnJda41xphqacSVWP+Txpg9wK+u7e8bY/YbY/42xmw0xtR3bW8JvAB0cvWWbXZtL2qMmWKMOeQ6brgx5rL/BhtjbjbGnDXGFEm2LdgYc9QVS2VjzCpjTLQx5rgxZnoW7nEh4EGgL1DFGBOQYn9DY8x6V937jDGdXdsLGGPeMcbsde1bZYzJ69p3t+uYKGNMhDGmYbL61hhjRhhjNrmOm2eMKebavcpVJrFXMdgYc7sxZoUx5oTr2qaluA/7jTEDjTE/u+qbkRiHa/+Drhj+NsbsMcY0zcq9d5V9zRgzy1V3DPCYMaZesms8ZIwZZ4zxTX4dwHbXdTzkqiezn68Rxph3XK/zGmNijTGvJ7aX630Rk6wHzhjzJlAPmOg659hkVTZzXfspY8y41M7pquOS3yeTYjhrJu51H9d5Thhj5htjbkpxilbGmD9d7Tgy8X6n9/k1xlQxxiwzxpw0xvyaeC+TxTveGPONMeYM8KIx5kDydjTGtDPGbHG9Tq/N0o0xlXuVXlwtjTE7jTExrnv2TFr3XESuQdZa/ehHP/rJth8gEmiSynYvoBvgB+QD3gc2Jdv/OTDM9boJEOl67QNYoHw6ZeOA14E8QH4gGDji+tcb6AH8DuRJJa7E+r8BigH5Xds7A8Vd+wcBB4C8rn2vAVNT1LMY+AAoAJQGNgOPp3GPVgHdk71/B3jf9Xq263xervt0dxbufXdgv+vYpcCYZPsqADHAI65rKgEEuPZ9CCwHbnLdrwaAL3AzcAJo5qqzOXAcuMF13BpgH1AFKAjMT7wvwG3O/4Iuia8yEOZqp5LAWmB0sv37gfWu+3cDsBvo6dpXH4hyHe/liu2OK7j3rwEXgFauehI/L3Vc96Wi67z90vn8ZeXz1RTY6nrd0FVubbJ9m1O7X6572y2Vz+kCoAhQHqfn8LLftZS/Iyl/pzJxr5sCR4EAnM/gB8D3KeJYhvP7Uh7YkxgraXx+cX7vDwBdXHXUwvls3ZEs3lM4CaIXkBfnvyWNksU8D3guWRtk1GZpxdgTCM9kXMeA+q7XxYHAnP5vrH70o5+r96MeJRHJCfNdf+mNMsbMB7DWJlhrp1prY6y1scAwoJYxpuBVOF8czpfCC9bac0Bv4ANr7UZrbby1drKrXHA6dbxurT3lOh5r7TRr7UlrbRwwCiiM82X2MsaYsjhf4J+x1p611h4GxgId0jjXdOBR17FeQHvXNoCLOF/sbrLWxlpr12bmBrh0BWZaaxNc9XUy/wwtewz4xlr7pbU2zlp73FobYZwhTt2A/tbaQ677tcZaexHny+NCa+3/XO33DfATTsKU6FNr7Q5r7RlgKNDBGGNSC85au9tau9zVTkdxEsSQFMXGWmsPW2tP4CRAib1ijwOTXMcnWGv3WWt3XcG9B1hjrV3kquec63Pyo+u+/AF8lEpcyWXl87UWp3evKE6i9BFQwRhTwHWOlemcJzVvWGujrbWRQDj/3J8rkda97gR8bK2NcP2uDgZCjDHlkh070vX7EgmMw/V5Ju3Pb2tgt7X2M9d93oyTWD+crM551tp1rnY5D8zkn9+TojgJ+0yATLZZWjEml1FcF3Haz8/134MtGdxTEbmGKFESkZzQxlpb1PXTBpw5B8aYUcaYP4wxf+P8hRecno1/64i19kKy97cCg5Ila1E4vSVl06ljX/I3xpgXXMNwonH+0l0wnVhvxfkL+JFk5xsPlEqj/GzgHmNMKaAREGut/cG171mc3pxNrmFRmZprZJyhiQ2BL1yb5gGF+CepuRmnNyOlUjg9PKntuxV4NMV9rAskX5wj+X37C+c+FE8jxtLGmC9dQ6r+BqZy+T09nOz1Wdc1pBd/Vu99ypgxxtxpjFlinGGhfwPDU4kr5Tkz9flyJZBbcdqmIU5ysx6n5+RKEqW07s+VSKuuMjhtCYC19m+c34Hk15ey3RM/E2l9fm8F7k5xz9rj3LfU6gQn2X/INaTuIeBHa+1+yHSbpRVjchnF1RYnmdprnOHCdVKpQ0SuUZqkKiKeogtwP9AY50vLDTjDWlLtfUhkrY0zxpzHGVaVqDT/JFrgDLNJbh/wqrX2zSzEl1SHMaYRMBCnp2KHa3N0slhTO99ZoLirNyf9E1l7whjzPdAOqAnMSLbvEM7QIIwzH+g7Y8wqa+2fGVTbxRXf0mQdOnlc2xe7YvRP5bgjOEPRKgHbU7muKdbavumc9+Zkr28BzuMMCSuaStk3XfurW2tPGmMeBkanU3fKWCqlsT3T994lZft9iJO8tLfWnjbGPAe0TKNs4jmz8vlaiTP0rTrOsMCVwH04w7xWZzLGrDrD5b8zmXUQJ4EAwBjjhzOE7UCyMjcDu1yvb3Edk+bnF+eeLbfW3pfOeS+5ZmvtNmPMIZyepI780+sK6bdZujGmkG5c1tofgdauZO0/OD1aFdK5BhG5hqhHSUQ8hR/Ol+QTOF/gRmTh2J9whpF5G2Na4MyhSc9HwFPGWUDAGGfSfKssDPPzwxnOdxznr+PDcHqUEh0ByicOMbPW7sP58jvaGFPYOAtX3GaSLXyQiuk4Q+UeJNkXQGPMI67hZODMybFAfCZi7oIz9C0g2U97nC95xXDmgDQ3xjxknEUjShhjalhr43F6dsa6eny8jbOAgy8wDWhrjLnXtT2fMaaRuXS59y6uv+4XBF4FvrTWWpw5LtYYUzFZWT+cL/DRxpibgecycV2JPgF6us7vZYwpZ4y54wrvfUp+OInwGeMsMPJE4g7X/TmBMw8mUVY/Xytxhjducw3lDMcZvrfbWnsyjWOOpDhnVkUALYwxxYyzEEP/LBw7A3jcGONvnAUe3gBWJ/bmuLxgnEU0bnHVPQvS/fwuBKoaYzoaY3xdP7WNMXdkIpZncHrg5iTbnmabZRRjCmnGZYzJ79pe2DUUNYbM/S6KyDVCiZKIeIopOH/RPYjTc/FD+sUv0R9nCEwUTi/MwvQKu/4K3BeYgDNkaDfOHJ3M+hpnIvhvOBPK/wYOJds/C6e35qQxZoNr22M4ydQO1zlnk/5f8efjLIKw11qbvCenDrDROCt/zQWestbuBTDG7DLGtE9ZkTGmAc6wovGuOSeHXXN15rnib+/qkWqFM9H+JLAFp4cDnC+iO3F6O07iLIxhXHM72gIv4/T+7cUZWpX8/y3TcJKwQzgLGwwAsNbG4HzB/tE1pCkIeAWojfMFdyHwVTr35xKuoYm9cOaaRAMr+Kc3K6v3PqVncZLWGJyeipRfqF8Bpruu48Er+HytwfnjQOIKettw5r6sSvMIZ55V4rDHMVm4lkRTcdr0L5yFSmZm9kDXXLThOJ+fQzi9MZ1SFFuEk4xtdZWb6tqe6ufXWhuN0zP0mKvOwzifj7ykbzpOL/R31tpTybZn1GbpxZj8WjOKqyvwl2t43+M4i7yISC5hnD/siYiIXF3GmDU4k/6n5nQsIiIiWaUeJRERERERkRSUKImIiIiIiKSgoXciIiIiIiIpqEdJREREREQkBSVKIiIiIiIiKeSaB86WKFHCli9fPqfDSHLmzBkKFszsI1kkO6hNPJPaxfOoTTyT2sXzqE08k9rF83ham2zevPm4tfbGjMrlmkSpfPnybNq0KafDSBIeHk5oaGhOhyHJqE08k9rF86hNPJPaxfOoTTyT2sXzeFqbGGP+ykw5Db0TERERERFJQYmSiIiIiIhICkqUREREREREUsg1c5RSc/HiRfbv309sbGy2n7tIkSLs3Lkz288rjnz58lGuXDl8fX1zOhQRERERuQbl6kRp//79+Pn5Ub58eYwx2XrumJgY/Pz8svWc4rDWcuLECfbv30+FChVyOhwRERERuQbl6qF3sbGx3HDDDdmeJEnOMsZwww035EhPooiIiIjkDrk6UQKynCSFTg0ldGqoe4KRbKPkWERERET+jVyfKOWkEydOEBAQQEBAAKVLl6Zs2bJJ7y9cuHDVzrNs2TKKFCmSVHdAQAArVqzIcj1xcXEULVr0iuOYPHkyhw8fTnrfvXt3du3adcX1iYiIiIjklFw9Rymn3XDDDURERAAwbNgwChUqxHPPPXdJGWst1lq8vP5dztqoUSPmz5//r+r4tyZPnkxgYCClS5cGYMqUKTkaj4iIiIjIlVKPUg7Ys2cP1apVo0+fPgQGBrJv375LenJmzpxJz549AThy5AgPPvggQUFB1K5dm/Xr12f6PM8++ywfffRR0vuXXnqJd999l7///pvGjRsTGBiIv78/ixcvvuzYZcuW0aZNm6T3ffr04fPPPwfglVdeITg4OOkarLXMmjWLiIgI2rdvn9Rj1qBBg6RE8fPPP6d69epUq1aNIUOGAP/0YA0ePJgaNWpQr149jh49moU7KSIiIiLiHtdNj9KAbwYQcTgiw3KJZTIzTymgdABjm4+9onh27NjBlClTmDhxInFxcWmW69+/Py+88AJ169YlMjKSli1b8ssvv1xWbsWKFQQEBCS9nz9/Ph06dGDw4MH07t0bgNmzZ7NixQry58/PggUL8PPz4+jRo9x99920bNky07H/5z//4dVXX8VaS8eOHfnmm29o37497733Hu+///4lcYCz+uBLL73Epk2bKFKkCE2aNGHx4sU0b96c6OhoQkJCGDlyJAMHDmTy5MkMHjw407GIiIiIiLjDdZMoeZpKlSoRHBycYblly5ZdMs/n1KlTnDt3jvz5819SLrWhd+XLl2ffvn0cOXKE/fv3U7p0acqUKcOFCxcYNGgQa9aswcvLi3379nH8+PFMz09avnw5b731FrGxsRw/fpxatWpx3333pVn+xx9/pHHjxpQoUQKAjh07smrVKpo3b07+/PmTjq1VqxarV6/OVAwiIiIiIu503SRKme35SexJCu8W7r5ggIIFCya99vLywlqb9D75stbWWjZs2ECePHmu6DwPPfQQX331FZGRkXTo0AGAzz77jOjoaLZs2YKPjw/lypW7bCltHx8fEhISLovp7Nmz9OvXjy1btlC2bFleeumlDJfhTn5tKSW/Lm9v73R710REREREsovmKHkALy8vihUrxm+//UZCQgLz5s1L2tekSRPGjx+f9D5xzk9mdejQgZkzZzJ37lweeughAKKjoylZsiQ+Pj589913HDhw4LLjbr31VrZv386FCxc4deoU33//PQDnzp3Dy8uLEiVKEBMTw1dffZV0jJ+fHzExMZfVVbduXVasWMGJEyeIi4tj5syZhISEZOk6RERERESykxIlD/Hmm2/SvHlzwsLCKFeuXNL28ePHs3btWvz9/alSpQqTJk1K9fjEOUqJP4nJVo0aNTh27BgVKlSgZMmSAHTu3JkffviBoKAgZs+eze23335ZfRUqVKBNmzZUr16dLl26EBgYCDgr+XXt2pVq1arRtm1b6tSpk3RM9+7d6dmz52XLn5crV47hw4cTGhpKQEAAdevWpUWLFv/+pomIiIiIuIlJb1jUtSQoKMhu2rTpkm07d+7krrvuylI9V2voXUxMDH5+fv+qDvl3UrZ/eHg4oaGhOReQpErt4nnUJp5J7eJ51CaeSe3ieTytTYwxm621QRmVu27mKGWWu+cmiYiIiIiI59PQOxERERERkRTUoyQiIiIiIm4RGgpRUQFkcT0yj6BESURERERE3CMigkJxcUCGU4I8jobeiYiIiIiIpKBEKaVQ14+IiIiIiFy3lCi5WaFChTJddtiwYYwePdpt9V/pOVITGRnJ9OnT/3U9IiIiIpKLWUteG5vTUVwRJUpyRZQoiYiIiEi64uN5OnYU42L7wrlzOR1NlilRygGLFi2iTp061KxZkyZNmnDkyJGkfT/99BONGzfm9ttvZ9KkSUnb33rrLYKDg/H39+eVV15Jtd60yowYMYI77riDJk2asGvXrlSP/euvvwgLC8Pf35+wsDD27t0LQLdu3ZgzZ05SucQerMGDB7N69WoCAgJ45513iI+P57nnnqN69er4+/vz3nvvAbB8+XJq1qxJ9erV6dGjB+fPnwegfPnyDBkyhHr16hEUFMSWLVto1qwZlSpVYuLEiele05kzZ2jRogU1atSgWrVqzJo1K/M3X0RERETcLzYWHn2UBhe+5+Ni9SFv3pyOKMuun1XvBgCZWZYwsUxoJsoGAGOzHkqDBg1Yv349xhg+/vhjRo0axdtvvw3Atm3bWL9+PWfOnKFmzZq0aNGCX375hd9++40NGzZgraV169asWrWKhg0bJtX57bffplqmYMGCzJw5k61btxIXF0dgYCC1atW6LKZ+/frRpUsXunbtyuTJk+nfvz/z589P8xpGjhzJ6NGjWbx4MQATJkzgzz//ZOvWrfj4+HDy5EliY2Pp1q0by5cvp3LlynTp0oUJEyYwYMAAAG6++WbWrVvHM888Q7du3Vi7di2xsbFUrVqVPn36pHlNx44do0yZMixZsgSA6OjorDeCiIiIiLhHVBS0acPKlZYWeSI4c9aXIX+f48aiBXM6siy5fhIlD7J//37at2/PoUOHuHDhAhUqVEja98ADD5A/f37y589Po0aN2LBhA2vWrOHbb7+lZs2aAJw+fZrffvvtskQptTIxMTG0bduWAgUKANC6detUY1q3bh1z584FoHPnzrzwwgtZuqZly5bRp08ffHycj1Tx4sX56aefqFChApUrVwaga9eujB8/PilRSoylevXqnD59Gj8/P/z8/MiXLx9RUVFpXtM999zDc889x6BBg2jZsiX33HNPlmIVERERETc5cICE5vfzxo6WvMxwyL+X2xJ2cWPR0JyOLMuun0Qpsz0/oa5/w90TBsDTTz/NwIEDad26NeHh4QwbNixpnzHmkrLGGKy1vPjiizzxxBNp1plWmbFjx15WZ2YkHuPj40NCQkLSOS5cuJDm+VOex1qb7jnyurpgvby8kl4nvo+Li0v3ujdv3szXX3/Niy++SNOmTRk6dGjmL05ERERErr6dOzl+bwc6H3qDbxLup2y91dy8Kw/ecVlbfMxTaI5SDoiOjqZs2bIAfPrpp5fsW7BgAbGxsZw4cYLw8HCCg4Np1qwZkydP5vTp0wAcOHCAo0ePXnJcWmUaNmzIvHnzOHfuHDExMSxatCjVmOrXr8/MmTMB+OKLL2jQoAHgzCXavHlzUmwXL14EwM/Pj5iYmKTjmzZtysSJE4mLiwPg5MmT3HnnnURGRrJnzx4Apk2bRkhISKbvU1rXdPDgQQoUKMBjjz3Gc889x5YtWzJdp4iIiIi4wQ8/sK7Ofwg4uJj/EUZI3y+JXF2fvPHX3tykRNdPj1IOOXv2LOXKlUt6P3DgQIYNG0a7du0oW7YsdevW5c8//0zaX7t2bVq0aMHevXt5+eWXKVOmDGXKlGHnzp3Uq1cPcBZU+PzzzylZsmTScU2bNk21TGBgIO3btycgIIBbb701zWFq48aNo0ePHrz11lvceOONTJkyBYBevXrxwAMPULt2bcLCwihY0Blb6u/vj4+PDzVq1KBbt248/fTT7N69G39/f3x9fenVqxf9+vVjypQptGvXjri4OIKDg+nTp0+m711a17Rnzx6ef/55vLy88PX1ZcKECZmuU0RERESuLjt/Ae+0W8uguCVQeB/93/mSd7o/5ow2CgjgdFRUTod4RUxGw6OuFUFBQXbTpk2XbNu5cyd33XVX1ioKdf0b/u/iiYmJwc/P799VIv9KyvYPDw8nNDQ05wKSVKldPI/axDOpXTyP2sQzqV2yV9TYqfR4pgjzaEu+2xfy/pQ4Hr/7waT9oaEQFRVFRETRnAsyBWPMZmttUEbl1KOUUnhOByAiIiIi4uGsZUufj2j3URP+4hYKN/s/Fk5sRkj5hhkfe43QHCUREREREck0ezGOifd8Qb2PuhHlm4dS/R5h3bROuSpJAvUoiYiIiIhIJsUcOcsTtTYy48Bj3F5sKfmGjOJ/T0znJr+bUi0fHg7h4RFk7iGlnkWJkoiIiIiIZOjn1VG0axrNb7ENqF15CMVeimD2Iwvxy5s75+Vr6J2IiIiIiKRr6ujj1AnJS3RsHuqHhlH9raMs6rgg1yZJoETpcqGhzo+IiIiIyHXu7Fno0eYk3Z8vQbBZzy3ta3LvsMZMajUJX2/fnA7PrZQouVmhQpc+iXjq1Kn069cvh6Jxj9DQUFIuzZ5Z4eHh/PDDD0nvJ06cyGeffXa1QhMRERGRK7RrF9SpdpqpC4ryTL4RnOrTjL6DRzI0ZKjzjKRcTnOUJEeFh4dTqFAh6tevD5ClB9KKiIiIiHvMnAm9ul8kX+w5Pir6CG/3XsW7vRfTtFLTnA4t26hHKQd169aNOXPmJL1P7H0KDw8nJCSERx55hMqVKzN48GC++OILateuTfXq1fn9998BWLRoEXXq1KFmzZo0adKEI0eOADBs2DB69OhBaGgoFStWZNy4came/9tvv6VevXoEBgbSrl07Tp8+zdKlS3nkkUeSyoSHh9OqVSsA+vbtS1BQEFWrVuWVV15Jtc7kPWhz5syhW7duacYaGRnJxIkTeeeddwgICGD16tUMGzaM0aNHAxAREUHdunXx9/enbdu2nDp1CnB6sAYNGkTt2rWpXLkyq1evzvK9FxEREZHLxcbCk0/Co49Cjdgf+ahcEGOe3crMZ9ZeV0kSXE89SgMGQERExuUSy2RmnlJAAIwdm26Rc+fOERAQkPT+5MmTtG7dOsOqf/rpJ3bu3Enx4sWpWLEiPXv2ZMOGDbz77ru89957jB07lgYNGrB+/XqMMXz88ceMGjWKt99+G4Bff/2VFStWEBMTwx133EHfvn3x9f1nHOnx48d57bXXWLZsGQULFuTNN99kzJgxDBkyhCeeeIIzZ85QsGBBZs2aRfv27QEYMWIExYsXJz4+nrCwMLZt24a/v3/G9wnSjLVPnz4UKlSI5557DoDly5cnHdOlSxfee+89QkJCGDp0KK+++ipjXfc7Li6ODRs28PXXX/Pqq6+ybNmyTMUhIiIiIqn74w9o186yZYvheUZR+86XeO2J2/hf9zXcXOTmnA4v210/iVIOyZ8/PxHJErSpU6dmaj5PcHAwN93krEdfqVIlmjZ1Mvjq1auzYsUKAPbv30/79u05dOgQFy5coEKFCknHt2jRgrx585I3b15KlizJkSNHKFeuXNL+9evXs2PHDu6++24ALly4QL169fDx8aF58+YsWrSIhx9+mCVLljBq1CgAvvzySz766CPi4uI4dOgQO3bsyHSilF6sqYmOjiYqKoqQkBAAunbtSrt27ZL2P/jggwDUqlWLyMjITMUgIiIiIqmbNw+6d7eYc2dZwKPsC17ExL6hLH90HkXzFc3p8HLE9ZMoZdDzkySxJyk83F2RJPHx8SEhIQEAay0XLlxI2pc3b96k115eXknvvby8iIuLA+Dpp59m4MCBtG7dmvDwcIYNG5bq8d7e3knHJLLWcu+99zJjxozL4mrfvj3jx4+nePHiBAcH4+fnx59//sno0aPZuHEjxYoVo1u3bsTGxl52bPKJfcn3pxfrlUi8vtSuTUREREQy5+JFGDwYxoyBoMK7mX2hGZMa/8VfT3ZkyQOTyeuTN+NKcinNUcpB5cuXZ/PmzQAsWLCAixcvZun46OhoypYtC8Cnn36apWPr1q3L2rVr2bNnDwBnz55l9+7dgDMHaMuWLUyaNClp2N3ff/9NwYIFKVKkCEeOHGHp0qWp1luqVCl27txJQkIC8+bNyzBWPz8/YmJiLqunSJEiFCtWLGn+0bRp05J6l0RERETk39u7Fxo2dJKkfjfOYGVMDV594C/skBf57MFp13WSBEqUclSvXr1YuXIltWvX5scff6RgwYJZOn7YsGG0a9eOe+65hxIlSmTp2BtvvJGpU6fy6KOP4u/vT926dfn1118Bp5emZcuWLF26lJYtWwJQo0YNatasSdWqVenRo0fSkL2URo4cScuWLWncuHHS0MH0Ym3VqhXz5s1LWswhuU8//ZTnn38ef39/IiIiGDp0aJauUURERERS9/XXULMmbP85gRkln2RU9GO073iBOi9N4PWw1/EyShOMtTanY7gqgoKCbMq5Pzt37uSuu+7KWkVXaehdTEwMfn6590nF14KU7R8eHk6oHibscdQunkdt4pnULp5HbeKZ1C7pi4uDoUPhjTfA/7azzDgRSukLm2nb2ZfnBsym1R2trvo5Pa1NjDGbrbVBGZVza6pojGlujNlljNljjBmcyv4+xpifjTERxpg1xpgqyfa96DpulzGmmTvjvER4eLbMTxIRERERyU6HDkGTJk6S1LP5PtYeKEdBNnP/k0UY/dJqtyRJ1zK3JUrGGG9gPHAfUAV4NHki5DLdWlvdWhsAjALGuI6tAnQAqgLNgQ9c9YmIiIiISBZ9/73zZJuNG+HTXqv5cFkF9hSJ4tFnb+WLwRsJLhuc0yF6HHf2KNUG9lh8LeKZAAAgAElEQVRr/7DWXgBmAg8kL2Ct/TvZ24JA4jjAB4CZ1trz1to/gT2u+kREREREJJPi42H4cKcn6YYbLBt6f0yXSQ35/uZ4nvu/IBY+s4FKxSvldJgeyZ3Lg5cF9iV7vx+ok7KQMeYpYCCQB2ic7Nj1KY4t654wRURERERyn2PH4LHH4NtvoVPHBCYUfA6/se/wRXVYOLgNi9pNJ79v/pwO02O5bTEHY0w7oJm1tqfrfWegtrX26TTKd3SV72qMGQ+ss9Z+7tr3CfC1tfarFMf0BnoDlCpVqtbMmTMvqbNIkSLcdtttV/nKMic+Ph5vb40WzEl79uwhOjo66f3p06cpVKhQDkYkqVG7eB61iWdSu3getYlnUrs4fv65CMOHVyE62pf/PLmTgVv6ctPq1YyuBz92e5A+tz+JdzbNbPG0NmnUqFGmFnNwZ4/SfuDmZO/LAQfTKT8TmJCVY621HwEfgbPqXcrVNHbu3Jnlleeu1vNmtepdzsuXLx81a9ZMeu9pK66IQ+3iedQmnknt4nnUJp7pem+XhAR4+2148UWoUAG+mxtD1f/rje/qHxjYFG4eNobZ9Z7J1piu1TZx5xyljcDtxpgKxpg8OIszLExewBhze7K3LYDfXK8XAh2MMXmNMRWA24ENbozVbQ4fPkyHDh2oVKkSVapU4f777096sGtWjR07lrNnz16VuCIjI5k+fXrS+02bNtG/f/+rUndyoaGhpFy2XURERESuvpMnoU0beOEFaNsWNi08SJUngrA//ECXdj7UG/Mlz2RzknQtc1uiZK2NA/oB/wN2Al9aa7cbY4YbY1q7ivUzxmw3xkTgzFPq6jp2O/AlsAP4BnjKWhvvrljdxVpL27ZtCQ0N5ffff2fHjh28/vrrHDly5IrqSy9Rio/P2u1JmSgFBQUxbty4K4pLRERERHLWhg0QGAjffAPjxsGXr+4kX5NAzv/xG490L0Tv0StoV7VdTod5TXHrc5SstV9baytbaytZa0e4tg211i50vf6PtbaqtTbAWtvIlSAlHjvCddwd1tql7ozTXVasWIGvry99+vRJ2hYQEMA999yDtZbnn3+eatWqUb16dWbNmgX80zX58MMPc+edd9KpUyestYwbN46DBw/SqFEjGjVqBEChQoUYOnQoderUYd26dQwfPpzg4GCqVatG7969SZx/tmfPHpo0aUKNGjUIDAzk999/Z/DgwaxevZqAgADeeecdwsPDadmyJQAnT56kTZs2+Pv7U7duXbZt2wbAsGHD6NGjB6GhoVSsWDHLidWMGTOoXr061apVY9CgQUnbP/nkEypXrkxoaCi9evWiX79+V37TRURERK4j1sJ770GDBs77NWvg6cC1XKxfm6i/j9Dh6dKMfGMjDW5pkLOBXoPcOUfJowwYABERGZdLLJOZYZQBATB2bNr7f/nlF2rVqpXqvrlz5xIREcFPP/3E8ePHCQ4OpmHDhgBs3bqV7du3U6ZMGe6++27Wrl1L//79GTNmDCtWrKBEiRIAnDlzhmrVqjF8+HAAqlSpwtChQwHo3LkzixcvplWrVnTq1InBgwfTtm1bYmNjSUhIYOTIkYwePZrFixcDToKW6JVXXqFmzZrMnz+f77//ni5duhDhujG//vorK1asICYmhjvuuIO+ffvi6+ub4b06ePAggwYNYvPmzRQrVoymTZsyf/58ateuzX//+1+2bNmCn58fjRs3pkaNGhnWJyIiInK9i46Gnj1hzhxo2RI+/RSKr5pPXIdHiCx0kedeqMYn/b+jdKHSOR3qNcmtPUqStjVr1vDoo4/i7e1NqVKlCAkJYePGjQDUrl2bcuXK4eXlRUBAAJGRkanW4e3tzUMPPZT0fsWKFdSpU4fq1avz/fffs337dmJiYjhw4ABt27YFnAUOChQokGFsnTt3BqBx48acOHEiafW4Fi1akDdvXkqUKEHJkiUzPYxw48aNhIaGcuONN+Lj40OnTp1YtWoVGzZsICQkhOLFi+Pr60u7duoSFhEREclIRAQEBcG8eTBqFCxYAMW+nEjCQw+yqcRFXhnRhOnPrVOS9C9cNz1K6fX8JHe1Vr0DqFq1KnPmzEl1X3rLsufNmzfptbe3N3FxcamWy5cvX9IS5LGxsTz55JNs2rSJm2++mWHDhhEbG5vuedKS2jHGmCzFlpk609suIiIiIpezFj7+GJ5+Gm64wfnO2uBuS/zQl/F6bQRf3w5LR3Rj2kOT8PG6br7qu4V6lNyocePGnD9/nkmTJiVt27hxIytXrqRhw4bMmjWL+Ph4jh07xqpVq6hdu3a69fn5+RETE5PqvtjYWABKlCjB6dOnkxK0woULU65cOebPnw/A+fPnOXv2bLp1NWzYkC+++AJwhuSVKFGCwoULpxtbWFgYBw4cSHN/nTp1WLlyJcePHyc+Pp4ZM2YQEhJC7dq1WblyJadOnSIuLo6vvvoqzTpERERErmenT0OXLtC7NzRsCFu3QoO6cVx4vBver43gk5rw08RXee/hyUqSrgIlSm5kjGHevHl89913VKpUiapVqzJs2DDKlClD27Zt8ff3p0aNGjRu3JhRo0ZRunT6XaO9e/fmvvvuS1rMIbmiRYvSq1cvqlevTps2bQgODk7aN23aNMaNG4e/vz/169fn8OHD+Pv74+PjQ40aNXjnnXcuqWvYsGFs2rQJf39/Bg8ezKeffppuXAkJCezZs4fixYunWeamm27ijTfeoFGjRkmLSjzwwAOULVuWIUOGUKdOHZo0aUKVKlUoUqQIAAsXLkyacyUiIiJyPduxA2rXhi++gOHDYelSKFnoLOda3UeeKZ8xIsSQZ/KnDGk8NGkkkPw7JrcMfQoKCrIpn9ezc+dO7rrrrizVowfOZt0vv/zC5MmTGTNmzBUdn/i05ri4ONq2bUuPHj2S5lT9Gynb/1p92Flup3bxPGoTz6R28TxqE8+UG9tl2jTo0wcKFYLp0yEsDDh+nDPNw8i/ZRvPtspLi3cW06Rik5wONVWe1ibGmM3W2qCMyqlPLoWrMTfpelOtWrUrTpLA6cFatmwZsbGxNG3alDZt2lzF6ERERESuTefOQf/+zpykhg1hxgwoUwaIjORMWEO89+7jiS7FefrNFfiX8s/pcHMdJUqS40aPHp3TIYiIiIh4lN9+g3bt4Kef4MUXneF2Pj7ATz9xtkkIF05HM6B/BUa8sopyhcvldLi5khIlEREREREPMns2PP44+PrCkiVw//3Odrt8OecfaMEJ7/O88nJtxg38liL5iuRssLmYFnMQEREREfEA5887y34/8ghUreqsapeYJMXPmE5886bsKXCet0a3ZeKg1UqS3EyJkoiIiIhIDouMhHvugfffh2eegZUr4ZZbnH3nR7+Jd8dO/FAmgXkfPcO7Pb8ij3eeHI33eqChdykkrsgRrlUdRERERCQbLFwIXbs6D5OdOxeSFv9NSOD0wKcp9O4HzL0LTn38Pi/XfypHY72eqEfJzQ4fPkyHDh2oVKkSVapU4f7772f37t1uP294eDgtW7Z06zkiIyOpVq3avy4jIiIicj26eBFeeAEeeAAqVoTNm5MlSRcuEN2+DYXe/YAP6/iQ96sFPK4kKVupR8mNrLW0bduWrl27MnPmTAAiIiI4cuQIlStXzuHoRERERCSn7N8P7dvDDz9A374wZgzky+faGRPDqRZhFFu9kdebF6TpxysIKhuco/Fej9Sj5EYrVqzA19eXPn36JG0LCAjgnnvu4fTp04SFhREYGEj16tVZsGABcHkPzOjRoxk2bBgA48aNo0qVKvj7+9OhQwcANmzYQP369alZsyb169dn165d6cY0depU2rRpQ6tWrahQoQLvv/8+Y8aMoWbNmtStW5eTJ08CTkJXt25d/P39adu2LadOnQJg8+bN1KhRg3r16jF+/PikeuPj43n++ecJDg7G39+fDz/8MEv36vPPP6d27doEBATwxBNPEB8fD0ChQoV49tlnCQwMJCwsjGPHjmWpXhERERFP8+23ULOms/T39OnwwQfJkqQjRzhVtwZ+azfyYqdSdJi+TUlSDrluepQGDBhAREREhuUSy2Tm6cEBAQGMHTs2zf2//PILtWrVSnVfvnz5mDdvHoULF+b48ePUrVuX1q1bp3u+kSNH8ueff5I3b16ioqIAuPPOO1m1ahU+Pj4sW7aMIUOG8NVXX6Vbzy+//MLWrVuJjY3ltttu480332Tr1q0888wzfPbZZwwYMIAuXbrw3nvvERISwtChQ3n11VcZO3Ys3bt3T9r+/PPPJ9X5ySefUKRIETZu3Mj58+e5++67adq0KcaYdGMB2LlzJ7NmzWLt2rX4+vry5JNP8sUXX9ClSxfOnDlDYGAgb7/9NsOHD+fVV1/l/fffz7BOEREREU8THw+vvgqvveasajd7Ntx55z/77e7dRDeqT55jJxj89F28+PpqbihwQ84FfJ27bhIlT2OtZciQIaxatQovLy8OHDjAkSNH0j3G39+fTp060aZNG9q0aQNAdHQ0Xbt25bfffsMYw8WLFzM8d6NGjfDz88PPz48iRYrQqlUrAKpXr862bduIjo4mKiqKkJAQALp27Uq7du0u2965c2eWLl0KwLfffsu2bduYM2dOUly//fZbpoYYLl++nM2bNxMc7Py15Ny5c5QsWRIALy8v2rdvD8Bjjz3Ggw8+mGF9IiIiIp7m8GHo2BFWrIDu3Z3V7QoU+Gd//I/rOde0ERfjYhk5rBH/fX4J+X3z51zAcv0kSun1/CR3NVe9q1q1alLikNIXX3zBsWPH2Lx5M76+vpQvX57Y2Fh8fHxISEhIKhcbG5v0esmSJaxatYqFCxfy3//+l+3bt/Pyyy/TqFEj5s2bR2RkZKZ6wvLmzZv02svLK+m9l5cXcXFxaR5nrU2zh8hay3vvvUezZs0u2R4ZGZlhPNZaunbtyhtvvJFh2cz0UImIiIh4kvBwePRRiI6GyZOdRCm584vmY9s9zNH88cwa143Xe3yCl9EMmZymFnCjxo0bc/78eSZNmpS0bePGjaxcuZLo6GhKliyJr68vK1as4K+//gKgVKlSHD16lBMnTnD+/HkWL14MQEJCAvv27aNRo0aMGjWKqKgoTp8+TXR0NGXLlgWc+UdXQ5EiRShWrBirV68GYNq0aYSEhFC0aFGKFCnCmjVrACfZS9SsWTMmTJiQ1KO1e/duzpw5c0m9Bw4cICws7LLzhYWFMWfOHI4ePQrAyZMnk+5HQkJCUrI5ffp0GjRocFWuUURERMTdEhLg9dchLAyKFIEff7w8SYr56H2827RlR7F4ln3+Ki8+PkVJkoe4bnqUcoIxhnnz5jFgwABGjhxJvnz5KF++PGPHjqVq1aq0atWKoKAgAgICuNM1QNXX15ehQ4dSp04dKlSokLQ9Pj6exx57jOjoaKy1PPPMMxQtWpQXXniBrl27MmbMGBo3bnzVYv/000/p06cPZ8+epWLFikyZMgWAKVOm0KNHDwoUKHBJ71HPnj2JjIwkMDAQay033ngj8+fPv6TOQ4cO4eNz+UeuSpUqvPbaazRt2pSEhAR8fX0ZP348t956KwULFmT79u3UqlWLIkWKMGvWrKt2jSIiIiLucvw4dO4M33wDHTrARx+Bn1+yAtZyYujz3PDa2yyvZDg9/VN61+6cY/HK5Yy1NqdjuCqCgoLspk2bLtm2c+dO7rrrrizVc7WG3sXExOB3yW+DvP/++9xyyy0ZLlqRXKFChTh9+vQVnS9l+4eHh2dqaKJkL7WL51GbeCa1i+dRm3gmT2iXH35wlv4+ehTefReeeAIumT0QH8+RxztQ6tM5zA7IQ9nZ/6P+baE5Fa7beUKbJGeM2WytDcqonHqUUrgac5Mkdf369cvpEERERETcxlp45x0YNAhuvhnWrYPAwBSFYmM5+EAYZb79gUmNCtNw5nruKJm1P+xL9lCiJB7tSnuTRERERLJTVBR06wYLFkCbNjBlChQtenmhg42DKbN1D2PalaPT5E2UKlQqJ8KVTNBMMRERERGRf2HzZqfnaMkSp0dp7tzLk6SEfXs5XLMyJX7aw6h+NXni81+VJHm4XJ8o5ZY5WJI1ancRERFxN2vhgw+gfn24eBFWrYIBA1LMRwIubIvgZOBdFDh4jPHDWzDw3Q0UzFMwZ4KWTMvViVK+fPk4ceKEvjRfZ6y1nDhxgnz58uV0KCIiIpJLxcQ4z0Z66iln+e+tW6FevVTKff8NsfWDuRh7ltkT+jFgyCJ8vDT75VqQq1upXLly7N+/n2PHjmX7uWNjY/VFPQfly5ePcuXK5XQYIiIikgtt2wbt2sGePc5zkgYNAq9Uuh+OfTEJv+5PsLewZftnb/P4/QOzP1i5Yrk6UfL19aVChQo5cu7w8HBq1qyZI+cWERERuR6FhkJUVAAREe47x5Qp8OSTzhyk77+HkJDUy+178/8o8+LrbCnnTey82bSt1dZ9QYlb5OpESURERETkajhzxhlm9+mn0LgxTJ8OpVJbi8Fa/ujfmYrvf8GyKvkovSic4Ip1sj1e+feUKImIiIiIpGPnTmeo3Y4dMHSo8+PtnUrBuDh2t2tM5fmrmVe/GMGLtlCuePnsDleuEiVKIiIiIiJpmD4deveG/Pnhm2+gadPUy9kzZ/jt3kAqr9vNtAfK03rGVorkT/kgJbmW5OpV70RERERErkRsLPTtC506Qc2aEBGRdpJ08cgh/qhVgUrrdzP1iTq0/2qXkqRcQImSiIiIiEgyv//uPBtp4kR44QVn0YayZVMve3rXLxwJuI2ye44xa9jDdJ2wjjzeebI3YHELDb0TEREREXGZOxe6d3fmIC1cCK1apV322Nrv4P77KXghjm8/fJ6Oj4/KvkDF7dSjJCIiIiLXvQsXYMAAeOghuOMO2LIl/STpr7lTyBfWjFgTz89zJ9BaSVKuo0RJRERERK5re/dCw4bw7rvQvz+sWQPly6ddfud7r3DTIz3YX8ybU8sW0/C+PtkWq2QfDb0TERERkevWkiXQpQtcvAizZ8PDD6dffusLXaj51jQ23pafkt+t49byNbInUMl26lESERERketOXBy8+CK0bAk33wybN6efJNn4eDZ2DKXmW9MIr3UDlTbsUZKUy6lHSURERESuKwcPQocOsHq184yksWOd5ySlJT72HFvuCyA4fDffNKtE6IKfyJe3YPYFLDlCiZKIiIiIXDeWLYOOHeHMGZg2DR57LP3yZ08eYXdodYJ/PsaSbg2475NwvLy8sydYyVEaeiciIiIiuV58PLz6qvPQ2BIlYOPGjJOk43/8wr6aFan2yzG+e6kjLaasVpJ0HVGPkoiIiIjkakePQqdOTm9S584wYQIUzGDk3F8bl+F1332U+zuOHyf8H/c+8Vr2BCseQ4mSiIiIiORaq1dD+/Zw6hRMmgSPPw7GpH/ML4smU/rRngD8/tUk7m7VMxsiFU+joXciIiIikuskJMCbb0KjRk7v0fr10LNnxknSuo+GUuGhxzmbz5uY77/BX0nSdUs9SiIiIiKSq5w4AV27Os9IatcOPv4YChfO+LjlQzsTMuJz9pQrQIkVP1KiYjX3ByseS4mSiIiIiOQaZ854ExgIhw7Be+/BU09l3IuUkBDPtz0b0XzKarZWL0HlFT9T8IbS2ROweCwlSiIiIiJyzbMW9u+HP/4oxC23wNq1EByc8XHnz59l5QM1aP6/PWwIvZ1aS3/CO186D1WS64YSJRERERG5psXHw3/+A7//DoULx7F1qy/FimV83KlTh9h2rz9NNx/nxw4Nqf359xhvLf8tDi3mICIiIiLXrNhYZ1W78eOhXDkoX/5MppKkfZHb2FP7NkI2H2fz849RZ8ZKJUlyCSVKIiIiInJNioqCZs3gq6/g7behUqWM5yMBbN/yP87UrUWNP8+yY9zL1Bo1zf3ByjVHiZKIiIiIXHP274d77oF162D6dBg4MHPHrVn6IUUa30fZqHgOzvqEKk8Pd2+gcs3SHCURERERuaZs3w7Nm0N0NCxdCmFhmTtuyeQXqf/USOLy+HBu+RLK393UvYHKNc2tPUrGmObGmF3GmD3GmMGp7B9ojNlhjNlmjFlujLk12b54Y0yE62ehO+MUERERkWvDmjXQoAHExcGqVZlLkqy1zPxvexo/MZLTxQqQb8MWSipJkgy4rUfJGOMNjAfuBfYDG40xC621O5IV2woEWWvPGmP6AqOA9q5956y1Ae6KT0RERESuLfPmQceOcMst8M03UKFCxsdcjL/IjKdC6PTROiJvL8Etq7bhW+om9wcr1zx39ijVBvZYa/+w1l4AZgIPJC9grV1hrT3rerseKOfGeERERETkGjVxIjz8MNSo4TwjKTNJUkzs38x+6E66fLiOPXUrU3Hzn0qSJNPcmSiVBfYle7/ftS0tjwNLk73PZ4zZZIxZb4xp444ARURERMSzWQsvvwx9+8J998Hy5VCiRMbHHTy1l+VhFei44A92PdCAO1ZtxxQq5P6AJdcw1lr3VGxMO6CZtban631noLa19ulUyj4G9ANCrLXnXdvKWGsPGmMqAt8DYdba31Mc1xvoDVCqVKlaM2fOdMu1XInTp09TSL+MHkVt4pnULp5HbeKZ1C6eR23ifvHxhrffrszSpTdx332HePbZ3Xh7p/3d9aWWhbDW0uezzZT+v/9w764LrG0XxsW+/5e5dcPFLTztd6VRo0abrbVBGZVz56p3+4Gbk70vBxxMWcgY0wT4P5IlSQDW2oOuf/8wxoQDNYFLEiVr7UfARwBBQUE2NDT06l7BvxAeHo4nxSNqE0+ldvE8ahPPpHbxPGoT9zpzxnmQ7NKl8NJLMHz4TRiT/rA5H58I4m9czp3PDCJwfzx73xzC3S+MyKaIJS3X6u+KOxOljcDtxpgKwAGgA9AxeQFjTE3gQ6C5tfZosu3FgLPW2vPGmBLA3TgLPYiIiIhILnf8OLRsCRs3woQJ0KdP5o7zvXU6H+5/i1tjDCemfcgtnXq7N1DJ1dyWKFlr44wx/YD/Ad7AZGvtdmPMcGCTtXYh8BZQCJhtnO7Qvdba1sBdwIfGmASceVQjU6yWJyIiIiK50J9/Os9I+usvmDMH2rbN+JiL8ReZNLYL036fSZ6L3lz4ZhElG9/n/mAlV3PrA2ettV8DX6fYNjTZ6yZpHPcDUN2dsYmIiIiIZ4mIcBZsiI2FZcuc5yVl5ODfB5jXqwFPzI5kb4FCDPSdyHQlSXIVuPWBsyIiIiIimbF8OTRsCD4+/zxUNiPhPy0gon5FnvoykoNhwfTzXspe7nB/sHJdUKIkIiIiIjlqxgynJ+nWW2HdOqhaNf3yCTaBjyY/RbnGbbh35wWODB/ELd/+yFnjOSurybXPrUPvRERERETSM2YMPPus05u0YAEULZp++RNnT/DZgEb0mfIz5wrn5+LyBZQKvdfZGRDA6ago9wct1wUlSiIiIiKS7RIS4IUX4O234aGH4PPPIV++9I/Z8NtKfu/cgmd+PMP+oDsou3glplSp7AlYrjsaeiciIiIi2erCBejc2UmSnnoKZs1KP0my1vLZ3FfI0zCUR388w8H+PSi3fruSJHEr9SiJiIiISLb5+2+nB2nZMnj9dRg8GJynxKQu5nwME4feR6931+Lt40vMV9Mo82D77AtYrltKlEREREQkWxw+7Cza8PPPMGUKdOuWfvlfDkawrmsYzy87yaE7ylJq6Sq8KlTMllhFNPRORERERNxu926oX9/5d9GijJOk2cvf4+Tdtei17CQHOrXmpog9GSZJ4eEwdmzEVYtZrm/qURIRERERt/rxR2jZ0nm9YgXUrp122di4WN5/qx2dXl9MsQteRH04jrK9n86eQEWSUaIkIiIiIm7z9dfQrh2UKgX/+x/cfnvaZX8/sYfFvUIYMP8gp8oWx2fJcor6B2RfsCLJKFESEREREbeYMgV69QJ/fydhKl067bJLNnwB3bvxnx1xHGx+N2VmfQ2FC2dfsOIWoaGhREVFERFx7Q2J1BwlEREREbmqrIURI6BHD2jcGFauTDtJuhh/kXcmdOWO5o/R7Nc4Trz+MmW+Xq0kSXKcepRERERE5KqJj4f+/eGDD6BTJ5g8GfLkSb3swZiDfNY/hAHT9nCuaEESwpdwwz0h2RuwSBqUKImIiIjIVREb6yRHc+fC88/DyJHglcb4pRXbl3C4+8MM3hjLobrVuGnh93DjjdkbsLjdqVOnOHr0aE6HcUU09E5ERERE/rVTp6BpUydJeucdGDUq9SQpwSYwfvozFA9ryaMbYzk2sA83rYlQkpTLJCQkMGLECLZt20ZUVBRnz57N6ZCyTD1KIiIiIvKv7NvnPEh2926YMQM6dEi93ImzJ/hgyL30n7gVL988nFswgxtbP5i9wYrbnTp1is6dO7NkyRJKlixJyZIlKVCgQE6HlWXqURIRERGRK7Z9O9SrB3v3wjffpJ0kbfhzLbNbVODld7dyvtKtFPp5F/mVJOU6W7ZsITAwkG+//Zbx48dz55134u3tndNhXRElSiIiIiJyRVavhgYNICHBed248eVlrLVMWTKC843uoU94DEe7PkzJLbsw5ctnd7jiZp988gn169cnLi6O1atX8+STT2KMyemwrpiG3omIiIhIls2dCx07QvnyTk9SanlPzPkYxoxszRNvhVM0zpvTUyZQsluv7A5V3OzcuXP069ePyZMn06RJE6ZPn86Nrjln4eHhhIeH52yAV0iJkoiIiIhkyQcfQL9+UKcOLFoEJUpcXuaXw9v4X+8wXlp8nKibbyTPkuX8P3t3HZ9V+bhx/HMYOUBgdAooiKA0SEgM6RggJSIiXdJdboxOKZEupbu7pGt0g+QXlUZgbLDt/v1x5k++fBGGPM+exfV+vXixJ85zrnkAubjvc99xP/o4/MOKU/3666/UqFGDI0eO0Lt3b3x8fCLtVLsXqSiJiIiISGt3v3AAACAASURBVJgYA717w8CBULkyzJ8PL7tHf/6OCSRo1ppOZ0K4WdmTFHOWQ8KE4R9YnGrlypV8/fXXAKxatYpKlSq5OJFj6R4lEREREXmtZ8+gcWO7JDVuDEuX/m9JCggKoP+ozyng1ZKy5w0PhvYjxYrNKklRTHBwML169cLLy4tMmTLh5+cX5UoSaERJRERERF7j8WOoXRvWrIHvvgMfH3jxHv2Ldy4wp10pusy7RoBHQqxf1pCoyKcuySvOc+vWLerWrcvmzZtp0qQJY8eOJW7cuK6O5RQqSiIiIiLyj27dsqfZHTwIEyZA8+b/+56Vh+fzsEl9+vg941bR3CRfukEbyEZBe/fupVatWty6dYupU6fSqFEjV0dyKk29ExEREZGXunQJihaFY8dg8eL/LUnPgp8xZHoTMlT4gi8OP+Ne17Yk335QJSmKMcYwbtw4ihcvTqxYsdizZ0+UL0mgESUREREReYnDh6FCBXj6FDZtsgvT8248vMEPPT6j2+QzxIgTh6CVC0lSqYprworTPHr0iGbNmjF37lwqV67MrFmzSJIkiatjhQuNKImIiIjIf9m0CYoXh9ixYefO/y1JW86uZ3nl9xnwwxmeZn2PBCfOEVslKco5c+YMn3zyCfPnz2fAgAEsX7482pQkUFESERERkefMmQMVK0KmTLBnD2TP/vdrISaEUUu6EqtseVr+8oS7jeqS7OBJyJDBdYHFKRYtWkSBAgW4efMm69evp2fPnsSIEb2qQ/T6bkVERETkH40YAfXqQZEi8MsvkDbt36/d8b9Dz96Fqfv1MArcjEnArGl4TJ0DceK4LrA43LNnz+jUqRO1atXio48+4vDhw5QuXdrVsVxC9yiJiIiIRHMhIdClC4wcCTVrwk8/wfMrPu+7uoftLSswYO0DHmRMRZyVm7By5HBdYHGKGzduUKdOHXbu3EmbNm0YPnw4sWPHdnUsl9GIkoiIiEg0FhgIX31ll6Q2bWDevL9LkjGGyZuGcrtMUbquecB9r7J4HDuvkhQFbd++nbx58+Ln58ecOXMYM2ZMtC5JoKIkIiIiEm39+ad9P9LcuTB4MIweDW5u9msPAx/SY2hZStfqRtmL8HjEYJIuXQcJErg2tDiUMYZhw4bx2WefkThxYvbv30/dunVdHStC0NQ7ERERkWjot9/sknTiBMycCV9//fdrJ/44zoL2Zei78A8CkibCbeda4hcq7Lqw4hQPHjygYcOGLF26lJo1azJt2jQSJkzo6lgRhoqSiIiISDRz9iyULw+3bsHKlfbXf5mzdwqmZQt8jwRzt3gBPBavgWTJXBdWnOLYsWPUqFGDS5cuMXLkSNq3b49lWa6OFaFo6p2IiIhINLJvn70v0uPHsHXr3yUpICiA3hNq83HVptQ9GszDHp3w2LJHJSkK+umnnyhUqBCPHz9m69atdOjQQSXpJTSiJCIiIhJNrFoFtWtD6tSwfj28/779/MW7F5nQvTR9Zl7GLW48zOpFJKxQ0bVhxeECAwNp3749EyZMoESJEsybN49UqVK5OlaEpRElERERkWhg2jSoVs3eQHb37r9L0orji1nnlZ1hky8T/OEHxD9xFjeVpCjn6tWrFCtWjAkTJtC1a1c2bdqkkvQaKkoiIiIiUZgx0L8/NG4Mn31mT7dLmRKeBT+j/9yWJK1Uk9a7nvKgWQOS7D8G6dO7OrI42Pr168mbNy9nz55lyZIlDBkyhJgxNbHsdVSURERERKKo4GBo1Qr69LH3Slq5EhImhBsPb9Cle16aNZlA/lsxefbzLBJNnAHRfN+cqCYkJARfX18qVKhA6tSpOXjwINWrV3d1rEhDVVJEREQkCnryBOrVg6VLoWtXGDQIYsSAzRc2sr9NdUasf8zDzGmJs3IjfPihq+OKg925c4f69euzdu1avvrqKyZMmED8+PFdHStS0YiSiIiISBRz9y6UKQPLltmbyA4ZAlghjFjVi8CKZemx7jGPqlci8ZEzKklR0MGDB8mXLx+bN2/mxx9/ZNasWSpJ/4JGlERERESikGvX7CW/L1yAefPsVe7u+N/Bd4QXHUbsJu3jGASMGUGib9uBloSOUowxTJ48mTZt2pAqVSp27NhBwYIFXR0r0lJREhEREYkiTpywS9LDh7BuHXh6wr5re1nesSJDl97jaXIPYm5YSyz95TnK8ff3p3Xr1syYMYOyZcsye/ZskmkPrLeiqXciIiIiUcAvv8Cnn0JICOzYASVLGiZsH8GFKkUYuOgeASWKkPDEOSyVpCjnwoULFClShBkzZvDdd9+xZs0alSQH0IiSiIiISCS3eLG9cEPGjPZGsh6pHtJxTB0aD1hL9tvg/10PEnn3t1dzkChl+fLlNGjQgBgxYrB69WoqVtQeWI6i3y0iIiIikdi4cVCrFuTNC7t2wcN4J+jdKhu+XdeS+Wl8WL8e974DVZKimKCgIHr06EG1atV4//338fPzU0lyMP2OEREREYmEjIFevaBNG6hSBTZtgnWXprOtWm5GT7tByEc5cD9xhhhlyro6qjjYzZs3KVeuHIMHD6ZZs2bs3LmTjBkzujpWlKOiJCIiIhLJPHsGjRrBwIHQtCnMnh+Az/wvyVS9Ed/uCeZxyyYk2uMH6dK5Oqo42O7du8mTJw+7d+9m+vTpTJw4kbhx47o6VpSke5REREREIpHHj+2pdmvXgo8PfNXmVzp3L0u/yRd5x8QmeN5M4tf5wtUxxcGMMYwdO5ZOnTrx7rvvsnfvXnLlyuXqWFGaipKIiIhIJHHrFlSqBIcOwcSJkPLTpcyrU5fxmwN59H4G4qzcAB984OqY4mCPHj2iSZMmzJ8/Hy8vL2bOnEnixIldHSvK09Q7ERERkUjg11+hSBE4fhwWLg7iRtI2xKr6Ob02BeJfqxrvHD6lkhQFnT59moIFC7Jw4UIGDx7M0qVLVZLCiVOLkmVZ5S3LOmtZ1gXLsrq/5PWOlmWdsizrmGVZmy3Leve51xpYlnU+9EcDZ+YUERERicj8/KBwYbh7F+atvMVav/w0bDyOMpdj8GzcWBLMWwLx47s6pjjYggULKFCgAHfu3GHTpk1069aNGFq9MNw47b+0ZVluwA9ABSA7UNeyrOwvvO0wkN8YkxNYBAwNPdYD8AY+AQoC3pZlJXFWVhEREZGIauNGKFEC4saF4XP3sGt8ZsYNPErS+MmItWcfsVp/C5bl6pjiQE+fPqV9+/bUqVOHnDlz4ufnh6enp6tjRTvOrKQFgQvGmF+NMU+BeUDV599gjNlqjPEPfbgX+GtplnLARmPMXWPMPWAjUN6JWUVEREQinNmzoWJFyJTJUH/gMGJ3KcLQpY946lmcBMfPQv78ro4oDvaf//wHT09PRo8eTbt27di2bRtp06Z1daxoyZmLOaQFrj33+Dr2CNE/aQysfcWx+hUiIiIi0YIxMGIEdOkCRYs/4/1SVanbYS0f3rEI7NuHhL29tYFsFLRlyxbq1q3L48ePmTdvHnXq1HF1pGjNMsY454MtqxZQzhjTJPRxfaCgMabNS977FfAtUMIYE2hZVhcgjjGmf+jrfQB/Y8yIF45rBjQDSJkyZb558+Y55Xv5Nx49ekSCBAlcHUOeo2sSMem6RDy6JhGTrkvE46xrEhICP/74HosWpSdv0QvkSVuEUctuYeLG4+J3/bifL5/DzxmVRMbfK8YY5s2bx5QpU0iXLh2+vr68++67rz8wkoho18TT0/OQMea1w7HOHFG6DqR/7nE64MaLb7IsqzTQi9CS9NyxJV84dtuLxxpjJgGTAPLnz29Kliz54ltcZtu2bUSkPKJrElHpukQ8uiYRk65LxOOMaxIYCA0awKJFULLmYapfLUDbBcE8yp+ThMvWkFtTsF4rsv1euX//Pt988w3Lly+nTp06TJ48mYQJE7o6lkNFtmvyF2eO2R4AsliWlcmyrNjAF8CK599gWVYeYCLgZYy5+dxL64GylmUlCV3EoWzocyIiIiJR0oMHUKECzJ8PhavPYODuvLTdH0xAm5Yk2H0QVJKinKNHj5I/f35Wr17NqFGjmDt3bpQrSZGZ00aUjDFBlmV9i11w3IBpxpiTlmX5AgeNMSuAYUACYKFlr9Zy1RjjZYy5a1lWP+yyBeBrjLnrrKwiIiIirvTbb3ZJOnnSUPyz9ixeP4aExCFkwSzi1qrt6njiBDNnzqRFixZ4eHiwbds2ihYt6upI8gJnTr3DGLMGWPPCc98993XpVxw7DZjmvHQiIiIirnf2LJQrB7/ffMaXOaoyfcta/LNmIs6KdZA1q6vjiYMFBATQrl07Jk2ahKenJ3PnziVlypSujiUvoeVSRERERFxkzx4oUsRw694DhnoUZubRtQTUqUmCQ8dVkqKgy5cv8+mnnzJp0iS6d+/Ohg0bVJIiMKeOKImIiIjIy61aBbVqhxArzjXWhZSi8M0rBP84HvfmLbSBbBS0bt066tWrR3BwMMuWLaNq1aqvP0hcSiNKIiIiIuFsyhSoWtWQKPZhTv1ZgHyJHhFzzz7cWrRUSYpigoOD8fHxoWLFiqRLl46DBw+qJEUSKkoiIiIi4cQY8OkbTNOm8JH7ei48KIFH6Y9wP3YatD9SlHP79m0qVapE3759qV+/Pnv27OH99993dSwJIxUlERERkXAQHAxfN3lMXx83vOLMZP9jL+L274b72k3g4eHqeOJgBw4cIF++fGzdupWJEycyY8YM3N3dXR1L3oDuURIRERFxsidPoHTVW+zemJyOMQbRz30wcdasg1KlXB1NHMwYw6RJk2jbti2pU6dm165d5M+f39Wx5F9QURIRERFxott3Qshf/DpXT6VjDG1onH8X7ktOaQPZKMjf35+WLVsya9Ysypcvz88//0zSpEldHUv+JU29ExEREXGSo2fv8X6Oq9w4lZL51KF5O3DfuU8lKQo6f/48hQoV4qeffqJv376sXr1aJSmS04iSiIiIiBPM2XScJlWTEcs/MaviVqHMz82xatRwdSxxgmXLltGgQQNixozJ2rVrKVeunKsjiQNoRElERETEgYwxtB+/mMbl05PEP4SNmb6i7LEfVJKioKCgILp160b16tX54IMP8PPzU0mKQjSiJCIiIuIgDwMfUq39BHZMaMv7XGR59R/J8vMC0GpnUc7vv/9O3bp12bZtGy1btuT7778nTpw4ro4lDhTmomRZVnxjzGNnhhERERGJrE7cPMHXXyzkyFZvCll7WTHyPMnajdEGslHQzp07qV27Nvfv32fWrFnUr1/f1ZHECV479c6yrCKWZZ0CToc+zmVZ1ninJxMRERGJoEomPkLvygn+//Gsw7NoVGQNh7f2pVK8DWzeGY9k7RuoJEUxxhi+//57SpYsSfz48dm7d69KUhQWlnuUvgfKAXcAjDFHgeLODCUiIiISGQQEBdB6dhOmeBoOXOxKk/SrWXrlE+IVyePqaOJgDx8+pHbt2nTs2JEqVapw8OBBcubM6epY4kRhWszBGHPthaeCnZBFREREJNIISHSdL/oU5VjDGux40ACf0r8w6VIFYiZP4upo4mCnTp2iQIECLFmyhKFDh7JkyRISJUrk6ljiZGG5R+maZVlFAGNZVmygLaHT8ERERESio2uZVpInxSQuDVnCEZOXyZ3P0mSYJtxERXPnzqVp06YkSJCAzZs3U7JkSVdHknASlhGlFkBrIC1wHcgNtHJmKBEREZGI6Lb/bZpOq06zgJkc2bCV09bHLJvxgCbDPnB1NHGwp0+f0rZtW7788kvy5MmDn5+fSlI0E5YRpQ+MMfWef8KyrKLALudEEhEREYl4lp5awhbfb6iwrABNAvfzlNhs3haTwsU8XB1NHOz69evUqlWLvXv30qFDB4YMGUKsWLFcHUvCWVhGlMaG8TkRERGRKOeO/x06javCOxVrkGX+N9QOXI+J4cYH8S5RuJi2pIxqNm/eTJ48eThx4gQLFixg5MiRKknR1D/+7rYsqzBQBEhuWVbH5156B3BzdjARERERV1t1fDGnOn+D96antIsxjRk0xKuK4c72KxD81NXxxIFCQkIYPHgwffr0IVu2bCxevJhs2bK5Opa40KtGlGIDCbDLVMLnfvwJ1HR+NBERERHXuPfkHgP6l+O9UjVpsMGdMon9mBHUkN69Yekyi5hWiKsjigPdu3ePatWq0atXL+rUqcO+fftUkuSfR5SMMduB7ZZlzTDGXAnHTCIiIiIus2H/PO60aUyv/f5sTVqCssnWcudxPObPh9q1Q9+UOzeP7t93aU5xjCNHjlCjRg2uXbvG2LFjad26NZY2ChbCtpiDv2VZw4AcQNy/njTGlHJaKhEREZFw9uDJfeb3rEq1Sb/gEQATyvxAhx0tSZ7cYtcGyKM9ZKOc6dOn06pVK5ImTcr27dspXLiwqyNJBBKWxRxmA2eATEBf4DJwwImZRERERMLVjs3TOZo7Fc1G/YJ/+rT0anCDlhtbkT+/xcGD/1uStm2DUaOOuCSrvL2AgACaNm1Ko0aNKFKkCH5+fipJ8j/CUpSSGmOmAs+MMduNMY2AQk7OJSIiIuJ0fz68zbL6BShQrhF5rj7jeJ8+tHn/GkOnp6ZpU9i8GVKkcHVKcaRLly5RtGhRpkyZQs+ePdmwYQMpdJHlJcIy9e5Z6M+/WZZVCbgBpHNeJBERERHnO7BgFInadqXaH884VvwD3PptoE6LDJw7B+PGQatWoFtVopY1a9bw1VdfERISwooVK6hSpYqrI0kEFpai1N+yrERAJ+z9k94BOjg1lYiIiIiTPPz9Kke+KU+x9af5T5KYnJk+jJvpOlO7ml2MNmyAUroTO0oJDg6mb9++9OvXj9y5c7N48WIyZ87s6lgSwb1y6p1lWW5AFmPMA2PMCWOMpzEmnzFmRTjlExEREXEMYzg5ujeBWTJReMNpttXIR5ILN1j/oDPlykHatHDggEpSVHP79m0qVKhAv379aNiwIbt371ZJkjB5ZVEyxgQDXuGURURERMQp/M+c4FT+jORoP4AbHrE4sWoahWcf5NvOyWnfHry8YPdu0N+fo5Z9+/aRN29efvnlF6ZMmcK0adOIFy+eq2NJJBGWxRx2W5Y1zrKsYpZl5f3rh9OTiYiIiLytZ8+41L0FVs6cpD9xlcUtSvD+2VukytsQT0+YPh369IHFiyFhQleHFUcxxjB+/HiKFSuGm5sbu3fvpnHjxq6OJZFMWO5RKhL6s+9zzxlAA9MiIiISYQXs2Mrdr2uT6fJt1ud0J9HEmdQoVJNDh6BaNbh7FxYsgFq1XJ1UHOnJkyfUr1+f2bNnU6lSJWbNmoWHh4erY0kk9NqiZIzxDI8gIiIiIg5x/z6/tWlIytnLCE4Ik3pXpF6fBcSPHZ+5c6FRI3vJ7127IHduV4cVRzp37hytWrXiypUr9O/fnx49ehAjRlgmUIn8L/3KERERkajBGALnzubP99KRYvYyZhRLyKWdq2jWbzVx3eLTvTt8+SUUKGAv2qCSFHUEBAQwaNAgPvzwQ65du8b69evp1auXSpK8lbBMvRMRERGJ2C5f5l7jeiTZspsTqWHDiM/5ttUMEsZJyIMHUK8erF4NzZrB2LEQO7arA4sjGGNYsmQJXbp04dKlSyRNmpQUKVJQpkwZV0eTKEA1W0RERCKvoCCeDR3E0w+zEmvnbvpWTcy9rWvp0WExCeMk5Px5KFQI1q+H8eNh4kSVpKji6NGjlCpVipo1a5IgQQI2b97M7du3GT9+vKujSRTx2hEly7LcsTebzWCMaWpZVhbgA2PMKqenExEREfkn+/fj3/Ar3E+dZ0VW2NX1C3p9NZF34rwD2BvH1qkDbm6wcSOULOnauOIYt27donfv3kyZMoUkSZIwfvx4mjZtSsyYmigljhWWEaXpQCBQOPTxdaC/0xKJiIiIvMqffxL0bWtCCn3CvWvnadrAgzir1jKk8VzeifMOxsD330OFCpA+vX0/kkpS5Pf06VNGjhxJlixZmDZtGm3btuX8+fO0bNlSJUmcIiy/qt4zxtSxLKsugDHmiWVZlpNziYiIiPw3Y2DpUp62bkHMP27xQwE43b4ew6qPI3HcxAAEBkKLFjBjBlSvDrNmQYIEro0tb8cYw+rVq+nUqRPnzp2jQoUKjBw5kmzZsrk6mkRxYRlRempZVjzsvZOwLOs97BEmERERkfBx9SohVb2gRg1OcYvKbZKS+adVjK/78/+XpN9+s0eOZswAb29YtEglKbI7deoUFSpUoEqVKliWxZo1a1izZo1KkoSLsIwoeQPrgPSWZc0GigLfODOUiIiICABBQTBuHMG9evI0KJA+ZeBus6+YXWkMSeIl+f+3HThgjyDdu2cXpBo1XJhZ3trdu3fx8fFh/PjxJEyYkFGjRtGqVStixYrl6mgSjbyyKIVOsTsDfA4UAiygnTHmdjhkExERkejs0CFMs6ZYfofZkMXiu5pJ6dNgKl4feP3X2+bMgcaNIWVK2L0bcuVyUV55a0FBQUycOJHvvvuO+/fv07x5c3x9fUmWLJmro0k09MqiZIwxlmUtM8bkA1aHUyYRERGJzh4+hO++w4wZw50EMWhZC2LX+YJ1FcaS1D3p/78tOBh69oShQ6F4cXskKXlyF+aWt7Jx40Y6dOjAyZMnKVWqFKNGjeLjjz92dSyJxsJyj9Jey7IKOD2JiIiIyPLlmOzZMaNHMzEfFOqUiLp9FzO7xpz/KkkPHoCXl12SWrSwl/9WSYqczp8/j5eXF2XLliUgIIClS5eyadMmlSRxubDco+QJNLcs6wrwGHv6nTHG5HRqMhEREYk+rl+Htm1h6VIupolH/UaGDOVrsafCOJLH/+8GdO4cVK0KFy7Ym8i2bOmizPJWHjx4QL9+/RgzZgxx48ZlyJAhtGvXjjhx4rg6mggQtqJUwekpREREJHoKDobx4zG9ehEU+ASfMm5M9YzHGK8Z1M5R+3/evn69vYlszJiwaROUKOGCzPJWgoODmTZtGr169eL27ds0atSI/v37kypVKldHE/kvYSlKxukpREREJPo5cgSaNYMDB9iXIxFffhZEnqKfc7TieFImSPlfb/1rE9kuXeCjj2D5csiY0TWx5d/bvn077du358iRI3z66aesW7eOvHnzujqWyEuFpSitxi5LFhAXyAScBXI4MZeIiIhEVY8fg7c3ZtQo/N+JR6tasViVLwY/VJpLnRx1eHFf+4AAaN7c3jy2Rg17nyTtjxS5XL58mS5durBo0SIyZMjA/PnzqVWr1v9ca5GI5LVFyRjzX3fSWZaVF2jutEQiIiISda1eDa1awdWrrCiekm8K/0Hx3F6crDyRVAn+d+rVjRvw+eewbx/4+ECfPhAjLEtRSYTw6NEjBg0axIgRI3Bzc8PX15fOnTsTL148V0cTea2wjCj9F2OMn1bBExERkTdy4wa0aweLFnEnUypqN4mN3/uBjK3wE/U+rvfSkYUDB6BaNXuFu8WL7cIkkUNISAg///wz3bt357fffuOrr75i0KBBpEuXztXRRMLstUXJsqyOzz2MAeQFbjktkYiIiEQdwcEwcSL06EFIYABTP89I6+yXKfthJU5WmUSahGleetjPP0OTJpA6tb2JbE6ttRtp7Nmzh/bt27N//34KFizIkiVLKFSokKtjibyxsIwoJXzu6yDse5YWOyeOiIiIRBnHjtmLNezbx7UCH1Cx2BWuJr/LpPLTaZCrwUtHkYKDoUcPGDbMXtFu0SJIlswF2eWNXb9+nW7dujFnzhzSpEnDrFmzqFevHjE0V1IiqbDco9Q3PIKIiIhIFOHvD76+MGIEwYneYUizD+mV+jTls5RnbZXJpHvn5dOv7t+HL7+EtWvt25hGjYJYscI5u7wxf39/hg8fzuDBgwkJCaFXr150796dBFpxQyK5fyxKlmWt5BVLgxtjvF734ZZllQdGA27AFGPM4BdeLw6MAnICXxhjFj33WjBwPPTh1bCcT0RERFxs3Tp7B9jLlzntVYTyOY9yz/06U8pNoVGeRv+4ytm5c+DlBRcvwoQJ9ip3ErEZY5g/fz5du3bl2rVr1KpVi6FDh5JR67ZLFPGqEaXhb/PBlmW5AT8AZYDrwAHLslYYY04997arwDdA55d8xBNjTO63ySAiIiLh5PffoUMHmDePZ1ky071nPkbG3k3pzKWZ6jWVDIky/OOh69bBF1/Yo0ebN0Px4uGYW/6VQ4cO0a5dO3bt2kXu3Ln5+eefKa4LJ1HMPxYlY8z2t/zsgsAFY8yvAJZlzQOqAv9flIwxl0NfC3nLc4mIiIgrhITAlCnQrRvG3x+/5lUol3YrgTFvMqHMBJrla/aPo0jGwIgR0K2bNpGNLH7//Xd69uzJjBkzSJ48OZMnT6Zhw4a4ubm5OpqIw71q6t0CY0xty7KO85IpeMaY160/kxa49tzj68Anb5AtrmVZB7EXkBhsjFn2BseKiIiIs504Yc+R272bgGKF+baKG1P9V+KZwZNpVaeRMXHGfzw0IACaNrVXt6tRA2bOhPjxwy+6vJnAwEBGjRpF//79CQwMpHPnzvTq1YtEiRK5OpqI01jGvPw2JMuyUhtjfrMs692XvW6MufLKD7asWkA5Y0yT0Mf1gYLGmDYvee8MYNUL9yilMcbcsCwrM7AF+MwYc/GF45oBzQBSpkyZb968ea+KFK4ePXqkmxgjGF2TiEnXJeLRNYmYItJ1iREYyLs//UT6efMIjh+fpV8WpVGa7QQTQvPMzfFK40UM659XOrt9OzZ9+nzEmTPv8M03l6hf/0qk3EQ2Il0TZzHGsHPnTiZMmMCNGzcoWrQoLVu2JG3atK6O9o+iw3WJbCLaNfH09DxkjMn/uve9aurdb6E/v7IQvcJ1IP1zj9MBN8J6sDHmRujPv1qWtQ3IA1x84T2TgEkA+fPnNyVLlvyXUR1v27ZtRKQ8omsSUem6RDy6JhFThLkuGzdC69Zw8SL+X9aitY8HLwAAIABJREFUcbG7zPtjLcXTF2ea1zTe83jvlYfv2wdt28Kff8KSJVC9eiYgU/hkd7AIc02c5NixY7Rv356tW7eSI0cOZs6cSenSpV0d67Wi+nWJjCLrNXntv99YllXIsqwDlmU9sizrqWVZwZZl/RmGzz4AZLEsK5NlWbGBL4AVYQllWVYSy7LihH6dDCjKc/c2iYiISDi7eRO++grKlsXEiMHGSd1Jm3Mjy+/sZnT50WxtsPW1JWnWLHtvpLhxYc8eqF49nLLLG7l16xYtW7YkT548HD16lB9++IEjR45EipIk4khhGegeB9QFzgPxgCbA2NcdZIwJAr4F1gOngQXGmJOWZflaluUFYFlWAcuyrgO1gImWZZ0MPfxD4KBlWUeBrdj3KKkoiYiIhLeQEJg6FbJlgwULeNStA7V6Z6XsjcHkSJ6Doy2O0vaTtq+cahccDJ07Q4MGUKQI7N8PH38cjt+DhMmzZ88YNWoUWbJkYfLkyXz77becP3+eVq1aETPma7feFIlywvSr3hhzwbIsN2NMMDDdsqzdYTxuDbDmhee+e+7rA9hT8l48bjegP0JFRERc6fRpe7GGHTswxYqxppMXX58dhP81f0aUHUG7T9rhFuPVq53dvw9169pLgLduDd9/r01kI6I1a9bQsWNHzp49S7ly5fj+++/58MMPXR1LxKXCUpT8Q6fOHbEsayjwG6B1aURERKKqgAAYOBAGD4YECfjzh5E08tjB4iNdKJSuEDOqzuCDZB+89mPOnrU3kf31V5g4EZo1C4fs8kZOnz5Nx44dWbduHVmzZmXVqlVUrFjxH5d0F4lOwjL1rn7o+74FHmMv0FDDmaFERETERbZsgZw5oV8/qF2b5cuG8N7jgay6sIahpYeys+HOMJWktWuhYEG4d8/+SJWkiOXevXu0a9eOjz/+mD179jBy5EiOHz9OpUqVVJJEQv1jUbIsKwPYq94ZYwKMMX8aY/oaYzoaYy6EX0QRERFxutu37ZuIPvsMQkK4v2IBtas+pdrWZmRKnAm/5n50KdrltVPtjIFhw6BSJcicGQ4cgGLFwul7kNcKCgpi/PjxZMmShXHjxtGkSRPOnz9Phw4diB07tqvjiUQor5p6twzIC2BZ1mJjjEaRREREohpj7N1eO3eGBw+gZ0+W1fyIZptacz/gPgNLDaRL0S7EjPH62fpPntgjRz//DLVqwfTp2kQ2Itm0aRMdOnTgxIkTeHp6MmrUKHLmzOnqWCIR1qum3j0/7prZ2UFEREQknJ09C6VKQcOG8MEH3N+9lS/zXqL6ii9Jnyg9fs396FGsR5hK0n/+Yy/9/fPP9qy9+fNVkiKKCxcuUK1aNcqUKcPjx49ZvHgxmzdvVkkSeY1X/cln/uFrERERicwCA2HIEBgwAOLFgwkTWF4sBc3X1OTuk7v08+xHt6LdiOUWtuXp9u6Fzz+Hhw9h6VKoVs3J+SVM/vzzT/r378+oUaOIEycOgwYNon379sSNG9fV0UQihVeNKOWyLOtPy7IeAjlDv/7TsqyHYdxwVkRERCKa7dshVy7w9obPP+f+4b18nWIX1RZ+TuqEqTnQ9AC9i/cOc0maOfO/N5FVSXK94OBgpk6dSpYsWRg2bBj16tXj3LlzdO/eXSVJ5A3844iSMebVd2uKiIhI5HHnDnTtCtOmQcaMsGYNq94LptmSUtzyv4V3CW96FutJbLew3dAfFATdusHIkeDpCQsXQtKkzv0W5PV27NhBu3btOHz4MEWKFGH16tXkz5/f1bFEIqWwLA8uIiIikZUx9o1D2bLZwz9du3L/0C4aPl1AlblVSOaejH1N9uFT0ifMJenePXtVu5Ej4dtvYf16lSRXu3z5MrVr16Z48eLcvn2buXPnsnPnTpUkkbcQlg1nRUREJDI6fx5atoTNm+GTT2DSJNa536DJjIL8/uh3ehXrRZ/ifYgTM06YP/L0aahaFS5fhsmToUkT58WX13v06BFDhgxh2LBhxIgRg759+9K5c2fc3d1dHU0k0lNREhERiWqePrU3M+rXD+LEgR9+4EGDL+i0uStTD08le/LsLPtiGfnTvNlow5o1ULeufT/Sli3w6adOyi+vFRISwuzZs+nevTs3btzgyy+/ZPDgwaRPn97V0USiDE29ExERiUp27oQ8eaB3b6hSBU6fZmO5LHw8KTfTj0yne9HuHGp26I1KkjH2InmVK8N779mbyKokuc7evXspUqQIX3/9NWnSpGHXrl3Mnj1bJUnEwVSUREREooJ79+zdXosVg0ePYOVKHv48jRZ+vpT9uSzxY8dnd6PdDCo9iLgxw77y2ZMn8NVX0L27vYnszp2QIYMTvw/5R//5z3+oX78+hQsX5urVq8yYMYN9+/ZRpEgRV0cTiZJUlERERCIzY2DuXHuxhqlToVMnOHmSLTnc+fjHj5l0aBKdC3fGr5kfn6T75I0++vp1KF4c5syxt1yaNw9060v4e/LkCf369SNr1qwsXLiQnj17cu7cORo0aECMGPqrnIiz6B4lERGRyOrXX6FVK3vZufz5Yd06HuXIQvdN3fnhwA9k8cjCzkY7KZL+zUcc9u6F6tXtwanly8HLywn55ZWMMSxcuJCuXbty5coVatSowbBhw8iUKZOro4lEC/pnCBERkcjm2TMYPBhy5IBdu2D0aNi7l188HpJrQi7GHxhPh0IdONLiyL8qSTNm2JvIurvbhUklKfz5+flRokQJ6tSpQ+LEidm6dSuLFi1SSRIJRxpREhERiehKliT3/ftw5Ajs2WPfi3TihD3kM2YM/ik96LmxE6P3jea9JO+x/ZvtFHu32BufJigIunSBUaOgVClYsED7I4W3P/74g169ejFt2jSSJUvGxIkTady4MW5ubq6OJhLtaERJREQkErCCg+1pdkWLwv37sGwZLFnCzpDL5JqQi9H7RtOmYBuOtjj6r0rS3btQsaJdktq21Say4S0wMJChQ4eSJUsWZs6cSceOHTl//jzNmjVTSRJxEY0oiYiIRGTGwM2bJDx/Hk6dsltMv348iRuT3us78f3e73k38btsbbCVkhlL/qtTnD5tT6+7cgWmTIHGjR37Lcg/M8awfPlyOnfuzMWLF6lcuTIjRowga9asro4mEu2pKImIiERUR45Au3Zw+jQh8eIR45dfIH9+9l7fS4OZDTh35xwt87dkaJmhJIid4F+dYtUq+PJLiBcPtm61B6wkfBw/fpwOHTqwefNmsmfPzvr16ylbtqyrY4lIKE29ExERiWhu3rTvQ8qbF06ehCxZeJQlCwG5P6Lbxm4UnVaUgKAANtXfxPhK4/9VSTLGXg/CywuyZIGDB1WSwsvt27dp1aoVuXPnxs/PjzFjxnDkyBGVJJEIRkVJREQkonj6FIYPt5vL9On2aNL58xyJcZPlcc+Rd2Jehu4eSpM8TTje8jifZf7sX53G3x/q1YMePaBOHdixA9Knd/D3Iv/j2bNnjB49mixZsjBp0iRatWrF+fPnadOmDbFixXJ1PBF5gabeiYiIuJox9hy4jh3hwgWoUAFGjoRs2XgQ8IDRuQKYlS2QNE8fsq7eOsq9X+5fn+r6dahWDfz8YOBA6N4dLMuB34u81Nq1a+nYsSNnzpyhbNmyjBw5khw5crg6loi8goqSiIiIK508CR06wMaN8MEHsGYNVKhAQFAAP+wewaCdg7iTPRCPWB6caHmCRHET/etT7d4Nn39ujygtXw5Vqjjw+5CXOnPmDB07dmTt2rVkyZKFlStXUqlSJSy1U5EIT1PvREREXOHuXWjTBnLlggMH7HW5jx8nqFwZpvpNJcvYLHTe2Jl8afKRN1Ve0runf6uSNG0aeHpCggT2JrIqSc517949OnTowMcff8yuXbsYPnw4J06coHLlyipJIpGERpRERETCU1AQTJgA330HDx5A8+bg64tJmpTFpxfTe0tvzt45yydpP2FWtVl4ZvIEYNu2bf/6dJ07w+jRULo0zJ8PHh4O/H7kvwQFBTFlyhR69+7N3bt3adq0Kf369SNFihSujiYib0hFSUREJLxs2GBPszt1CkqVskeRPv6YTb9uosfSHhy8cZDsybOzrM4yvD7w+v+Rh5Il4f793Bw58manu3vXXqxh0yZ7XYjhwyGm/s/vNFu2bKF9+/YcP36cEiVKMGrUKHLnzu3qWCLyL2nqnYiIiLOdO2fPdStXDgICYOlS2LSJ/R5P+GzWZ5T5qQy3Ht9iRtUZHGtxjKrZqr719KyTJ6FgQdi+HaZOtTuZSpJzXLx4kerVq/PZZ5/x8OFDFi1axNatW1WSRCI5/ZEpIiLiLA8eQL9+MGYMxIkDQ4ZAu3ac/vNXei+syZLTS0junpzR5UfTPF9z4sSM45DTrlxpbyIbPz5s2wZFijjkY+U5JUuW5M6dO1SsWJFRo0YRK1YsBgwYQMeOHYkbN66r44mIA6goiYiIOFpwsD2M07s33L4NDRvCgAFcjfcUn3UtmXl0JvFjxce3pC/tC7UnYZyEDjmtMTBokH3avHntgSvtj+R4gYGB3Lhxg0uXLnHixAkaNGjAwIEDSZMmjaujiYgDqSiJiIg40vbt9g1BR4/Cp5/C2rXcypaBgTsGMv7geCws2n/Snh7FepDMPZnDTuvvD40a2Ys1fPGF3dPc3R328QI8ffqUGTNm0L9/f65du4a7uzu7du2iYMGCro4mIk6goiQiIuIIly5Bly6weDFkyADz5vGwagVG7v2e4WOG4//Mn4a5G+Jdwpv0iRw7zHPtmr2J7OHD9ohSt27aRNaRnj17xsyZM+nfvz9Xrlzhk08+IXHixFiWpZIkEoWpKImIiLyNR4/sdjJiBLi5ga8vAe2/ZcLJmQwY+x63/W9TM3tN+nn2I1uybA4//a5d9iayT57AihVQubLDTxFtBQUF8dNPP9GvXz8uXbpEgQIF+PHHHylfvjyWZf3rJdtFopWSkPt+bnjDVTsjAq16JyIi8m+EhMDMmZA1KwwcCDVrEnT6JNMrp+ODqbnpsL4DuVPlZn+T/SystdApJWnqVHsT2XfegX37VJIcJSgoiJkzZ5ItWzYaNWpEkiRJWLlyJfv27aNChQraMFYkmtCIkoiIyJvas8e+D+nAAShYELN4McsS/06vlRU5ffs0BdIUYJrXND7L/JlTTh8UBB07wtixUKaMfV9SkiROOVW0EhwczNy5c/H19eX8+fPkzp2b5cuXU6VKFZUjkWhIRUlERCSsrl+H7t1h9mxInRpmzmRL0TT02Nqe/f/ZT7Zk2VhcezHVs1V32l+s79yxN5HdvNneu3boUO2P9LaCg4OZP38+vr6+nD17lpw5c7JkyRKqVaumgiQSjemPVhERkdfx94fhw+19kIKDoVcv/BqUpfve/mz8eSPp30nPNK9p1M9Vn5gxnPe/1pMnwcvL7mvTp8M33zjtVNFCSEgICxcupG/fvpw+fZqPPvqIRYsWUb16dWLE0N0JItGdipKIiMg/MQYWLICuXeHqVahZk4vdm9P914ksmjOAZO7JGFl2JC0LtCRuTOduMvrgQUwKFYIECexNZAsXdurporSQkBAWL15M3759OXnyJNmzZ2fBggXUqFFDBUnEUR4Bm4Cz4P4kcu5VoKIkIiLyMocOQfv2sHMn5MrFzfHD6Rm8numry+Eeyx3vEt50LNyRd+K849QYT57A5ctw5Up88uWDZcsgXTqnnjLKCgkJYdmyZfj4+HD8+HGyZcvG3LlzqVWrFm5ubq6OJxL5XQRWh/7YBjwF3ICEQHDo15GIipKIiMjzfv8devWy57YlS8bDcSPpm+kq4/zqYzC0LdiWnsV6kjx+cqfGePIEJk60Z/v9/jskTvyMHTtiEy+eU08bJRljWL58OT4+Phw9epSsWbMye/Zs6tSpo4Ik8jaeAbuAVdjl6Ezo89mANkAlwBv8//Qntlts12R8CypKIiIiAIGBMGoUDBgAAQE8bfcto0onpP8xbx4ffMzXub7Gp4QP7yZ+16kxXixInp6QMiWAP/HiRb6/aLiSMYZVq1bh4+ODn58f77//PrNmzaJu3brE1AoYIv/OLWAtdjFaDzwAYgMlgJbY5ei9597fN7wDOo7+lBARkejNGFi+HDp1gl9/JbhyJX7+OjddLk/i1sFbVM9Wnf6l+pM9eXanxnhZQZo3D0qUgJIl4f59p54+SjHGsGbNGnx8fDh48CCZM2dmxowZ1KtXTwVJ5E0Z4Ch/jxrtC30uNVATqAyUBhK4KqDz6E8LERGJvo4ft+9D2rIFkz07m8Z3pmngQq6cWo1nRk8GfTaIT9J94tQIrypI8maMMaxbtw4fHx/2799PxowZmTp1KvXr1ydWrFiujicSeTwGNmOXozXAf0KfLwj4YJej3EAUX/tERUlERKKf27fhu+9g4kRMokQc792U+il2cezmcPKlzsfkKpMpnbm0U/fQUUFyHGMMGzduxNvbm71795IhQwYmT55MgwYNVJBEwuoSfy/EsBUIxF6EoSx2MaoApHRZOpdQURIRkejj2TP44Qfo2xcePuT6V1VpnPcqG+5PJquVlYW1FlLjwxoqSJGEMYbNmzfj7e3N7t27SZ8+PRMmTKBhw4bEjq37uUReKQjYzd9T6k6FPp8VaIVdjj7Fvv/obWyDI9uOUJKSb/lB4U9FSUREooe1a6FDBzh7lj9LFKJLeTcmBS4lXUg6JleZzDe5v3HqZrEqSI61detWvL292bFjB2nTpmX8+PE0atSIOHHiuDqaSMR1G1iHXY7WA/eBWNgLMTTFXoghi8vSRTgqSiIiErWdOQMdO8LatTzNnJHvu39K9zg78YjhwfAyw2lVoBXxYjlvzW0VJMfavn073t7ebN++nTRp0jB27FiaNGlC3LjO3fBXJFIywHH+HjXaC4RgT6Grzt8LMTh3O7hIS0VJRESipnv3wNcXxo0jxD0eixsW4ut0+3GLe4s+hfvQqXAnEsVN5LTTqyA51s6dO/H29mbLli2kSpWK0aNH06xZMxUkkRf5A1v4uxxdD30+P9AHe9QoH1F+IQZHUFESEZGoJSgIpkyB3r0xd++yr8LH1M55lt/dD9Ey/7f0LNaTlAmcd0eyCpJj7d69G29vbzZt2kSKFCkYOXIkLVq0IJ523hX52xXsUrQKeyGGAOzlustg72NUAXs5b3kjKkoiIhJ1bNliL/d9/DhXcmfkqy8D2ZX0OPVz1advyb5kTJzRaadWQXKsffv24e3tzfr160mePDnDhw+nZcuWuLu7uzqaiOsFAXv4e5W6E6HPvwc0x55SVwzQLXtvRUVJREQiv4sXoXNnWLaMP1MnpUP9REzLfJmq2apyrFR/PkrxkdNO/WJBKlUK5s+H4sWddsoo7cCBA3h7e7N27VqSJk3KkCFDaN26NfHjx3d1NBHXusvfCzGsA+5h/02+GDACe0pdVsB5i3ZGO04tSpZllQdGA27AFGPM4BdeLw6MAnICXxhjFj33WgOgd+jD/saYmc7MKiIikdDDhzBgAOb77wlysxhdKQm9c9+h0Psl2P3ZIAqnL+y0U6sgOdahQ4fw8fFh1apVeHh4MHDgQL799lsSJkzo6mgirmGwR4r+mlK3B3shhuSAF/aoURnAebdaRntOK0qWZbkBP2BfwuvAAcuyVhhjTj33tqvAN0DnF471ALyxbzszwKHQY+85K6+IiEQiISEwYwamZ0+sP/5gRaHEtCxyn1RZs7P8s7mUfa+s0/ZCUkFyrMOHD+Pj48OKFStIkiQJ/fv3p02bNrzzjpbhkmjoCfY9Rn8txHA19Pm8QC/sUaMCaCGGcOLMEaWCwAVjzK8AlmXNA6ry93ZWGGMuh74W8sKx5YCNxpi7oa9vBMoDc52YV0REIoOdO+37kA4d4sR7CWlcBe7nTM73nhOolaMWMSzn/A3ClQVp2zbYtu0IRMING//JsWPH8PHxYenSpSROnBhfX1/atm1LokT653GJZq7x96jRFuyyFB972e4+QEUgjcvSRWvOLEppsS/9X64Dn7zFsWkdlEtERCKjq1eha1eYP59bHnFp9zlsL5IA75LDaZi7IbHcYjnltBpBcqwTJ07g4+PD4sWLeeedd/D29qZ9+/YkTpzY1dFEwkcw9n5Gfy3EcCz0+UxAE+wpdSXQQgwRgGWMcc4HW1YtoJwxpkno4/pAQWNMm5e8dwaw6q97lCzL6gLEMcb0D33cB/A3xox44bhmQDOAlClT5ps3b55Tvpd/49GjRyRIkMDVMeQ5uiYRk65LxBPRrkmMJ0/IMG8e6ebNJdgEM7hICD+WSEC19+tRPU114rg5528TgYExWLkyDXPnpufu3TjkyXOPBg0ukyvXA6ec73Ui2nV5U5cvX2bmzJls376dePHiUaNGDWrVqhWp70GK7NckqoqI1yXmw5h47Pcg6d6keOz3INafsTAxDA8+fsCdwne4U+gO/hn8o+xCDBHtmnh6eh4yxuR/3fucOaJ0HUj/3ON0wI03OLbkC8due/FNxphJwCSA/Pnzm5IlS774FpfZtm0bESmP6JpEVLouEU+EuSbGwJw5BHftjNuN35n3sYV3+TjULNeRM0W7kDiuc0YgXjaC5O0NxYsnAZI45ZxhEWGuyxs6ffo0vr6+zJ8/n/jx49OjRw86deqEh4eHq6O9tch6TaK6CHFdDPbNJn9NqduNPZKUDPtGlMpglbVInDgxiUnMe7znuqzhIEJck3/BmUXpAJDFsqxMwH+AL4Avw3jsemCgZVl//R+pLNDD8RFFRCRCOnCAoDatibnvAEfTWHRs7MZHn7dge/HepEqQyimn1BQ7xzp37hy+vr7MmTMHd3d3unXrRqdOnUiWLJmro4k4RwD2Qgx/laMroc/nBrpjL8RQEHstaIkUnFaUjDFBlmV9i1163IBpxpiTlmX5AgeNMSssyyoALMX+J7oqlmX1NcbkMMbctSyrH3bZAvD9a2EHERGJwm7cIKh7V2L+NJs7CSx6VIWg+l8yrZQvmZNkdsop/f3/Lkh//KGC9LbOnz9Pv379mD17NnHjxqVz58506dKF5MmTuzqaiONdB9ZgF6PNgD/gjr0QQ0/shRjSuSydvCWn7qNkjFmD/cvn+ee+e+7rA/zDLx9jzDRgmjPziYhIBBEQQPDwYYQMHEDI00CGFwW/hmXpXXkoOVPmdMopX1aQFixQQfq3Ll68SP/+/fnpp5+IHTs2HTp0oGvXrqRIkcLV0UQcJxjYz9+jRkdDn88INMReiKEkENcF2cThnFqUREREXskYQhYvwr9daxLcuMXybDD/m3y0rTua7hmKOuWUKkiOdenSJfr378/MmTOJFSsWbdq0oVu3bqRK5ZwpkiLh7j72/KjVwFrgNvZcqaLAEOwpddmJsgsxRGcqSiIi4hLm8GHutmhA0v3H+TUFjG2XmeqtxzLv/QpO2SxWBcmxrly5woABA5g+fTpubm60bt2a7t27kzp1aldHE3k7BjjD35u+7sQeSfIAKmCPGpXDlWu7SDhRURIRkfB18ya/dWhKyrkrMHGhT61k5OjxPRNzf+mUzWJVkBzr6tWrDBw4kGnTpmFZFs2bN6dHjx6kTavtDiUSCwC28/eUukuhz+cEumKXo0/QQgzRjIqSiIiEj6dPuTGwB4mGjiFZYBBTPnXHzduXPiXbENsttsNPp4LkWNevX2fQoEFMnjwZgCZNmtCjRw/Sp0//miNFIqgb/L3p6ybgMfa9RaWxy1FFIIPL0kkEoKIkIiLOZQy/z5+K6diRNL89ZOMHMbnUpwP1avUjfuz4Dj+dCpJj3bhxg0GDBjFp0iRCQkJo1KgRPXv25N1333V1NJE3E4K9nvJfo0aHQ5/PAHyNPWrkCcRzSTqJgFSURETEaW4d3M6tZvXJfvgaZ5NZrBtQi2odJlImnuMn96sgOdZvv/3GkCFDmDBhAkFBQTRs2JBevXqRMWNGV0cTCbsHwAb+j737jq+6uv84/jqZhBFG2Al7r4QlS0YgAVFQiXtRV63b6q9qta0FrW1tXbVqHW1pq1RttUZFUJQRFERk7y2ICZBAAoGE7JzfH+cmNwsMkOQm5P18PPJIcu/33nsuh5vcd87n+zkuHM0DDgF+wCjg97hGDP1RIwapkIKSiIhUufT9e9h891UM+2gVAUHw7m3nM/qpt7i5RdXXsSggVa3k5GT+8Ic/8Morr5CXl8ePfvQjfvWrX9G1a/XsYyVSpcbB4OTBcBsuHH0J5OMaL0zG24ghzHdDlLpDQUlERKrMiaxjLPvljxjy2kcMz7IsmtSdbi/+myt7DKv6x1JAqlIpKSk8/fTTvPzyy+Tk5DB9+nR+9atf0b17d18PTeTU9gMJwGLgGwjNDoUHcStFP8OFoxHoXa+cNv2XERGRs5ZXkMdnrz5EtydfZuLBfNb1C6PBi68wcfyVVf5YCkhV6/Dhwzz99NO89NJLZGdnc9111/HYY4/Rs2dPXw9NpGIH8QajBGCH5/KmQCM4EXaChssagk6jk7OkoCQiImes0Bbyybw/E/zIr5iyKZOkVg3Y8trjDLztUajivZAUkKpWamoqzzzzDC+++CInTpzg2muv5bHHHqN3796+HppIaSm4QJSAC0fbPJc3AcYCP8E1YYgCYiD3aC4NOzWs+XHKOUdBSURETpu1loXr3mf/z+/imoUp5AX6sfXBm+j9m1cIb9CgSh+rbECKiYF334UxY6r0YeqNtLQ0nnvuOV544QUyMzO56qqr+PWvf03fvn19PTQR5zClg9EWz+WNgTHALUA0MIjy72QTYF3COqKJrv5xyjlPQUlERE7LV3u/ZOnjt3LjuzuZcAK+vXQcXV7+N33aV+2GowpIVevIkSM8//zzvPDCCxw7dowrr7ySGTNm0K9fP18PTeq7NNxmr0WldBs9lzcCRgPTcStGg4FAH4xP6i0FJRERqZRNKZv498t3cNXry3j4IOyP6kbB67PpPmxElT6OAlKE+fXdAAAgAElEQVTVSk9P509/+hPPP/886enpXHbZZcyYMYPIyEhfD03qqyPAF3hXjDYAFrd/0fnANbgVo/NQMBKfUlASEZFT2nNkDy/+92eM/HM8v98C6W2akT37T7S/7kdVeh6SAlLVOnbsGC+88ALPPfccR48eZdq0acyYMYOBAwf6emhS36Tj2nQv9nyswwWjBrj9jB7HrRgNA4J8NEaRCigoiYiIV3Q0A48ehXXrSM5I5unPZhD2wl/53VeF+PkHcuKxB2n66GMQUnVb1ysgVa3jx4/z4osv8uyzz5KWlsbFF1/MzJkzGTx4sK+HJvXFcbzBKAFYAxQCwcBIYAbeYFS1pzSKVCkFJRERKSU9oIDnFvyK/a89zePzcwk/DieuiqPBs38mKCKiyh5HAalqZWRk8NJLL/HMM8+QmprKlClTmDlzJkOHDvX10ORclwEsxVtKtxoowJXNjQB+hSulG4ErrxOpIxSUREQEgOSMZGa2/JqdnXL47U2bGJ4EWYMj4eXXaDii6s5DUkCqWpmZmfzlL3/hj3/8I4cPH2by5Mk8/vjjDBtW9Zv8igCQCXyFt5RuFZCPe1c5HHgUF4xGAurSLXWYgpKISD23/uB6/vLFs5x47y1+tLaAid9CbpuW8K9nCbnhBvDzq5LHUUCqWidOnODVV1/lD3/4AykpKUyaNImZM2cycuRIXw9NzjVZeINRAvANkAf44xouPIQrpRuF61Qnco5QUBIRqYcKbSEfb5/D3P88SeTcVTy1EZpnQ25IEFltWxCycyc0blwlj6WAVLWysrJ47bXXeOqpp0hOTiYmJobHH3+c888/39dDk3NFNrAcbyndCiAXF4yGAP+HWzEajdvbSOQcpaAkIlKPZORm8HbCSxx8/VkuWXqY15IhLyiAwsvi4LY7CHr8cY6mpxNSBSHpxAl49VX44x8VkKpCbm4uL774Ir///e85cOAA48eP591332WM/kHlbOXgwlDRitFyz2V+uL2L7sOtGI0GQn0zRBFfUFASEakHvkv9ls9efYiW/5nDj7bkEVwAaf26UvDr/yPwuuuhWTN34BNPnPVjFQWkP/wBUlIUkM5WUlIS48aNY9++feTl5TF27FjeeustoqOjfT00qatyceVzCbhw9BVuFckAg4C78QajZr4ZokhtoKAkInKOstayetm77H1+BsMXbOO2Y3C8SRBpN11Nu/t+QYsq3nC0ooA0Y4YC0pnYsWMH8fHxxMfHs2LFCgAaNWrEp59+yvjx4zFVuH+V1AN5wEq8wWgZ7rwjgCjgDlwp3Vigec0PT6S2UlASETnH5B4/yqqXfkHQP2czdMdxBhnYObQrh+95iJZX30yT4OCT3zghgXUJCUSfxuMpIJ09ay1r1qwpDkdbtmwBYMiQITz55JPExcWRnJzM+PHjfTxSqRPycS26i0rpluI61QEMAH6MWzEaC4T5YHwidYSCkojIucBa0r9cwO5nf0X3z1YyKtvyXctAVtx5CQMefJreXXtW+UMqIJ2dgoICli5dWhyO9u3bh5+fH2PHjuX2229n2rRpdOzYsfj4lJQUH45WarV8YC3eFaMvcXsbAfQDbsIbjFrV/PBE6ioFJRGRuuzQIQ6++gwFf/sr4fuO0DsAlg1vR+id93PeNf9HJ//T+zEfHQ1Hjw5k3bqTH6OAdOays7NZsGAB8fHxfPTRRxw+fJjg4GAmTpzIjBkzuPjii2nVSu9k5QcUAOvx7mP0JXDMc11vYDqulC4aaF3zwxM5VygoiYjUNfn52E8/JfnFp2i58CvaFlhWRBgW3j2aoQ88zcRuVbc5bEkKSGfm2LFjzJs3j/j4eObNm0dGRgahoaFMmTKFuLg4Jk+eTJMmTXw9TKnNCoENeEvpvgCOeq7rCVyDWzGKBtrW/PBEzlUKSiIidcXOneT97XVy//FXGh1Kx68h/G10I8zNt3DZFY8xvFH1rEQoIJ2+lJQUPvzwQ+Lj41m4cCG5ubm0bt2aa6+9lri4OCZMmEDwqc4Vk/qtENiEt5RuCXDEc1134ApcMBoHhPtgfCL1hIKSiEhtlpkJ771HzuuvEPzVCvwMLOoBSy7vyuAfP8YtA68jyD+oWh5aAen07N27l/j4eN5//32WLVuGtZYuXbpwzz33EBcXx8iRI/H39/f1MKU2ssAWvKV0S4BUz3VdgDi8pXQdan54IvWVgpKISG1jLXz9NcyaRcHbb+GfeYK9YfCPWMPhyydz44WP8nTH0dXWIrqwEJ57TgHph1hr2bRpU3EzhnWeE7sGDBjAY489xmWXXUZkZKRaeUt5FtiGt5QuATjkua4TcDHeYNSppgcnIkUUlEREaovkZHjzTeysWZitWzkR7Mc7fQp5Z1gI/eNu597h99GleZdqeejMTEhIgF27IDk5lJ/9TAGpIoWFhaxYsaJ45Wj37t0YYxg5ciRPP/00cXFxdOvWzdfDlNrGAjvwltIlAMme6yKAyXjPMaqel7iInAEFJRERX8rLg08+gVmzsB9/jCkoYHXnIF65BFae35Efj3uA9wbeRGhwaJU+bGEhbNgA8+e7j6VL3VD8/KBx4wI+/thPAckjNzeXhIQE4uPj+fDDDzlw4AABAQFMmDCBBx98kEsvvZR27dr5ephSm1hgN95QtBg44LmuPRCLC0Xjga6AFh1FaiUFJRERX9i2Df7xD3jjDTh4kGPNGvK3UX68HllA26EjeWDEA7zecyr+flV3TktKCnz2mQtGn3/uFrAAIiPhpz+FCy6AJ56AY8cyGTOmWZU9bl2UmZnJ/Pnzef/99/n4449JT0+nYcOGXHjhhcTFxTFlyhSaNavf/0b1XjQMPDoQ1uGC0R5KB6Mkz3Ft8a4Wjcc1Y1AwEqkTFJRERGrK8ePw7rvw97/DV19R6O/HNwNb8fto+LxXLlcNvJ63h/+UQe0GVcnD5ebCsmUuGH32Gaxd6y5v2RImTnTBaNIkKLkY8uSTVfLQdVJaWhpz5swhPj6e+fPnk52dTYsWLYiLiyMuLo6JEycSEhLi62FKbZENQWlBcCMuHO3zXN4abyiKBnqhYCRSRykoiYhUJ2tdWpk1C/77X8jM5Gjndvz9snY83eUAhW0KuXPor3ntvDtp2/jsNkCxFnbu9K4aLV7szj0KCIBRo+C3v3XhaNAgV2InkJSUxAcffMD777/PkiVLKCgoICIigh//+MfExcUxduxYAgL0q1KAFNxK0SJgIbAbGtIQ5uEC0cO4cNQHBSORc4R++ouIVIcDB1xZ3axZsGMHhY0bsXZcTx7rsodPWh5gQJsB/G7Ek1w34DoaBDQ444dJT4dFi7znGu3d6y7v1g1uvNEFo+hoCK3aU5zqtO3btxd3qvvmm28A6N27Nw8//DBxcXEMHTpUneoEjuHadBcFo42ey0NxwQg45n+M0K2hoD88iJyTFJRERKpKbi7MnevC0SefQEEBGcMH8c695/NQs2846r+WqT2nsnDEA4zvPP6M3owXFMDq1d5g9PXX7rLGjV2XuocecuFIjde8rLWsWbOG999/n/j4eLZu3QrA0KFD+e1vf0tcXBx9+vTx8SjF57KAr/AGo1VAAdAAGA1cC8QAg3HvnqKh8GihQpLIOUxBSUTkbG3Z4sLRG2/AoUPYdu3Yees0ftP1e2Znf0OjwEbcPPB27h1+Lz3Dep723Sclec8z+vxzSEsDY2DwYPj5z10wGjkSAgPP/qkkJEBCwjqK/2ReR+Xn57N06VLi4+P54IMP2LdvH/7+/owdO5Y777yTadOm0aGDdu6s1/JxYWghLhwtA3IAf2AY8CguGI3AhaWyEmBdwjqi6/hrRUROTkFJRORMHDsG77zjAtKKFRAQQN7Ui/hkTFseMgvYcex/dAzuyNNjnubWQbfSPKR5pe86Kwu++MJ7rtHmze7ydu3g4otdMIqNhVatqum51VHZ2dl8/vnnxMfH89FHH5GamkpwcDCTJk1i5syZXHzxxbRs2dLXwxRfKQQ24Q1GS4DjnuuigLuBCcBYoIkvBigitY2CkohIZVnrEsysWa57XVYW9O1L6m9+wQs9Unlhz9scO36MUR1G8eSkp4jrE0eA3w//mLXWLUoVldN98QVkZ0NwsNvs9aabXHe6AQPcSpJ4paenM2/ePOLj45k3bx6ZmZmEhoYydepU4uLimDx5Mo0bN/b1MMUXivYyKgpGi4FDnut6ANfjgtF4QPlZRCqgoCQi8kOSkuBf/3IBafduCA3FTp/O+ilD+E3Wp3yw/Sn8dvhxZd8ruX/E/QwLH/aDd5maCgsWeEvqkjx7rvTpA3fc4YLRuHHQsGE1P7c6KDk5mQ8//JD4+HgWLlxIXl4ebdq04frrrycuLo4JEyYQFBTk62GKL+zHG4wW4W3ZHQ5ciAtGEwBVXYpIJSgoiYhUJCcH5sxx4Wj+fCgshOho8h/7Je/2LuTZ9a+weu3rNG/QnIdHPczdw+4mIjTipHeXl+cq9IpWjVatcitJzZu7MrpJk9xHx441+BzrkD179hR3qlu2bBnWWrp27cp9991HXFwcI0aMwN+/6jbnlToiDbeHUVE42ua5vAVupegR3HlGPVDLbhE5bQpKIiIlbdzowtGbb7pln4gI+MUvSLv6El5J+4yXV/6SA58eoHfL3rw65VWmR02nYWDFyz579niD0aJF7rQmPz8YPhxmzHDnGp13Huj9fXnWWjZu3FgcjtavXw9AZGQkM2bMIC4ujgEDBqiNd32TASzFG4zW4krsGuHOLfoxbsUoCnWjE5GzpqAkInL0KLz9tgtIq1a59nHTpsEtt7A5qj0vrHqJNz8cS3Z+NpO6TWLWpbOY1G0Sfqb0O7GMDLfJa1EThp073eUdO8LVV7tgFBMDzZr54DnWAYWFhXz99dfF4Wj37t0YYxg1ahTPPPMMcXFxdO3a1dfDlJqUA6zAG4y+xnWrCwJGAo/jgtEwoAq6PoqIlKSgJCL1U2Gh64U9axb873+ue8KAAfCnP1F43bXMP7qa579+js9f/5wGAQ34UeSPuG/4ffRr3a/UXaxf7101WrbMldg1bOg2eb3nHheOevZUE4aTyc3NZfHixcTHx/Phhx9y8OBBAgMDmTBhAg8//DCXXHIJbdu29fUwpaYU4FaJioLRl7j9jfyAIcCDuGB0PqDz90SkmikoiUj9sm+fa8zwj3+42rimTeGWW+CWW8js34s3NrzJC/8Zy/bU7bRr3I7fTvgtPxnyE1o2dG2xkpO9K0affw4pKe5uo6LggQfceUajR7uOdVKxzMxMPv30U+Lj4/n4449JT0+nUaNGXHjhhcTFxTFlyhSaNm3q62FKTbDAVrybvCYARz3X9cOV0sUA4wCtxIpIDVNQEpFzX04OfPCBWz36/HPXRSEmBp58EuLi+D73MC+vfJnX//Q6R7KPMKTdEGbHzebKfldi84NYtszbnW7dOneXrVp5GzBMmgRa9Di11NRU5syZQ3x8PJ999hnZ2dmEhYVx2WWXERcXR2xsLCEhIb4eptSEvXiD0SLgoOfyLsDluGA0HtBrSkR8TEFJRM5d69a5cPTvf0NaGnToAI895jYm6tKFFYkr+NO8W3h387tYLHG947h/+AO0zBrFZ58ZLvuFO+foxAl32tL558PvfufK6QYOdI0Z5OQSExP54IMPiI+PZ8mSJRQUFBAREcFtt91GXFwcY8aMISBAv4bOecm4PYyKgtG3nsvb4MroYjyfu/hkdCIiJ6XfUCJybklLg7fecgFp7VpXAxcX58rrJkwg31je3/o+f/r79SxPXE5ocCh39H+E/pn3sXZha254GL77zt1V9+5w880uGEVHQ5MmPn1mdcK2bduKmzGsXLkSgD59+vDzn/+cuLg4hgwZok5157p0YAneVaNNnsubAtHA/bhg1Be17BaRWk1BSUTqvsJCWLjQhaP4eFdqN2gQvPQSXHsttGjBkawj/PXrZ3npm5f4/mgS4cencWHGctI2nserK/0pKHBBKCYGHnnEldOpwdoPs9ayevXq4nC0detWAM477zx+97vfERcXR+/evX08SqlWWcAyvMFoFVAIhACjgetxq0aD0LsOEalT9CNLROquvXvhn/90jRn27XO7t/7kJ24ZaNAgAHak7uCFuY8x64vPyN42llYH3qDxjlEkpQex38DQofDoo27VaPhwV2Inp5afn8+XX35JfHw8H3zwAd9//z3+/v6MGzeOu+66i2nTphERcfLNd6WOywNW4g1GXwG5uHcUw4Ff4oLRCEBNTUSkDlNQEpG6JSvLrRrNmuVWkYyBiRPhj3+ESy+FBg2w1jJ38yKeeCOBlV80x+y+G3voZQAC28OUOBeMYmOhZUsfP586Ijs7m88//5z333+fOXPmkJqaSoMGDZg0aRJPPPEEF198MWFhYb4eplSHQmAD3mD0BW7jVwMMBO7FBaPRgMpTReQcoqAkIrWftbBmjQtHb73lNojt3Bkef9w1ZujYEWth1dpsnn5jBfPmF5C5cxQUTMA/MJ/RYwq4+CIXjvr1055GlZWens7cuXOJj4/nk08+ITMzk6ZNmzJ16lTi4uKYPHkyjRo18vUwpapZYBfe5guLgcOe63oC03HBKBpQNhaRc1i1BiVjzGTgBcAf+Ju19qky1wcDb+C2kUsFrrbW7jXGdMbtrLDdc+jX1to7qnOsIlILpabC7NkuIG3YAA0awOWXu8YM0dEcTvNjwQKI/8UJPvk0n+OpocBwgtvtZtI1u7nnuh7Ejg8iJER/E6qsffv2MWfOHJ566ikWLVpEXl4ebdu25YYbbuCyyy4jOjqaoKAgXw9TqloS3mC0EEj0XB4BTME1X5jg+V5EpJ6otncPxhh/4GVgIu5H7kpjzEfW2i0lDrsVOGKt7W6MuQb4A3C157rd1tqB1TU+EamlCgrcXkezZsGHH0JurjuR6C9/Ie+Ka/l6WzPmz4f5P4fVqy3WGgjJhq6fE3V5Mo/+aChXjRqpzmqVlJaWxuLFi1m4cCELFixg586dAHTr1o2f/vSnxMXFMWLECPzUC/3ckopbKSoKRjs8l4fhDUUxQHfUmU5E6q3q/DPrMGCXtfZbAGPMO8ClQMmgdCkw0/P1e8BLRu9uROqN6GbryM9vzNIMYPdu15ThX/+CxEQIC4M77+TbSXcw/7vezJ8Pi34Ox4+Dn38hjbtuwka/S4NeX3LrlCh+OvIeeoT18PVTqvWysrJYunRpcTBas2YN1loaN25c3IyhadOm3HTTTQqb55IM3LlFRcFoPa7ErjEwDrgdF4wGAMrEIiJA9QalcOD7Et8n4vrhVHiMtTbfGJOOt+K5izFmLXAM+JW19stqHKuI+ECwzSIm73MY/xAkJICfH8djprH4uneYnz6Cz+b6s+sFd2zHToX0j9nE7uavkNL6bZq3bcavh93LrYM/oFmDZj59HrVZQUEBq1evZsGCBSxcuJBly5aRk5NDQEAAI0eOZObMmcTExDBs2DACPS3/EhISFJLquhzga7zldCuAfCAIGAU8gQtGQwF1ehQRqZCx1lbPHRtzJXCBtfbHnu+nA8OstfeWOGaz55hEz/e7cStRGUBja22qMWYI8AHQz1p7rMxj/AT4CUCbNm2GvPPOO9XyXM5ERkYGjRs39vUwpATNSe0QdOgQYV9/TdjXX9PoqzUEk8PylpP4oPNtLDwxho07WpKf70eDBgUMHHiUngP3kBz+Bl/Yv5NVeIL+of25IuIKRrccjb/x9/XTqXWstXz//fesXr2aNWvWsHbtWjIzMwFXTjd48GCGDBlCZGQkISEhFd6HXiu10ynnpQCa7GxC8zXNaba2GU03NsU/xx/rZzne8zhHBh/h6OCjpPdPpzC4sGYHfg7Ta6V20rzUPrVtTsaPH7/aWjv0h46rzhWlRKBDie8jgP0nOSbRGBOA27c7zbr0lgNgrV3tCVA9cdvYFbPWvg68DjB06FAbHR1dDU/jzCQkJFCbxiOaE58pLIRVq+Djj93H2rUU4MfC1tfxe7/fsaJwGFmHQ+AwDBwIP/sZTJpkKYz4ipfXPseb2z7E3/pzdb+r+enwn3Je+Hm+fka1zv79+4tL6RYuXEhSUhIAnTt35tprryU2Npbx48fTunXrSt2fXiu1U6l5sbhC9qIVowQg3XNgf+AOYAKYcYbQpqGEEkonOtX0kM95eq3UTpqX2qeuzkl1BqWVQA9jTBdcP51rgOvKHPMRcCOwHLgCWGSttcaYVrjAVGCM6Qr0AL6txrGKSFU6dsw1ZJg7132kpGCNH+uibmT26Fd5a9sgDqYE4k8BLfyP8vo/Q5g4EZq3zOU/m/7Dg18/z9ov19IipAWPjn6Uu867i/DQcF8/q1ojPT2dhISE4mC0detWAMLCwoiJiSEmJobY2Fi6du3q45FKlYmGwcmD4We4YLQISPZc1xW4CteAYTzQxicjFBE551RbUPKcc3QPMB/XHnyWtXazMeYJYJW19iPg78CbxphdQBouTAGMBZ4wxuQDBcAd1tq06hqriFSB3bu9q0ZLlkBeHjRrxndjbuCtkFuZvb4/W9YFEBgIU6bA9Onwp5s3UViQxwVxhby66lX+suovHMw4SJ+WfXht6mvcEHkDDQMb+vqZ+Vx2djbLly8vDkYrV66ksLCQhg0bMnbsWG655RZiY2OJjIxUd7q6zgIpuA0ytpX4/DWE5oTCbUBb3PlFMbhw1Nk3QxUROddV6+Yi1tp5wLwyl/26xNfZwJUV3O5/wP+qc2wicpby8mDZMheM5s6Fbdvc5X36cPSOR3ivwQ3MXtGDJXNcU4DRo+HVB+DKK6FFC3cuzW9nFbC31Z/p8Px/ySnIYXL3ydw//H4mdZtUr5sJFBQUsG7duuJyui+//JLs7Gz8/f0ZNmwYv/zlL4mJiWHEiBEEBwf7erhyJgqAPZQOQ0Wfj5Q4rhHQG2gKJwJP0PCzhtAHtewWEakB2oVRRCrv8GH49FMXjj79FNLTISgIoqPJue0ePml4GbMXtGPOa277o1694Mkn4brroEsXyMjNYMG3C5i3bB7zds4j6bwkyA/m9oE3cd/w++jbqq+vn6FPWGvZtWtXcTBavHgxaWluEb1fv37cfvvtxMTEMG7cOEJDQ308WjktJ3Bbp5cNRDuA3BLHtcEFoKs9n3t7Pofj2nVHQ+7RXBr21QqriEhNUVASkZOzFjZt8q4aLV/umjO0aQOXX46dMpWvmlzA7Pcb8p8n4cgRaN0a7rwTbrgBhgyBXWk7+WjnPOYuncuS75aQW5BLk6AmTOw2kSk9phB2OIxLJ17q62da45KTk1m4cGFxONq3bx8AHTp04JJLLiE2NpYJEybQrl07H49UKuUQ5VeGtgLflTjGD3c+UW/gQryBqDfQ/AfuPwHWJawjmugqHbaIiJycgpKIlJadDYsXe8838ryBZ8gQeOwxmDKF7Y2HMPstP/79IOzZAw0bQlycC0djonNYvv9L/r1jLte9NJedaTsB6BXWi3vOu4cpPacwuuNogvyDANcJpz44fvw4S5YsKQ5GmzZtAqB58+aMHz+eRx55hJiYGHr06FGvyw5rtQJc8KmoXC61xHEhuPAzCrgV7+pQd6BBDY5XRETOioKSiEBSkrdD3YIFcOKESz8TJ7pwdNFFJPu35z//gTfvct2+/fwgNhYefxyGxxzgi4NzeW3nXK58fgEZuRkE+wcT3Tmae4fdy0U9LqJbi26+fpY1Kjc3lxUrVrBgwQIWLFjAN998Q35+Pg0aNGD06NFcf/31xMbGMmjQIPz9tR9UrZKFK42rqFwuu8RxrXAB6HJKl8t1wK0eiYhInaagJFIfVbC3EQCdOsEtt7i2dNHRZBY04MMPYfaP4bPPoKAABg2CZ54tpOfYNaw49gHP7ZzLur+uAyAiNILrB1zPlB5TmNBlAo2CGvnwSdaswsJCNm7cWNyZ7osvviAzMxM/Pz+GDh3KQw89RGxsLKNGjaJBAy0r1AqpVFwutxfXfQ5c04QuuAA0kdLlcmE1O1wREalZCkoi9UUFexvh5wejRsFTT8HUqdC3LwWFhkWL4M2fwPvvQ2YmdOwI9z6QRftRi1hv3+b3uz4ldW4qfsaPUR1G8fuY33NRj4sY0HpAvSob27NnT6mNXg8fPgxAr169uOmmm4iNjSU6OppmzZr5eKT1WCGwj4rL5Q6VOK4B0AsYhtvdr2h1qAeulE5EROodBSWRc9lJ9jbiwgvdqtHkyRAWhrWwbh3MfhDefhsOHICmTS2T49JoMewTtjR8nT8nLaNwQyFhIWFc2ONCLup+ERd0v4AWIS18/SxrzKFDh1i8eHFxMPr2W7cPdrt27bjwwguLN3uNiIjw8UjroRwqLpfbjiulKxKGC0CXUrpcriNuxz8REREPBSWRc8kp9jbi/vvdqtGoURDgXvr79sFbf4U334QtWyAw0DJ43EH63/gRW5s/w/+ydkEaDAoaxKOjH2VKjykMCx+Gv1/9eEeZmZnJl19+WRyM1q1zJYahoaFER0dz//33ExsbS+/evevVSppPHcEbgkoGoj241SNw5XKdcAFoPKUDUcsaHq+IiNRZCkoidd0p9jbizjvdylE3byOFo0fhvfdg9my3yATQNWo/fW9+j11tf8+K4IM0DmrMxE4TmdHj51zU4yLaN2nvm+dWw/Ly8li5cmVxMFq+fDl5eXkEBQUxatQonnzySWJiYhg6dCgBAfrxWW0s8D0Vl8sllzguGOgJDAauxxuGegLabkhERM6SftOL1DU/sLcRU6e6dnRNmhTfJDcXPvnErRx9/LElJ8fQPDyFllPe4nC3P/Ntiz30aNGDu3pcw5SeUxjTcQzBAcE+fJI1w1rL5s2bi88zWrJkCcePH8cYw6BBg3jggQeIiYlh9OjRNGyod95VLhfYScXlcpkljmuOC0BTKL061BmVy4mISLVRUBKpCyqxtxFDhrjmDB7WwldfuZWj//ynkCNH/AhuepTCIS6f6FMAACAASURBVG9Bv1lkdNhIdOdxTOnxUy7qcRE9wnr46MnVrH379hUHo0WLFnHw4EEAunfvznXXXUdsbCzjx48nLEwtzapMOuXD0FbgW9zeREU64gLQGEoHola4cjoREZEapKAkUltVYm8j2pcvidu+Hd580/KPN3PYv68BJjAb2/t/cNFswqK2MKX3BUzp8RgxXWNoHNTYB0+sZqWlpbF48eLicLRzp9sAt3Xr1sTExBAbG0tMTAydOnXy8UjrOAskUXG53IESxwXiSuMigavxBqJeQP3pJi8iInWAgpJIbXGyvY06d3Z7G02dCuPGQQV78KSkwD/ePMFf/5nF7k1hYAqh6xLMZW8xbMJ+Lokcz5QeTxHZJvKcbzqQlZXF0qVLi4PRmjVrsNbSqFEjoqOjufPOO4mNjaV///7n/L9FtcgDdlFxIMoocVxTXAi6gNKrQ13Qbx4REakT9OtKxJcqubcRFbyhz8y0vPRGIv94I5ft33SCwobQdhshU57ngmlHuHL4+VzQ7TnCGp7bJWQFBQWsXr26uAHDsmXLyMnJISAggJEjRzJjxgxiY2MZNmwYgYGBvh5u7RcNA48OhC9w5wqVDUO7gPwSx0fgAtDNlA5EbVC5nIiI1GkKSiI17VR7G02dChdcACc5P+Z49gn+9PYGZs+Gncv6Y3M6QNPvaD3xX1x6ZQY3ThzKiIjHz+n23dZatm/fXhyMFi9eTHp6OgCRkZHcfffdxMTEMHbsWBo3PvdLC89aIS78rPN8bITQ46FuRahIAG7j1b7AZZQul2uCiIjIOUlBSaS6nebeRmV9m7aH1+d+w3/eDmTv0pFwfAQ0OEqnUV9xxTU53HfVIDo2u7UGn1DNS0pKYuHChcXldPv37wegU6dOXHnllcTExDBhwgRat27t45HWcieATXhD0TpgA94OcwFAMOQ3zifo4SDv6lBX3LlFIiIi9YiCkkh1ONXeRnfd5brUde1a4U3zCvJY9v0y3l66jPh3Qzi0/AI4dDX459J12Dauuz6ZB2/sQ9PGk2r2OdWg9PR0EhISileNtm7dCkBYWBgTJkwobsDQtWtXnWd0MsnAekqHou14N2VtCgwEfuz5PBAXioLhq4SviI6OrukRi4iI1CoKSiJV4Qz2NiopOSOZT3Z9Qvy6xXw2J5Ts1ZfDd78EoEtkEjc+nMy9t7ShRYvImnxWNSY7O5vly5cXB6OVK1dSWFhISEgIY8eO5ZZbbiEmJoaoqCj8SrRAF1x77d2UDkTrKN1prhMuCF2FNxR1QucQiYiInIKCksiZ+qG9jaZOhcGDS+1tVKTQFrJ6/2rm7pzLnK3zWfNFa1g/HXa+BvkNaN/5OLfMyOHmHwXTtWt4DT+x6nf48GFWr17N6tWriY+PZ9OmTWRnZ+Pv78+wYcP4xS9+QWxsLCNGjCA4+Nzf+LbSKlM61w+YhDcQReE2bBUREZHToqAkcjrOcG8jgPTsdD7b/Rlzd85l3s5POLStO2yYTsDWTyGzKc3D8rjhzgCmT4ehQ5tU1OiuTioZioo+vvvuu+Lrg4ODuf3224mNjWXcuHGEhob6cLS1yFmUzomIiMjZU1ASOZWz2NvIWsvWw1uZu2Mu83bNY+m+peSndCV4y48J2PQHSGlDSIglLs5www0QGxtIXe9eXRSKVq1aVRyK9hWttAHdunVj+PDh3HXXXQwdOpRBgwaxfv36+n0+TAGlu84VhSOVzomIiPiUgpJIWWext1FWXhaL9y4uDkd7j+6FjFa0++7/aLXhDQ5s70Cen2VsjAtHcXHmZKct1XqHDh0qt1JUNhSNHDmSe+65hyFDhjB48GCaNWvmwxHXAieAjZQvnTvhuV6lcyIiIrWGgpIInNXeRt8d/c5TTjePRXsWkZWfRYgNo/fhR2i09iq2rejAgQLDoEHw4LNwzTXmZNV5tdYPhaLu3bsrFJWVTPkGCzsoXzp3GyqdExERqYUUlKR+OtneRn37wgMPuPbdJ9nbKK8gj+WJy5m7Yy5zd85l86HNAHRp2p1JPE3G+mms+Lw9azMMHTrAQw/BDTdAv341+QTPXMlQVFRC9/333xdfXzIUFZXP1etQVLZ0rujjYIljikrnrkalcyIiInWEgpLUD9HRDDp8GB555Iz2NkrJTOHTXZ8yd+dc5u+aT3pOOgF+AYzpOJZJDR/myDdTmf9acz48YGjaFK65xoWjMWMqbHpXa6SkpJRbKSoZinr06MH555/PkCFDGDJkiEJRZUvnLkClcyIiInWcgpKce3JzYccOt69R0ceKFYRmZ8P06dC2LVxxhXdvo8aNy91FoS1k7YG1zN3pVo1WJq3EYmnTqA2X9bmMYY2u4ODXE3jv6QY8vxkCA13Du+nTXd6qoLeDz51uKBo8eDBNmzb14Yh9TKVzIiIi9ZqCktRdBQXw7belA9GmTS4k5ee7Y/z9oVcvaNKE7GbNCJkz56R7Gx3LOcbnuz9n7s65fLLrEw5mHMRgOC/8PGZGz2Rs60vYsTSSt5734x9L3G3OPx9eeQWuvPKkpzD5RMlQVFQ+l5iYWHx9jx49GD16dKmVonobilQ6JyIiIhVQUJLaz1r4/nvYvLl0INqyxW36Cq4DXZcu0L8/TJvmPvfvDz17gmfD0hUJCUQPHVribi3bU7cXd6j78rsvySvMo2lwUy7ofgFTekxhQsfJrP6iNbNfgt/NgZwcd5dPPAHXX3/SSr0alZycXG6lqGQo6tmzJ2PGjFEoApXOiYiISKUpKEntkpJSfoVo82bXsrtIeLgLQXff7Q1EffpAo0Y/ePfZ+dkk7E0oDkffHvkWgH6t+vHAiAeY0nMKI8JHsnJFILNfhQf+C2lp0KoV3H67O+9o6NAKO4PXiNMJRUWNFurtBq4qnRMREZGzoKAkvnH0qAtAZVeJDh3yHhMW5kLQ9OneQNSvHzSv3J/3rbXsS9/HhuQNrE9ez7yN81j/1XpO5J0gJCCECV0m8ODIB7mox0V0ataJ7dvh33+Hm2bDnj0QEuIWp6ZPd6cy1fRmsCVDUVH5XFJSUvH1vXr1YuzYsaVWiuplKFLpnIiIiFQDBSWpXidOwNat5VeJSqyC0LixC0GXXuoNRP37Q+vWlV66ycrLYlPKpuJQtD55PRuSN3A0+2jxMREhEdw88GYu6nER4zuPJyQwhJQUeOcNmD0bVq50py7FxMDMmRAXR41tBnvw4MFyK0VFocgYQ8+ePRk3bpxCkUrnREREpIYoKEnVKNtprmilaPdud44RuHOF+vRx7bhLBqKOHSsdiKy1JB1PYv3B9aVC0Y7UHRRaV1PVKLARkW0iuabfNUS1jSKyTSQDWg9g9fLVREdHc+IEfPCeC0fz57ueEAMHwrPPurbe1b0ZbGVCUXR0dKlQ1KSmElttotI5ERER8SEFJTk9BQWuLq3sCtH27aU7zfXsCYMGlS6b69q1wg1cTyY7P5sth7aUC0VpWWnFx3Ru1pmoNlFc1feq4lDUtXlX/EzprnZjxsD+/UMZPRrefx8yMijeDPb6693wqkPJUFRUPrd//37AhaJevXopFBUA21HpnIiIiNQqCkpSMWtdeVzZpgpbtkBWlve4ok5zl1ziDUS9ehV3mqvcQ1kOZhx0QejgejakbGD9wfVsO7yNAlsAQEhACAPaDODyPpcT1SaKqLZRDGg9gKYNmpa5L9i3D9av935s2AA7dwI0JjW1+jaDPXDgQLmVorKhaPz48cWNFgYOHFg/QtFxIAlILPPZ8/WYLWPA07xQpXMiIiJSWygoiWugUHaFaNOm0p3m2rd3IejOO0t3mqtgs9ZTyS3IZeuhreVC0aET3iYOHUI7ENU2imm9pxWHom7Nu+Hv51/qvrKy3HlFJQPRhg2uT0SRbt0gKspVBvr5ZbBlS+Mq2Qy2MqFowoQJxStF52QoKgQOUSr0VBSEOF7BbZsDEUA4HOhygIipESqdExERkVpFQak+SU8v32Vu82bXkrtIixYuBN1wQ+lOcy1anPbDpWSmsP7g+lLNFbYe2kpeYR4Awf7B9G/dn4t7XkxU2yii2kQxoM0AWoSUfixrISnJG4aKgtGOHVDoOV+lUSOIjHSrRVFR7mPAgNI5LiFhFQ0aRJ/28ygbilatWsWBAwcAF4p69+597oWiXGA/5UNPyc/7gbwyt/MD2gHhuNATS3EgItzzdXugofcmuxJ2EREdUW1PRURERORMKCidi7KyKu409/333mMaNXIh6OKLvWGof39o2/a0NwnKK8hje+r2cqHoYIb3JJPwJuFEtonkou4XFYeiHmE9CPAr/V8wJwfWri1dOrd+vdvLqEjnzi4IXXWVNxR16VI1ZXT79+8vt1JUNhTFxMSUKp9rfJqraj53jJOv/hR9nVLB7ULwhp7RlA9A4UAb9FNFREREzgl6S1OX5eWV7jRX9FGy01xQkCuRGzu2fKe5M0gWqSdSi8vmikLRlkNbyC3IdQ/nH0TfVn25oNsFxWVzkW0iadmwZbn7OniwfCDats31iwC3j9GAAXD55aVXiZo2LXdXZ+SHQlGfPn2IjY0ttVJUq0NRIS7gnCwAFX3OqOC2YXgDz1BKh5+ir5uh5gkiIiJSbygo1QVFnebKls1t3+7CErjQ07On63NdVDbXrx90735aneaK5BfmszN1Z7lQtP/4/uJj2jZuS2SbSCZ2nVgcinqF9SLQv/TOrLm5pUvmikroSlb8dejggtC0aa6ELirKDd2/9GlJp81ay9GjR0lKSmLZsmUkJCQUl88dPOhWvPz8/Ojdu3ftDkU5eIPPyYLQfiC/zO38caVwEUB/YDLlV4Ha41aLRERERKSYglJtUnQyTtkVorKd5jp3dkFo6tTSnebOsEvBkawj3vbbnlC0+dBmsvNdK7IAvwD6turLhC4TXCDyhKLWjVqXu69Dh8oHoi1bvHkuONg79KJAFBl5RqdAUVhYyOHDh0lMTCz1kZSUVOr7EydOFN+mKBRNmjSpVChq1KjRGf3bnTULpPPDDREOV3DbhnjDzjjKB6AIoDUuLImIiIjIaVFQ8pWiTnNlV4nS073HtGvnUsUdd3jPIerbF86wUUBBYQG70naV2pNo/cH1fH/Me+5Sy4YtiWoTxV1D7yo+l6hPqz4E+QeVuq/8fDf0koFo/XrwVK4BrlFeZCRMnuwtnevZs3ILXPn5+Rw8ePCk4afosry80t0EAgICCA8PJzw8nIEDBzJ16lQiIiKIiIjg0KFD3HjjjTUXigpwpXCnKoNLAjIruG1LvIFnGBWfD9QUlcKJiIiIVBMFpep27Fj5MLRpU+m6s+bNXQi67rrSnebCws74YdOz09mQvKFUKNqUsokTeW51xd/407tlb8Z0GkNk68jiUNS2cVtMmWYOaWnlS+c2b3aNFwACA11+mzjRG4giI6FVq4rHlpOTUxx8ThaADhw4QGFRSzuPBg0aFIee0aNHF38dHh5e/HXr1q3xO8m5VwkJCVUXkrI5dRlcUSlcQZnbBeBK3cKBSOAiyp8P1B6oghbmIiIiInLmFJSqQ5cunJ+a6gLQvn3eyxs1cgGoqGSuaJWoXbvT7jRXpNAW8u2Rb92eRCVC0d6je4uPaRHSgqg2Ufxk8E+IbONCUd9WfWkQUPrdeEGB6w1RtsFCYqL3mNatXRC6915vKOrd24UlgIyMDJKSktiwIfGkJXGHDh2irNDQ0OKw079//1Lhp+ijefPm5UJclbPAUU5dBpcEpFZw28Z4Q894ypfBheNK4apwk1sRERERqR4KStUhPR2/vDwYPbp0p7lOnc6qh/XxnONsTNlYKhRtTNlIRq5rY+Zn/OgZ1pPh4cO5bfBtxecShTcJLxcw0tNhZZlVok2bvKdCBQS4ADRuXNEKkaVTp6Pk5XmDz86diSQklF4RSi9ZOujRsmXL4pWfYcOGlQtA4eHhNbPvUAGl9wY6WUlcVgW3bYULOx2BUVR8PlBo9Q5fRERERGqOglJ1SE3lyyVLiI6OPqObW2vZe3Rv8TlEG1I2sP7genYf2V18TNPgpkS1jeLmgTe7VaI2UfRr3Y+GgQ1L3VdhoesWXrbBwt693mNatCikb99DxMUl0rJlIiEhiRQWJnHwoAs/33zjPmdllU4Qxhjatm1LREQEPXv2ZMKECeXK4dq3b09ISDW0VMvDreqU/Th8ksu+hXF548rfTyDeUrhBwFTKnw/UDgiu+qcgIiIiIrWXglJ1OI3ysMzcTDalbCoVijYkb+BYzjF3Vxi6t+jOoHaDuGngTcWhqGPTjuVWiY4fh69Wlg5EGzbkk5l5AEjEmERat06iWbNEBgxIpKAgkWPHEklO3s/SpRU3RYiIiGDw4MFccskl5crh2rZtS2BRzd2ZssAJKhd2Sn5/7BT3GYxrhhDm+RgARMO+zH10GtWpdBBqhUrhRERERKQcBaUaYq3l+2Pfl9qTaEPyBnam7sTiNodtEtSEyDaR3DDghuLmCv1b96dRUKMy9+VWhFauzOarr5JYsyaR7duTSElJxNWOJeLvn4i/fxJ5eQdxO5G62yUnw7FjIcWrPoMHj6mwFO5UTRFOqhDX6rqyYafospxT3Gco3sATBvQq830YpUNRGK5tdgVZdU/CHjpFdzq95yQiIiIi9ZKCUjXIysti+/Ht7F6zu1QoOpp9tPiYrs27EtUmiuv6X0dU2ygi20TSuVln/IwLJ8ePHycpKYnF65bzzTeJbNiQyK5diezfn0R6eiKFhRVvrtOoUVPatw+nS5cIIiIGVNgZrlJNEfJwra0rG3ZSgTSKMll5fkALvMGmMzCEk4edMM/xQRXcl4iIiIhINVNQqgbn/fU8Nh/aDGugUWAjBrQZwNX9riaqjQtE4YHhHDt0zDVA2JHImkVr+ChxDrt3J7JnTyIpKYnk5JSvLTOmJQ0bRtChQwSdOo2gd+9wBg+OoFu3UzRFKFvatobqKW2rKOiUDEBNUYmbiIiIiNQZCkrV4ET8j2iVlsRdVzcnOy2bpK1JbE/czsLEhSQlJZVrigAGY9phbQSutiyGFi0i6No1gv79Ixg+PILo6Pb07N4Av+OUDzYbgQTOvrStJeVL2yoKQCcpbRMREREROVcoKFWD7xb9hsLCDB5fA4GBgTRv3p6QkAisHUJIyKVkZ0d4QlE4IcERDOjalkEdAolqBVFNoH8ghGbggs5OYDnwGJUrbSsKNp3xlrZVFHZaeo4/y14MIiIiIiLnomoNSsaYycALgD/wN2vtU2WuDwbewL2lTwWuttbu9Vz3KHArbveb+6y186tzrFWpf9MFpGUYTgR0Ii2rFSkpruasUxCMDoCoQIjMhSigWw74bQW2lriDBpQONZGcuqxNpW0iIiIiIlWq2oKSMcYfeBmYiGvFttIY85G1dkuJw24FjlhruxtjrgH+AFxtjOkLXAP0w+1ys8AY09NaW1Bd461KLY4NJ7gAovIgsgFENYPIdtCsDT9c1tYSV9omIiIiIiI+U50rSsOAXdbabwGMMe8AlwIlg9KlwEzP1+8BLxnXju1S4B1rbQ6wxxizy3N/y6txvFWm1VAwx9P567qmKm0TEREREamDqrNYKxz4vsT3iZ7LKjzGWpuP24UnrJK3rbVSGkBaoFVIEhERERGpo6pzRamivmi2ksdU5rYYY34C/ASgTZs2JCQknOYQq8fMmZCRkUFCQmNfD0VKcHOS4OthSBmal9pHc1I7aV5qH81J7aR5qX3q6pxUZ1BKBDqU+D4C2H+SYxKNMQG4lgRplbwt1trXgdcBhg4daqOjo6tq7GctISGB2jQe0ZzUVpqX2kdzUjtpXmofzUntpHmpferqnFRn6d1KoIcxposxJgjXnOGjMsd8BNzo+foKYJG11nouv8YYE2yM6QL0AL6pxrGKiIiIiIgUq7YVJWttvjHmHmA+rj34LGvtZmPME8Aqa+1HwN+BNz3NGtJwYQrPcf/FNX7IB+6uKx3vRERERESk7qvWfZSstfOAeWUu+3WJr7OBK09y298Cv63O8YmIiIiIiFREW5SKiIiIiIiUoaAkIiIiIiJShoKSiIiIiIhIGQpKIiIiIiIiZSgoiYiIiIiIlKGgJCIiIiIiUoaCkoiIiIiISBkKSiIiIiIiImUoKImIiIiIiJShoCQiIiIiIlKGgpKIiIiIiEgZCkoiIiIiIiJlKCiJiIiIiIiUoaAkIiIiIiJShoKSiIiIiIhIGcZa6+sxVAljzCHgO1+Po4SWwGFfD0JK0ZzUTpqX2kdzUjtpXmofzUntpHmpfWrbnHSy1rb6oYPOmaBU2xhjVllrh/p6HOKlOamdNC+1j+akdtK81D6ak9pJ81L71NU5UemdiIiIiIhIGQpKIiIiIiIiZSgoVZ/XfT0AKUdzUjtpXmofzUntpHmpfTQntZPmpfapk3Oic5RERERERETK0IqSiIiIiIhIGQpKZ8kYM9kYs90Ys8sY80gF1481xqwxxuQbY67wxRjrm0rMyf8ZY7YYYzYYYxYaYzr5Ypz1TSXm5Q5jzEZjzDpjzFJjTF9fjLM++aE5KXHcFcYYa4ypcx2L6ppKvE5uMsYc8rxO1hljfuyLcdY3lXmtGGOu8vxu2WyMeaumx1jfVOK18nyJ18kOY8xRX4yzvqnEvHQ0xiw2xqz1vA+7yBfjrCyV3p0FY4w/sAOYCCQCK4FrrbVbShzTGQgFHgQ+sta+V/MjrT8qOSfjgRXW2hPGmDuBaGvt1T4ZcD1RyXkJtdYe83x9CXCXtXayL8ZbH1RmTjzHNQHmAkHAPdbaVTU91vqikq+Tm4Ch1tp7fDLIeqiS89ID+C8wwVp7xBjT2lqb4pMB1wOV/flV4vh7gUHW2ltqbpT1TyVfK68Da621r3j+IDrPWtvZF+OtDK0onZ1hwC5r7bfW2lzgHeDSkgdYa/daazcAhb4YYD1UmTlZbK094fn2ayCihsdYH1VmXo6V+LYRoL/iVK8fnBOP3wB/BLJrcnD1VGXnRGpWZeblNuBla+0RAIWkane6r5VrgbdrZGT1W2XmxeIWEACaAvtrcHynTUHp7IQD35f4PtFzmfjO6c7JrcAn1ToigUrOizHmbmPMbtwb8/tqaGz11Q/OiTFmENDBWvtxTQ6sHqvsz6/LPSUr7xljOtTM0Oq1ysxLT6CnMWaZMeZrY4xWw6tXpX/Xe8rruwCLamBc9V1l5mUmcIMxJhGYB9xbM0M7MwpKZ8dUcJn+Cu5blZ4TY8wNwFDg6WodkUAl58Va+7K1thvwc+BX1T6q+u2Uc2KM8QOeB35WYyOSyrxO5gCdrbWRwALgX9U+KqnMvAQAPYBo3OrF34wxzap5XPXZ6bz/ugZ4z1pbUI3jEacy83It8E9rbQRwEfCm5/dNrVRrB1ZHJAIl/5oXQS1fQqwHKjUnxphY4JfAJdbanBoaW312uq+Vd4Bp1Toi+aE5aQL0BxKMMXuBEcBHauhQrX7wdWKtTS3xM+uvwJAaGlt9VpmfX4nAh9baPGvtHmA7LjhJ9Tid3ynXoLK7mlKZebkVdz4f1trlQAOgZY2M7gwoKJ2dlUAPY0wXY0wQ7sX4kY/HVN/94Jx4yolew4Uk1ZHXjMrMS8k3FVOAnTU4vvrolHNirU231ra01nb2nGj7Ne41o2YO1acyr5N2Jb69BNhag+Orryrzu/4DYDyAMaYlrhTv2xodZf1SqfdfxpheQHNgeQ2Pr76qzLzsA2IAjDF9cEHpUI2O8jQoKJ0Fa20+cA8wH/fL6r/W2s3GmCc8XbswxpznqcO8EnjNGLPZdyM+91VmTnCldo2Bdz1tQxVuq1kl5+UeT1vddcD/ATf6aLj1QiXnRGpQJefkPs/rZD3uPL6bfDPa+qOS8zIfSDXGbAEWAw9Za1N9M+Jz32n8/LoWeMeqxXONqOS8/Ay4zfMz7G3gpto8P2oPLiIiIiIiUoZWlERERERERMpQUBIRERERESlDQUlERERERKQMBSUREREREZEyFJRERERERETKUFASEZGzYoyJM8ZYY0zvGnzM+40xDWvq8c6EMSbaGDPK1+MQEZEzo6AkIiJn61pgKW5zwZpyP+DzoGSMCTjF1dGAgpKISB2loCQiImfMGNMYOB+4lTJByRjzsDFmozFmvTHmKc9l3Y0xCzyXrTHGdPNc/pAxZqUxZoMx5nHPZZ2NMduMMf/yXP6eMaahMeY+oD2w2Biz2HPsK8aYVZ7NWB8vMYa9xpjHPY+1sWjVyxjT2BjzD89lG4wxl3sun2SMWe45/l3P8yv7nBOMMb8zxiwBfmqMudgYs8IYs9bz3NoYYzoDdwAPeDa2HmOMaWWM+Z/nea40xpxftbMhIiJV6VR/CRMREfkh04BPrbU7jDFpxpj/b+9uQqys4jiOf38KJeFYTlGKZQa9kFiE2IsUvTEIQouKCCYQo6SFhAsLXZQgIdhiqKBFLwuLKEt6GZiCaiJa1KSLsjSrZaC1aijMtFrEr8Xzv3h5mhuXkbhBv8/mnuf/nHOec+/m8ud/7rkrbe+XtLbuXWv7hKTh6v8K8LjtcUnzgDmS1gCXANcAAiYk3QgcBi4D7rc9JWkXsNH2mKTNwC22p2veR2z/JGku8KGkK20frHvTtldK2gg8DGwAtgFHbV8BIGmhpHOAR4ER28clbQU2A4/N8L7Psn1TZyxwnW1L2gBssf2QpGeBX22PVb/dwJO2P5G0lObf6y8/xc8/IiL+JUmUIiLiVIwCT1X7tbreD4wAL9g+AVBJzBCwxPZ4xX6HpooDrAG+qHnm0yROh4Ejtqcq/jKwCRibYR13S3qA5nttMbAc6CRKb9Xr58Cd1R6hqwJm+2dJt9W4KUkApwF7e7zvPV3t84E9khbXmO96jBkBltfcAAskDdk+1qN/REQMUBKliIiYFUlnA7cCKyQZmAtY0haaypDbQ3pNBey0/Vxr/mUzzNG+RtJFNJWiqyvheRGY19Xlj3r9k5Pfe73W94Ht0R7r7Ha8q/008ITtzRfT9gAAAXNJREFUCUk3A9t7jJkDrLb9Wx/zR0TEgOU3ShERMVt3AS/ZvtD2MtsX0FRTbgAmgfs6J9NJGrb9C/C9pNsrdnrdf7/6zq/4Eknn1jOWSlpd7c6hEQDHgKFqL6BJXI5KOg9Y28faJ4EHOxe1fW4fcL2kiyt2hqRL+5jrTOCHaq/vinevcaZnXtXH3BERMSBJlCIiYrZGgfFW7E3gHtvvARPAZ5K+pKn4AKwDNkk6CHwKLLI9CewG9kr6CniDkwnGt8D66j8MPFPx54F3JX1k+wDNtr2vgV1AZ6veP9kBLJR0SNIBmt87/QjcC7xaz9sH9HPk+XbgdUkfA9Nd8beBOzqHOdBsG1xVh0d8Q3PYQ0RE/EfJ/tsuhoiIiIGrrXfv2F4x4KVERMT/UCpKERERERERLakoRUREREREtKSiFBERERER0ZJEKSIiIiIioiWJUkREREREREsSpYiIiIiIiJYkShERERERES1JlCIiIiIiIlr+AuOSoSWILWqKAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.005264   0.002192   0.00982052 0.0024     0.00374226]\n",
      " [0.020592   0.00848    0.02420321 0.01774236 0.0128507 ]\n",
      " [0.045072   0.017448   0.04904311 0.04793028 0.02959571]\n",
      " [0.081872   0.033168   0.08121554 0.07111066 0.05171983]\n",
      " [0.126304   0.04644    0.12945698 0.11302403 0.07829868]\n",
      " [0.182592   0.068232   0.18199805 0.18157928 0.12062678]\n",
      " [0.246712   0.089384   0.24644845 0.25673201 0.16885112]\n",
      " [0.320464   0.11408    0.32160807 0.32028404 0.23373392]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.081181\n",
      "0.0022437312620555002\n",
      "0.005478239914242801\n",
      "0.04118162396552446\n"
     ]
    }
   ],
   "source": [
    "failure_rates = np.zeros((8, 5))\n",
    "failure_sems = np.zeros((8, 5))\n",
    "\n",
    "nIter = 5\n",
    "\n",
    "for r in np.arange(1, 9):\n",
    "\n",
    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
    "\n",
    "    f_rate_true = np.zeros(nIter)\n",
    "    f_rate_label = np.zeros(nIter)\n",
    "    f_rate_human = np.zeros(nIter)\n",
    "    f_rate_cont = np.zeros(nIter)\n",
    "    f_rate_caus = np.zeros(nIter)\n",
    "\n",
    "    for i in range(nIter):\n",
    "\n",
    "        print(i, end=\" \")\n",
    "\n",
    "        # Create data\n",
    "        train_labeled, train, test_labeled, test, df = dataWithUnobservables()\n",
    "\n",
    "        # Fit model and calculate predictions\n",
    "        logreg, predictions = fitLogisticRegression(\n",
    "            train_labeled.dropna().X,\n",
    "            train_labeled.dropna().result_Y, test.X, 0)\n",
    "\n",
    "        # Attach the predictions to data\n",
    "        test = test.assign(B_prob_0_logreg=predictions)\n",
    "\n",
    "        logreg, predictions_labeled = fitLogisticRegression(\n",
    "            train_labeled.dropna().X,\n",
    "            train_labeled.dropna().result_Y, test_labeled.X, 0)\n",
    "\n",
    "        test_labeled = test_labeled.assign(B_prob_0_logreg=predictions_labeled)\n",
    "\n",
    "        # True evaluation\n",
    "        #\n",
    "        # Sort by failure probabilities, subjects with the smallest risk are first.\n",
    "        test.sort_values(by='B_prob_0_logreg', inplace=True, ascending=True)\n",
    "\n",
    "        to_release = int(round(test.shape[0] * r / 10))\n",
    "\n",
    "        # Calculate failure rate as the ratio of failures to those who were given a\n",
    "        # positive decision, i.e. those whose probability of negative outcome was\n",
    "        # low enough.\n",
    "        f_rate_true[i] = np.sum(\n",
    "            test.result_Y[0:to_release] == 0) / test.shape[0]\n",
    "\n",
    "        # Labeled outcomes only\n",
    "        #\n",
    "        # Sort by failure probabilities, subjects with the smallest risk are first.\n",
    "        test_labeled.sort_values(by='B_prob_0_logreg',\n",
    "                                 inplace=True,\n",
    "                                 ascending=True)\n",
    "\n",
    "        to_release = int(round(test_labeled.shape[0] * r / 10))\n",
    "\n",
    "        f_rate_label[i] = np.sum(\n",
    "            test_labeled.result_Y[0:to_release] == 0) / test_labeled.shape[0]\n",
    "\n",
    "        # Human evaluation\n",
    "        #\n",
    "        # Get judges with correct leniency as list\n",
    "        correct_leniency_list = test_labeled.judgeID_J[\n",
    "            test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
    "\n",
    "        # Released are the people they judged and released, T = 1\n",
    "        released = test_labeled[\n",
    "            test_labeled.judgeID_J.isin(correct_leniency_list)\n",
    "            & (test_labeled.decision_T == 1)]\n",
    "\n",
    "        # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
    "        f_rate_human[i] = np.sum(\n",
    "            released.result_Y == 0) / correct_leniency_list.shape[0]\n",
    "\n",
    "        # Contraction, logistic regression\n",
    "        #\n",
    "        f_rate_cont[i] = contraction(test_labeled, 'judgeID_J', 'decision_T',\n",
    "                                     'result_Y', 'B_prob_0_logreg',\n",
    "                                     'acceptanceRate_R', r / 10)\n",
    "\n",
    "        # Causal model - empirical performance\n",
    "\n",
    "        released = bailIndicator(r * 10, logreg, train.X, test.X)\n",
    "\n",
    "        #released = cdf(test.X, logreg, 0) < r / 10\n",
    "\n",
    "        f_rate_caus[i] = np.mean(test.B_prob_0_logreg * released)\n",
    "\n",
    "        #percentiles = estimatePercentiles(train_labeled.X, logreg, N_sample=train_labeled.shape[0])\n",
    "\n",
    "        #def releaseProbability(x):\n",
    "        #    return calcReleaseProbabilities(r*10, train_labeled.X, x, logreg, percentileMatrix=percentiles)\n",
    "\n",
    "        #def integraali(x):\n",
    "        #    p_y0 = logreg.predict_proba(x.reshape(-1, 1))[:, 0]\n",
    "\n",
    "        #    p_t1 = releaseProbability(x)\n",
    "\n",
    "        #    p_x = scs.norm.pdf(x)\n",
    "\n",
    "        #    return p_y0 * p_t1 * p_x\n",
    "\n",
    "        #f_rate_caus[i] = si.quad(lambda x: integraali(np.ones((1, 1))*x), -10, 10)[0]\n",
    "\n",
    "    failure_rates[r - 1, 0] = np.mean(f_rate_true)\n",
    "    failure_rates[r - 1, 1] = np.mean(f_rate_label)\n",
    "    failure_rates[r - 1, 2] = np.mean(f_rate_human)\n",
    "    failure_rates[r - 1, 3] = np.mean(f_rate_cont)\n",
    "    failure_rates[r - 1, 4] = np.mean(f_rate_caus)\n",
    "\n",
    "    failure_sems[r - 1, 0] = scs.sem(f_rate_true)\n",
    "    failure_sems[r - 1, 1] = scs.sem(f_rate_label)\n",
    "    failure_sems[r - 1, 2] = scs.sem(f_rate_human)\n",
    "    failure_sems[r - 1, 3] = scs.sem(f_rate_cont)\n",
    "    failure_sems[r - 1, 4] = scs.sem(f_rate_caus)\n",
    "\n",
    "x_ax = np.arange(0.1, 0.9, 0.1)\n",
    "\n",
    "plt.figure(figsize=(14, 8))\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 0],\n",
    "             label='True Evaluation',\n",
    "             c='green',\n",
    "             yerr=failure_sems[:, 0])\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 1],\n",
    "             label='Labeled outcomes',\n",
    "             c='magenta',\n",
    "             yerr=failure_sems[:, 1])\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 2],\n",
    "             label='Human evaluation',\n",
    "             c='red',\n",
    "             yerr=failure_sems[:, 2])\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 3],\n",
    "             label='Contraction, log.',\n",
    "             c='blue',\n",
    "             yerr=failure_sems[:, 3])\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 4],\n",
    "             label='Causal model, ep',\n",
    "             c='black',\n",
    "             yerr=failure_sems[:, 4])\n",
    "\n",
    "plt.title('Failure rate vs. Acceptance rate with unobservables')\n",
    "plt.xlabel('Acceptance rate')\n",
    "plt.ylabel('Failure rate')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "print(failure_rates)\n",
    "print(\"\\nMean absolute errors:\")\n",
    "for i in range(1, failure_rates.shape[1]):\n",
    "    print(np.mean(np.abs(failure_rates[:, 0] - failure_rates[:, i])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Without unobservables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 0 1 2 3 4 [2] 0 1 2 3 4 [3] 0 1 2 3 4 [4] 0 1 2 3 4 [5] 0 1 2 3 4 [6] 0 1 2 3 4 [7] 0 1 2 3 4 [8] 0 1 2 3 4 "
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.01592    0.005728   0.02139331 0.0150846  0.01577991]\n",
      " [0.042      0.01616    0.04126017 0.03929379 0.04248489]\n",
      " [0.074528   0.02756    0.0763992  0.07527238 0.07662577]\n",
      " [0.11492    0.040664   0.12183729 0.11392414 0.1152359 ]\n",
      " [0.1634     0.056664   0.15907742 0.16494027 0.16069447]\n",
      " [0.213856   0.070952   0.22093032 0.20375053 0.21518658]\n",
      " [0.27124    0.084888   0.26991842 0.27906662 0.27472274]\n",
      " [0.342664   0.097256   0.34408503 0.33531832 0.34245826]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.104832\n",
      "0.003642642230080494\n",
      "0.004012485889942298\n",
      "0.0013454046105136883\n"
     ]
    }
   ],
   "source": [
    "f_rates = np.zeros((8, 5))\n",
    "f_sems = np.zeros((8, 5))\n",
    "\n",
    "nIter = 5\n",
    "\n",
    "for r in np.arange(1, 9):\n",
    "\n",
    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
    "\n",
    "    s_f_rate_true = np.zeros(nIter)\n",
    "    s_f_rate_labeled = np.zeros(nIter)\n",
    "    s_f_rate_human = np.zeros(nIter)\n",
    "    s_f_rate_cont = np.zeros(nIter)\n",
    "    s_f_rate_caus = np.zeros(nIter)\n",
    "\n",
    "    for i in range(nIter):\n",
    "\n",
    "        print(i, end=\" \")\n",
    "\n",
    "        s_train_labeled, s_train, s_test_labeled, s_test, s_df = dataWithoutUnobservables()\n",
    "\n",
    "        s_logreg, predictions = fitLogisticRegression(\n",
    "            s_train_labeled.dropna().X,\n",
    "            s_train_labeled.dropna().result_Y, s_test.X, 0)\n",
    "        s_test = s_test.assign(B_prob_0_logreg=predictions)\n",
    "\n",
    "        s_logreg, predictions_labeled = fitLogisticRegression(\n",
    "            s_train_labeled.dropna().X,\n",
    "            s_train_labeled.dropna().result_Y, s_test_labeled.X, 0)\n",
    "        s_test_labeled = s_test_labeled.assign(\n",
    "            B_prob_0_logreg=predictions_labeled)\n",
    "\n",
    "        #### True evaluation\n",
    "        # Sort by actual failure probabilities, subjects with the smallest risk are first.\n",
    "        s_sorted = s_test.sort_values(by='probabilities_Y',\n",
    "                                      inplace=False,\n",
    "                                      ascending=True)\n",
    "\n",
    "        to_release = int(round(s_sorted.shape[0] * r / 10))\n",
    "\n",
    "        # Calculate failure rate as the ratio of failures to successes among those\n",
    "        # who were given a positive decision, i.e. those whose probability of negative\n",
    "        # outcome was low enough.\n",
    "        s_f_rate_true[i] = np.sum(\n",
    "            s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
    "\n",
    "        #### Labeled outcomes\n",
    "        # Sort by estimated failure probabilities, subjects with the smallest risk are first.\n",
    "        s_sorted = s_test_labeled.sort_values(by='B_prob_0_logreg',\n",
    "                                              inplace=False,\n",
    "                                              ascending=True)\n",
    "\n",
    "        to_release = int(round(s_test_labeled.dropna().shape[0] * r / 10))\n",
    "\n",
    "        # Calculate failure rate as the ratio of failures to successes among those\n",
    "        # who were given a positive decision, i.e. those whose probability of negative\n",
    "        # outcome was low enough.\n",
    "        s_f_rate_labeled[i] = np.sum(\n",
    "            s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
    "\n",
    "        #### Human error rate\n",
    "        # Get judges with correct leniency as list\n",
    "        correct_leniency_list = s_test_labeled.judgeID_J[\n",
    "            s_test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
    "\n",
    "        # Released are the people they judged and released, T = 1\n",
    "        released = s_test_labeled[\n",
    "            s_test_labeled.judgeID_J.isin(correct_leniency_list)\n",
    "            & (s_test_labeled.decision_T == 1)]\n",
    "\n",
    "        # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
    "        s_f_rate_human[i] = np.sum(\n",
    "            released.result_Y == 0) / correct_leniency_list.shape[0]\n",