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": 10,
   "metadata": {},
   "outputs": [],
   "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": 63,
   "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": 19,
   "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": 13,
   "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",
    "    Parameters:\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 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}} \\delta(y=0) \\delta(F(x) < r)\n",
    "$$\n",
    "\n",
    "where\n",
    "\n",
    "$$\n",
    "f(x) = P(Y=0|T=1, X=x)\n",
    "$$\n",
    "\n",
    "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` function.\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 +- $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": 64,
   "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",
    "    Parameters:\n",
    "    x = individual features, an array, shape (observations, features)\n",
    "    model = a trained sklearn model. Predicts probabilities for given x. Should\n",
    "    accept input of size (observations, features)\n",
    "    class_value = the resulting class to predict (usually 0 or 1).\n",
    "\n",
    "    Returns:\n",
    "    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.\n",
    "\n",
    "    '''\n",
    "    prediction = lambda x: 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",
    "\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",
    "    Returns:\n",
    "    --------\n",
    "    (1) Boolean list indicating a bail decision (bail = True).\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",
    "    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 by\n",
    "    bootstrapping the data set.\n",
    "    \n",
    "    Returns 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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitLogisticRegression(x_train, y_train, x_test, class_value):\n",
    "    '''\n",
    "    Fit logistic regression model with given inputs. Checks their shape if \n",
    "    incompatible.\n",
    "    \n",
    "    Parameters:\n",
    "    \n",
    "    \n",
    "    Returns:\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": 73,
   "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": "iVBORw0KGgoAAAANSUhEUgAAA1wAAAH/CAYAAABD8tytAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XmcT9X/wPHX2xiDGbuxZ8tWImUU2YZkKJLsISprm7avvtEvg1al/VsKZc1ehKKUQRmF0oJEWZMi22Awy/n9ce7n0+fzmc/MfMZ8Zknv5+NxH+Nz7rnnnHvPvR/3fM6554oxBqWUUkoppZRSwVcgrwuglFJKKaWUUhcrbXAppZRSSimlVA7RBpdSSimllFJK5RBtcCmllFJKKaVUDtEGl1JKKaWUUkrlEG1wKaWUUkoppVQO0QaXUv8AIvKkiBgRaeER1s4Jezwvy6aUUoEQkVnOd1aVLGxzQER25WS58oKIfCEiyXldjryU1WNwIeePUvmFNriUChIRqe78Z5Decjyvy3ix+Dc3NkVkpbPvW/K6LMH0b67TYPin3sCLyCCn3vvldVmUUiqnFMzrAih1EdoBzPUTfjYbab4MzAL2ZiMN9Q/n/LLbDjDAlSJylTHm2zwullKB+g/wJHAorwuilFK5SRtcSgXfT8aY2GAmaIw5AhwJZprqH2kgdmTCROBh4E7gvrwskFKBMsb8Dvye1+VQSqncpkMKlcoDIhImIiNEZJWI/CYi50XkoDNG/VI/8dM8w5VOurWceFMCXed6RkJEyojI2yLyu4ik+jwvVltEpnuUdb+IvC4iZQPc34JO3qtEpJqIzBWRw57j8UWkm4jMF5FfReSsiBwTkU9FpK3vsQA+dT6O9xiymewTr6JTxt0ick5EDonIDBGpFkB5RUT2OmUMTSfOL04ZCzmfi4jIf0XkRxE5JSInROQnEXlHRCoGcpwCMBA4BowGfgVuE5GwDPajnYgsd/bjrIjsEZGZIlLfJ15JEXlKRLaJSKKIHBWRr0TkoXTS/NiJc9bZZqSIFPSJ5x4qJiK9RWSLk/ZvIvK8iBT1iJtpnYpIExF5w8kvQUROi8hmERnmp4ye51tF57r6S0TOiMjnItIoneNVR0TeFZF9zjnzu4isEJGbfOIVEJFhIvK1U9enRORLEemSXl34yct9TYvIUBH53jmeU5z1VURkvIhsFJEjTnl2isgEEYnw3VegORAi3sOYH/fJs6eIrHHOzUQR+UZEBgVY3iZOmuN9wh9wwrf7hFdwwt/1CPN6BkdEZgGTndUzPcqd5pktESku9no+5Bynr8XnuyGT8qc75NLfOp/66e9RP/tEZKyIpLl/EpFiIvK0U0/nxF53C3yvN59tiorIy2K//xOdc/pWP/FKi8izIrLDOY+Pif2u+Z/nteTELeGUY4dT5r9E5AMRaeAn3fS+/1tK1r8DAzpnL/QYZLB9wNdjVo6jUsGkPVxK5Y1IbC/FGuBD4CRQD+gNdBSRq40xuTl8sDAQh/0RZgEQCiQAiG14fQSEAUuAPcBlwN1AexG5xhgT6PNpkUA8cACYCZQCkpx1zwKnsMfkD6AicAvwqYjcaoxZ4sT7HKgK9AdWA2ud8FRXJiJS19mfcsByYKGzTR8gRkSaGmN2p1dIY4wRkfeA/wLtnTTcRKQpUBOYbIw57wS/55R3HbDSCasOdAPeJpu/7ItIa+BS4C1jzDnnZvUJoAsw30/8kcBzwAlgsZP/JdghiV8BW514FZ0yX+qEvwYUARo4+/+iR5oPOJ//dNI8BrRy8mkC9PBT9D7A9dhhtiuAGOARoJGIxBhjUgmgToGhzrZrgaVAcefzmyJSyxjziJ+8SwNfOuWdjq2PrsDnIlLPGPOnx761cdItDCwDtgNlgWbAHTjngHOjPR9brz8C07DXzU3AYhG5zxjzup+ypGc0cJ2T98fAQSc8GhgBfObsgwGaYofltRSRlsaYZOcYjcX2dlYBxnmk7TqOiMhLwAPAbmxdnAVuACaLSF1jzH8yKec32O+pNj7h0c7feiJSwRjjGi7oiheXQZrvY+uxM/AB8L0TftQnXhiwCntezsPWa2/gY+e7cmsmZc+OB7HXzBLseXoL9roLAdwNWudmPQ64GvsdtxB7vfXEfqffYIyJ95P++0Bt7PdHOHa/FonIAGPMDCftAtgfJK7Cfrcsxp6nl2LrfTxwxolbDlvvdZ3yLsV+73YDbhCRtsaYr33K4O/7/6RTpqx8B0YT2Dmb5WOQnqxcj1k5jkoFnTFGF110CcKCvZkzwE9ArJ+lnkfcwkBFP2m0BVKAST7hTzppt/AIcz3L87hHWC0nbIqftP2uwzZ+DPY/n0I+68KA/cBfQF2fdX2c7V4O4NgUdOIa4HVA/MSp4SesIvYG9Cef8DT77rP+a+wNZXOf8BZAMrA4gDJf4eTxnp91rznrWjmfyzif5/uJWwQID8L5Nc3Jo7nzubbz+WM/caOwN+K7gAo+60KBch6fP3TS+Y+fdKp4/Luhc+y+BIp7hAvwppPGLR7hg5ywVJ/ztgD2JtAAt2ehTqsBBfycV5865ariE+463170PN+wN1Ve++vU0SHgvO8546yv7PHve5ztX/EsDxABbHLOuwr+9sEnTdc1fQyo42d9OaCon/BYZ7vePuFfAMnp5HWTs81CIMwjvJBHXVwVQJmXO8eoqEfd/4W9sfcqE/CWE1bNI2yWE+ZZV67zpF86ebq+n+YDoR7hdznh/wvw+sno+KRZ51E/R4CaHuFlnTo7DhT0c1695ZNOW/7+f0F88jTAFs96xt78JzjpF3PCrnbiTvBT9uI+x2UB9prr4ROvjpPulnSOr7/v/4C/A7NxzgZ0DDI4fwK+HrNyHHXRJdhLnhdAF10uloW/G1zpLbcEmM42YJdPWG40uOr62aans+6BdMq6BTgUwD65boDPACWzeFzf8POfbLo358A1ZNAQdG4skoGIAPL+DtvrFu6zL39iJzARJ6y0k+f0HDq3ijnl+NUnfAO2gV7ZJ3yyU57umaRbxYn3PT6NmQzqoZGfdaWcdXM9wlw30sv8xG/orPskkDrNpFyuc7SfR5jrfDuJzw0g9mbOAPM8wvo6Ya8HkN824DB+bs6wvR8GGBZAOq5r+pks7m+5dK7jjBoUHznnSRk/6xo56T0bQN4jnbg3+GzbA9uD+pZH3J+B3T7bZ6fBVcUnvJCzT18FeNwutMHl7ztmprPuMo+wfdjvt7J+4i9z4jfzydPvNYr9kcAAtzmfXQ2FsZnsYwXnmPj9QQk7+ZLB+8e/dL//nfUBfQdm45wN6BhkcP4EfD0Gehx10SUnFh1SqFTwLTHG3JJZJBFpgh1q0Rz7H5Ln9ZjbwxpOGWN2+Am/1vnbUERi/awPA8qLSEkT2LDCX9KL5wxtG4UdJnYJthfQU0XszUFmXGWumk6Zy2OHA9XCNhgzMguYgP2Pe7YTdgN2iM6zxhgDYIw5KiKrgNvFPiO2BDtM71tjTEoAZc5MT+xQm1k+4TOx+zsAeNojvInz95NM0o1y/q4ydmhfRq7F3sx1FRF/5/dZ7LBYX1/4BhhjvheRk8CVmeTpJiKFscOVemJ/rfd9JsTfc3I7jDG+19Jvzt+SHmEBHS8RKY4dTrsbGC0ivlHKO3/9HYf0bMogv17AEGzDpiTez11n5bnAa7FDS+/zU2bXM4CBlDnO+RuN7VmMxt7AxmGHAkc75a6I7YGdloUyZuSIMcbr2jfGnBeRw3jXY07wNwuo1zkkIqWx31kbjZ3gyFcctpexEXa4oac014cT9iD2+ngP+AE7xPVxEWmM7WlcB2x1fQc5mmDPkeLpfPfVdf7Ww/a4uaT3/Q8Bfge6XOA5G8gxSOMCrsdAj6NSQacNLqXygPM8jmso1Ers0K8z2JuXO4FKuVykP9MJL+38vSOT7cOxwz8uKB8RiQQ2Yvd7LfZZlhPYoTFtgZb8fWOYGVeZuzpLesIDSGsO9tmy2/j7ZqOv89e38dMV+2xHH/5+7umwiLwIPJfN/9Bdx983z3nAS9jJNDwbXCWA08aYk5mkW8L5ezDDWFZpbEP1iQzi+Dumh9OJ+ye2hy1Qi7GN8W3YG7DD2OunJvbZL3/nxwk/Ya5nSEI8wgI9DqWcvzWAMRnEC+TccknvmngMW6d/YHuoDgDnsDew/0fg1wPYcgvZL/Nm7FCvaOdzNPZm9bCIxAG9RKSSx/q4LJQxI/7qEWxdhqSzLlgCOYeKO3//SCeNQz7xPPm7PlzpFAcwxiSJSDR22OKt2MYbwD4RGWeMmep8dn33tSHts3aefOs6ve9/yMJ3YDbO2UyPQTqydD1m4TgqFXTa4FIqb4zCPkvTwvg8wCwiff1vEhBXL4W/m5CM/uNKrzHgumFvY4yJu9BCBZDPIKAyMNIY87znChGpjG1wBcpV5juMMdOyXEIPxpgDIrIWOzlIWWyj+BbgO+PzoL4x5hR2yNVIZ9KO64H7gWeA09hnHrJMROpge0EBdvj5FRegtvNA+jrn83GguogUz6TR5WokB9LAP4md4CTcGJOUWWQPkemEl+PvusqQiDTDNraWAV08e+Oc66V/FsrjT6DHwVXeNcaY6Gzm6ZLmmnBmfRuFfX6ykTHmqMe6ytib16xIAI4ZY6pno5wYY1JE5EvgehEphr0uXb0Pcc7faAKbMCO3peJMQOrnx4+MvhsD4TovyqezvrxPPE+RpH0vWZr4xk7wMlREhmOfrYrB9vhOEZE/jTFLPeKPNVl7NUm6PwYF+h2YzXM2oGPgR5avxwCPo1JBp9PCK5U3LgX+8NPYqoR9FuxCuW4cK/tZd9UFpOcqX9MLK07AXFPhe/1nJ7Z10cxPfNcwPX8Ny2CXeTb2x6me2BsNf0P7vBhjdhhj3gA6OEE3ZyN/V+/W58BUP8tSn3hgewvBzi6WkU3Ym63rxc801z6+xv5I0DiwYruleZWBiDTE3uR+5xGcUZ26zo/lfoY+NveNfAECOl7GmGPY3ugGOTyFdDnskMn1njeujvT2NwWnQeFn3dfYIbbB6DmPw54Hw7E9KqsBjDE/YW+ao51ljwlsptWM6j2YjmPvebyGtTnTldfKTsJOHe0H6jvDC321dv76G8Ls71UfrrDvfFcYY1KNMd87P0z1c4Jd3y+u8zjY39eBfAdeyDnrkqVj4JKd6zGT46hU0GmDS6m8sQ+IdHovAPtuLuwMfhfc8+z8R7cHaC0e75sSkfLYXx+z6n3sMKtRIhLlu1Ls+1OuTbtZlu1z/vr+x/wI4O8dNq7/0P01LNdjp7AeJCI3+q4UkVDJ5H1mPhZgh8X0dZZU7DAbzzTLO88E+HL9SpvoEbeoiNQTkUsyy1hEQoDbsUOY+hhjBvku2AkLjgE95O933bzllPNZEangk2ZBZ+pojDG/YRtsDQF/79zyPL5vOGm+4ZumE7eCiPh7DuhG8X6nWwHgKeej501bRnXq9/wQkebY2eqy6wPsEKYhInKd70qfhspr2IbG6+LnHWgicoUE+H66DLhmTGzsPLvmWY6n0tnmKH4aFB5lFmCq89yLb5lrSgDvp3PEOX8fwTbW13isW4O9Ia9F4L1bGdV7MG12/t7uCnAap89gZ6nMrhlAUewU/W7OELZO2ElENvjZ7nHxfifdpcBg7FDGpa4wp9fcl9f3i/Oc2wfYV18M8Y0s9n1VrX3DA5DpdyAXds66ZHoMMhDw9RjocVQqJ+iQQqXyxuvYYTfxIjIP+x9YO+wN0w/A5dlI+2Vn2SAiC7E3EzdjHw6umZWEjDGJItIDOx7/KxH5BPsMTSh23Hxr7DNXnbJRXrDvSPoP9p1K12MbeddgHwL/CPBtOG3DPnfQV0TOOvFTjTETjDFGRHpjf3lf7gyH2YI9xtWww6D+wA4nyZQx5oSILMc+o5UKxDkNFU+XABtFZIuT1+/Y4WldsY2lVz3iXod9fu8zbJ1nJMZJZ4nxeGeUT/nOicgc7HvRegDvGmM2i8go7LMXP4nI+9gbospOns9gz0GAYdhj8byIdMOeJ2HYhm4DnJsRY8y3IjICO/3yzyLyEbZxXxo7QUJL7Dt7PB/GB/s83qfOeX4I24t0Ffa9Sp4NrnTrFNuI/hbo59zAbcb2et2MndY+4Jek+uOc532wQxbXisgypzxlsL0FO4HuTvTXsXV4B9BWRFZjz6dK2Ibrldjz1t/kCYGWJ1lE3gLuA751jnVp7Puq4vDfI7Ma29hZICIrsTe/a40x640xH4rI89hrbJdzHR/A9kpchp1Uoyd21rnMbMbOWheJHVb2l8e6OKCXx78DsR57M/+QiJTCTjN/zBjzVoDbB2oq8DDwtIhcjd3/FtiJHX7EHofseBr7TNC9InIV9jqqgj2uicCdfoYypmCviR9E5ANsg60PtqdogDEmwYl3FbZe47HvzzuM/S7vgh2u7HmshmInx3jLaXR9jR0GWBU7WqAUaSecyVAg34EXeM5m5RikJyvXY1aOo1LBlRNTH+qiy79x4e9p4TN9x5MTvw/25vwM9j+cd7A3QBlNUZzhtPAe6x4GfsXedP2MfZbI9d4mf9PC78qkrNWwPRy/Ym+OjmKnEn8FiApgX13TdK/KIE5jbCPkuLN87ISl2XcnfgvnWJ121vses0jsC3m3Y294Tjr/noJ9Ji0rdXsrf0/vf4ef9aWw75pZ59TlOWyvzEKgiU9cV72leyw84i4ggFcKYGcbNMA6n/AO2ElZjmFnEdyN/SX+Mp94pZ1jtdMp+1/YX+NH+MmrObCIv3/RPoSdee1x0pnuG/si0y1OGQ4CL+D/fT3p1il2yusZ2MbsGexwyN7+roOMzrdM1l2Gnfnxd2ffDmIb/B194gn2ubE451w9i22srMDe8KbZNz95+T2vPdaHOefULif9XdgJS4r4Kz92mvSXsNdzsu8xceLchL2ujjj795uzDw/hZ8r4DMq+Aj+vXsDOBue6Tqr52S7NtN5O+C3YXulEZ/0uj3Xpfj9ltC6d+NdgfyBKdM7xmWThOzezddhhss8CvzjH9wj2WmngJ40vnHoKx36PHnTq+Rugm0/cqtjr82tsI+Es9rv4Xfy/ziMC+0LtLdhr6RT22n4Pn++SQI8hmXwHXuA5G/AxyOT8Ceh6zOpx1EWXYC6ud8gopZRSQSMig7DvA+tvjMnwmTellFLqYqbPcCmllFJKKaVUDtEGl1JKKaWUUkrlEG1wKaWUUkoppVQO0We4lFJKKaWUUiqHaA+XUkoppZRSSuUQfQ+XH2XLljXVq1fP62IAcPr0acLDw/O6GMqH1kv+o3WSP2m95D9aJ/mT1kv+o3WSP+Wnetm8efMRY0xkZvG0weVH9erV2bRpU14XA4C4uDiio6PzuhjKh9ZL/qN1kj9pveQ/Wif5k9ZL/qN1kj/lp3oRkUBeGK9DCpVSSimllFIqp2iDSymllFJKKaVySK43uETkEhFZKCInROSkiLwvIlUD2K6aiCwRkb0ikigiR0QkTkQ6+olr0lka5cxeKaWUUkoppVRaufoMl4gUBT4HzgEDAAM8CawWkYbGmNMZbB4BHAEeBw4AxYHBwEci0s0Y875P/GnAWz5hP2d7J5RSSimllFIqQLk9acZgoCZQ1xizC0BEvgd2AkOBF9Pb0BizFbjLM0xElgO7gTsA3wbXb8aYDcErulJKKaWUUkplTW4PKbwZ2OBqbAEYY3YDXwJdspqYMSYZOAEkBa2ESimllFJKKRUkud3DVR9Y4id8K9AjkAREpAC2oVgW22NWBxjhJ+pwEfkPkAJsAMYYY9ZdSKH9OXnyJH/++SdJSTnb1itRogTbt2/P0TxU1mm9BCY0NJRy5cpRvHjxvC6KUkoppVSeEGNM7mUmch540RjzX5/wJ4H/GmMybQCKyAvAw87HU8AA3+e3RGQmsAw4CFQD/gNcDtxgjIlLJ90hwBCA8uXLN547d266ZQgJCaF48eJUrlyZQoUKISKZFfuCpaSkEBISkmPpqwuj9ZI5Ywznz5/nt99+4+TJk6SkpORofqdOnSIiIiJH81BZp/WS/2id5E9aL/mP1kn+lJ/qpU2bNpuNMVGZxcuLBtdEY8xjPuFPAY8G2OCqAlRwltuxwxS7G2OWZbBNMeBHYL8xpkVmeURFRZmMXny8a9cuKlWqRNGiRTNLKtsSEhIoVqxYjuejskbrJXBnzpzh4MGD1KpVK0fzyU8vQlR/03rJf7RO8ietl/xH6yR/yk/1IiIBNbhy+xmuY0BpP+GlnHWZMsYcMMZsMsYsM8b0xA4XfCGTbRKA5UCTLJbXr6SkJIoUKRKMpJS66BUpUiTHh94qpZRSSuVXud3g2op9jsvX5cC2C0xzExDIT+eCnYY+KHJyGKFSFxO9VpRSSin1b5bbDa4PgaYiUtMVICLVgebOuixxJtBoAfySSbziwE3AV1nNI7dET4smelp0XhdDKaWUUkopFUS5PUvhZOBeYImIPI7tcRoP7MfjJcUiUg3biBpnjBnnhMVihyN+CRzCPsN1F3ANcJvHto8AdYHV/D1pxiNO/L45undKKaWUUkop5SFXe7iMMaeBtsDPwExgNvbFxW2NMac8ogoQ4lO+b4ArgNeAT4AJwFmgpTHGc0rBHdghiq8Cn2JfprwbaBHMaeEvFiKS6VK9evW8LiYA//3vf9MtY9OmTXMkz59++gkRIaNZK7Nr4cKFvPrqq2nCV6xYgYiwYYO+v1sppZRS6p8qt3u4MMbsA7plEmcPttHlGfYhAQw7NMYsBZZmo4j/KvHx8V6fu3btypVXXklsbKw7LCwsLJdLlb6QkBC++OKLNOH/5BkDFy5cyKZNm7j//vu9wps1a0Z8fDxXXHFFHpVMKaWUUkplV643uFT+4tszFBYWRtmyZQPuMTp37lyuN8hyqjcrvylRosS/Zl+VUkoppS5WuT1phvoH6927N7Vq1WLt2rU0bdqUIkWK8MQTT3D27FlEhGeffdYrfnrD8VatWkV0dDQRERFERERw0003sX379qCUccaMGYgIP//8c5p1bdq08WrAvPTSSzRt2pRSpUpRqlQpmjdvzieffJJpHk2bNqVr165pwitUqMCwYcPcn3///XcGDx5M7dq1KVq0KFWrVuX222/n0KFD7ji9e/dm3rx5/PLLL+7hkfXq1QP8DylMTU1lwoQJ1K5dm0KFClG5cmVGjBjB6dOn3XFc9fHkk08yceJEqlWrRrFixbj++uvZsWNHpvunlFJKKaWCRxtcKkuOHDlC//79uf322/n444/p3r17lrZ///33iYmJoWzZsrz33nvMnDmTw4cP06pVK37//feA0khOTk6zpKamAtCtWzfCw8OZNWuW1zb79+9n7dq19O/f3x22d+9ehg4dyqJFi5gzZw5XXHEFHTp0YPXq1Vnap/QcOXKEYsWK8dxzz7FixQqeffZZfvjhB1q1auV+L9WTTz5Ju3btqFKlCvHx8cTHxzNv3rx003zkkUd49NFH6dSpE8uWLePBBx9k8uTJ3Hzzzfi+xHzKlCl8/vnnvP7660yZMoWff/6Zrl27uo+VUkoppZTKeTqkMEgeWPEAWw5tueDtXdv6Tg2fkpJCSEhIQGk0qtCIlzu8fMFlCMSJEyeYN28eMTEx7rCzZ88GtG1qaiojRowgJiaGhQsXusNbt25NzZo1eeWVV9L0kvlKSUkhNDQ0TfjDDz/MCy+8QHh4OF27dmXWrFmMHTvW/Q6o2bNnExISQq9evdzbvPzy38cqNTWVdu3asX37diZNmkSbNm0C2qeMNGjQgBdffNH9OTk5mSZNmlCnTh1WrVpFx44dqVWrFmXKlCEsLCzT4YOHDh3itddeY+jQobz00ksAtG/fnpIlSzJ48GA+/fRT2rdv744fHh7Ohx9+6D5/kpKS6N+/P1u2bOHqq6/O9v4ppZRSSuWm6Gg4frwRWy78ljtPaA+XypKiRYt6NbayYuvWrRw4cIB+/fp59U4VL16cJk2asHbt2kzTCAkJYePGjWmWBx54wB2nf//+7N69my+//NIdNmvWLG688UbKli3rDvvqq6/o2LEj5cqVIyQkhNDQUNatWxe0YXfGGF599VUaNGhAREQEoaGh1KlTB+CC8li/fj3Jycn069fPK7xv376ICGvWrPEKj4mJ8WqsN2jQAIB9+/ZlOW+llFJKqbxkjGFjyEvsPLUzr4uSZdrDFSTZ7Vly9WzFDYzzCk9ISMhXM/BVqFDhgrf9888/AdtA6Ns37SvRXI2RzERFRWW4vl27dlSqVImZM2fSokULvvnmG7Zu3crYsWPdcX799VfatWvH1VdfzRtvvEGVKlUoWLAgjz76KL/99lsW9ip9L7zwAo8++igjR47k+uuvp2TJkiQmJtK6deuAewU9HT16FICKFSt6hRcpUoTixYu717uULl3a67NrcpMLyVsppZRSKq+cPn+aQUsHcabVXMLWPAs0yesiZYk2uFSWuIboeQoNDSUkJITz5897hf/1119en8uUKQPAxIkTadWqVZp0ChcuHJQyFihQgNtuu42pU6fy6quvMmvWLEqVKkWnTp3ccZYvX86pU6dYtGiRV6/XqVOn/CWZppyuZ7BcUlNTOX78uFfY3LlzufHGG72GSWZnchBXA+rQoUNceuml7vDExEROnjzpPr5KKaWUUheLX47+Qtd5Xfnxzx8J23IfIfva5nWRskyHFKpsCwkJoXLlyvz4449e4cuXL/f63KBBAypVqsT27duJiopKswTzfVO33347x44dY8mSJcyZM4eePXt6TV9/5swZAAoW/Ps3hx9//JFNmzZlmna1atX4+eefSUlJcYetWrWKc+fOecU7c+ZMmufN3n333TTphYWFkZiYmGm+1113HQULFkwz6+N7772HMYbWrVtnmoZSSiml1D/Fxzs/JmpyFAdOHmBFvxU0PfYqtSNq53Wxskx7uFRQ9O7dmxdffJHnnnuOqKgoVq9ezYIFC7zihISE8Prrr9OjRw/OnDlDt27dKFOmDIcOHeLLL7+kTp063HvvvZnm5TlNuktoaCiNGzd2f27QoAFXXnklDz30EIcOHfKanRDsZBOjRo2iX79+jBgxggMHDjBmzBiqVq0a0L7OmDGDQYMG0bdvX3bt2sWrr75KeHi4V7wOHTqgyqnOAAAgAElEQVTw2muvMWHCBK6++mpWrlzJ4sWL06R3+eWXM2PGDKZOnUrDhg0pWrQo9evXTxOvQoUK3Hfffbz88ssULlyY9u3b8/333/PEE0/Qtm1b2rVrl2nZlVJKKaXyu1STylNrn2JM3Bgalm/IB70+oEapGjyd1wW7QNrgUkExZswYEhISeOmllzhz5gydO3dm2rRptGjRwite165dWb16NU8//TR33XUXiYmJVKxYkWbNmqWZDMKflJQUmjVrlia8TJkyHDlyxCusf//+PPLII9SsWZPmzZt7rbvqqquYPn0648aNo3PnztSuXZuXXnqJBQsWsCWTqW86duzIhAkTmDRpEnPnziUqKoo5c+akmUxk/PjxnDp1iueff55z587Rtm1bli9fTt26db3iDR8+nE2bNvHwww9z4sQJ6taty08//eQ37xdeeIEKFSowefJkXnnlFcqWLcugQYN4+umn/Q73VEoppZT6Jzlx9gQDFg9gyY4l9G3Ql7c7v03R0KKcOwd790I+mtogYOL77h4FUVFRJqOhZdu3b+eyyy4Lap7/lEkzlKX1kjU5cc34iouLIzo6OkfzUFmn9ZL/aJ3kT1ov+Y/WSe7bfng7t8y7hV+O/sLE9hO5/9r7ERGOHoWuXWHtWqhe/RS7d0fkdVEBEJHNxpiMZ3NDe7iUUkoppZRSeez97e8zYPEAioYW5bPbP6N1dfts+u7dcOON8OuvcNllUKhQch6XNOt00ox8Im5gXJreLaWUUkoppS5mKakpjPpsFN3md6N+ZH02D9nsbmxt3AhNm8Iff8Cnn0K5cnlc2AukPVxKKaWUUkqpXPfXmb+47f3b+OSXTxh89WBe6/gaYQXtrNIffgh9+thG1scfQ716eVzYbNAGl1JKKaWUUipXbTm0ha7zunIw4SBvd3qbwY0Hu9e9/jqMGAGNG8PSpVC+fB4WNAh0SKFSSimllFIq18z+fjbXTb2OpJQk1g5c625spabCww/DffdB586wevU/v7EF2uBSSimllFJK5YKklCQeWPEA/T7oR5PKTdg8ZDPXVrkWgMRE6NkTXnwR7r8fFi0Cn1ec/mPpkEKllFJKKaVUjvrj1B/0XNiTtXvXMuLaETx/w/OEhoQCcPgwdOkCGzbASy/BAw/kcWGDTBtcSimllFJKqRzz1YGv6Da/G0cTjzKz60z6NeznXrdzp532/cABWLAAunVLP524OIiL2wJE53SRg0obXPlFtPM3Lg/LoJRSSimlVBBN3jyZez++l8rFKrP+rvU0qtDIvW79erj5ZhCBzz+HZs3ysKA5SJ/hUkoppZRSSgXVueRzDFk6hCHLhhBdPZpNQzZ5NbYWLoS2baF0aYiPv3gbW6ANLgVMmzYNEWHXrl3ZTis6OpoWLVoEoVTWwIEDqV69etDSi42NRUSCll5W8v38889zPV+llFJKqdx24OQBWk1rxeRvJvNYi8f46LaPKF2kNADGwMSJdoKMxo1tL1etWnlc4BymDS6lcsHYsWO1waWUUkqpi96aPWto/HZjth3exqKei3j6+qcJKRACQEqKnfL9kUege3dYtQrKls3jAucCbXAppZRSSimlssUYwysbXuH6GddTsnBJvhr0Fbdedqt7/enT0LUr/O9/8J//wNy5UKRIHhY4F2mDSwVk48aNdO/enSpVqlCkSBHq1q3LqFGjSExM9Bt/yZIlXHHFFYSFhVGvXj3mz5+fJs53333HzTffTKlSpShSpAjNmzdn3bp1mZblzJkzPProo9SoUYNChQpRo0YNnnrqKVJTU73iffvtt7Rs2ZLChQtTuXJlxo8fjzEmoP1NSkri8ccfp3r16hQqVIjq1avz+OOPk5SU5I4TFxeHiBAXF+e1rWuI5p49ewDcQxifeuopRAQRITY21h1/zZo13HDDDZQoUYLw8HCuvPJKpk6dmqWy7NmzBxFh0qRJPPbYY1SoUIFixYrRr18/zpw5w65du4iJiSEiIoJatWoxffr0NPscSH1s3LiRG264gTJlylC0aFFq1qzJ3XffHdAxVUoppdTF6UzSGfp/0J8HVj7ATXVu4utBX3N55OXu9YcOQXQ0LF9uG1wTJkCBf1ErRGcpVAHZt28fjRo1YuDAgRQrVoytW7cybtw4fv31V+bOnesVd9euXdx///3ExsZSrlw53nzzTXr37k1kZCRt2rQB4JtvvqFly5ZcddVVTJ48maJFizJp0iTatWvH+vXrady4sd9yJCcnExMTw7Zt2/i///s/GjRowIYNGxg/fjxHjx5l4sSJABw5coS2bdtSoUIFpk+fTlhYGM8//zz79u0LaH8HDBjA/PnzGTVqFC1atCA+Pp4nn3ySX3/9lffeey9Lxy4+Pp5mzZoxcOBAhg4dCkCVKlUA2zDt1q0bzZs356233qJs2bJs3bqVvXv3XlBZnnnmGaKjo5k+fTrbtm1j5MiRFChQgG+//ZbBgwfzyCOP8Oabb3LHHXcQFRVF/fr1A66PU6dOERMTwzXXXMO0adMoVqwYe/bsYf369Vk6HkoppZS6eOw+tptb59/Kd4e+Y3yb8YxqOYoC8ndravt26NjRvmtryRLo1CkPC5tXjDG6+CyNGzc2Gdm2bVvawBHGmNbZWEo4i094UoukwNMYkWGx0/Xuu+8awOzcuTOg+KmpqSYpKcnMnDnTiIg5cuSIe13r1q0NYOLj491hycnJpm7duqZFixbusLZt25p69eqZc+fOecWrV6+e6dKliztswIABplq1au7PM2bMMIBZs2aNV5mefPJJExoaav744w9jjDGjRo0yoaGhZu/eve44p06dMmXKlDH2tE/fDz/8YAAzZswYr/Dx48cbwHz33Xfm5MmTZvXq1QYwq1ev9ornOp67d+92hwFm9OjRXvFSU1NNtWrVTOPGjU1KSsoFl8UYY3bv3m0A06ZNG694Xbt2NYCZOXOmO+zo0aMmJCTExMbGusMCqY+NGzd65ZkVfq+ZIPOtB5U/aL3kP1on+ZPWS/6jdZK5lbtWmlLPljIlny1pPvr5ozTr4+KMKVnSmPLljdm4MQgZtm5tjl15ZRASCg5gkwmgbfEv6sxT2XHy5EkeffRRLr30UsLCwggNDaV///4YY9i5c6dX3EsuuYSmTZu6P4eEhNCjRw++/vprUlNTSUxMZM2aNfTo0YMCBQqQnJxMcnIyxhjatWvH2rVr0y3HihUrqFatGtddd517u+TkZNq3b09SUhIbNmwAbK9S06ZNqVq1qnvb8PBwOnfunOm+uvLv16+fV7jr85o1azJNIxA7duxg7969DBo0iALp9KtntSwdO3b0+lyvXj0AYmJi3GGlSpWiXLly7N+/HyDg+qhduzYlS5Zk6NChzJo1y729Ukoppf5djDE8s+4ZOszqQJXiVdg0eBMda3vfg8yeDTfcABUrwoYNEBWVR4XNB3RIYbC8nM3to52/cd7BiQmJFCtWLJuJZ98dd9zBqlWrGDduHI0aNSI8PJyvv/6ae+65h7Nnz3rFLV++fJrty5cvz/nz5zl8+DDJycmkpKQwfvx4xo8f7ze/1NRUv42QP//8k7179xIaGup3u7/++guA33//nSuuuMJvOTJz9OhRACpWrOgVXqFCBa/12eUqq2t4YTDKUqpUKa/PhQoVSjfcVW9Hjx4NqD5KlCjB6tWrGT9+PHfffTcJCQnUr1+fsWPH0i2j18IrpZRS6qKRcC6BAYsH8MFPH9D7it5M6TyF8ELh7vXGwNNPw+OP2+e23n8ffG5D/nW0waUydfbsWZYsWUJsbCwjRoxwh//www9+4//xxx9+wwoVKkRkZCSJiYkUKFCAe+65h9tvv91vGun1+JQpU4YaNWr4nYQDcL+zq2LFiumWIzOlS9v3RBw6dIhLL73UHX7o0CF3GQAKFy4MwPnz5722dzWkMlPWmQf1t99+y3ZZsqNkyZIB10ejRo1YtGgRycnJbNq0iWeeeYaePXvy3Xff+W3gKqWUUurisePIDm6Zdws7/9rJxPYTebDpg17vN01KgrvvhilToF8/+zcsLIgFSE4OYmK5RxtcKlPnzp0jJSUlTa/StGnT/Mbfv38/GzZscA8rTElJYcGCBVxzzTUUKFCA8PBwWrZsyXfffcfVV1+dbuPKnw4dOrBo0SIiIiLcw+X8adasGc8//zz79+/nkksuAeD06dMsXbo00zxat24NwNy5cxk9erQ7fPbs2QC0atUKgGrVqgHw448/0r59e3e8jz76KE2ahQoVSjOjY506dahevTpTpkxhyJAhfl/IHGhZsuNC6qNgwYI0bdqU8ePH8+GHH7J9+3ZtcCmllFIXsSU/LaH/B/0JKxjGp/0/pU2NNl7rT560LzNeudL2bo0bB35ubS7cihXw1VeEOPdf/yTa4FJuK1ascA9VcylRogQ33HADTZs2ZeLEiVSsWJGyZcvyzjvvpNszU758eXr16sXYsWOJjIzkzTff5Oeff+bNN990x3nxxRdp1aoVMTEx3HXXXVSsWJEjR47wzTffkJKSwrPPPus37b59+/Luu+9y/fXX8/DDD3PllVdy/vx5fvnlFz788EMWL15M0aJFefDBB3njjTdo3749sbGx7lkKiwTwwof69evTp08fYmNjSU5O5rrrriM+Pp7x48fTp08fGjZsSEJCAhUrVqR169Y888wzlC1blnLlyjFr1ix++eWXNGlefvnlLF++nA4dOlCqVCkqVapEpUqVePnll7n11ltp27Ytw4YNIzIyku3bt/Pnn38yduzYgMoSDIHUx7Jly3j77be55ZZbqFGjBqdPn+bVV1+lWLFiNGvWLCjlUEoppVT+kpKaQmxcLE+ue5KoSlEs6rmIqiWqesX57Te46Sb48Ufbq3XXXUEuxLx50L8/FC5MalC7zHJJIDNr/NuWC5qlMLtaO4uPkydPBj8vH65Z9fwt9evXN8bYWfA6dOhgIiIiTGRkpLnnnnvMsmXL0szS17p1a9O8eXOzZMkSU79+fVOoUCFTp04dM3fu3DT5btu2zfTq1ctERkaaQoUKmcqVK5vOnTub5cuXu+P4zlJojDGJiYlmzJgxpm7duqZQoUKmVKlSJioqyowZM8YkJSW5423evNm0aNHChIWFmUqVKplx48aZJ554ItNZCo0x5vz582b06NGmatWqpmDBgqZq1apm9OjR5vz588aYv+tl//79plOnTqZEiRKmfPny5rHHHjOTJ09OM0vhF198Ya6++moTFhaWZtbBzz77zERHR5vw8HATHh5uGjZsaN55552Ay+KqH8BMnjzZaz/GjBljAK/jYowx1apVM3379s1Sffz000+mZ8+epnr16iYsLMyULVvWdOzY0WzYsCHT46mzFP57ab3kP1on+ZPWS/6jdWLM0TNHTcdZHQ2xmDsW32ESkxLTxPnuO2OqVDGmWDFjVq7MgUK89ZYxIsa0bGlM8+b/yFkKxcZVnqKiosymTZvSXb99+3Yuu+yy4GYa7fyN8w5OSEjIF5NmKG9aL1mTI9eMj7i4OKKjo3M0D5V1Wi/5j9ZJ/qT1kv/82+vkhz9+oOu8ruw7sY9XO77K0MZD0zz+8Mkn0L07FC9uX2p85ZVBLsRzz8F//ws33ggLFsCNN3L8+HFKbtkS5IwujIhsNsZkOv+iTguvlFJKKaWUcpv741yaTm3KmaQzrBm4hmFRw9I0tt55xw4jrFHDTvse1MaWMfDoo7ax1acPLF4MRYsGMYPcpQ2u/CKONL1bSimllFJK5Zbk1GQe+eQR+izqw1UVrmLzkM00u8T7OW1j4Ikn7HNabdvCunWQwRtusi4lBYYOhQkTYPhwmDULXBO3xcWx5eXsvosp9+mkGUoppZRSSv3LHT59mF4Le7F6z2rubXIvE2MmUiikkFec8+dh0CCYORPuvBMmTfq7LRQU58/b+eQXLIDRo2H8+CBPdZg3tMGllFJKKaXUv9jG3zbSbX43Dp85zLQu0xjQaECaOMePw623wurVth00enSQ20KnT0O3bnZe+RdegIcfDmLieUsbXEoppZRSSv1LvfPtO9y9/G7KR5Tnyzu/5OqKV6eJs3evnbdi507bu9WvX5ALcewYdOpkHwabOtV2n11EtMGllFJKKaXUv8z5lPOM+HgEkzZP4voa1zO3+1zKFi2bJt7mzbYtlJhoO5/atPGTWHYcOgTt28OOHXYo4a23BjmDvKcNLqWUUkoppf5FDiYcpPv87sQfiGfkdSN56vqnKFggbbNg+XLo1QvKloXPPoPLLw9yQXbvhhtusI2u5cuhXbsgZ5A/aINLKaWUUkqpf4kv9n1BjwU9SDiXwPzu8+lRv4ffeG++CffeC1ddBcuWQYUKQS7I1q22Zysx0bbmrr02yBnkHzotfH4RHW0XpZRSSimlgswYw/++/h9tprcholAEGwZt8NvYSk2FkSPh7rvtc1txcTnQ2Pr6a2jVys4xv3btRd3YAu3hUkoppZRS6qKWmJTIsOXDmPHdDDrV6cTMrjMpWbhkmnhnz8KAATB/vm1wvfIKFAx2a+Hzz6FLFyhXDj79FGrWDHIG+Y/2cCmmTZuGiLBr164065KTkxERYmNjc79gF7GcPqZxcXHExsaSmprqFb5nzx5EhGnTpuVY3koppZTKP/Ye30uLd1sw47sZjGk9hiW9l/htbP31l32Eav58eP55eP31HGhsLV4MHTtC9erwxRf/isYW5EGDS0QuEZGFInJCRE6KyPsiUjWA7aqJyBIR2SsiiSJyRETiRKSjn7iFReR5EfndiRsvIq1yZo+Uyn/i4uIYO3ZsmgZXxYoViY+P56abbsqjkimllFIqt6z6dRWN327MrqO7WNpnKbHRsRSQtLf/v/wC110HmzbBvHnwyCM58L7h6dPte7auvhrWrIGKFYOcQf6Vqw0uESkKfA7UAwYA/YHawGoRCc9k8wjgCPA4cCNwF3AK+EhEfOePnAoMBp4AOgG/AytFpFGQdkWpf6SwsDCaNm1KZGRkXhdFKaWUUjnEGMPzXz5PzKwYKkRUYNPgTXSq08lv3A0boFkz28P12WfQs2cOFOiVV2DgQLj+ejuMsHTpHMgk/8rtHq7BQE3gFmPMYmPMEuBmoBowNKMNjTFbjTF3GWNmGmNWO9veAhwA7nDFE5ErgduAB40xk40xnwE9gX3AuBzZq3+Z2NhYxM/PHgMHDqR69eruz67ha5MmTeKxxx6jQoUKFCtWjH79+nHmzBl27dpFTEwMERER1KpVi+nTp3ult2vXLvr370+NGjUoUqQINWvWZPjw4Rw7dixNvlWqVOHbb7+lZcuWFC1alNq1azNp0qSA9ufIkSMMHz6cypUrExYWRr169Xj77bfd67/++mtEhKVLl6bZdvjw4URGRpKUlATA3Llzadu2LZGRkURERHDVVVel2S9/fI+dS3R0NNEek6mcPXuWBx98kCuuuIKIiAgqVKhA586d+emnn9xxYmNjGTt2LAChoaGIiLu+0htSOGvWLK688koKFy5M2bJl6d+/P7///rtXnOrVq9OvXz/mzp3LZZddRnh4OFFRUXzxxReZ7p9SSimlcsep86fotbAXI1eNpNtl3dgwaAO1y9T2G/eDD+x7tYoXh/h4aN48yIUxBsaMgQcesL1bS5dCRESQM8n/crvBdTOwwRjjfljIGLMb+BLoktXEjDHJwAkgySePJGCeT7y5QIyIhF1Y0S9+KSkpJCcney0pKSnZTveZZ57h4MGDTJ8+nXHjxjFv3jyGDRtG165duemmm/jggw9o2LAhd9xxB1u3bnVvd/DgQapUqcLLL7/MypUreeKJJ/jss8+48cYb0+Rx8uRJbrvtNvr168eSJUto0qQJw4cPZ/Xq1RmW7eTJkzRv3pzly5cTGxvL8uXL6dy5M8OHD+e1114D4JprrqFu3brMnDnTa9vz588zf/58evfuTWhoKAC//vor3bt3Z/bs2SxevJjOnTszaNCggBt/mTl37hwJCQk8/vjjLF++nDfffJOzZ8/StGlTDh06BMCgQYO46667APjiiy+Ij48nPj4+3TTffvtt+vfvz2WXXcb777/Ps88+y8qVK2ndujWnTp3yirtu3TomTpzI+PHjmTdvHikpKXTq1Injx48HZf+UUkopdeF2/rWTplOasmj7Iia0m8C87vOIKOS/gfPyy7YN1KiRbWzV9t8mu3CpqTBiBIwbB3feCXPnQti/8zY8t2cprA8s8RO+FfD/EgAfIlIA21Asi+0xqwOM8MljtzHmjJ88CgG1nH8H1wMPwJYtF769a1ufqeGLpKRASEhgaTRqZK+eC1SvXr0L3jYjl156qbuXJyYmhnXr1jFz5kxmzpxJv379AIiKiuLDDz9k4cKF1K9fH4BWrVrRqtXfj95dd9111KpVi5YtW/Ltt99y1VVXudclJCTwxhtv0MZ5/XmrVq345JNPmDNnjjvMn1deeYW9e/fyww8/UNv5pmnXrh3Hjx9n7NixDB8+nIIFC9K/f3+efPJJTpw4QYkSJQD46KOPOHr0KP3793enN2rUKPe/U1NTiY6O5vfff+fNN99k2LBh2TqOACVKlGDKlCnuzykpKcTExFC+fHnmzJnDgw8+SJUqVahSpQoA1157LQUzeOI1JSWF//u//yM6Opq5c+e6w+vVq0fLli155513uP/++93hJ0+eZMuWLZQqVQqAChUq0KRJEz766CNuu+22bO+fUkoppS7Msp+X0e/9fhQsUJCV/VbSrqb/lwinpMBDD8Grr8Ktt8KsWVCkSJALk5RkG1mzZsHDD9tZOIL+UNg/R273cJUGjvkJPwqUCjCNCdgerN+BkUBvZ9hgIHm41is/PvjgAzZu3Oi1bNiwIdvpduzoPa+Jq2EXExPjDitVqhTlypVj//797rDz58/z9NNPU69ePYoUKUJoaCgtW7YEYMeOHV5pFi1a1KthFRYWRu3atdm3b1+GZVuxYgXXXnstNWrU8OrZi4mJ4a+//mLbtm0A9OvXj3PnzrFgwQL3tjNnzqRu3bpcc8017rCdO3fSp08fKleuTGhoKKGhoUyZMiVNebNj/vz5XHvttZQsWZKCBQsSHh7OqVOnLiiPHTt28Oeff9K3b1+v8BYtWlCtWjXWrFnjFd6sWTN3YwugQYMGAJkeZ6WUUkrljFSTyti4sXSe05mapWqyacimdBtbZ85A9+62sfXgg3ZGwqA3thITbdfZrFnw1FP/+sYW5M17uIyfsKzUwsvY4YEVgNuB90SkuzFmmUdaWc5DRIYAQwDKly9PXFxcunFLlChBQkKCd+D48YGVPh1FnGFyiT7PCaWkpBASaA8XgG+5AnD27FnAPqNz6aWXeq1LTk4G/h7K5vq3zco7r6SkJIwx7nDXcLQiRYp4xTXGVk/BggW9wkNDQ0lISHCHjRo1irfeeotHH32Ua6+9loiICA4ePEjfvn05fvy4O15SUhIlS5ZMU56CBQty+vTptHXl4dChQ/z666/uIYG+9u/fT40aNShdujTNmzdn2rRp9OrVi6NHj7J8+XJGjhzptb/t2rWjSJEijBkzhpo1axIaGsrUqVOZOXNmmnJ4HlPfY+fiGtLpCv/444/p1asXt912G//5z38oU6YMBQoUoHv37l7HzrOOPHu4XHVy9uxZEhISOHDgAOD/nI6MjOTw4cPucGMMxYoV83s8T5w4keFxPnv2bIbXVDCcOnUqx/NQWaf1kv9oneRPWi/5zz+hTk4ln+Lp7U8TfzSe9uXb81Cth9izZQ972JMm7rFjoYwa1YAdO4px3327uPnm31i3LrjlCTl9mgajR1Pi++/Z+cADHLzuOjsjYRD9E+rFV243uI7hv4epFP57pdIwxhzATpQBsExE4oAXAFeD6yjgb5r5Uh7r/aX7NvA2QFRUlIn2Gdrnafv27RQrViyQ4gbOaVT5ppuQkBD8vHwULlwYgIiIiDR5uRpcYWFh7nWuIXVhYWEUKlTIHffkyZOIiDtehPNQZOHChb3SDXPG7xYrVsyrMSAihIaGuuO+//773H777Yz3aMy6nsnyTNM1MYRv2UPSOaaeIiMjqVChAq+88orf9XXr1nVvP3DgQAYPHszRo0dZsmQJ58+f584773Sv37BhA/v27WPdunW0aNHCncY777zjtxyex7RYsWIkJSWliXP8+HHKlCnjDl+yZAm1atVi9uzZ7jhJSUkcO3bM69ild4x968Q19PDkyZNp8j58+DBRUVHucN/6SW9f/ClcuLDXENCcEBcXR0bXrcobWi/5j9ZJ/qT1kv/k9zrZ+udWhswbwu7ju3mt42vc0+Qev5OaAezYYUf4HTpkJ8ro0qU2dqLwIDp82L5ja+tWmD2bOn36UCe4OQD5v178ye0hhVuxz1j5uhzYdoFpbsI+l+WZRw1nCnrfPM4Dad/uq7KkWrVqAPz444/usOPHj7N+/fqg5nPmzJk0PU/vvvtuUPPo0KEDP/30E1WrViUqKirN4tmI6NGjB4ULF2b27NnMnTuXVq1aec0seOaMfWzQs8zHjh1jyRJ/jy16q1atGn/88QdHjhxxh/3yyy9phgmeOXMmzTNZM2fOTDO5iavBlZiYmGG+devWpXz58l7PbwGsX7+evXv30rp160zLrpRSSqnctWDrAq6dci0J5xNYPWA1915zb7qNrXXr7LTvp09DXBx0yfI0dQHYvx9atbKNrcWLoU+fHMjknyu3G1wfAk1FxP1aaRGpDjR31mWJM4FGC+AXnzxC8ZiEQ0QKAr2AT4wx5y6k4OpvHTt2pESJEgwePJhly5axaNEi9/TuwdShQwemT5/OG2+8wSeffMKwYcOC3qh78MEHKVeuHC1btmTSpEmsXr2aZcuW8cILL9DF5xupePHi3Hzzzfzvf/9jw4YNXpNlgJ3Uo3jx4txzzz0sX76c+fPn07p1a8qWLZtpOXr06IGI0LdvX1auXMns2bPp0qVLmm1dDcQHH3lr8KQAACAASURBVHyQzz77jAkTJvDEE09QsqT3G+Mvv/xyACZOnMhXX33Fpk2b/OYbEhLCuHHjWLVqFf369WPFihVMnTqVW2+9ldq1a3PHHXf43U4ppZRSuS85NZlHP32Ungt70rB8QzYP2UyLqi3SjT93LrRrB+XK2ZkIPR47D56ff4YWLeDgQfjkE7jpphzI5J8ttxtck4E9wBIR6SIiN2NnLdwPvOWKJCLVRCRZRJ7wCIsVkVdFpJeItBaRXsAK4BpgjCueMWYLdkr4l0VkkIhcj33mq4ZnPHXhSpYsybJlyyhQoAA9e/bkscce47777stwNsAL8dprr3HzzTczevRoevXqRUJCAnPmzAlqHiVKlGD9+vXceOONPPfcc8TExHDnnXeyZMkSv/vTv39/Dh48SFhYGN27d/daFxkZyQcffEBKSgrdu3fnscceY9CgQe6ZGDNSq1YtFi5cyG+//cYtt9zChAkTePHFF6lTx7szfvDgwYwePZp58+bRuXNnli9fztKlS93DPF06derE3XffzRtvvEGzZs1o0qRJunkPGTKEmTNn8sMPP9ClSxdGjhzJDTfcwJo1a4LeiFZKKaXUhTly5ggdZ3dkwvoJDGs8jLiBcVQqVslvXGPguedsR1PTprB+PdSs6Tdq9nz7rW1sJSba7jNncjPlwxiTqwv2+apFwEkgAVgMVPeJUx078UWsR9jNwOfAn8A5YC+2N6u5nzyKAC8Ch4CzwFdAdKBlbNy4scnItm3bMlx/QVq3touPkydPBj8vlW1aL1mTI9eMj9WrV+d4HirrtF7yH62T/EnrJf/JT3Wy+eBmU+2laiZsfJiZ+s3UDOMmJRkzdKgxYEyfPsacPZtDhVq71pjixY255BJjduzIoUzSyk/1AmwyAbQtcn2WQmPMPqBbJnH24DOroDHmQwIcdmiMSQQechallFJKKaX+kWZ8N4Ohy4YSWTSSdXeso0nl9EetJCRAr17w8cfw2GPw5JNQICfGs330kZ36vVo1+PRTuOSSHMjk4pEX08Irf/5h01sqpZRSSqmccz7lPA+tfIj/bfwf0dWjmdd9HuXCy6Ub/+BB6NQJvv8e3noLhgzJoYLNmQO33w4NG8KKFRAZmUMZXTy0waWUUkoppVQ+cujUIXos6MEX+77goaYP8dwNz1GwQPq37T/+CDfeCEePwtKldnb2HPHmm3DPPfZZraVLoXjxHMro4qINLqWUUkoppfKJ+P3xdJvfjRPnTjCn2xx6X9E7w/iffQa33grh4XYK+Bx57aUx8MwzMHq07UabPx+KFMmBjC5OuT1LoVJKKaWUUsqHMYZJmybRelprioQWIf6u+EwbW9OnQ4cOULUqbNiQg42tkSNtY6tvX3j/fW1sZZE2uJRSSimllMpDZ5PPMujDQQxfPpx2NduxafAmGpZvmG58Y2DsWBg4EFq3hi++sI2uoEtJgcGD4YUX4N57YcYMCA3NgYwubjqkUCmllFJKqTyy/8R+us3vxsaDG3m85ePERscSUiAk3fjnz8PQoTBtGgwYAG+/DYUK5UDBzp2zPVqLFvH/7N13fE33G8Dxz5FIIkYlZu09iyqKGgmxtyo1IzVqr5i1KSElRq3Y1KyV2iNGxFar9t6bBCESktzv749DfhIhN9x7Ezzv1ysvcu4553mu06jnfr/f58vgwTB0KGharJeJt0nBJYQQQgghRDzwu+pHo+WNCA0PxednH+rlq/fe8588gZ9+gq1b9fpn8GAz1UDPnukLw3x9Yfx46N7dDEG+HFJwJRDOzvqv0h1eCCGEEOLzppRi/P7x9PHtQ+5UufH52Yd8qfO995obN/ROhGfP/n90yywCA6FmTTh4EObO1ectio8iBZcQQgghhBAWEvwymDZr27D05FJ+zP8j8+rOI7lt8vdec/SoXgMFB+tbX7m4mCm5O3egShU4f16fSljv/SNuwjjSNENE2rdvH40aNSJDhgzY2NiQKlUqKleuzPz584mIiDBLTD8/P4YOHYrBYDDL/WMzYcIEVq1a9dbxoUOHoiWQecrOzs44vx4CFUIIIcQn61LgJUrPLs3fJ//Go6IHKxquiLXY2rgRypcHa2vYs8eMxdbly1C2LFy5Ahs2SLFlQlJwCUAvPMqUKUNgYCCenp5s3bqVOXPmkCdPHjp06MC6devMEtfPz49hw4YluIKrTZs27Nu3Lx4yEkIIIcTnaOOFjRSfWZybQTfZ1HwTv5X7LdYPd2fMgNq1IVcuve37N9+YKbmTJ/Vi6/Fj2L7djFXdl0mmFAr8/f1xd3enc+fO/Pnnn1Feq1u3Lu7u7gQHB8dTdv8XFhaGtbW1RUaeMmXKRKZMmcweRwghhBCfN4My4LHLg8E7BlM4XWF8fvYhu0P2919jgIED9b2Gq1eHv/+G5O8fCPtwBw7oQZIkAX9/KFjQTIG+XDLCJRg9ejSOjo788ccfMb6eM2dOChf+/14QBw8epFKlSiRLloykSZPi4uLCwYMHo1zj5uZGpkyZOHr0KOXKlcPe3p7cuXPj7e0dec7QoUMZNmwYAIkTJ0bTtMhi6urVq2iaxtSpU+nTpw8ZMmTA1taWx48f8+DBA9q1a0eePHmwt7cnc+bMNG3alFu3br2V+3///Uf9+vVJlSoVSZIkIW/evIwaNQqAbNmyce3aNRYtWhQZ2+3VwtCYphQGBQXRuXNnMmTIQOrUqcmbNy/jx49HKRV5jp+fH5qmsWbNGjp37kzq1KlJkyYNzZs35/Hjx8Y+klidO3eO+vXrkzJlSpIkSUKpUqXYtGnTW+ctWbKEfPnyYWdnR6FChVizZo1MURRCCCEsJOhFED/+/SODdgyiaaGm7G29N9Zi68ULaN5cL7batYM1a8xYbG3dqo9mOTrqm3lJsWUWMsL1hYuIiMDPz4969ephZ2cX6/nHjx/HycmJAgUKMG/ePDRNY/To0Tg5ObF//36KFCkSeW5QUBBNmzale/fuDB48mLlz59KhQwfy5s1LhQoVaNOmDTdv3mT27Nns3r0bK6u395wYOXIkJUqUYMaMGURERGBnZ8f169exs7Nj1KhRpEmThtu3b+Pl5UWZMmU4e/Zs5Ps4ePAgzs7O5MqVi/Hjx5MpUyYuXLjA8ePHAfDx8aFGjRoUKVKEoUOHApAmTZoY37fBYKBmzZocOXKE4cOHkzNnTnbs2IG7uzsPHjzAw8MjyvndunWjVq1aLF68mHPnztGnTx+srKyYP3++Uc/lfW7fvk3ZsmVJnjw5kydP5quvvmLKlCnUrFmTdevWUb16dQB8fX1p1qwZderUwcvLi4cPH9K9e3dCQ0PJkyfPR+chhBBCiHc78+AM9f+uz8XAi0yoOoGuJbvGOksnMBDq19cHmkaPhj59zLj11apV0KQJ5M0LmzfD11+bKZCQgstEuneHY8c+/PrX10YfeIiISEIMdUiMvv0WJkyIW9yHDx8SEhJC1qxZjTp/+PDh2Nrasm3bNlKmTAlA5cqVyZYtG8OGDYuyHurp06dMnTqVChUqAFC+fHm2bNnCkiVLqFChQpRpeyVLlsTa+u3/HNOlS4ePj0+Uv6Dy5s3LxIkTI7+PiIigTJkyZMmShY0bN1K/fn0AevXqRapUqdi/fz/29vYAVKxYMfK6okWLYmtrS+rUqSlVqtR73/eGDRvYvXs3c+fOxc3NjadPn1KvXj2Cg4Px8vLC3d2d1KlTR55fvnx5Jk2aBECVKlU4d+4cs2bNiixSP8a4ceN49OgR+/btI1euXADUqFGDAgUKMGDAgMiCa8iQIRQoUCDKn1+hQoUoVqyYFFxCCCGEGfmc8cH1H1fsE9uzzXUbTtmcYr3m8mW97fuVK7B4sV4Lmc2cOdC2LZQsCevXg4ODGYMJmVIo4sTf359atWpFFlsAKVKkoE6dOuzcuTPKufb29pHFFoCtrS25c+fm+vXrRserV69ejAXKtGnTKFKkCMmSJcPa2posWbIA+lQ7gOfPn7Nnzx6aNWsWWWx9DH9/fxIlSkSTaH/7NW/enJcvX77VYKNmzZpRvi9UqBAvXrzg3r17JsmlVKlSkcUWgJWVFU2aNOHYsWMEBQURERHBoUOHaNCgQZQ/v++++47s2d8/lUEIIYQQHybCEEH/bf35cdmPFExTkMO/Hjaq2Pr3XyhdGu7f1/caNmuxNW4ctG4NlSrpwaTYMjsZ4TKRuI4sRfeujY+fPg0hudkm7hK5tunatWtGnR8YGMjXMQw5p0+fnkePHkU55hDDD7CtrS2hoaFG5xdTrEmTJtG1a1fc3d0ZM2YMDg4OGAwGSpUqFXnvR48eYTAYTNb4IjAwEEdHR2xtbaMcT58+feTrb3J0dIzy/evr4vLe35dL0aJF3zqePn16lFI8evSIkJAQwsLCSJs27VvnpUuX7qNzEEIIIURUgSGBNF3ZlM2XNtP2u7ZMqj4JW2vbWK9bvVovsNKn17ux53v//scfTikYNAhGjoSGDWHBArCNPT/x8aTg+sJZW1vj7OyMr68vL168eKugiM7R0ZG7d+++dfzu3btvFRmmENPo1tKlS3FxccHLyyvy2JUrV6Kc4+DgQKJEiWJspPEhHB0dCQwM5OXLl9jY2EQef/1nkSpVKpPEMTaXdz0DTdNwdHTE3t6exIkTc//+/bfOu3fvXuSIoBBCCCE+3n93/6P+3/W59fQWM2rNoG2xtkZdN2kSdOsGJUrozTHM9pmowQBdusDUqdCmDXh7Y/SaFfHRZEqhoF+/fgQEBNC7d+8YX79y5UpkowknJyfWr1/P06dPI19/+vQpa9euxckp9iHz6F4XeCEhIUZf8/z5cxInThzl2Ny5c6N8b29vT9myZVm4cOF7721ra2tUbCcnJwwGA8uXL49yfNGiRdjY2MS6BsyUXjcouXr1auSxiIgI/v77b4oWLUry5MmxsrKiePHirFy5MkoXxcOHD79VnAohhBDiwy06vojSs0vzMuIl/m7+RhVbBgO4u0PXrlCnDuzYYcZiKywMWrTQi63evfXNvaTYsigpuATly5dn3LhxTJ48mcqVK7No0SJ27drFmjVr6NatG998803kP9IHDRpESEgILi4urFy5klWrVlGpUiWeP3/O4MGD4xy7QIECAHh5eXHgwAEOHToU6zXVqlVj8+bNeHh4sHXrVvr378/SpUvfOm/s2LEEBARQunRpFixYwI4dO5g9ezZdunSJEn/Xrl2sW7eOQ4cORSli3lS9enXKli1L+/btmTBhAtu3b6dHjx7MmjWLnj17RmmYYSw3N7cPaqDRo0cPUqZMSeXKlVm8eDHr1q2jdu3anD9/npEjR0aeN2zYME6dOkX9+vXZsGEDf/31Fw0bNiR9+vQkShT1R9/a2prWrVvHORchhBDiSxUWEUb3Td1p7tOcEhlLcPjXw5TMVDLW60JC9Bl948frBdfKlWCC5eYxe/5cb3u4eLHeZ/6PP8zY9lC8ixRcAoDu3buze/duUqZMSa9evahYsSJubm6cOXOG6dOnU7t2bQAKFy6Mn58fKVKkoGXLlrRo0YJkyZKxc+fOKC3hjVWrVi06duzI1KlTKV26NCVKlIj1msGDB9OuXTvGjx9P/fr1OX78OJs3b37rvBIlSrBnzx4yZ85Mly5dqFGjBmPGjImyrmvUqFHkzZuXRo0aUaJEicj28NElSpSI9evX07JlSzw9PWnYsCHr169n3LhxUYqcuAgODv6g9VQZMmRg9+7dFCxYkA4dOvDTTz8RGBjI+vXrqVatWuR5r4vnM2fOUL9+fTw9PfHy8iJ9+vR89dVXUe4ZERFBRETEB70PIYQQ4ktz79k9Ki+ozMQDE+lWshtbW2wlXbLY/5/+4AFUrAg+PnrBNXGiGQebnjyBatX0hWHe3tCvn5kCiVgppeQr2lexYsXU+5w+ffq9r38IJyf9K7qgoCCTxxIfzxTPJUOGDMrT09ME2Rjvxo0bytbWVg0fPtyicc3xMxPdjh07zB5DxJ08l4RHnknCJM8l4XnXMzlw84DK6JVRJRmRRC34b4HR9zt/XqmcOZWys1Nq5UoTJfku9+4pVbSoUtbWSi1dauZglpWQflaAQ8qI2kKaZggRDy5cuEBoaCgdO3Y0W4yQkBDc3d2pVKkSqVOn5vLly/zxxx/Y29vTpk0bs8UVQgghPnXOzvD48bdv7bE668gsOm3oRIbkGdjbei/fpv/WqPvt2QN16+qz+XbsALMu/b5+HSpXhhs39E4cr/bnFPFHCq4EIno7ePF5y507NwEBAWaNYWVlxd27d+ncuTMBAQEkTZqUcuXKsXz58hjb7QshhBAiZi/CX9BlYxdmHplJlZxVWNJgCY5JjOvOvHy53rMiSxZ9dt8b22ia3rlzerEVFARbtkDZsmYMJowlBZcQnykbGxt8fHziOw0hhBDik3Yz6CY/LfuJA7cO8FvZ3/i9wu9YJYp94ZVS4OWlNwYsUwb++Qc+oMeW8Y4cgapVIVEi/ZP8b40bfRPmJwWXEEIIIYQQMfC/5k/D5Q15HvaclY1W8mP+H426Ljxc319r6lS9I+Fff4GdnTkT9YdatcDBAXx9IU8eMwYTcSVdCoUQQgghhHiDQvEgx3Rc/nIhpV1KDrQ5YHSxFRysd2J/ve3V0qVmLrbWr9dHtjJm1BeLSbGV4MgIlxBCCCGEEK8EhgSyL0cTwrJuoU7uOvxV7y++svsq9guBu3f1gaajR/WCq0MHMye7eDG0bKlPH9y40cxzFsWHkhEuIYQQQgghgM0XN1NoWiHCMm8n8dGO+PzsY3Sxdfq03n3wzBlYvdoCxdbUqdC8ud4YY9s2KbYSMCm4hBBCCCHEFy34ZTAd1nWg2qJqONg58N3hAxS4OpJEmnH/VPbzgx9+gBcv/r+cymyUghEjoFMnqF1bH9lKkcKMAcXHkoIrgXB2dsbZ2Tm+0xBCCCGE+KLsvbGXIt5FmH54Or1K9+LQr4dI/uw7o69fuBCqVNGXUO3fD8WKmTFZpaBXLxg0SO81v3KlmReICVOQgksIIYQQQnxxXoS/4Letv1FubjkiVAR+bn6MqTIGO2vjCpjXA00tWuht3/fsgaxZzZhweDi0bg3jxkGXLjBvHlhLO4ZPgRRcItK+ffto1KgRGTJkwMbGhlSpUlG5cmXmz59PREREfKf3XlevXkXTNObNmxffqbzTvHnz0DSNq1evxvlaTdMYOnSoyXMSQgghvkTH7x3n+1nfM3rPaFp924rj7Y9TPmt5o68PC4O2bfWBpubNYdMmSJnSjAmHhkKjRjB3LgwdChMn6vttiU+CPCkBwIQJEyhTpgyBgYF4enqydetW5syZQ548eejQoQPr1q2L7xSFEEIIIT5KhCECz92eFJ9RnHvP7rG2yVpm1plJctvkRt8jKEhfozV7NgwcqO+xZWtrxqSfPtUD+vjAhAkwZAhomhkDClOTcUiBv78/7u7udO7cmT///DPKa3Xr1sXd3Z3g4OB4yk4IIYQQ4uNdCryE6z+u7L2xlwb5G+Bdy5vU9nHr7HfzJtSsqXcknD0bWrUyU7KvBQRAjRpw+DDMnw+urmYOKMxBRrgEo0ePxtHRkT/++CPG13PmzEnhwoUBePDgAe3atSNPnjzY29uTOXNmmjZtyq1bt6Jc4+bmRrZs2d66V/TmIM+ePaNLly5kyZIFW1tb0qVLR6VKlTh79mzkOZMnT6Z06dI4OjqSMmVKSpUqxfr16z/ovQ4dOhRN0zh79ixVq1YladKkZMmShblz5wKwYMEC8uXLR7JkyahQoQKXLl2Kcn1YWBgDBw7km2++wcbGhmzZsjFw4EDCwsKinHf58mVq1qyJvb09adKkoVu3brx48SLGnGbOnEmRIkWws7MjderUtG7dmsDAwA96fzF5+PAhHTp0IGPGjNja2pIvXz5mzJgR5ZzX0x39/f2pV68eyZIlI1WqVHTq1ImQkBCT5SKEEEJYmlIK70PeFPEuwqn7p1hYfyHLGy6Pc7F1/Lje9v3KFX2vYbMXW7dvg5MT/Pef3hxDiq1PloxwfeEiIiLw8/OjXr162BnR5SYwMBA7OztGjRpFmjRpuH37Nl5eXpQpU4azZ88adY839ejRgzVr1uDh4UHu3LkJCAhgz549PH78OPKcq1ev0qZNG7Jly0Z4eDhr166lVq1abNiwgerVq8f5PQM0bNiQtm3b0qtXL6ZOnUqrVq24cOECfn5+jB49mrCwMLp160bTpk05cOBA5HUtW7Zk2bJl9OzZExcXF/bt28eIESO4fPkyixcvBuDly5dUrlyZkJAQpkyZQtq0aZk+fTqrVq16K49+/frh5eVF165dGTNmDLdu3WLgwIGcPHmSvXv3YmVl9UHv77WgoCDKlClDSEgIQ4cOJXv27GzevJkOHTrw4sULunTpEuX85s2b06hRIzp27MjBgwcZPnw4wcHBCXptnBBCCPEut5/epvWa1my6uInKOSozp+4cMqXIFOf7bNkCP/2kd1/fvRtefQ5tPpcuQaVK8PCh3va9QgUzBxTmJAWXiXTv3p1jx4598PWvr43eGj4iIsLof3R/++23TJgwIU5xHz58SEhICFmNbKuTN29eJk6cGCW/MmXKkCVLFjZu3Ej9+vXjFH/fvn00a9aM1q1bRx6Lfo+xY8dG/t5gMODi4sL58+fx9vb+4IKrd+/euL76pKh48eKsXbuW6dOnc+XKFVK82svizp07dOvWjWvXrpE1a1ZOnjzJkiVLGDJkCD179iR58uRUqVIFKysrBg0aRL9+/ShcuDDz58/n8uXL7Nu3j1KlSgFQvXp1ChUqFCWHq1evMmbMGIYMGcLgwYMjj+fJk4eyZcuydu1a6tWr90Hv77WJEydy7do1Tpw4Qe7cuQGoVKkSjx8/ZtiwYXTo0AHrNzoc1ahRI/LPu0qVKmiaxuDBg+nfvz958uT5qFyEEEIIS1p6cikd13ckNDyUKTWm0KF4B7QPWPs0Zw78+isULKiPbGWKe70WN8ePQ9WqemeO7duhRAkzBxTmJlMKRZxNmzaNIkWKkCxZMqytrcmSJQsA586di/O9SpQowbx58/Dw8ODQoUMxdkM8fPgwtWrVIl26dFhbW5M4cWJ8fX0/KN5rbxZqDg4OpE2bllKlSkUWWwD58uUD4MaNG4C+1g30UaA3vf5+586dgF5EZs6cObLYAkiUKBGNGjWKcp2vry8Gg4FmzZoRHh4e+VWyZElSpEgRGe9jbNq0iZIlS5I9e/YoMapWrUpAQACnT5+Ocn70HBs3bozBYODgwYMfnYsQQghhCYEhgTRe0ZgmK5uQN3VejrU/RscSHeNcbCmlN8Vo3RpcXGDXLgsUW/v26dMIraz0HZSl2PosyAiXicR1ZCm61yNbfn5+UY4/ffqU5MmN75wTV6lSpSJJkiRcu3bNqPMnTZpE165dcXd3Z8yYMTg4OGAwGChVqhShoaFxjj9p0iTSp0/PnDlzGDBgAI6Ojri6ujJy5Ejs7e25ceMGLi4uFChQgEmTJpElSxasra0ZNGgQZ86ciXO81xwcHKJ8b2NjE+MxIPJ9vV5X9fXXX2MwGCLPS58+fZTX79y5Q7p06d6KGf3Y/fv3AciVK1eMOQYEBBj3Zt7j/v37XLx4kcSJExsVI3qOr7+PvkZPCCGESIg2XthI6zWtefD8ASMrjqRPmT5YJ4r7P3cNBrhxw56RI/WCa9o0eMf/Sk1nyxaoXx8yZABfX4hhLbz4NEnB9YWztrbG2dkZX19fXrx4gW0sfU2XLl2Ki4sLXl5ekceuXLny1nl2dna8fPnyreMBAQGkSpUq8vtkyZIxatQoRo0axbVr11ixYgX9+vXDxsYGT09PNm3axJMnT1i2bBmZ3vhY6fnz5x/ydj+Ko6MjAHfv3iVt2rSRx+/evQsQ+b6+/vprTp069db19+7di/L96/O3bNnyVrH35usfI1WqVKRNmzbKNNA35c2b960cCxYsGOV7gIwZM350LkIIIYS5PHv5jF5bejH98HS+SfsN65uup+jXRT/oXnfv6rP6njyxYcQI6N/fAl3YV6yApk0hf37YvBlefZgrPg8ypVDQr18/AgIC6N27d4yvX7lyhePHjwN6oRN9tOR1h783Zc2alXv37vHw4cPIY5cuXXrvNMCsWbPSs2dPChUqxMmTJyPjAVFinj9/nj179hj57kzHyckJ0IvONy1atAiA8uX1DRNLly7NjRs32L9/f+Q5BoOBZcuWRbmucuXKJEqUiOvXr1O8ePG3vrJnz/7ROVerVo2zZ8+SJUuWGGNEHz2NnuPSpUtJlCgR33///UfnIoQQQpjDnut7KOJdhBmHZ9D7h9782/bfDy629u2DYsX0ra+yZAlmwAALFFuzZ8PPP+vTB3fulGLrMyQjXILy5cszbtw43N3dOXPmDG5ubmTJkoVHjx6xbds2Zs2axeLFiylcuDDVqlXD09MTDw8Pvv/+e7Zv386KFSveumfDhg0ZNGgQzZo1w93dnYcPHzJq1ChSp47agrV06dLUqVOHQoUKkSxZMnbu3Ml///1Hy5YtAb3Bg7W1Na6urvTs2ZM7d+4wZMgQsmTJEmVanyUULFiQJk2aMHToUIKDg6lQoQL79u3j999/p0mTJpGt81u2bMno0aP58ccf8fDwIG3atHh7exMUFBTlfjlz5qRv37507tyZc+fO4eTkhJ2dHTdu3MDX15c2bdpQ4R1dia5evUr27NkZMmQIQ4cOfWfOPXr04O+//6ZcuXL06NGDvHnzEhwczNmzZ9m1axerV6+Ocv6GDRvo3bs3VapU4eDBgwwbNgxXV1dpmCGEECLBeRH+gsE7BjNm7xiypczGTredlMta7oPupRRMnw5du0LmzFC0KISHh8V+4ccaOxZ694Zq1fRRrqRJzR9TWJwUXALQuyx+//33jB8/nl69evHw4UOSJ09O8eLFmT59OrVr1wZg8ODBPH78mPHjxxMaGoqTkxObN28mR44cthSgpQAAIABJREFUUe6XK1cuVqxYwcCBA6lXrx558uRh3LhxeHh4RDmvfPnyLFu2jNGjRxMeHk6OHDkYP348Xbt2BfQiZ9GiRQwePJg6deqQM2dORo8ezaZNm95a72YJ8+fPJ0eOHPz111+MGTOGDBky0LdvX4YMGRJ5jo2NDb6+vnTu3JmOHTuSNGlSmjZtSs2aNWnfvn2U+3l4eJA/f36mTJnClClT0DSNzJkz4+LiEtlVMCavN6JOH8unYF999RV79+5l+PDheHp6cuvWLVKmTEnevHlp0KDBW+cvXLgQLy8vpk2bho2NDW3bto3SJVIIIYRICP67+x8tfFpw4v4Jfv3uV8ZWGUty2w9b8x4aCh07wty5UL06LFqkL6V6Y4ca01MKBgyAUaOgUSNYsABerR0XnyGllHxF+ypWrJh6n9OnT7/39Q/h5OSknJyc3joeFBRk8lji48X3c5k+fbpKnTq1Cg4ONsn95s6dqwB14cIFk9wvOnP8zES3Y8cOs8cQcSfPJeGRZ5IwyXMxTlhEmPLw91CJhydW6cemV+vPr/+o+127plSxYkqBUoMGKRUerh93clKqSJFHH59wTMLDlWrfXg/666//DyqMkpB+VoBDyojaQka4hPgE7dy5kx49emBvbx/fqQghhBAWcTHwIq4+ruy7uY+GBRoyreY0Utl/eIOpbdugcWN4+RJWr4Y6dUyY7Lu8fAktW8LSpdC3rz7CZfZFYiK+Wbzg0jQtMzAeqAxowFagu1LqeizXFQd+BcoDWYCHwC5goFLqSrRzrwIx7eRbXyn1z8e+B3OIj+lx4tP1ulGHEEII8blTSuF9yJtevr2wsbJh8Y+LafxN4w/axFi/n750ql8/yJcPVq2CaE17zeP5c/jpJ9i4EUaP1gsu8UWwaMGlaZo9sB14AbQEFDAC2KFpWmGlVPB7Lm8MFAT+BE4BGYFBwCFN075VSt2Idv5mYGi0Yx++U64QnzE3Nzfc3NziOw0hhBAiiltBt2i9pjWbL22mSs4qzKkzh4wpPnyrkmfPoFUrWL5cr33mzAEzbnf6f48fQ+3asGcPzJgBbdtaIKhIKCw9wtUWyAHkVUpdBNA07ThwAWgHjHvPtZ5KqQdvHtA0bQ9w5dV9B0c7/6FSaj9CCCGEEOKTopRi6cmldNzQkZcRL5laYyrti7f/4FEtgPPn9WYYZ8/CH39Ar14Wms13757ehfDUKX0qYaNGFggqEhJLF1x1gP2viy0ApdSVV4VTXd5TcEUvtl4du6Zp2gP00S4hhBBCCPGJC3geQMcNHVl2ahmlM5Vmfr355E717s69xlizBlq0gMSJYcsWcHExUbKxuXYNKlWCW7f0JKpVs1BgkZBYeuPjgsDJGI6fAgrE9WaapuUH0gJnYni5tqZpzzVNe6Fp2n5N0+rF9f7vozcmEULERn5WhBBCGGvDhQ18M+0bfM744FHRA/9f/D+q2DIYYMgQqFsXcueGw4ctWGydOQNlysDDh+DrK8XWF8zSI1yOwKMYjgcCDnG5kaZp1oA38ACYHe3ltcC/6NMN0wGdAR9N01oopRbGNenoEidOTEhIiHSIE8IIISEhJE6cOL7TEEIIkYA9ffGUnlt6MvPITL5J+w0bm23k2/TfftQ9Hz2C5s1hwwb45ReYOhXs7EyUcGwOHdILLGtr2LkTChe2UGCREGmW/PRZ07SXgJdS6rdox0cCfZVSRheAmqZ5A62BmkqpLbGcawXsB9IrpTK/45xf0bsgki5dumJLly595/2srKxIkSIFGTNmxMbG5qPmE8cmIiICKysrs91ffBh5LrFTSvHy5Utu3bpFUFAQERERZo337NkzkiVLZtYYIu7kuSQ88kwSpi/5uRx/fJzR50ZzN/QujTM3xi2bGzaJPm4T4EuXkjJ48Dfcv29Lly4XqV37dpzWa3Xv/i0RERFMmnQizrFTHjvGN/37E/bVVxwfO5aQjLLyxZQS0s9KhQoVDiulisd2nqVHuB6hj3JF50DMI18x0jRtFHpx1DK2YgtAKRWhadpywFPTtK+VUndiOGcGMAOgePHiytnZ+b33DAoK4v79+4SFhRmb9gcJDQ3FzmIfxwhjyXMxTuLEicmePTspUqQweyw/Pz9i+7kVlifPJeGRZ5IwfYnPJTQ8lME7BjP2v7Fkd8iOfxN/ymYp+9H3XbwYunQBBwfw94fSpfMAeeJ0j5Qp4fHjx3F/JmvW6P3mc+bEessWSkqxZXKf4s+KpQuuU+jruKIrAJw25gaapg0A+gFdlVIL4hD79ecaJhnSS5EihcX+EVm0aFGzxxFxI89FCCGE+HDH7h6jhU8LTt4/Sbti7RhbZSzJbD5u1CIsDPr0gQkToFw5WLYM0qc3UcLGWLBAn7v43Xf6XlupPnxTZvF5sXTTjDVAKU3Tcrw+oGlaNqDMq9feS9O0ruj7dg1QSk0yNuir9V4NgetKqbtxzFkIIYQQQphAuCEcj10efD/zewKeB7Ch6Qa8a3l/dLF17x5UrqwXW127wrZtFi62Jk0CV1dwctKDS7El3mDpEa6Z6A0sVmuaNhB9tOl34AYw/fVJmqZlBS4Bw5VSw18dawxMADYB2zVNK/XGfYOUUqdfndcEvcX8hlf3TQd0AooBTcz67oQQQgghRIwuBFzA9R9X9t/cz88Ff2ZKjSmksv/4wuTAAWjQAAID9UGm5s1NkKyxlILff9dbIdarB0uWWLAzh/hUWLTgUkoFa5pWERgPLECf5rcN6K6UevbGqRpgRdQRuGqvjld79fWmnYDzq99fQW8VPwZ9vdhz9I6F1ZRSm035foQQQgghxPsppZh2aBq9fXtja2XLkgZLaPxNY5Pce8YMfb1Wxoywdy98+3GNDePGYAB3d5g4EVq2hFmz9K6EQkRj8f8qlFLXgQaxnHOV/6+5en3MDXAz4v77gYofnKAQQgghhDCJm0E3abW6Fb6Xfamasyqz68wmY4qPbyQRGqoXWrNmQdWqeqMMx5jasplLeDi0aQPz50O3bjBuHCSy9Eod8amQMlwIIYQQQpiUUorFJxbTeWNnXka8xLumN78W+9UkW+ncuKFPIfz3XxgwAIYNA1Pv1OLnB35+x/j/BKo3hIZC48awejUMHw4DBxKnnvPiiyMFlxBCCCGEMJmHzx/SYX0HVpxewQ+Zf2B+vfnkcsxlknvv2AE//6zXPD4++rIps3B25tvHj+HYsajHnz6FunX1RP78Ux9mEyIWUnAJIYQQQgiTWHd+HW3WtCEwJJDRLqPp9UMvrBJ9/PCTUjB+vN72PU8evdjKm9cECcdFQABUrw5HjsRDdw7xKZOCSwghhBBCfJSnL57ivtmdWUdnUThdYba02ELhdIVNcu/gYGjdGv7+W59KOHcuJE9uklsb79YtqFIFLl3Sq73atS2cgPiUScElhBBCCCE+mP81f1r+05LrT67Tr0w/hjoPxdba1iT3vnABfvwRTp+G0aP1ES6LL5e6eBEqVdL7zm/aBM7OFk5AfOqk4BJCCCGEEHEWGh7KoO2D8NrnRQ6HHPi7+VMmSxmT3X/dOn3WnpWVXudUrmyyWxvvv//0Nojh4bB9OxQvHg9JiE+dFFxCCCGEECJOjt45SgufFpx6cIr2xdozpsoYktkkM8m9DQa9+d+wYfDdd7ByJWTLZpJbx4lVcDA4OenzF3fsgPz5LZ+E+CxIwSWEEEIIIYwSbghn9O7RDNs5jLRJ07Kx2Uaq5apmsvs/fqyPaq1fr+8lPG0aJElistsbLyCAZJcuQa5c4OsLWbPGQxLicyEFlxBCCCGEiNX5gPO4+rhy4NYBmnzThMk1JuOYxHS7DZ84AfXrw7VrMGUKdOgQD+u1DAYYMQJOniTCzg7rXbsgXToLJyE+N1JwCSGEEEKIdzIoA1P/nUof3z4kSZyEpQ2W8vM3P5s0xtKleifCr76CnTvhhx9MenvjBAZCixawYQOkTcuztGlJKcWWMIFE8Z2AEEIIIYRImG48uUHVhVXpsrELztmcOdHhhEmLrfBw6NULmjSBokXh8OF4KraOHIFixfTpg1OmQL58ercOIUxACi4hhBBCCBGFUoqFxxdSaFoh9t3Yx/Ra01nfdD0ZkmcwWYz79/XOg15e0Lmz3gTw669NdnvjzZmjV3nh4eDvDx07xsNcRvE5kymFQgghhBAi0oPgB3RY34GVZ1ZSJnMZ5tebT07HnCaNcfCgvonxw4cwfz64upr09sYJDYUuXWDWLHBxgSVLIE2aeEhEfO6k4BJCCCGEEACsPbeWtmvb8ij0EZ6VPOlZuidWiUw7tW72bH0QKUMG2LtXn0pocVev6hXfkSPQv7/eh16mEAozkYJLCCGEEOILF/QiCPfN7sw+Opsi6Yrg28KXQukKmTTGixfQtSvMmAFVqsDixZAqlUlDGGfjRmjWTO9IuHo11KkTD0mIL4ms4RJCCCGE+ILtvLqTIt5FmHtsLv3L9udg24MmL7Zu3oTy5fVi67ff9EaAFi+2DAYYOhRq1oTMmeHQoXcXW35+HJswwaLpic+XjHAJIYQQQnyBQsNDGbBtAOP3jyenY052/7Kb0plLmzyOnx80aqQvmVq1St9ry+ICAvQdlTdt0heMTZsG9vbxkIj4EknBJYQQQgjxhTly5wgtfFpw+sFpOhbvyB+V/yCpTVKTxlAKJkyA3r0hd27w8dG7rVvc4cP6eq07d/RCq1076UIoLEqmFAohhBBCfCHCDeH8vvN3Ss4qyePQx2xqtokpNaeYvNgKDtaXSbm767P2DhyIp2Jr1iwoU0afTrhrF7RvL8WWsDgZ4RJCCCGE+AKce3gO139cOXjrIE0LNWVy9ck4JHEweZxLl/RpgydPgocH9OsXDzVOSIi+udecOfpmX4sXQ+rUFk5CCJ0UXEIIIYQQnzGDMjDl4BT6bO2DfWJ7lv20jIYFG5ol1oYN+shWokT6cqkqVcwS5v0uX4affoKjR2HgQL1RhrR8F/FICi4hhBBCiM/UjSc3+GX1L2y7so0auWswq/Ysvk7+tcnjGAwwciQMGQJFiujNMbJnN3mY2L2u+ADWroVateIhCSGikoJLCCGEEOIzo5Ri4fGFdN7YGYMyMKPWDNp81wbNDHP7njyBFi30+qZFC/D2jocGgBERMGwY/P77/yu+HDksnIQQMZOCSwghhBDiM/Ig+AHt1rXD56wP5bKUY169eeRwME/xceqUvl7ryhWYNAk6dYqH9VoBAdC0KWzZAm5uMHUqJEli4SSEeDcpuIQQQgghPhNrzq2h7dq2PA59zJjKY+hRqgdWicyzfmn5cvjlF0ieHHbsgLJlzRLm/f79V1+vdfcuTJ8ObdtKF0KR4EhbeCGEEEKIT1zQiyBarW5F3aV1yZA8A4d/PUyvH3qZpdgKD9f31mrUSJ+9d/hwPBRbSsGMGf8PvHs3/PqrFFsiQZIRLiGEEEKIT5jfVT/c/nHjRtANBpQbwGCnwdhY2Zgl1oMH0LgxbN+uTx8cNw5szBPq3UJCoGNHmDdPb4O4aJG0fBcJmhRcQgghhBCfoJCwEAZsH8D4/ePJ7ZibPa32UCpTKbPFO3QIfvxRL7rmzYOWLc0W6t0uX4YGDeDYMRg8WP+Slu8igZOCSwghhBDiE3Po9iFcfVw58/AMnUp0wrOSJ0ltkpot3pw5+qBS+vSwZw98953ZQr3bunV6G0SA9euhRo14SEKIuJM1XEIIIYQQn4iwiDCG+Q2j1KxSBL0IYkvzLUyuMdlsxdaLF9C+PbRuDeXK6aNcFi+2IiL0DYxr19Y39zpyRIot8UmRES4hhBBCiE/A2YdnaeHTgkO3D9G8cHP+rPYnDkkczBbv1i29AeD+/dC3r76xscVn7z18qLd89/WFVq1g8mRp+S4+OVJwCSGEEEIkYAZlYNKBSfTb1o+kiZOyvOFyfirwk1lj+vtDw4bw/DmsWKEvm7K4gwf1iu/+fZg5E9q0iYckhPh4UnAJIYQQQiRQ159cx+0fN3Zc3UGtPLWYWXsm6ZOlN1s8pfQNjHv2hBw59P21ChQwW7h3JzF9OnTrBhky6IvGihWzcBJCmI4UXEIIIYQQCYxSir/++4uum7piUAZm1Z5Fq6Kt0My4z9Tz5/pWVosWQd268NdfkCKF2cK9O4kOHfTg1arpyTg6WjgJIUxLCi4hhBBCiATkfvB92q1rxz9n/6F81vLMqzuP7A7ZzRrz8mW95fvx4/parX79IJGlW6tdvKjPXTxxAoYOhUGD4iEJIUxPCi4hhBBCiARi9dnVtF3blicvnjC28lh6lO5BIs28RcemTXpfCoCNG6FqVbOGi9maNeDqqhdYGzboo1tCfCak4BJCCCGEiGfPwp/xy+pfmHdsHkXTF2VH/R0UTFvQrDENBvDw0PcOLlwYVq3S121ZVESEnoCHh75Oa8UKyJbNwkmIT4WzszOPHz/m2LFj8Z1KnEjBJYQQQggRj4p4F+HM/TMYMDCo/CAGlh+IjZWNWWM+eQItW8Lq1dCsGcyYAfb2Zg35tgcPoEkT2LZN70A4aRLY2Vk4CSHMTwouIYQQQoh4EBgSSB/fPhy/dxzbRLbs+mUXJTOVNHvc06ehfn193daff0LnzmDGXhwxO3BAb/n+4AHMnq3vsSVELEJDQ1FKxXcacWb0pGBN0wprmrZM07S7mqa91DTtu1fHR2iaVsV8KQohhBBCfD5edyDMOzkv847NI3OKzORJlscixdaKFfD99/oI17Zt0KWLhYstpWDqVChXDqytYe9eKbZErE6ePEnTpk05cOAAwcHB8Z1OnBlVcGma9gNwACgCrALe3Gc8EdDe9KkJIYQQQnxezj08h8tfLrT8pyW5HXNztN1Rrve4zp9F/zRr3PBw6NtX38y4UCE4fBjKlzdryLcFB+uNMTp1gsqV9SS++87CSYhPyaFDh6hfvz6FChVi7dq1ZM6cGVtb2/hOK86MHeHyBLYB+YGuwJufhRwCZDc6IYQQQoh3CA0PZciOIRT2LszRu0eZXms6u1vtplC6QmaP/fAhVK8Of/yhb3Hl5wcZM5o9bFQXLkDp0vq+WsOHw9q1sr+WeKddu3ZRrVo1SpQogZ+fH0OGDOHatWvkyJGDxIkTx3d6cWbsGq5iQAOllEF7e8e9h0A606YlhBBCCPF52Hp5Kx3Wd+Bi4EWaFWqGVxUv0iWzzD+dDh/W99e6dw/mzIFffrFI2Kj++Ufv0GFtHY9950VCp5Ri69atjBgxAn9/f9KkScPo0aPp0KEDKSy+A7dpGTvC9QJI8o7X0gNPTJOOEEIIIcTn4d6zezRf1ZzKCyoD4NvCl4U/LrRYsTV/PpQpo/9+z554KLbCw/UdlOvXhzx54MgRKbbEWwwGA2vWrKFkyZJUqVKFS5cuMXHiRK5evUrfvn0/+WILjB/h2g101TTtnzeOvW4R0grYYdKshBBCCCE+UQZlYObhmfTb1o/nYc8ZXH4wv5X7DTtry7Q8f/kSevTQe1O4uMCSJZAmjUVC/9/9+9C4MezYAb/+ChMnSst3EUVERAQrVqxg5MiRnDhxguzZszNjxgxcXV3fuU7Lz88PPz8/yyZqAsYWXIPRi66jwHL0Yqu5pml/AKWA782TnhBCCCHEp+PEvRO0W9eOfTf34ZzNGe+a3uRNnddi8W/f1rut79sHffrAyJH6TD6L2rdP784REABz54Kbm4UTEAlZWFgYixYtYtSoUZw/f578+fOzYMECGjdujLXF/2O1DKOmFCqljgLOwGNgKHrTjO6AHVBBKXXG2ICapmXWNG2FpmlPNE0L0jRtlaZpWYy4rrimaTM0TTuradpzTdOua5q2SNO07DGcm0jTtN80TbuqaVqopmn/aZrWwNgchRBCCCHiIvhlMH18+1B0elEuBF5gfr35bHfdbtFia/duKFYMjh+HZcvA09PCxZZSMHkyODmBra1eeEmxJV4JDQ1l2rRp5M6dm19++QV7e3tWrFjByZMnad68+WdbbEEcNj5WSv0LOGmaZg+kBh4ppZ7GJdira7ejrwlriT5SNgLYoWlaYaXU+xrrNwYKAn8Cp4CMwCDgkKZp3yqlbrxx7u9AL2AAcPjVtcs1TaullNoQl5yFEEIIId5n3fl1dN7QmWtPrtGmaBtGVxpNKvtUFov/us5xd4fs2WHrVihY0GLhdcHB+tTBxYuhVi346y9wcLBwEiIhCg4OZvr06YwdO5Y7d+5QunRppkyZQo0aNXi7F9/nyaiCS9O0GYCHUuqqUuo5cP2N17IAA5VSvxpxq7ZADiCvUuriq+uPAxeAdsC491zrqZR6EC2vPcCVV/cd/OpYWvRia7RSauyrU3dompYLGA1IwSWEEEKIj3Yz6CbdNnVj1ZlVFExTkF2/7KJslrIWzeH5c2jfHhYsgDp19Drnq68smgKcP6+3Qjx9GkaMgN9+g0TG9mUTn6snT54wefJkxo8fT0BAABUrVmTRokU4Ozt/MYXWa8b+NLQB0r7jtTRAayPvUwfY/7rYAlBKXQH2AHXfd2H0YuvVsWvAA/TRrteqAjbAwminLwQKxTQFUQghhBDCWOGGcCbsn0D+KfnZeGEjo1xGcaTdEYsXW1eu6F0IFy6E338HH594KLZWrYLixeHuXdi8GQYMkGLrC/fw4UMGDhxI1qxZGThwIKVKlWLv3r1s27aNChUqfHHFFsRhSuF7pANCjDy3ILA6huOngIZxDaxpWn70QvDNNWQF0acsXox2+qlXvxZAHxUTQgghhIiTQ7cP0W5dO47cOUL1XNWZUmMK2R0s/1nu5s3QpIk+nXD9en1jY4sKD4f+/WHMGChRAlasgCyxLskXn7E7d+4wduxYvL29CQkJoUGDBvTv35+iRYvGd2rxTlNKxfyCptXl/6NObsB69NGkNyUBnICLSqnysQbTtJfAOKVUv2jHRwD9lFJGF4CaplkD24D86FMUH706PgOoo5RKH+38XOhTF12VUgtiuN+vwK8A6dKlK7Z06VJjUzGrZ8+ekSxZsvhOQ0QjzyXhkWeSMMlzSXjkmXyYZ+HPmHNlDv/c/gdHG0c65+qMU2onk31ab+xzUQoWLcrCnDnZyZ49mOHDT5IxY6hJcjBW4sBACvz+Ow7HjnGrTh0uduqEsrGxaA6WID8rxrl79y5Llixh48aNRERE4OLiQrNmzciaNatZ4iWk51KhQoXDSqnisZ33vgInB1D51e8Veuv3l9HOeQEcAvrGIbeYKrwP+dtqMvADUPN1sfXGveIcQyk1A5gBULx4ceXs7PwBKZmen58fCSUX8X/yXBIeeSYJkzyXhEeeSdwopVhxegXdNnXj7rO7dCrRiREVR/CVnWnn7hnzXIKC9KZ/Pj7QtCnMmJGMpElLmTSPWO3dC126QGAgzJ9PRlfXKOs6Pifys/J+58+fZ9SoUSxcuBBN03Bzc6Nv377kzJnTrHE/xefyzoJLKTUeGA+gadoNoJZS6r+PjPcIcIzhuMOr14yiadoo9NGolkqpLdFeDgQcNE3TVNThO4c3XhdCCCGEeK8rj67QaUMnNl7cSNH0RVndeDUlMpaIl1zOnIH69eHiRZgwAbp2BYsuhVEKJk2Cnj0ha1bYvx+KFLFgAiKhOH78OB4eHixfvhwbGxs6duxI7969yZQpU3ynlmAZNYVPKZXZRPFOoa+xiq4AcNqYG2iaNgDoB3SNaWrgqxi2QE6iruMq8OpXo+IIIYQQ4ssUFhGG1z4vhu8cjlUiKyZUnUCn7zthnSh+9gny8QFXV7C3h23b9G2uLOrZM2jbFpYuhdq19VaIKVNaOAkR3/79919GjhzJ6tWrSZYsGb1796ZHjx6kS5cuvlNL8OL0N4emaSmAXOgbHkehlNprxC3WAGM1TcuhlLr86p7ZgDLoRVRs8bui79s1QCk16R2nbUKf+tgMGPbG8ebAyVddEYUQQggh3rL7+m7ar2vPqQen+DH/j0ysNpFMKcz7yb2zMzx+/C3HjkU9HhEBgwbBqFFQsqTel8Ligwhnz0KDBvqvHh7Qt690IfzC+Pv7M3LkSLZs2YKDgwNDhw6lS5cuODrGNGlNxMTYfbhsgZlAE97dSt7KiFvNBDoDqzVNG4i+1up34AYw/Y14WYFLwHCl1PBXxxoDE9ALqu2apr05aTlIKXUaQCl1X9O08cBvmqY9BY4APwMViaX1vBBCCCG+TIEhgfTx7cPso7PJ8lUW1jZZS608teItn4AAvQuhry+0awcTJ4KtrYWTWLlSXzRmZwdbtoCLi4UTEPFFKcWWLVsYOXIku3btIm3atHh6etKhQweSJ08e3+l9cowd4RqI3kCjDTAX6IreMMMNfR8ud2NuopQK1jStIvrasAXojSy2Ad2VUs/eOFVDL+DeLO6qvTpe7dXXm3YCzm98PwB4BnQD0gPngEZKqbXG5CmEEEKIL4NSigXHF9BzS08ehTyi9w+9GeI0hKQ2SeMtpyNH9EGl27dh1ixobexup6YSHg79+oGXlz60tnw5ZDbV6hKRkBkMBtasWcPIkSM5dOgQmTJl4s8//6RNmzYkSZIkvtP7ZBlbcDUEhqNvHjwX2KuUOgLM1DRtFeACrDPmRkqp60CDWM65SrSugkopN/QCz5gYEehTD0cYc74QQgghvjznHp6jw/oO7Li6g1KZSjG91nQKpyscrzn99Zc+opU6NezerW9xZVF378LPP4O/P3TsCOPGxcPQmrC0iIgIli1bhoeHBydPniRnzpzMnDkTV1dXbD7Dlv+WZuwk3CzAqVeFTBjw5sc+s9CnGgohhBBCJHih4aEM2TGEwt6FOXr3KN41vdnTak+8FlsGA3TuDC1bQunScPhwPBRbu3fDd9/Bv//CggUwZYoUW5+5ly9fMmfOHPLnz0/Tpk2JiIhg4cKFnD17ljZt2kixZSLGjnAFAK93GLsJFAZ2vfreAX0DZCGEEEKIBG3r5a10XN+RC4EXaFqoKeOqjCNdsvjtsvbiBVzGHPX+AAAgAElEQVS6lIwTJ6BXL71JhrUlGyIqpS8S690bsmWDzZuhUCELJiAsLTQ0lDlz5uDp6cn169cpWrQoK1eupF69eiSSpigmZ+yP8wGgCLABWAX8rmmaPRAO9AH2mCc9IYQQQoiPd+/ZPXpu6cmiE4vI5ZiLLc23UDln5XjN6dEjmDlTH82KiLDi77+hUSMLJ/H0KbRpA8uWQb16MG8efGXaTZ1FwvHs2TO8vb3x8vLi7t27/PDDD3h7e1OtWjU0i27s9mUxtuD6A8j66vcjgDzAKPQpiYeAjqZPTQghhBDi4xiUgVlHZtF3a1+ehz1ncPnB/FbuN+ys39rhxmLOnIE//9TXaz1/rm9plTbtUxo1SmH5RBo0gHPnYPRo6NPHwrspC0t5/PgxkydPZvz48QQGBuLi4sKSJUtwcnKSQssCjN34+CBw8NXvnwB1NU1LAtgppR6ZMT8hhBBCiA9y4t4J2q1rx76b+3DO5sy0mtPIlzpfvORiMOid1SdOhE2b9KVRzZpBt27QtSs8fmywbELLl0OrVpAkid57vmJFy8YXFvHgwQMmTJjA5MmTCQoKolatWgwYMIBSpUrFfrEwmVgLLk3TbIDd6JsN+74+rpQKAULMmJsQQgghRJwFvwxm2M5hjNs3DockDsyvN58WhVvEyyf5wcF6/4mJE/W9g9Onh99/1zsRpklj8XQgLEzfvHj8eChVSi+8LL6bsjC327dvM3bsWKZPn05ISAg//fQT/fv359tvv43v1L5IsRZcSqmXmqblASIskI8QQgghxAdbd34dnTd05tqTa7Qu2hrPSp6ksk9l8TyuX9eb/M2YAY8fQ7FieuHVqBHEW+O3O3f0lu+7dkGXLjB2bDwmI8zh6tWreHp6MmfOHCIiImjWrBm//fYb+fLFz8iu0Bm7hmsrUAnYbsZchBBCCCE+yM2gm3Tb1I1VZ1ZRIE0B/N38KZe1nEVzUAr27YMJE2DVKv37H3+E7t3hhx/ieXnUrl16tRcUBIsWQdOm8ZiMMLVz584xatQoFi5ciJWVFb/88gt9+vQhR44c8Z2awPiCaxywWNO0RMA/wB1AvXnCqw2NhRBCCCEsJtwQzpSDUxi4YyDhhnA8KnrQ84ee2FhZbuTm5Ut9Zt6ECXDokN4Ew90dOnWCrFljv96slNKnD/bpAzlz6uu1vvkmnpMSpvLff//h4eHB8uXLsbOzo0uXLvTq1YuMGTPGd2riDcYWXLtf/doH6P2Oc6w+Ph0hhBBCCOMcun2IduvaceTOEarlqsaUGlPI4WC5T/QfPIDp02HqVH22Xt68+u9dXSFpUoul8W5Pn+qNMVasgPr19ZbvKSzcCVGYxYEDBxg5ciRr164lefLk9OvXj+7du5M2bdr4Tk3EwNiC61eijWgJIYQQQsSHoBdBDNw+kCn/TiFd0nQs+2kZPxX4yWJNMY4f15tgLFqkb1pctSrMmQNVqsCH7Bnr5wd+fscAZ9Mlefq03vL9/Hn44w99R2Vp//1JU0rh7+/PiBEj2Lp1K46OjgwfPpzOnTvj4OAQ3+mJ9zC2LfwscycihBBCCPE+SilWnF5Bt03duPvsLp1KdGJExRF8ZWf+jXojImD9en3a4I4dejf1X37RW7rnz2/28HHz99/QurU+zLZtGzg7x3dG4iMopdi8eTMjRoxgz549pEuXjjFjxtCuXTuSJ08e3+kJIxg7wiWEEEIIEW+uPLpCpw2d2HhxI0XTF2V149WUyFjC7HGDgmDuXJg0CS5d0juoe3pCmzbg6Gj28HETFga9e+vDbz/8AMuWgazl+WQZDAZWr17NyJEjOXz4MJkzZ2by5Mm0atWKJEmSxHd6Ig6k4BJCCCFEghUW8T/27ju+xvON4/jnScQm9iitUWrWKFUtraBUh1Gr2tpKahS1YwRBSNQqyonYVXsUrZ8dKvZWO0JtakSERMa5f3/csZWEkzwnJ9f79fLCWc91nKp8c933dUcxatsovDZ54ezkzJhPxtCpQidSOCXslzDBwTpkTZ2qt0J98AF4e+utUC4uCXrpl3Pxop5CGBio224jR8rI9yQqOjqaBQsW4O3tzeHDhylUqBD+/v40a9aMlPKZJkkSuIQQQghhlwLPBuK+0p3D/x7my6Jf8vOnP5M3Y8Id0qsUbNqklw0uXw7OzjrDdOkCFSok2GVf3aZN+nytsDCYOxeaNDG7IvESIiMjmT17NsOHD+fUqVOUKFGCOXPm0LhxY1KkkC/ZkzL59IQQQghhV26E36D32t747/PnDdc3WN5kObWL1E6w60VE6JwydqweiJEtG/TtCx06wGuvJdhlX51SMGoU9OkDhQrp/VolSphdlYin8PBwpk6diq+vL+fOnaNcuXIsWbKEunXr4vQyU1iE3ZHAJYQQQgi7oJTi14O/0n1Nd26E36DH+z0Y5DaIdCkTZsb6pUswaRJMnqxHvJcsCf7++kxgu98iExqqp3YsWaKnEU6bJiPfk5jbt28zefJkRo0axZUrV6hUqRJ+fn588skniTZxUySOeAcuwzDSAFmAK0qpaNuXJIQQQojk5vi143T4swMbTm+gYt6KrP18LaVzlU6Qa+3Zo7tZ8+dDdDR88QV07QpVqyaRyemHD0P9+nqKx08/6VOWk0ThAuDmzZuMHz+ecePGcePGDWrUqEG/fv346KOPJGg5qDgHLsMwPgUGA+/E3lQB2GsYhgXYqJSalwD1CSGEEMKBRURHMPyv4YwIHEFal7RM/nwybcu1xcmw7VKq6GhYtkwHrcBASJ8e2reHH37Qq/GSjLlz9YjEDBn0EsIqVcyuSMTR1atXGTNmDBMnTuT27dvUqVOHfv36UcGuNwgKW4hT4DIMozawDAgA+gPej9x9DmgJSOASQgghRJytD15P+z/ac/LGSb55+xtG1xxNzvQ5bXqNmzf1MsEJE+DsWShQAEaPhtatwTXhj++KGzc3yoSEwP79//2YyEh9ePH48VC5sm7P2fUGM3HfhQsXGDlyJH5+fkRERNCoUSP69u1L6dIJ08EV9ieuHa5BwCylVCvDMFLweOA6BHxv68KEEEII4ZiuhF2h+5ruzDk0h0JZCrGm6RpqvFnDptc4fhx+/hlmzIC7d/XZvz//rJcPOjvb9FIJ78IFaNQItm2DH3/UB4HZ5Wx68ajg4GB8fHyYMWMGMTExNG3aFA8PD4oUKWJ2aSKRxTVwFQf6xP5aPXHfTSCbzSoSQgghhEOyKiv+e/3pva43dyLvMOCjAfT9sC+pU6S2yesrBWvW6HN/V63Sx1B9+60+lqpMGZtcIvFt3KjHvN+5o7tajRubXZF4gaNHjzJ8+HB+++03nJ2dad26Nb169aJAgQJmlyZMEtfAdRvI+h/35QP+tU05QgghhHBEh64c4vs/vmfrua1UyVeFyV9Mpmi2ojZ57Tt3YPZs3cE6ehRy5oTBg8HdXf86SVJKH17s4QFvvQUBAVCsmNlViefYv38/3t7eLFq0iDRp0tC5c2d69OjBa7L0M9mLa+BaD/QxDONP4E7sbcowjJRAR2B1QhQnhBBCiKTtTuQdvDZ5MXr7aDKlzsSMujNoXrq5TaaxnTsHEyeCn5/eq/XOOzBrlm4CpUplg+LNcusWtGypp3w0agRTp+ohGcIubd++nWHDhrFy5UoyZsyIh4cHXbt2JXv27GaXJuxEXANXX2AncAz4A72ssCdQGt35apgg1QkhhBAiyVp5YiWd/uzEP7f+oXWZ1vjW8CVr2v9aMBM3SsH27Xra4OLF+vdffqnHuleq5ADT0Q8d0udqBQfr6R5duzrAm3I8SikCAgIYNmwY69evJ2vWrAwZMoROnTqRKVMms8sTdiZOgUspddowjPKAF3D/qPcawP+A/kqp8wlUnxBCCCGSmPOh5+nyvy4sObqE4tmLs7nlZj7M9+ErvWZkJCxapIPWrl16wuCPP0LHjpA/v23qNt2cOdCunT7AeONG+PDV/syE7SmlWLVqFcOGDWPr1q3kypWLn376CXd3d9KnT292ecJOxXUsfDrgolKqRQLXI4QQQogkKsYaw4SdE+i/sT/R1mi8q3nT/YPupHRO+dKvee0aWCzwyy9w8aLezjRhArRooc/ScghWK2nOn4emTXXImj8fcuc2u6pkzc3NjZCQEPbHjuq3Wq0sXbqUYcOGsW/fPt544w0mTpxI69atSZ3aNkNfhON6YeAyDMMFuAXUB5YneEVCCCGESHJ2X9yN+0p39l7aS61CtZj42UQKZi740q936JCeNjhnDkREQM2aMGUK1KoFTrY9E9lcR47A/v2kun0buneH4cNl5LsdiY6OZv78+Xh7e3PkyBEKFSrEtGnT+Pbbb0mZ8uW/kSCSlxcGLqVUlGEYV4HoRKhHCCGEEElI6L1Q+m/oz8RdE8mRLgfzG86nUfFGLzUUw2qFP/7QywY3bIA0aaB5cz3WvUSJBCjeTGFhMGSI3qcF3MmXj3Q//WRyUeI+q9XK9evXKVKkCMHBwZQsWZK5c+fSqFEjnJPcQW7CbHEdmvEb0Ar4MwFrEUIIIUQSoZRi8dHFdPlfFy7dvkSHdzswrNowXFO7xvu1bt+G6dNh/HgICoK8eXWjp21byPpqMzbsj1KwZIkehnH+PLRqBceOEXX3rtmVCSAqKooZM2awc+dO7t27R/ny5Rk9ejS1a9fGyaFaqyIxxTVwnQC+MgxjG/A7cIknDkBWSs2ycW1CCCGEsEOnb56m06pO/HnyT8rkKsPSr5ZSIU+FeL9OcLDejzV1KoSGQsWKMHQo1K/voKvqTp6ETp306cylSsG8eXq0opsbSOAyVXR0NLNnz2bIkCGcPn2aDBky8Nprr7Fz506bHGEgkre4Bq7JsT/nAd57xv0KkMAlhBBCOLComChGbRuF1yYvnAwnxnwyhk4VOpHCKa5fTugGz+bNetng77+Ds7M+aqpLF3jvWV9hOIK7d3XLztdXHxA2dqwer5gi7n9uImHExMQwd+5cBg8eTFBQEOXKlWPChAn4+Phw69YtCVvCJuL6N71wglYhhBBCCLsWeDYQ95XuHP73MPWK1uPnWj/zuuvrcX5+RIRu6IwdCwcO6KWCHh7QoQPkyZOAhZttxQq9Ce3MGfj2Wxg5UiYQ2gGr1cqCBQsYPHgwx44do3Tp0ixbtow6depgGAa+vr5mlygcSFzP4TqV0IUIIYQQwv7cCL9B77W98d/nzxuub/B7k9+pU6ROnJ9/+TJMmqR//PuvHn4xZYrOHmnSJGDhZjt9WgetlSuheHF9rpabm9lVJXv3x7sPHDiQw4cPU6JECRYtWsSXX3752B6tgIAAAgICzCtUOBTpZQshhBDiKUopfj34K93XdOdG+A16vN+DgW4DSZ8ybodf7dmjx7rPmwdRUfDFF3rZYPXq4NCrtCIidBfL21uvlxw5Ur9xh9yUlnQopVi+fDkDBw7kwIEDFC1alHnz5tGoUSMZhiESXFwPPj7JE0MynqSUessmFQkhhBDCVMevHafDnx3YcHoDFfNWZO3naymdq/QLnxcdrfdljR0LW7ZAunTg7g4//KAPLHZ4q1froRhBQXpj2ujReuSiMI1SilWrVuHp6cmePXsoVKgQs2fP5uuvv5bx7iLRxLXDtYOnA1dWoCIQCmy2ZVFCCCGESHwR0RGM2DKC4VuGkyZFGiZ9Pol25drhZDy/AxASAv7+euLgP/9A/vwwahS0bg2ZMiVO7aY6d06PeV+yBAoX1sGrZk2zq0rWlFKsXbsWT09PduzYQYECBZg+fTpNmzYlhQwrEYksrnu4mj7rdsMwsgD/A/6wZVFCCCGESFzrg9fT/o/2nLxxkq9Lfs3oT0aTK32u5z7n+HH4+WeYORPu3IGPPoIxY6BOHb2azuFFRuo37OWlxy8OGwbdu+tJhPEREMD+gADcEqTI5GfDhg14enoSGBjIG2+8gZ+fHy1btsRFlnUKk7xSxFdK3TAMwxfwAubbpiQhhBBCJAQ3NwgJKcP+/Q9vu3rnKt1Wd2POoTm8mflNVjddTc03/7s7oxSsXav3Z/35J6RMCV9/rbcplS2b8O/BbmzYoEe7HzsGdevqdZT585tdVbL2119/4enpSUBAAHny5OGXX36hdevWpIpvABbCxmzRU70LvGGD1xFCCCFEIrEqK/57/em9rjd3Iu8w4KMBeFT2II3Ls0cH3r0Lv/6qg9aRI5AjBwwaBN9/DzlzJm7tprp4UXex5s2DAgX0FMLPPze7qmRt27ZteHp6sm7dOnLlysW4ceNo164dqVOnNrs0IYBXCFyGYTgBxQFP4KjNKhJCCCFEgth/eT/R0dEcupKK7//4nq3ntlIlXxUmfT6JYtmLPfM558/DxIng5wc3bugu1owZ0KRJ/FfOJWlRUXqT2sCBeinhwIHQu7eDz7a3b7t27WLgwIGsWrWK7NmzM2rUKL7//nvSpk1rdmlCPCauUwqjeHpohhNgAGGAfGtHCCGEsHPKOZzItyfzjt9vuKZyZUbdGTQv3RzjGXPat2/Xq+QWLdLLCOvV08sGP/zQwce6P8tff+nlg4cOwaef6o1rhQqZXVWytW/fPgYOHMiKFSvImjUrPj4+dOzYkXTp0pldmhDPFNcOlw9PB64I4B/gD6XUTZtWJYQQQgibiYqJYuq+qdz+YgAq7TVal2qNbw1fsqbN+vjjonTAGjsWdu6EjBl1yOrUSa+eS3auXIFevWDWLHjjDT2FsF69ZJg47cOhQ4cYOHAgS5cuJVOmTAwdOpTOnTuTIUMGs0sT4rniOqWwf0IXIoQQQgjbsiori44sov+G/py8cRLnO2Vw2TyCqQPbPPa4a9f0ksGJE/UWpcKFYfx4aNECkuXXsjExMHky9OunN695eOhfSwfFFEeOHGHw4MEsWLCAjBkzMmjQILp27Yqrq6vZpQkRJ3IQgRBCCOGA1p5ai8d6D/Zc2kPJHCVZ3mQ5TevmJSY65sFj/v5bD8H49VeIiICPP9bB69NPwen5R285ru3boUMH2LcPqlfX+7aKFjW7qmTp+PHjeHl5MXfuXNKlS0e/fv3o1q0bWbJkMbs0IeLlPwOXYRh+8XgdpZRyj8sDDcN4HRgD1EDvAVsHdFVKnY3Dc72B8kA5IAvQSik14xmPCwCqPOMlflRKjY1LnUIIIURStOvCLjzWe7D+9HryueZjZr2ZfPv2tzg7OVM2F9y8GcLKlTporVsHqVNDs2bQuTOULGl29Sa6fh369NEnOL/2mp5C2LixLB80walTpxgyZAizZ88mderU9OrVix49epAtWzazSxPipTyvw/UZT+/b+i9xepxhGGmBDcA9oEXs84YCGw3DKKWUuvOCl/gB2A+sBJq/4LEHgSdD4Jm41CmEEEIkNcevHaf/xv4sOrKIbGmzMfaTsXxf/ntSpdCjBJWCq1fh1KkM1K6tM4W3N7RtC8n661irFaZO1WHr1i098n3gwGS6ltJcZ86cYejQocyYMQMXFxe6du1K7969yZEjh9mlCfFK/jNwKaXyJsD12gIFgSJKqSAAwzAOAifR4Wj0C57vqpSyGoZRiBcHrttKqe2vWrAQQghhzy6EXmDwpsFM2zeNNC5pGFhlIN3f706GVA8Dw+XL+ryso0chTRrFb79Bw4bg4mJi4fZgzx69fHDnTj1+8Zdfknmbzxznzp3D29ubqVOnYhgGHTt2pE+fPuTOndvs0oSwicTew1UH2H4/bAEopU4bhhEI1OUFgUspZU3g+oQQQogk4Wb4TUZsGcHPO38mxhpDx3c70u+jfuRI97AboJReGdepE9y5AwULQvr0YXz9dSYTK7cDN29C//4waRJkz66nEDZtKssHE9nFixcZPnw4fn5+KKVo27YtHh4e5M2bEN/zF8I8z9vD9RpwVSkVHfvr51JKXYzD9UoAvz/j9sNAozg8Pz7KGoZxC0iLPph5nFJqqo2vIYQQQiSqu1F3+XnHz/gE+nAr4hZNSzVlsNtgCmR+fG771avQvr2eZF6hgj6suH17CAkxp267oJQOVz176j1bnTqBlxdkSuYBNJFduXKFESNGMHnyZKKjo2nVqhX9+vUjX758ZpcmRIJ4XofrHPA+sBM4z4v3aTnH4XpZgGed2XUDyByH58fVZmAOcALIhF5+6G8YRm6l1FAbXkcIIYRIFFExUUzbN43BmwZzKewSnxf+HO/q3pTKWeqpxy5YoM/pDQ2FESP0tqQUyX0u8cGD+g9lyxaoWBFWr4ayZc2uKln5999/GTlyJBMmTCAyMpLmzZvTv39/ChYsaHZpQiQoQ6ln5yjDMNoAy5RS1w3D+I4XBK64dI8Mw4gERimlPJ64fRjQWykVp38OYvdwneQ/phT+x3OWArWA7EqpsGfc3w5oB5AzZ85y8+bNi8vLJriwsDDSp09vdhniCfK52B/5TOyTfC6vzqqsbPp3E9POTON8+HlKZCxBuwLtKJXp6aAVEuLC2LGF2bQpB0WKhNK79zEKFLj74P6uXcsQExPD+PGHEvMtmMr5zh3yz5hB3iVLiE6fnlPt2nHZDufeO/LflVu3brFgwQKWLFlCZGQk1atXp3nz5na/dNCRP5OkzJ4+l6pVq+5RSpV/4QOVUon2A7gCWJ5x+y/Av/F4nULoANgyHs9pHPuc91/02HLlyil7sXHjRrNLEM8gn4v9kc/EPsnn8mrWnlqrylnKKQahSkwsoZYfW66sVuszH7tokVLZsyvl4qLUsGFKRUU9/ZgqVZQqXfpmwhZtL6xWpX77TancuZUyDKXc3ZW6ds3sqv6TI/5duXnzpvL09FQZMmRQhmGoJk2aqCNHjphdVpw54mfiCOzpcwF2qzjkkMReYHAYvY/rScWBIwl87fs7YeM66l4IIYQwxe6Lu/FY78G64HW84foGM+rOoGmppjg7Pb16/9o1vRVp/nx45x1Yvx7eftuEou3J0aN6+eDGjVCuHCxbpjeyiUQRGhrKuHHjGDVqFLdu3aJBgwYMGjSIkjIBUiRTcQ5chmFkA74CigCpn7hbqbgdfLwc+MkwjIJKqeDY180PVAL6xLWWl/QNEA4kn3UUQgghkpQT10/Qf0N/Fh5ZSLa02RjzyRjal2//4CytJy1dqse937wJQ4ZA797JfNR7WJj+gxg9GtKn12Pe27UD57hsMxevKiwsjAkTJjBy5Ehu3LhB3bp1GTRoEGXKlDG7NCFMFdc9U28B29BBKzV68EUmwAm4BdyO4/WmAJ2A3w3D6I/uNg1BD+iwPHK9fMApwEsp5fXI7VWA7ECu2JvKG4YRBqCUWhT7mA/R4W0J+qBjV/Qhy3WAPurFhysLIYQQiepC6AW8Nnkxdd9UUqdIjedHnnT/oDsZU2V85uOvX4fOneG336BMGVi7Fko9vaUr+VBKj2P88Uc4dw5atgQfH5ADcxPF3bt3+eWXX/Dx8eHatWt8/vnnDBo0iPLlX7y1RYjkIK4drpHAXvRZWWFATfTywBZAf+DzuLyIUuqOYRjVgDHAbPQyv/VAV/X4IAsDPfXwyR2tg4Eqj/y+Y+yP+88BuBT7PC8gGxAFHAS+UUrNjUudQgghRGK4GX4Tn0Afxu0YR4w1hg7vdqDfh/3ImT7nfz5n+XJwd9dLCQcNgr59497VCgiAgID9gJsNqrcTJ0/CDz/oqYOlSsHcuVCpktlVJQvh4eFYLBZGjBjBlStXqFmzJoMHD6ZixYpmlyaEXYlr4HoX6ABExP7eSSl1D/AzDCMLMBaoHpcXUkqdBRq84DFneBigHr3dLQ6vHwR8GpdahBBCCDPcjbrL+B3jGRE4glsRt/jm7W/wqupFwcz/PR775k3o0gVmz9a5YtUq3d1Ktu7eheHDwdcXUqWCsWP1vq1kP/8+4d27dw9/f3+8vb25ePEi1apVY9GiRVSuXNns0oSwS3H9v1JG4LpSymoYRii6c3TfTnSXSwghhBDPEW2NfnCW1sXbF/ms8Gd4V/OmdK7Sz33eypV6K9LVq+DpCf36QcqUiVS0PVqxQq+pPHMGvv0WRo6E3LnNrsrhRUZGMn36dIYNG8a5c+f48MMPmTNnDm5ubmaXJoRdi2vgOgPcX99wHN2h+l/s7z8FkvO59UIIIcRzKaVYfHQx/Tb048T1E7yf933mNpjLR/k+eu7zQkKga1eYOVNPHly5Uk8iTLZOn9ZtvhUroHhxPYVQvthPcFFRUcyePZshQ4Zw5swZKlasyLRp06hevTqG8dSCJCHEE+J66t864OPYX48B2hiGcdgwjANAN2BGAtQmhBBCJHnrg9dTwb8CjRY2wsXJhd+b/E5g68AXhq1Vq6BkSfj1V93R2rUrGYetiAg9fbB4cdiwQS8j3L9fwlYCi46OZtasWRQrVow2bdqQLVs2Vq1axdatW/n4448lbAkRR3HtcPUB0gAopeYZhnEPPSI+LXq64OSEKU8IIYRImvZc3EOf9X1YF7yO1zO+zvS602lWqtkzz9J61K1b0K0bTJum88WyZZCsh72tXq0PGgsKgkaN9Mj3vHnNrsqhxcTEsGDBAgYPHszx48cpU6YMy5cv54svvpCQJcRLiFPgUkpF8HBgBkqppcDShCpKCCGESKpOXD/BgI0DWHB4AVnTZGV0zdG0f7c9qVM8eYTl09asgTZt4OJF8PCAgQP1PIhk6dw5PeZ98WIoXFgHr5o1za7KoVmtVhYvXsygQYM4cuQIb7/9NkuWLKFu3bo4OcV1UZQQ4kn/Gbhix7fvfGJcuxBCCCGe4eLti3ht8sJ/rz+pU6RmwEcD6PFBj/88S+tRoaHQowdMmQJFi8K2bVChQiIUbY8iI2HMGPDy0udrDRsG3bsn4+SZ8JRSLFu2jIEDB3Lo0CGKFSvG/PnzadiwoQQtIWzgeR2utcD76CmEGIbhBAQAbZRSJxO+NCGEEML+3Qy/iW+gL+N2jCPaGk378u3p/1H/556l9ai1a+G77+D8eejVCwYPhtQvboY5po0b9Wj3owoX2cYAACAASURBVEehbl096j1/frOrclhKKf744w88PT3Zt28fhQsXZs6cOXz11Vc4Oz9/6asQIu6eF7ieXKRrAJWBDAlXjhBCCJE0hEeFM37neEZsGcHNiJt88/Y3DKk65LlnaT3q9m3o2RMsFihSBAIDIdmeF3vpku5izZ0LBQrocYyff252VQ5LKcXq1avx9PRk165dFCxYkBkzZvDtt9+SQs4xE8Lm5G+VEEIIEQ/R1mhm7J/BoIBBXLh9gU8LfYp3dW/K5Ir7KcTr1+u9WmfP6pwxZAikSZOARdur6GiYMEEfLhYZqTet9e6dTP8wEp5Sig0bNuDp6cnWrVvJly8f/v7+NG/eHBcXF7PLE8JhSeASQggh4kApxZKjS+i3oR/Hrx+nYt6KzKk/hyr5q8T5NcLCdJ745Rc9B+Kvv6BSpQQs2p5t2QIdOsChQ/Dpp/Dzz1CokNlVOaxNmzbh6enJ5s2byZs3L5MnT6ZVq1akTNYnaAuROF4UuPIYhnF/bYTzI7c9ddCxUirYppUJIYQQdmLD6Q30WdeHXRd3UTx7cZZ9tYw6RerEa0R2QAC0bg1nzujhe0OHQtq0CVay/bp6VW9WmzkTXn8dliyBevVAxo0niK1bt+Lp6cn69evJnTs348eP57vvviN1st0oKETie1HgWvSM25b9x2Nld6UQQgiHsvfSXvqs68Pa4LXxOkvrUXfuQJ8+euVcoUKweTNUrpyARdurmBi9Ya1fP/2H4uGhf50undmVOaQdO3YwcOBAVq9eTY4cORgzZgzu7u6kkeWaQiS65wWuVolWhRBCCGFHTl4/yYCNA5h/eD5Z0mRhVM1RdHi3Q5zO0nrU5s3QqhUEB0OXLuDtnUy7Wjt26OWDe/dC9eo6fRYtanZVDmnPnj0MHDiQP/74g6xZs+Lr60uHDh1IJ8FWCNP8Z+BSSs1MzEKEEEIIs126fUmfpbXPn5TOKen/YX96fNAD19Su8Xqdu3ehb1+9LalAAb2csErct3o5juvXdSfL3x9y54Z586BxY1k+mAAOHDjAoEGDWLZsGZkzZ8bb25tOnTqRIYMMlxbCbDI0QwghRLIXEhGCb6AvY7ePJcoahXs5d/p/1J9c6XPF+7W2bNFdraAg6NQJRoxIhqvmrFaYNk2vpQwJgW7d9ARC+eLf5g4fPsygQYNYtGgRrq6uDB48mC5duuDqGr9vEgghEo4ELiGEEMlWeFQ4E3ZOYPiW4Q/O0vJy8+LNLG/G/7XCoX9/GDMG8uWDDRugatUEKNre7d2rlw/u2AEffqhHMpYsaXZVDufYsWMMHjyY+fPnkz59egYMGMCPP/5I5syZzS5NCPEECVxCCCGSnSfP0qpVqBbDqw+P11laj9q2DVq2hBMnoH178PWF9OltW7PdCwnRiXPSJMiWDWbNgqZNZfmgjQUFBeHl5cWcOXNIkyYNvXv3pkePHmTNmtXs0oQQ/0EClxBCiGRDKcXSY0vpt6Efx64d47087/Fr/V9xy+/2Uq8XHq7P7B09GvLmhXXr9EyIZEUpmD0bevaEa9egY0fw8oJMmcyuzKGcPn2aoUOHMnPmTFKmTEm3bt3o2bMnOXLkMLs0IcQLSOASQgiRLGw8vZE+6/uw88JOimUrxtKvllK3SN14naX1qB07dFfr2DFwd4eRI5PhFqVDh/TywS1boGJF+N//oGxZs6tyKGfPnmXYsGFMmzYNZ2dnfvjhB3r37k2uXPHfXyiEMIcELiGEEA5t76W9eKz3YM2pNbye8XWm1ZlGs9LNSOH0cv8ERkTAoEE6YOXJA2vWQI0atq3Z7oWG6j+En3/WnSx/fz0pxMnJ7MocxoULF/D29mbKlCkYhoG7uzseHh7kyZPH7NKEEPEkgUsIIYRDCroRRP8N/V/5LK1H7dqlu1pHjsB338GoUZAxo+1qtntK6dHu3bvD5cvQrh0MGwayf8hmLl++zIgRI5g8eTIxMTG0adOGvn378sYbb5hdmhDiJUngEkII4VAu3b7EkM1DmLJ3CimdU9Lvw370/KBnvM/SetS9e3pbko+PPk7qf/+DTz6xYdFJwdGjes79hg1QrhwsWwYVKphdlUNwc3Pj33//5dNPP+WXX34hMjKSFi1a0L9/fwoUKGB2eUKIVySBSwghhEO4FXFLn6W1YyyRMZG0e6cd/T/qT+4MuV/pdffs0V2tv/+G1q31gIxkdcTRnTswZIh+4+nS6THv7dqBs7PZlTmEs2fPEhwczIULFzh27BhNmzZlwIABFCpUyOzShBA2IoFLCCFEkhYeFc7EXRMZvmU4N8Jv8HXJr/Gq6kWhLK/2BWtkpM4Zw4dDzpzwxx/w2Wc2KjopUAqWLIEff4Rz53Tq9PEBmYr3ymJiYvjzzz+xWCysWrUKq9VKpkyZ2L59O0WKFDG7PCGEjUngEkIIkSRFW6OZuX8mgzYN4nzoeWoVqoV3NW/K5n71KXl79+p8cegQtGihDzNOVufJnjwJP/wAq1dDqVIwdy5UqmR2VUnehQsX8Pf3x9/fn/Pnz5MrVy48PDxYt24dEREREraEcFASuIQQQiQpSimWHVtGvw39OHrtKBXyVGD2l7Nf+iytR0VG6hkQ3t6QPTusWAFffPHqNScZ4eG6pefjA6lSwdix+lytFPLlwsuKiYlhzZo1WCwWVqxYgdVqpWbNmowbN47atWvj4uLC0KFDCQgIMLtUIUQCkf+DCiGESDICzgTQZ10fdlzYQdFsRVnSeAn1itZ76bO0HnXggO5mHTgATZvCuHGQJYsNik4qVqyAzp3hzBn49ls99z73q+1/S84uXbrEtGnTmDJlCv/88w85cuSgV69etG3bloIFC5pdnhAiEUngEkIIYff2XdqHx3oPVp9aTd6MeZlaZyrNSzd/6bO0HhUVpZs6Q4bo6ebLlkHdujYoOqk4fRq6dNGBq3hx2LgR3NzMripJslqtrFu3DovFwvLly4mOjqZatWr4+vpSr149UqZMaXaJQggTSOASQghht4JuBDFg4wDm/T2PzKkzM7LGSDq+25E0Lmls8vr392jt2wfffKPP8XXoI6Xc3CgTEgL79+tZ9yNH6jWUzs7g6wtdu4KLi9lVJjlXr15l+vTp+Pn5ERwcTNasWenatSvt2rWjcOHCZpcnhDCZBC4hhBB253LYZYZsGoLfXj9SOqekb+W+9KzUk0ypM9nk9aOj9TalwYP1MIwlS+DLL23y0knD6tX6TK2gIGjUSI98z5vX7KqSFKUUGzduxGKxsHTpUqKioqhSpQpDhw6lfv36pEqVyuwShRB2QgKXEEIIu3Er4hYjt45kzPYxRMZE0vadtgz4aMArn6X1qL//1hMI9+yBJk1g/HjIls1mL2/fIiJIe+YM1KoFhQvr4FWzptlVJSnXrl1jxowZ+Pn5cfLkSTJnzkynTp1o164dRYsWNbs8IYQdksAlhBDCdBHREUzcORHvLd7cCL9Bk5JNGFJ1yCufpfWo6Gi9gm7QIH1w8aJF0KCBzV7evp05o0cv7tyJC8DQodCjh55EKF5IKcXmzZuxWCwsXryYyMhIKlWqxIABA2jYsCFp0thmiasQwjFJ4BJCCGGaaGs0sw7MYmDAQM6HnueTNz/Bu7o37+R+x6bXOXJEd7V27dIr6CZO1GPfHV5wsA5aM2eCkxPkzk2oqyuu/fqZXVmScOPGDWbNmoXFYuHYsWO4urri7u5Ou3btKFmypNnlCSGSCAlcQgghEt2zztKaVW8WVQtUtel1YmJg1Cjw9IT06WH+fGjc2KaXsE9BQTpozZqlz9Bq3x5694Zvv0WFhJhdnV1TSrF161YsFgsLFizg3r17VKxYkenTp9O4cWPSpk1rdolCiCRGApcQQohEtenMJvqs78P289spkrUIixsv5suiX9rkLK1HHTsGrVrB9u1Qvz788gvkzGnTS9ifkyf1csE5c/S0wU6doFcveO01syuzeyEhIcyePRuLxcLhw4fJkCEDrVu3xt3dndKlS5tdnhAiCZPAJYQQIlHsv7wfj/Ue/C/of+TJkIcptafQskxLm5yl9aiYGBg7Fvr1g3TpYO5c+OorsHGesy/Hj+ug9dtvel9W587Qs+fTBxcHBLA/IAA3U4q0P0opduzYgcViYf78+YSHh1O+fHmmTJlCkyZNSJ8+vdklCiEcgAQuIYQQCerUjVMM2DiAuX/PJXPqzPh+7EunCp1sdpbWo06c0F2trVv14cWTJ0OuXDa/jP04elQHrXnzIHVq+PFHHbQcvpX3akJDQ5kzZw6TJ0/m4MGDpEuXjmbNmuHu7s4779h2/6AQQkjgEkIIkSAuh11m3MlxrPxrJS5OLnhU9qBXpV42O0vrUTEx+tDivn0hTRr49Vd9kLHDdrWOHIEhQ/SmtLRp9cTB7t0hRw6zK7Nru3fvxmKxMHfuXO7cuUPZsmWZPHky33zzDRkyZDC7PCGEg5LAJYQQwqb+CfmHUdtGMXHXRKzKyvflvseziqdNz9J6VFCQ7mpt2QK1a4PF8vRKOofx9986aC1cqNdL9u4N3bolk5GLL+f27dvMnTsXi8XC3r17SZs2LU2aNMHd3Z13333X5nsHhRDiSRK4hBBC2MShK4fw3erL3ENzMQyD7Gmzk9nIzKQvJiXI9axWmDAB+vTR25ZmzYKmTR20q3XwoA5aixZBhgzg4aGXDyabE5vjb9++fVgsFubMmUNYWBhvv/02EyZMoGnTpri6uppdnhAiGZHAJYQQ4qUppdhydgs+gT78cfIP0rmko/N7nfmx4o+87vo6AQEBCXLdU6egdWvYvBk+/xz8/Bx0EN/+/eDlBUuXQsaM0L+/DlpZsphdmV26c+cO8+fPx2KxsHPnTlKnTs1XX32Fu7s7FStWlG6WEMIUEriEEELEm1VZWXF8BT6BPmw7v41sabMxpOoQOrzbgSxpEi4MWK16vHvv3nrq+fTp0KKFA3a19u2DwYPh99/B1VUfJNa1K2TObHZldunQoUNYLBZmz55NaGgoxYoVY9y4cTRr1ozM8mcmhDCZBC4hhBBxFhkTyW+HfsM30Jej146SP1N+Jnw6gVZlW5HWJWEPhD19Wne1AgKgVi2YMgXy5k3QSya+PXt00FqxAjJlgkGDoEsX/WvxmPDwcBYsWIDFYmHbtm2kSpWKhg0b4u7uTuXKlaWbJYQjcoMyIWVgv9mFxI8ELiGEEC8UFhnGlD1TGL19NOdDz1MqZynm1J9D4xKNbX6O1pOsVj0Io2dPcHaGqVP1kAyH+np61y4dtP74Q3exvLz0WVqy1+gpR44cwWKxMGvWLEJCQnjrrbcYNWoULVq0IGvWrGaXJ4QQT5HAJYQQ4j/9e+dfxu8cz4SdE7gZcZMq+arg94UftQrVSpQOwpkz0KYNbNgANWuCvz+8/nqCXzbx7Nihg9aqVXpf1tCh8MMPer+WeCAiIoLFixdjsVj466+/cHFxoUGDBri7u1OlShXpZgkh7JoELiGEEE85ffM0o7aNYtq+aYRHh1OvaD16V+pNxbwVE+X6SulBGD166E6Wnx98950DdbW2bdNBa/VqyJoVhg+Hjh31BELxwPHjx/Hz82PmzJlcv36dN998Ex8fH1q2bEkOOXNMCMengH+AfehlhH+DUzYnc2t6CYkeuAzDeB0YA9QADGAd0FUpdTYOz/UGygPlgCxAK6XUjP94bFugO1AAOAOMUUpNtsFbEEIIh3XwykF8An2Y//d8nAwnmpVqRs9KPSmarWii1XD2rA5Xa9dC9ep6CWG+fIl2+YS1ZYsOWuvW6ZHuPj7QoQOkT292ZXbj3r17LF26FIvFQkBAAClSpKBevXq4u7tTrVo1nJyS3hdbQog4iASOooPVfh6GrFux9zsBqcGITnrfeUvUwGUYRlpgA3APaIHOrUOBjYZhlFJK3XnBS/yA/qNfCTR/znXaAhZgODrQVQd+MQzDUEolzIEwQgiRRCml2PzPZnwCfVgVtIr0KdPTtWJXulbsSt6MLz+Vws0NQkLKsD+Om5uV0uGqWze9b2vSJHB3d5Cu1ubNOmht2AA5csDIkdC+vT68WAAQFBSEn58f06dP59q1a+TPnx9vb29atWpFrly5zC5PCGFLt4ADPAxX+4HD6NAFkBYoBXwNlAXKACWBzyAmJCbRy31Vid3hagsUBIoopYIADMM4CJwE3IHRL3i+q1LKahhGIf4jcBmGkQIYBsxWSvWLvXmjYRivAUMMw/BXSkXZ4L0IIUSSZlVWlh9fjk+gD9vPbyd72uwMrTqUDu92IHOaxB2lff687mqtXg3VqunglT9/opaQMAICdNAKCICcOWHUKPj+e0ibsBMdk4qoqCh+//13LBYL69atw9nZmTp16uDu7k6NGjWkmyVEUqeACzzdtQp+5DE50KGqJjpYlQEKA86JWmmCSuzAVQfYfj9sASilThuGEQjU5QWBSylljcM13geyA78+cftsoBVQGdgYn6KFEMKRRMZEMufgHHy3+nLs2jEKZCrAxM8m0qpMK9K4pEnUWpSCGTP0EVMxMTBxos4jSfrrbKVg40YdtDZvhly5YMwYaNdOglas06dPM2XKFKZNm8aVK1d4/fXXGTJkCK1bt+Y1hzzBWohkIBo4wcNQdf/HtUceUxi9MagNDztXudCbjBxYYgeuEsDvz7j9MNDIhtcA+PsZ1wAojgQuIUQydPvebfz2+DFm+xgu3L5A6ZylmdtgLg2LN0zw0e7PcuGCziB//glVqsC0aVCwYKKXYTtKwfr1Omht2QKvvQbjxkHbtpAmcYOsPYqOjmbFihVYLBbWrFmDYRh8/vnnuLu7U6tWLZydHejb2UI4ujDgEI93rQ4BEbH3p0IvAazHw65VKeBV5wIFwP6A/bjh9oovlLgS+1/YLMDNZ9x+A7DV+pUssT8/eZ0bT9wvhBDJwtU7V/l5x89M3DWRkIgQ3PK7MbXOVGq+WdOUcdpKwaxZ+jzfqCgYP17PjUiyXS2l9ISPwYNh61bIk0e/qe++g9Spza7OdGfPnmXKlClMnTqVS5cukSdPHjw9PWnTpg2vO9SMfyEc1BWe7lqdQC8XBP0VfFmgAw+7VkUAl0Sv1G6ZMRZePeM2W/6Lf/+1nnWd/36SYbQD2gHkzJmTgIAAG5b08sLCwuymFvGQfC72Rz6Tp10Mv8iC8wtYdXkVUdYoKmerzNfFvqZYxmJwHjad35Sg1w8JKUNMTMxjn8u1aykZPfottm3LRqlSIfTqdYw8eSLYvDlBS0kYSpFl1y7yzZyJ65EjROTIwdmuXbn06aeolClh+3azK3ymxPi7EhMTw44dO1ixYgU7duwAoEKFCnTs2JGKFSvi7OzMqVOnOHXqVILWkZTI/8PsT7L7TKyQ5kIa0gelf+xHqhupHjwkPFc4YYXDCHs/jLBCYYQVDuNe9nuPfyV/jceXEdpYUvxcEjtw3eTZHabMPLvz9TIe7WRdeuT2LE/c/xillB/gB1C+fHnl5uZmo3JeTUBAAPZSi3hIPhf7I5/JQwcuH9Cj3Q/Px9lwpnnp5vT8oCdFshVJ1DoyZYKQkBDc3NxQCubMgc6dISICxo6FH37IhJNT4pzrZVNK6YOKBw+GnTvhjTdg8mRSt2zJW6lS8ZbZ9b1AQv5dOX/+PFOnTsXf35/z58+TK1cu+vbty3fffUd+h5iCknDk/2H2x6E/k3D05ptHu1YHgPvzwlOgN+nURnesygKlIU2mNKQhDdnJnvg1x0qKn0tiB67DPNxj9ajiwBEbXoPY6zwauIrH/myr6wghhN1QSrHpn02M2DKC1adWkz5lerpV7EbXil3JkzGPqbVdvqwHYfz+O1SqBNOnQ+HCppb0cpSClSvBywt279ZjFP38oEULSJnS7OpMExMTw+rVq7FYLKxcuRKr1UrNmjUZN24ctWvXxsVF1hUJYarrPD0l8Bhwf7p6RnSoasPD/VbF0fuwhE0kduBaDvxkGEZBpVQwgGEY+YFKQB8bXWMbupH5LfoMrvuaortbgTa6jhBCmM6qrPx+7HdGBI5g54Wd5EiXg2HVhtG+fPtEH+3+JKXg5k0XSpSAu3f1RPQuXSDJzUZQCpYv10Fr714oUAD8/aF5c0jGYeLSpUtMmzaNKVOm8M8//5AjRw569epF27ZtKZikp58IkUQp4AxP77c698hj8qID1Zc83G+VH32osEgwiR24pgCdgN8Nw+iP/k9jCPo/Bcv9BxmGkQ84BXgppbweub0KeuT7/RMQyxuGEQaglFoU+3OUYRgD0AcdX0CHrmpAa+AHpdT9I9WEECLJuhd9j18P/srIrSM5fv04BTMXZNLnk2hRukWij3Z/lmPH4PBhuH49HRUr6tHvRRJ3ReOrs1p1W87LC/bvhzff1KMUmzZNtkHLarWybt06LBYLy5cvJzo6murVqzNy5Ejq1q1LymTc6RMiUUWi12w92rXaD4TG3u8EFAU+4mHXqgyQLdErFSRy4FJK3TEMoxowBn0ulgGsB7oqpcIeeaiBPu7sybw9GKjyyO87xv64/5z715lsGIYCugM9gbNAJ6XULzZ8O0IIkehC74U+GO1+8fZFyuYqy7wG82hQvIEpo92fdPy4zidz54JhQO7c4WzZkiZpdbWsVli6VL+RgwehUCGdGL/9FlKY/2dshitXrjB9+nSmTJlCcHAw2bJlo2vXrrRr147CSXJ9qBBJyC0e71jtR2+giYq9Py1QGr22637XqiRg/vfeRKxE/5dDKXUWaPCCx5zhGZMLlVJu8biOhUe6ZkIIkZRdCbvyYLT7rXu3qFagGtPrTqdGwRqmjHZ/0okTMGQI/PabnoTesyf89RfcvXsPZ+ck8q++1QqLF+ug9fff8NZbMHs2NGmSLIOW1Wpl48aNWCwWli1bRlRUFFWqVGHo0KHUr1+fVKlkg4cQNqWA8zzdtTr9yGNyokNVLR52rQqh2xTCbiW/f0GEECIJCb4ZzE9bf2LavmlExkRSv1h9elfqzbt53jW7NACCgnTQ+vVXHbS6d9dhK3t2cHPTe7fsXkwMLFqk38jhw1C0qB6p+NVXSXDD2au7du0aM2bMwGKxEBQURJYsWejUqRPt2rWjaNGiZpcnhGOIBo7z9H6r67H3G0Bh4F2gLQ87V7meeiWRBEjgEkIIO7Tv0j58An1YeGQhKZxS0KJ0C3p80IO3strH0PFTp2DoUN0ASpkSfvwRevWCHDnMriweYmJg/nz9Ro4eheLF9VrIRo2SXdBSSrF582YsFguLFy8mMjKSypUrM3DgQBo2bEhqOcBZiJcXBhzk8c7VIeBe7P2pgbeB+jzsWpUC0id6pSKBSOASQgg7oZRi45mN+AT6sObUGjKkzECP93vQtWJXcmfIbXZ5AAQH63wya5aeG9G5sw5auZLSd12jo2HePP1Gjh+HEiV08GrYEJyS16iuGzduMHPmTPz8/Dh27Biurq64u7vj7u5OiRLPOsVFiGTCDcqElNHhKD4u83jXah8QhF4uCPpU2LLoEXL3u1ZFkK/IHZx8vEIIYbIYawzLji1jROAIdl/cTc50ORlefTjfl/+eTKkzmV0eAGfO6Hwyc6Zu/nTqBL17Q277yIFxEx2tN5kNHQonT8Lbb8PChVC/frIKWkoptmzZgsViYeHChdy7d4+KFSsyffp0GjduTNq0ac0uUQj7F4MOUk/ut7ryyGMKoENVMx52rvLyjCkFwtFJ4BJCCJPci77HrAOzGLl1JCdvnOTNzG9i+cJC89LNSZ3CPpZwnTkD3t76sGJnZ+jQQQet114zu7J4iI7Wm8yGDdObzkqX1sMx6tVLVkHrzJkzVK9enYsXLxIREUGGDBlo06YN7u7ulCpVyuzyhLBf4eglgI92rQ4C9/eougAlgE952LUqBdjH98uEHZDAJYQQiSz0XiiTd09m7PaxXAq7xDu532FBwwXUL1YfZyf72Dt09qzOJ9On6/Hu338PffpAnjxmVxYPUVF6k9mwYXotZNmyetx7nTrJJmgFBwezaNEiFi5cyO7duwFImzYt/v7+NGnShHTp0plcoRB2xooeuX4e0l5Pq4PUsdjbAVzRgaotD7tWxQE5gk48hwQuIYRIJJfDLjNu+zgm7Z7ErXu3+Ljgx8z6chbVC1S3i9HuAOfO6Y7W1Kk6aLVtCx4ekDev2ZXFQ2Sk3mTm7Q2nT0O5cvoA49q19ZtycKdOnWLhwoUsXLiQvXv3AlC+fHl8fHxo2LAhZ8+exc3NzdwihbAXCh2oNsb+CACu6btSuKSAN9GHGd3vXOVHlgSKeJPAJYQQCSzoRhA/bf2JGftnEBkTScPiDeldqTflXitndmkPnD8Pw4eDvz8oBW3aQN++8PrrZlcWD5GR+oBib2/45x94910YPx4++8zhg9bJkycfdLL27dsHQIUKFRg5ciQNGzYkf/78Dx579uxZk6oUwg4o4BQPA9ZG9KALgNeBz4CqwGQIjQgl03JZFyhenQQuIYRIIHsu7sEn0IfFRxeTwikFLUu3pMcHPSictbDZpT1w4QKMGAF+fjpotW6tO1r58r36awcEQEDAfsDt1V/see7dg2nTdGI8dw7eew8mTYJatRw6aJ04ceJBJ+vAgQMAVKxYkVGjRtGgQQPy2eJDFMIRnOHxgHU+9vZc6HBVLfbngjzsXs0AIhKzSOHIJHAJIYQNKaXYcHoDIwJHsC54HRlTZaTnBz3p8l4XuxntDnDx4sOgFRMDrVpBv362CVqJJiJCr30cMUK36N5/H6ZMgZo1HTZoHTt27EHIOnToEADvv/8+o0ePpkGDBrzxxhsmVyiEHbjAw3C1AR24ALKjv/9TNfZHEWR5oEgUEriEEMIGYqwxLDm6BJ9AH/Zc2kOu9Lnw+dgH93LuuKZ2Nbu8By5dAh8fsFj0TImWLXXQKlDA7MriISJCBysfH92iq1RJd7g+/tghg9bRo0cfhKy///4bgEqVKjF27FgaNGhA3iS1wU6IBHCFxztYQ9YJJAAAIABJREFUJ2Nvz4wOWN3QAasEcQ9YAbA/YD9uCd2hF8mCBC4hhHgFEdERD0a7B90IonCWwvh94Uez0s3sZrQ7wOXL4OurV9pFRUHz5tC/PxQsaHZl8RAerltyPj46OX74oT4YrFo1hwtahw8ffhCyjhw5gmEYVK5cmXHjxtGgQQPyJKlxkULY2DVgEw8D1pHY2zMCHwHfowNWaSB5DCQVdk4ClxBCvIRbEbf0aPcdY7kcdpnyr5VnYaOFfFn0S7sZ7Q5w5crDoBUZCc2a6Y5WoUJmVxYPd+/qlpyvr06OVarAnDng5uYwQUspxd9///1g8MXRo0cxDIMPP/yQ8ePHU79+fV5LUoefCWFDITwesA7G3p4O+BBogQ5YZZGvbIVdkv8shRAiHi7dvsTY7WOZvGcyofdCqVGwBnPqz6Fq/qp2M9od4OpVGDkSfvlFr8Br2hQGDEhiQevOHZg8Wb+RK1egalWYN08HLgeglOLQoUMPOlnHjx/HycmJjz76iI4dO1K/fn1y57affX9CJJrbwF/o/Vcb0QcNKyA1UAkYih50UR596LAQdk4ClxBCxMHJ6ycZuXUkMw/MJNoa/WC0+zu53zG7tMdcu6bzyYQJOmh9840OWm+9ZXZl8RAWppPiTz/Bv/9C9eqwcKFeQpjEKaU4cOAACxcuZNGiRZw4cQInJyeqVKlCly5dqF+/Pjlz5jS7TCES1x0gkIcdrN1ADPow4feBgegO1ntAKpNqFOIVSOASQojn2H1xtx7tfmQxKZ1T0rpMa7p/0J1CWeyrVXTtGowapY+dunsXvv4aPD2hSBGzK4uH27dh4kT9Rq5d09MGPT31UIwkTCnF/v37H3SygoKCcHJyomrVqnTr1o0vv/ySHDlymF2mEIknHNjGw4C1E4hCf1VaAfBAB6z3gTQm1SiEDUngEkKIJyilWBe8Dp9AH9afXo9rKlf6VO5D5/c6kyt9LrPLe8z16w+D1p070KSJ7mgVK2Z2ZfEQGqpbcqNH6zdUq5YOWu+/b3ZlL00pxd69ex90sk6dOoWzszPVqlWjZ8+efPnll2TPnt3sMoVIHJHADh4GrG3APfRAi/I8nCJYCUhvUo1CJCAJXEIIESvGGsPio4vxCfRh76W95E6fG9+PfXEv707GVBnNLu8xN27ofPLzz3oFXuPGOqMUL252ZfFw65ZOiqNHw82b8Nln+k28957Zlb0UpRS7d+9m0aJFLFq0iODgYJydnalevTp9+vShXr16ZMuWzewyhUh4UehlgfcDViC6q2UAZYBO6ID1IXqyoBAOTgKXECLZi4iOYOb+mYzcOpJTN0/xVta3mFJ7Cs1KNSNVCvvaMHDzJowZA+PG6cZQo0Y6o5QsaXZl8RASopPimDH61198od/Eu++aXVm8KaXYtWvXg07WmTNnSJEiBR9//DH9+vWjbt26ZM2a1ewyhUhYMejBFvcD1l9AWOx9bwNt0QHrIyCLGQUKYS4JXEKIZCskIoRJuyYxbsc4rty5wruvvYtvDV/qFqlrV6PdQeeSsWN1RgkNhQYNYOBAePttsyuLh5s3dVIcO1Z3t+rU0UGrXDmzK4sXpRQ7dux4ELLOnj2Li4sLNWrUwNPTk7p165Ili3xVKRyYFTjEwymCm4FbsfcVA5qjA1YVQFbOCiGBSwiR/Fy8fVGPdt89mduRt/nkzU/oXak3bvnd7Gq0O+hccj9o3boF9evrjFK6tNmVxcONG/pN3G/L1aun30TZsmZXFmdWq/WxkHXu3DlcXFyoWbMmXl5e1KlTh8yZM5tdphAJQ6EPF77fwdoEXI+9rxDQGB2w3AA5yUCIp0jgEkIkG8evHWfk1pHMPjibaGs0jUs0ptcHvSib2/6+8A8N1flk9Gjd3apXT3e0ypQxu7J4qFSJikFBEB6uJxAmsbRotVrZtm0bCxcuZPHixZw/f56UKVPyySefMGzYMGrXrk2mTJnMLlMI21PACR4GrADgaux9+YE66IBVFcib+OUJkdRI4BJCOLydF3biE+jD0qNLSZUiFW3KtqH7+915M8ubZpf2lNBQPUdi1Ci9Aq9OHRg0KEk1g+DUKZ0Wt28nldWqN5oNGJAk1j9arVYCAwNZtGgRixcv5sKFC6RKlYpPPvmE4cOHU7t2bVxdXc0uUwjbUsBpHgasjcDF2PvyADV5GLAKmFGgEEmbBC4hhENSSrHm1Bp8An3YeGYjmVJnwqOyB53f60zO9PZ3sOzt23oy+k8/6RV4tWvrjlaS2d6kFAQG6pbcsmWQIgVkz85tV1cyLlhgdnXPFRMTQ2Bg4INO1qVLl0iVKhWffvopvr6+fPHFF2TMKKPUhIM5y+MB62zs7Tl5GK6q8n/27jsurir///jrUBJCSCExpJIKaRNJA2MakGYSSLEEy2pMWdctuquuruW3369r33WLru5+v35XV9RVd3WJ3SQajUsSTaLBhBTSgIRAOimQ0Nv5/XFmmGEYSsLADPB5Ph73MXDn3uHc3ADz5pzzOWbIoHeNtBai1ZHAJYRoUyqqKli1dxXPfvMsqSdT6delH3+c80funHgnXTp28XTzaikosAets2chPt70aEVGerpljVReDqtWmUlm27ZBjx7wyCNw113Qrx/bk5OJ9XQbXaisrGTTpk0kJSXx/vvvc/LkSQICAoiLi2PJkiUsWLCALl287/+LEJftBCZY2QpdHLLu74mZe/UQJmCNRAKWEG4mgUsI0SaUVpby0raX+OOWP3Lo/CFG9BzBq4te5dYrb/W60u5gFin+n/+BP/wBzpyB+fNN0LrqKk+3rJHy8uCVV0x596NHYfhw+N//hdtvh86dPd06lyoqKmqErFOnTtGpUyfi4uJISEggPj6eoCBZdVW0Eacxc69sPVgHrPu7Y6oH/gITsMZgFiAWQjQbCVxCiFYt81wmM9+YyfGLx6nQFUzqP4k/XfMnFo1YhI/yvncRhYXw0kvw+99Dbi7MnWuC1tVXe7pljXTokJmf9eqr5mJmzDAXFBcHPt73711RUcGGDRuqQ1Zubi6BgYHEx8eTkJBAXFwcnb00IApxSc5iqgfaAlaadX8XzPpXtrWwxgLeteqFEG2eBC4hRKtTWFbIe/veI3FHIhuObACgi18XPrn1E6IHRXtdaXeAoiJ70Dp9Gq65xgStyZM93bJG0Bo2bzbzsz74AHx94ZZb4L77vLKaR0VFBcnJySQlJfHBBx+Qm5tL586dWbBgAUuWLGH+/PkSskTrl49Z/8oWsHZiil8EAtOA2zABayLybk8ID5NvQSFEq6C1ZuvRrSTuSOTdtHe5WHaRsB5hPDPzGW4fezvp29OJGRzj6WbWUlwM//d/8OyzcOoUzJ5tgtbUqZ5uWSOUl8N775n5Wd99B8HBNeZneZPy8nL+85//VIess2fP0rlzZxYuXEhCQgLz5s0jMDDQ080U4vIVAF9jn4O1HbMAcQAwBXgCE7CigA4eaqMQwiUJXEIIr3ay4CRv7nyTxNRE9p/ZT6B/IDdabmTluJVMGzitujcrnXQPt7Sm4mJ4+WX43e/g5EmYOROSkmD6dE+3rBHy8uDvfzfzs3JyIDzcK+dnlZeXs379epKSkvjwww85d+4cQUFBLFq0iCVLljBv3jw6derk6WYK0bBYGJc3DlId9hUBm7H3YG0DKgB/4GrgvzAB62pM6BJCeC0JXEIIr1NeWc7q9NW8lvoaqw+uplJXMjV0Kn9f+HdutNzoldUGbUpKTC2J3/4WTpyA2Fh4912IjvZ0yxrh0CETsl591ZRPjI01lT3i471mflZZWVmNkHX+/Hm6dOnCokWLSEhIYO7cuQQEyLtP0QpVUbPIxbdAGeadWhTwICZgTcEMGxRCtBoSuIQQXmNv7l4SdyTy5q43OV14mj5BfXhgygOsGLeCEVeM8HTz6lVSYjqFfvtbOH7cBKx//tNkFq/mOD/rww9NsPKy+VllZWV88cUXJCUl8dFHH5GXl0fXrl1ZvHgxCQkJzJkzR0KWaF2Kgb3AbmAXkArdLnQzgcoHmADcA8zEzMeS4plCtGoSuIQQHpVfks+7ae+SuCORb499i5+PHwuHL2Tl+JXMC5uHn493/5gqLTUdQs88A8eOwbRp8OabpnifF9busKuoMPOznnvOPj/roYfM/Kz+/T3dOkpLS1m3bh2rVq3io48+Ij8/n27dutUIWR07el+5fyFq0MAR7MHKth3E9GgBdAL8oLRnKQGJATAdU7pdCNFmePc7GSFEm1Slq9iQtYHE1ETe2/sexRXFWHpZeO6a57g14lZCOod4uokNKiuDxEQTtHJyTBGMN94wc7W8Omjl59vnZ2VnQ1iYGTa4bJnH52eVlJSwbt06kpKS+Pjjj7lw4QLdu3fnuuuuIyEhgdmzZ9Ohg1QDEF7qAiZYOYar3db9NkOBCOBG62OEdd8sKMkrIWCh9NQK0RZJ4BJCtJjs/GzeSH2D11Jf43DeYbp27MqysctYOX4lkf0ivbKcu7OyMnj9dXj6aZNXJk82PVyzZ3t50Dp82L5+lm1+1l//6vH5WSUlJXz22WesWrWKjz/+mIsXLxIcHMySJUtISEhg5syZErKEd6kE0qnda5XlcEx34EpgKfZgZcGsiSWEaHckcAkhmlVJRQkf7v+QxB2JfHnoSzSaWUNm8eSMJ7lu1HUE+reO2d/l5fagdeQITJpkqhBec40XBy2tYcsW+/pZPj5w881mftaECR5rVnFxMZ999hlJSUl88sknFBQU0KNHD2688cbqkOXv7++x9glRLZfawSoNKLE+7wuMwFQKvBN7uBoAXMrPhWRITU4llli3NFsI4V0kcAkh3E5rzY6TO0jckcjbu98mrySPgd0G8mjMoywbu4whwUM83cRGKy+Hf/wDnnoKsrIgKsosYDxvnhcHrYoKeP99E7S+/dbMz3rwQbj7bo/NzyoqKmLt2rUkJSXx6aefUlhYyBVXXMEtt9xCQkICsbGxErKE55QC+6gdrk46HNMH02t1F/ZgNRIpyS6EaJAELiGE25wtOsvbu98mcUciO0/tpKNvR24YfQMrxq1g5pCZ+CjvKC3eGBUVpvjFU0+ZaumRkWaq0/z5Xhy08vPNkMEXXvCK+VmFhYUkJyfz0ksv8emnn1JUVESvXr247bbbWLJkCbGxsfj5ya8h0YI0cBT7/CpbsNqPGSoI0BEz/G8e9mB1JeD9U0uFEF5KftMJIZqksqqSdZnrSExN5OMDH1NWWUZkv0j+N+5/uXnMzQR3CvZ0Ey9JRQW8/TY8+SRkZpqRd598YqY6eW3QOnzYvn7WxYsQEwN/+QssWNCi87MKCwvZsmULGzduZMOGDWzatAmtNSEhIdx+++0kJCQQHR0tIUu0jAJgD7V7rfIcjhmECVTXYg9XYci7IyGEW8mPFCHEZck4l8FrO17jjZ1vcOziMXp26snPIn/GivEriOgd4enmXbKKCrNu1pNPQkaGWYLqo49g4UIvDlq2+Vnvv2+C1U03mflZEye2yJfPz8/n66+/ZuPGjWzcuJGUlBQqKirw9fVlwoQJ9O/fn44dO3LgwAF8fX1bpE2iHaoEDlG71yrT4ZgumF6qm7EHqzFAtxZtqRCinZLAJYRotIKyAlbtXUXijkQ2ZW/CR/kwP2w+L8x7gYUjFtLBt/VVk6ushH/9ywStgwdh7FhTX2LxYi8NWhUVpoHPPQdbt0L37i02P+vMmTNs2rSJDRs2sHHjRlJTU9Fa4+/vz1VXXcWDDz5IdHQ0U6ZMoUsXU44tOTlZwpZwn3PUDlZ7gCLr8z7AcMzCwcuxh6tBXFoRCyGEcCMJXEKIemmt2XJ0C4k7Enk37V0KygoI7xHOb2f9ltvH3k6/Lv083cTLUlkJ774LTzwBBw5ARITpKFq82KNV0utmm5/14oumTGJYmCnrvmwZBAU1y5c8fvx4de/Vhg0b2Lt3LwCdOnVi8uTJ/OY3vyEmJoZJkybRqVOnZmmDaKfKgAPUDlfHHI65AhOmHKsDjsYsJCyEEF5EApcQwqUTF0/w5q43SdyRyIGzB+js35mbLDexYvwKpoZO9ao1s2JjIS9vHKmpDR9bWQn//rcJWvv3w5gxsGoVXHedlwatrCwTsv7+dzM/KzraFMVYsADc3HOUlZVVHa42btxIRkYGAF26dGHq1KksXbqU6OhoIiMjZW0s4R4aOEHtYLUPKLce0wETpGZiD1YRQG+k10oI0SpI4BJCVCurLGP1wdUkpiayNn0tlbqSaQOn8dDUh0iwJBDUoXl6UlpCVRUkJZmgtXcvWCwmeN1wg5cGrS1b4Pnn4b33mmV+ltaa9PT06nC1ceNGsrOzAQgODiY6Opqf/vSnREdHM27cOCl0IZquCLOGlXO4OutwTChmrlUc9mA1HJAVA4QQrZj8BhVCsOf0Hl7b8Rpv7nqT3KJc+gb15cGpD7J83HKG9xzu6eY1SVWVySyPPw5paTBqFLzzDiQkeGHQcjU/61e/MvOzBgxo0ktXVVWRlpZWowfr1KlTAPTu3Zvo6OjqOVgWiwUfr/vHEa1GFZBF7WCVjunRAuiMKVpxPTVLr7euoqZCCNEoEriEaKfySvJ4Z887JO5IZNvxbfj7+LNoxCJWjl/JNcOuwc+ndf94qKoy2eXxx2H3bhg50hTHSEhw+0i8prtwwb5+1pEjMGyYKeu+fPllz8+qqKggNTW1uvdq06ZNnDt3DoDQ0FDmzJlDdHQ0MTExhIeHe9UQUdGK5GEPVY6PBdbnFabM+pXAD7CHqyGYAhdCCNEOtPg7KqVUKPA8MAfzo/hL4F6tdXYjzg0AngRuA7oDqcBDWuuNTsdlYWoSObtOa/1hky5AiFasSleRnJVM4o5E3tv3HiUVJVwZciXPz32eW6+8lV6de3m6iU1WVQUffmiC1q5dMGKEWVfrppu8MGhlZZlg9corTZ6fVVZWRkpKSnUP1jfffMPFixcBCAsL49prryUmJobo6GgGDRokAUtcmgrgILV7rRx/cwcDY4EV2IOVBdObJYQQ7ViLBi6lVCDwFVAKLMMMLngK+I9SKkJrXdjAS7wKxAO/wqy6cRfwuVJqstbaebr858BjTvsONO0KhGidjuQd4fXU13l95+tk5WXRrWM3Vo5byYrxK5jYd2KbePOttT1opaZCeDi8+SbccosXBq2tW82wQdv8rBtvNPOzIiMb/RLFxcV8++231cMDt2zZQnFxMQCjR4/mtttuIzo6mujoaPr1a52VJIWHnMIeqGzhai/mNzeYdw6jgGnULGLRDyliIYQQLrR0D9ePgKHACK11BoBSyjay+8fAc3WdqJQaixmQsFJr/Zp13wbMFNwngEVOp5zRWm91+xUI0UoUlxfz4f4PSUxNZP2h9QDMGjqLZ2Y+w7Ujr6WTf+utnZyfDzk59u3wYcjNDeK660y19DfegB/8ALyqzkNFhUmEzz1nCmJ07w4PPGDmZ4WGNnj6xYsX2bx5c3UP1nfffUd5eTlKKcaNG8edd95JTEwM06ZNo1ev1t9TKVpACSZIOfdanXY4ph8mTM3GHqxGYioHCiGEaJSWfjuyCNhqC1sAWuvDSqlvgMXUE7is55YD7zqcW6GUegd4WCnVUWtdWufZQrQDWmu2n9hO4o5E/rnnn+SV5DG4+2Aei32MZWOXMai7q5G23qWwsGaYct6OHjWj75x17Kh47TW47TYvC1oXLkBiohkqmJXV6PlZ58+fZ9OmTdVzsLZv305lZSW+vr5ERkZy3333ER0dzdSpU+nevXuLXY5ohUowf9bcDzwIU/KmQF/MEMFK6zGdMEUsFlCziMUVLd9cIYRoa1r6bYkF+MjF/jQgoRHnHtZaFzntT8P8rS3M+rHNQqVUEeAL7AB+J/O3RFuVW5jL27vfJnFHIrtP7ybAL4AbRt3AyvEriR0ci4/yjtnpJSUmMNUXps6fr31e796mE2jkSJgzx3wcGmoK94WGwtKlkJ9/keXLvSh4HDliXz/rwgWYPt2UeV+40OUYx1OnTrFp06bqIYK7d+9Ga03Hjh2ZNGkSjzzyCDExMVx99dUENdNCx6IV00AuJlQ5b1nYqwMCvh18Tan1JdjD1TDMb0shhBBup7TWDR/lri+mVBnwnNb6Yaf9TwEPa63rDIBKqXVAV6311U77ZwNfANFa603WfX8BtgGHMUsj3g3EAEu11m/V8fp3Ytarp3fv3hPfeeedy7tINysoKJA3V17IG+5Lpa5k27ltrD25ls1nN1OhKxjZZSTz+8xnZshMgvxatn3l5YqzZzty+rTZcnM7cvp0gMPHHcnPrz0OqWvXckJCSggJKaVXr1LrY0n1x1dcUUqHDvX/nLr33nFUVlbyl7/sbq7La7Que/cSmpREr42mls/pGTM4mpDAxREjahyXm5tLamoqu3btYufOneTk5AAQEBCAxWJh7NixREREMGrUqFa9yLA3fK+0JapSEXA8gMDsQPuWYx79L9oXq6rsWEnRwCKKQotqPIa/GE6lrmS3F3yviJrke8X7yD3xTt50X2bMmPG91rrBCdieCFx/0lo/4rT/aUy1wfoC1xdAkNZ6stP+OcA6HAKXi3N9ga1AH611g5MlIiMjdUpKSoPX0xKSk5OJjY31dDOEE0/el4NnD/Lajtd4Y+cbnCg4Qa/AXiyNWMqK8SsYEzKmWb5mRQWcOFF/79SpU6ZwhaNu3ey9Uc7bgAFmCwxsevtiYyEvL4/UVA/1cFVW2udnbd5sLvzHP66en6W15tChQ9XDAzds2MDhw4cB6Nq1K9OnT68u0T5hwgT8/dvOKq/yM+wy5WPKPDn3VmVgBtfb9MXMqXLeBlBn2XW5J95J7ov3kXvinbzpviilGhW4WnpI4Xmgh4v9wdbn6nMOGFjHubbnXdJaVyqlkoBnlVJ9tdYnGtNYIbxFQVkBSWlJJKYm8nX21/goH+LC41g5biXxw+Pp4Hv5PSBVVSYs2Yb0uQpTJ06YTOGoc2d7eLrySteBqkuXJl64t7PNz3rxRVO5Y+hQePFF9PLl7D96lA2rV1eHrGPHjgHQs2dPoqOjueeee4iOjiYiIgJfryujKFpEFXAU18MAHX9L+QHhmCB1LfZQNQLo1oLtFUIIcVlaOnClYeZiORuNqZXU0LnXKaUCneZxjQbKMH/3q4+tWG3LdekJ0QRaazbnbCZxRyLvpr1LYXkhI3qO4NnZz7I0Yil9u/RtxGvAmTM150g5h6ljx6C8vOZ5AQH2+VEzZ7oOU927QxuoJn95srNNyHrlFbhwgcpp09h9991s9PFhQ3Iym558ktzcXAD69u1bvf5VTEwMI0eOxMfHO+bUiRZSjL1oheN2AHD8bdYdU259HjV7q4YAbafTUwgh2p2WDlwfA39USg3VWh8CUEoNBqYCD9dznu3cxzHFNd6wnusH3ASsq69CofW4BCBba32yidcgRLM6fvE4/9j5D15LfY2DZw8S1CGIm8fczMrxK5k8YHL1mllaQ15e/WHq6FFTqMKRvz/072+C05Qprof79ezZjsNUfb77Dp57jvKkJLYDGyMi2BgUxNd79pD39dcADB48mPnz51eHrGHDhrWJdc5EAxpbtEIBgzFBKpaawaoXso6VEEK0QS0duF7BFLD4SCn1X5hfQU8COcDfbAcppQYBmcATWusnALTWqUqpd4E/K6X8MQUxfor529+tDufegikxv8b6ur0xCyRPBG5p7gsUbZ+ZLzSOVOeltpugrLKMTw9+SuKORNZmrKVKVzElZC7LxjzL6I5zOXOyE+tehVedAlWh01LhPj7Qr58JTRMmwOLFtcNUSIg5TjRSZSWlSUl89/TTbNyzhw1+fmz29aWwvBxSUxkxYgQJCQnViwwPHOhq5LNoM8oxv31cBSvHgfGdMCHqamA59lAVbn1OCCFEu9GigUtrXaiUmgk8D7yJ+VveeuBerXWBw6EKU6DW+W3hCuBp4CnM4IudwDyt9XaHYw4DIcAfMPPFijAVC+dprT93+0UJcRmKi01g2rDrEElbtvLNniMUne1Bx8L76Fnyd0rO9WLzBV82O5yjlL08+ujRMHdu7TDVp4+XrUHVQpKTITk5FdNl0HSFhYVs/eorNvz1r2zcuJGtJSXYutCvHDGC5bGxxMTEMH36dPr06eOWrym8zKUWrbiZRhetEEII0b60+FszrXU2cEMDx2ThYmCF1roY+KV1q+vcrcDMprVSiMtXWmrmRbka3peTA9k5VZw7a3snNtS6QdfgMoYN9id0uHI5zK9fP2jF1cG9Wn5+Pt98842pILhuHSk7d1JRVYUPMD4oiLsWLiR6xQqmx8TQo4eruj+iVZKiFUIIIVpAO/xbuBBNU1YGhYW+vPOO6/lTp07VPic4WBPcu4CSwAzyh6bA2CxCQ2HxVRNZOj2WiPAeBARImmopZ86cYdOmTdUVBFNTU6mqqsLfx4eoqioeUIqYmBimPPooXWfK329avWLgIK6LVhQ7HCdFK4QQQjQDCVxCNMKxY/D++5CUBFu2AHThFuuMwC5d7JX7xo6t2Svl0+0Y68++wT8PvMyh/CN0D+jOT668lZXjVzK+z3gpptBCTpw4Ub3+1caNG0lLSwPMIsOTw8L47/79ic7J4eqgIAJt62fJXKzWRQOncd1bdQTXRStmIEUrhBBCNDsJXELUIScH3nvPhKzN1slUY8bAoEHg41PAxx8HERpq1rh1VFxezAf7P+DZHYms37wehWLOsDk8O/tZFo9cTIBfQMtfTDtz5MiR6nC1ceNG0tPTAQgKCmLq1Kn84IYbiMnPJ/Kjj+i4Zw8MGQIvvAArVrSDxcNauXLgEK6DVZ7DcYGYIX+TMbN/pWiFEEIID5HAJYSDrCx7yPr2W7Nv7Fh48klYsgRGjrRVKaxgzBj7eVprUo6nkLgjkX/t+Rf5pfkM6T6EJ2KfYNm4ZQzsJr0lzaWyspL9+/ezevVqEhMT2bBhA9nZ2QAEBwczffrEkdngAAAgAElEQVR0fvzjHxMdHc34nj3xe+klE67y82HqVPjTn0w5R1l82LvkUXfRigqH42xFK25BilYIIYTwShK4RLt36BCsWmVCVkqK2TdhAjzzjAlZ4eF1n5tbmMtbu94iMTWRPaf30MmvE0tGL2HFuBXEDI7BR8k7PnfSWpOZmcm2bdtISUlh27ZtbN++nUJrffyQkBCio6N54IEHiImJYcyYMWaR4W3b4LnnzE0GSEiA++6Dq67y4NUIqjCLd7jqrXJcMdFWtGIUcB1StEIIIUSrIoFLtEvp6faQtWOH2RcVBc8+a0LW0KF1n6tVBRf6fMYN/07i4wMfU1FVwaT+k/jbgr9xk+UmugXIO0B30Fpz9OjRGuEqJSWFvDwzbiwgIIBx48axcuVKIiMjAVi6dKl9XlxlJXz0kQlaX38NXbuakPXzn8v8rJZ2qUUr5iNFK4QQQrQZErhEu7F/vz1k7dpl9l19Nfzxj3DDDTB4cN3n5pXksS5zHavTV7Nl5r8oryqnMDuEeyfdy4rxKxjda3SLXENblpuby7Zt22oErFPWko9+fn5ceeWVJCQkEBUVRVRUFBaLBX9/67vw2Fjy8vJQt98OBQXw2mvw5z+b7sshQ8zHK1fK/KzmVApkYYb82ba3YXrhdDPvSopWCCGEaKckcIk2LS3NHrKshemYOhWef96ErNBQ1+dprUnLTWP1wdWsyVjDN9nfUKkr6dGpBwmWBEZVjeKh6x7C31f+7H458vLy+P7776uD1bZt26rnXSmlGDVqFHPnziUqKorIyEjGjh1Lp071VzpQZWXw4IPw8sv2+Vl/+IPMz3KnYkzBigwXWzZmiKBNV/N5ZWAlvvf5StEKIYQQ7ZYELtGmaA179piAtWoV7NsHSsH06fDii3D99dC/v+tzC8sK+erwV6xOX82a9DXkXMgBYFyfcTw87WHiwuOY1H8Svj6+JCcnS9hqpMLCQlJTU6uD1bZt26qrBgIMHTqUyZMn84tf/ILIyEgmTJhAl4Z6oiorTZdlSgp8/z3s2EHXCxfg4EEzJvS++2DSpGa+sjaqEMikZphKtz4edTq2BxAGTAFut35s264AFGxO3kxsbGyLNF0IIYTwRhK4RKunNezcaQ9ZBw+Cjw/ExJjllK67Dvr2dX1u5rnM6oCVnJVMaWUpQR2CmDN0Do/GPMr8sPn071pHQhO1lJWVsWvXrhrDAtPS0qiqMl0f/fv3JzIykmXLlhEVFcXEiRPp2bNn/S9aVWVuakqKPWBt3w5FReb5zp3Bz4/SkBACvvvO1O0X9buA616qDOCE07G9ML1SM6kZqIZhApcQQggh6iWBS7RKWpv33LaQlZlpRo3NmAG//CVcey307l37vNKKUjZlb2JN+hpWp6/m4NmDAIzoOYK7ou4iLjyO6YOm08G3QwtfUetTWVnJ3r17awwL3LVrF2VlZQD07NmTqKgorr32WiIjI4mKiqJvXcnXpqoKMjJMqLIFrO3bzbwsgMBAGD8e7rgDIiPNNnw4zJpFSV4eARK27M5TO0zZeqpynY7tiwlR86gdqqQGjBBCCNEkErhEq6G1qe5tC1lZWSZkzZoFDz9spur06lX7vGMXjrEmfQ1rMtbw5aEvKSgroKNvR2YMmcHdUXcTFx7HsB7DWvx6WpOqqqrqcuy23qvt27dTZO1l6tKlC5GRkdxzzz3VRS0GDRpkrxjoitamqIWt18r2eOGCeT4gAMaNg+XLTbCaONEshObn4sdWcjKpycnEuv3KvZgGzlB3T9U5p+NDMSHqWmqGqqFAUMs0WQghhGiPJHAJr1ZVZRYgTkoyCxJnZ4O/P8yeDY8+CosWgfOItMqqSrYe3Vrdi7Xz1E4ABnYbyNKIpcSFxzFzyEwC/QM9cEXeT2tNTk5OrXLs+fn5gCnHPn78eO64447qohbDhw83613V/aJw5EjNYYEpKWAt8U6HDiZc3Xqrvedq1Chzs9szDZyi7p6qCw7H+gADMSHqRmqHKilUIYQQQniEBC7hdaqqYPNme8g6dsy8H7/mGnjySVi4EIKDa55zpugMn2d8zur01Xye+Tnnis/hq3yZNnAaz85+lvjweEb3Gl1/j0s7derUqRrDAlNSUjh9+jRgyrFHRERw8803Vw8LtFgs+LnqZbLRGnJyag4L/P57OHvWPO/vDxERcNNNptcqMhIsFnOT26Mq4Dh191QVOhzri1mTylaowjFUDQY6tlSjhRBCCNFYEriEV6isNGvTrlplQtaJE9CxI8ybB7/7nQlZ3Rzmkmit2XFyR3Uv1rdHv0WjCekcwsLhC4kPj2fOsDl0D+juuYvyQnl5eTV6rbZt20ZOjqnGqJRi9OjRzJ8/v3pYYEREBAEBAXW/oNZw/HjNXquUFMi1ThLy84MxY0zlEtuwwCuvNDe3PanEVPhz1UuVCZQ4HOuP6ZEKA2IxBStsoWogsgCwEEII0cpI4BIeU1EBGzeakPX++3DqlJm2ExdnKnsvWFBzndoLpRf48tCXrD64mrUZazlRcAKFIqp/FL+J+Q1x4XFM7DcRH1XP0LZ2pLCwkO3bt9fovcrIyKh+ftiwYUydOrV6WOCECRMICmpgMs/Jk7WHBZ48aZ7z9TU9VQsW2IcFRkSYm9oeVABHcN1LdQgoczg2AFOQwlWhilBMT5YQQggh2gQJXKJFlZdDcrIJWR98YDpCAgMhPt6ErLg4sL3n11qzL3d/dS/WpuxNVFRV0K1jN+aGzSU+PJ55YfMI6Rzi0WvyBqWlpdXl2G29V3v37q0uxz5gwACioqJYsWJFdTn2Hj0aqOl9+nTNXquUFNObBabu/qhRMHeufVjg2LHmZrZlZUAWrnuqsjChy6YzJkBZgMXUDFX9MHOuhBBCCNHmSeASza68HNavNyHrww/NVJ7Onc0wwSVLYP58+/v04vJi1qYnV6+NdTjvMABjQsZw/+T7iQuPY0roFPx82u9/3YqKCvbu3VtjWOCuXbsoLy8H4IorriAqKorrr7++uveqT58+9b/omTMmXDkGLOtQQ5SCESNg5kx7z9W4ceYmtkUlmB4pVz1VRzBzrmy6YIb8TaB2oYo+gEwZFEIIIdq99vuuVTSr0lL48ksTsj76CM6fN8MDFy0yIWvuXOhkrZqWlZfFmjTTi/XV4a8oqSgh0D+QWUNm8eDUB4kLj2Ngt4GevSAPqaqqIj09vcawwB07dlBcXAxA165diYyM5Je//GV1UYuBAwfWXxzk/PnaBS2ysuzPDx8O06bZw9X48TXHdrYFRZi5U656qo5iqgPaBGNC1WRgKTVD1RVIqBJCCCFEvSRwCbcpKYF160zI+vhjyM83hS4WLzYha84cM52nvLKcb3K+YfXB1azJWMPe3L0ADAsexp0T7iQuPI6YwTEE+LWTuT9WWmuys7NrDAv8/vvvq8uxd+rUiQkTJnDnnXdWF7UICwurvxx7fr5ZONhxWOChQ/bnhw2DSZPgrrvM0MAJE2pWJ2nNLlJ35b/jTsf2wl6kIsxpa2DkpRBCCCFEfSRwiSYpLobPPjMh65NP4OJFU7L9+utNyJo1yxSkO1lwkn/tW8uajDWsy1zHhdIL+Pv4EzM4hjvG30H88HjCe4S3q7LtJ0+erLXWVa61up+/vz8RERHccsst1cMCR48eXX859osXTbhy7L1KT7c/P3iw6bG6807zOGFC7fr6rYkGTgKHgR/CpLxJMBd7T9Vpp+P7YgLUXGoGqmFAG8mYQgghhPA+ErjEJSsqgrVrzTpZn34KhYXQowfceCMkJMCMGeDrV0nK8RSe3mzmYn1/4nsA+nXpx42jbyR+eDyzhsyiS8c2NlStDufOneP777+v0Xt19OhRAHx8fBg9ejQLFiyoHhYYERFBx/pKpxcUQGpqzWqBBw6YMu0AAweaULV8ub0cu/MK0a3BeUygcrVlUaOceic6wXpMiFqEPVCFY8qsN1CAUQghhBCiOUjgEo1SUABr1piQtWaNCV29esGtt5qQFRMDBRXn+Tzzc+5YvYa1GWs5U3QGH+XD5AGTeXrm08SHxxPRO6LN92IVFBSwffv2Gr1XmZmZ1c+Hh4czffr06mGB48aNq78ce1ER7NxZc1jg/v1mhWiA/v1NqLr1VhOsJk6EkFZSubEIE5zqClX5Tsd3xyz8OxqIt348BPgN5JXm0X2XrLsmhBBCCO8igUvU6eJF04OVlGR6tEpKoHdvWLbMhKxp0zT7zu1mTfoaHn9rNZtzNlOlq+jZqSfzwuYRHx7PNcOuoWdgK+xZaaSSkhJ27txZo6jFvn370NaeptDQUKKiorjjjjuIjIxk4sSJBNc3jK+kxB6ubD1Xe/ealaEB+vQx4erGG+09Vw1VIPSkciCHugPVKafjOwGDMSFqKvZAZdvqylNxkJqcSiyx7m2/EEIIIUQTSeASNeTnm7lYSUnw+eem2mDfvnDHHSZkjY0qIPnIet5JX8Ptf13D0QtmWNyEvhP4f9P+H/HD44nqF4WvT9tbuTU/P5+0tDSWL1/O2bNnGTx4MLt3764ux96rVy+ioqJISEionnfVu3fvul+wtBR2765ZLXDPHrMitHlBiIqCa6+1Vwzs168FrvQSVGGfR+Vqy6FmGXU/YCAmPC3EHq5sW2+k6p8QQggh2hQJXILz501VwaQk+OILKCszo9R+8hNT+KLXiHQ+y1zDU+mr2bBxA2WVZXTp0IU5w+bweOzjzAubR78uXhYEmuDixYvs3buXPXv2kJaWVr0dO3as+hgfHx+Cg4O5//77q8NVaGho3cMly8pMmHIsaLF7t1mkDMz8qshIswK0redqwACzBpYnaeAcdQ/7ywJKnc7phwlP06ndQ9Uf+akjhBBCiHZF3vq0U2fPmvWxkpLMelkVFabOwt13w6Jryyjuk8xnmWtYsWM1GeszABh1xSh+ftXPiQuPY9rAaXTw7eDhq2iawsJC9u3bVytYZWdnVx8TEBDAqFGjmDFjBhaLhTFjxmCxWDh8+DAzZ850/cLl5WYYoOOwwJ07TegCUxlw4kS4/357z9XAgZ4LV4XUX5jigtPxPTDh6UpMcQrHQDUIaF/V/IUQQggh6iWBqx3JzYUPPzQl3NevN9OCBg+G++6D6fNOcbzrR6zJWE38pvUUlhcS4BfAjMEzuHfSvcwPn8/Q4KGevoTLUlxczP79+2sFq6ysrOq5Vh06dGDkyJFMnTqVH//4x1gsFiwWC0OGDMHXt/bwyCNHjpgPKipMAQvHYYGpqWYuFpg1rSZOhHvvNY+RkTBkSMuGqzIgm7pDVa7T8YHYA1QMNQPVYKSEuhBCCCHEJZDA1cadOgUffGBCVnKyCVnDhsH9D1QRPm0nGR3/zdrMNfxh0y4ABnUbxLKxy4gLj2PGkBkE+gd69gIuQWlpKQcOHKgVrA4dOkSVtaKfv78/w4cP56qrrmLFihXVwWrYsGH1r3GltfnHzMiAO+5g8tmzMHy4CVdFReaYoCATqu66yz4scNgwqG9hYneowizkW1egOkbteVSDMAHqWmoP++uFzKMSQgghhHATCVxt0IkT8P77JmRt3Giqhw8fDr/4ZSE9Jv6H3T5v8fKhz8n7Pg8/Hz+mDZzG72f/nvjh8Yy6YpTXl20vKyvj4MGDNUJVWloaGRkZVFqr+fn6+jJ8+HDGjRvHrbfeWh2swsPD8ff3d/3CVVVw9ChkZppg5bhlZpoFx6w6+PiAr699EeHISAgPb55wpYGz1B2ojmB6sWwU9nlUsbieR9X2apoIIYQQQnglCVxtxLFj8N57JmR9/bXpkBk1SvPDe07gf+XHpFS8zp+Pf4fer+nduTfXjbyOuPA45gydQ7cA7xwjVlFRQXp6eq1gdfDgQSqslfx8fHwICwvDYrGQkJBQHayGDx/ueuHgigp7oHIOVocOmcqBNh06mB6qYcNg5kwICzPbo4+SX1JC940b3XexBdQdqA5bn3fUExOexgHXUXseVT1rJgshhBBCiJYjgcuLxcZCXt44UlNdP5+TYwLWqlWwebPZN9pSScLP9lM+8l9sKX2VVwpOorIVV/W/isdiHyM+PJ7xfcfjo5p5mNslqKysJDMzs1awOnDgAGXWQhNKKYYOHYrFYmHx4sXVwWrkyJEEBDhVaSgthcOHa/dQZWRAVpa97DpAYKAJUaNGwYIF9lAVFmZKNbqYv8XcuaQmJ1/aik9lmJ6ougLVGafjO2MPUDOo3UvV5VK+uBBCCCGE8BQJXK1MVpY9ZH37rdk3wlLC3Du2cW7oK+yo+Bd7qyroXtiducPmEh8ez9ywuYR0DvFouwGqqqo4fPhwrWC1b98+Sh16lgYPHozFYmH+/PnVlQFHjhxJYKDDfLLCQtMjtXZt7eF/OTmmi8+mWzcToCZOhJtuMh8PG2Ye+/RxTwGLShqeR+XQJPyxz6O6ntqB6gpkHpUQQgghRBsggasVOHTIBKykJFMID2CYJZ9JtyeTM+B5DnTYwAEgIjiCB8IeIH54PFcPuBo/H8/c3qqqKrKzs10GqyJbgQkgNDQUi8XCrFmzqsutjxo1iqCgIHNAfr4JUOnp8NlnNUPViRM1v2ivXiZERUfX7KUKC4MePZoeqsqBE5iFfH8Ek85PMiXRHedRlTscrzBzpYYAM6kdqPoh86iEEEIIIdoBCVxe7MwZOHQoiGHDzOcDR59ixM2rOdzvD2R23c8J/0BmD51NfPjfmB82n9BuoS3aPq01R48erRWs0tLSKHQoMNGvXz8sFgt33nlndbAaPXo0Xbt0MQuC2ULU6tXwwgv24X9nnMbZ9etnAtT8+fYeKltvVbcmzEOrBE5iwtRR66PzdpIalf460Qk+wISnCcAN1AxUA5F5VEIIIYQQQgKXNysJyKK8s6bXvH+TO/AlsoOPENYjjJ+GxxMX/gIxg2Lo6Nf87+q11pw4ccJlsLpwwb4qbu/evbFYLKxcudIerEaNIrikpGaBinXr7B87nI9SZgHgsDC44YaagWroUOjc+dIbX4VZZ8oxPDmHquNAhdN5gUCodZtrfRxg37cpexPT50+/9PYIIYQQQoh2RQKXF/MNX09l3M8YFx5DfPh9xIXHEd4zvNm+ntaa06dP1whUtjWt8vLyqo+74oorsFgsLF261BSvGDkSS3AwPW29VZmZZgjgX/9qPnYYRoifn1ltOSwMpkypOfRv8GBwVVmwzgYD56jdG3XU6eMyp/M6Yg9PMdiDlWOoCqbeOVSVuZWNb6cQQgghhGi3JHB5sZBTN9Ph4FzWfT/A7a995swZl8Hq7Nmz1ccEBwczZswYbr75ZhOqevbE4udHyJkz9h6q9evNJLMyh1TTsaN9yN/s2TVD1cCBJnQ1Rj6uh/c5hqpip3P8MHOnQoFJwBJqBqpQpCCFEEIIIYRoMRK4vJhvVWd8K8sbPrAe58+frxWq0tLSOH36dPUx3bp1w2KxcP3ixVhCQrAEBmKpqqLPqVOozEwzBPCVV6DSoVenc2cToCwWWLy4ZuW//v0bXgC4gLrnS9kC1UWnc3wwxSZCgbHAAmqHqd7W44QQQgghhPACEri8WHIyJCenQiNWfMrPz2fv3r21gtUJh2p+QUFBWEaOZMGUKVi6dcPi64uluJj+J06YYLVlS81y6t27mwB11VXwgx/UnFPVu3fdlf+KMYGpvkCV5+K8PpjQNAq4hhpzpggF+iL/Y4UQQgghRKsib19bmYKCApfB6ujRo9XHBAYGMnrQIK4JD8cSEYGlooIx+fmE5uSgUlLsteUBQkJMiJoxo2blP1s5dWdlmDWlNlF3VT/nRXzBDOMLxVTwi6b2nKn+QIem/usIIYQQQgjhXSRwebGsrCw+//xz1qxZUx2sjhw5Uv18QIcOjOrbl9jgYCw9ezKmqAjL6dMMys/HZ98+2LfPHNi/vwlQCxbUHPo3bBh07Wr/ghXY15r6AteB6hQ1F/AF6I49QF1F7SIUA4BObv7HEUIIIYQQohWQwOXFFo4cyZ7SUjr4+TGyRw+mdOzIj/r2Zcz581hKShhSVobvkSNmvpStnPqsWbXLqQcGmvLop7AHpw3AW9QMVcepsdYUAEHYw1MEtedMDbAeI4QQQgghhKhFApcX+6pvX85lZTGsogK/c+dMeHLsobJtgwbDhQ41e6I2A+9iD1THAOf6G52wB6dZ1A5ToUAT1hMWQgghhBCivZPA5cV69e5NJ+WD33tfgg6FE372QJUCfIA9UJU6ndwB+/yoadRauJdQoAdSHl0IIYQQQohm1OKBSykVCjwPzMG83f8SuFdrnd2IcwOAJ4HbMDOHUoGHtNYbnY7zAR4CfoypfXcAeEJr/Z4bL6X5/XArnX5RCRN8a+73xb7WVBRwPbWLUPRCyqMLIYQQQgjhYS0auJRSgcBXmP6YZZjyC08B/1FKRWitCxt4iVeBeOBXwCHgLuBzpdRkrXWqw3FPAg8Avwa+B24GkpRSC7TWa9x5Tc1qNBxfcJzQKaE1A1UfTOgSQgghhBBCeLWW7uH6ETAUGKG1zgBQSu0C0jG9Uc/VdaJSaizwA2Cl1vo1674NQBrwBLDIui8EE7Z+p7X+o/X0/yilwoDfAa0ncE2FzPJMQmNDPd0SIYQQQgghxGVo6UFni4CttrAFoLU+DHwDLG7EueWYUhC2cyuAd4C5SqmO1t1zMTOY3nI6/y3gSqXUkCZdgRBCCCGEEEI0UksHLguwx8X+NGB0I849rLUucnFuByDM4bhSIMPFcTTi6wghhBBCCCGEW7R04OoBnHex/xwQ3IRzbc/bHvO01s7L8zofJ4QQQgghhBDNyhNl4Z2DEDSuOLlq5LmNPa7mk0rdCdwJ0Lt3b5KTkxvRpOZXUFDgNW0RdnJfvI/cE+8k98X7yD3xTnJfvI/cE+/UGu9LSweu87juYQrGde+Vo3PAwDrOtT1vewxWSimnXi7n42rQWr8MvAwQGRmpY2NjG2hOy0hOTsZb2iLs5L54H7kn3knui/eRe+Kd5L54H7kn3qk13peWHlKYhplj5Ww0sLcR5w6xlpZ3PrcM+5ytNKAjMMzFcTTi6wghhBBCCCGEW7R04PoYuFopNdS2Qyk1GJhqfa6hc/2BBIdz/YCbgHVa61Lr7s8wAexWp/NvA/ZYqyIKIYQQQgghRLNr6SGFrwB3Ax8ppf4LM9fqSSAH+JvtIKXUICATeEJr/QSA1jpVKfUu8GellD9wGPgpMASHcKW1Pq2Ueh54RCl1EdiOCWUzabj0vBBCCCGEEEK4TYsGLq11oVJqJvA88CamkMV64F6tdYHDoQrwpXYP3ArgaeApoDuwE5intd7udNyvgQLgHqAPcAC4UWv9iXuvSAghhBBCCCHq1uJVCrXW2cANDRyThYuqglrrYuCX1q2+8ysxoeypy26oEEIIIYQQQjRRS8/hEkIIIYQQQoh2QwKXEEIIIYQQQjQTCVxCCCGEEEII0UwkcAkhhBBCCCFEM5HAJYQQQgghhBDNRAKXEEIIIYQQQjQTCVxCCCGEEEII0UwkcAkhhBBCCCFEM1Faa0+3wesopXKBI55uh9UVwBlPN0LUIvfF+8g98U5yX7yP3BPvJPfF+8g98U7edF8Gaa17NXSQBC4vp5RK0VpHerodoia5L95H7ol3kvvifeSeeCe5L95H7ol3ao33RYYUCiGEEEIIIUQzkcAlhBBCCCGEEM1EApf3e9nTDRAuyX3xPnJPvJPcF+8j98Q7yX3xPnJPvFOruy8yh0sIIYQQQgghmon0cAkhhBBCCCFEM5HA5SFKqVCl1CqlVL5S6oJS6n2l1MBGnvuMUmqdUuqsUkorpZY3c3Pbhcu9J0qpSKXUy0qp/UqpIqVUtlLqbaXUkJZod1vXhPsySCn1kVLqiFKqWCl1RimVrJSa3xLtbsua8vPL6XUesf4M+7o52tmeNPF3iq5jG9fc7W7rmvq9opQapZRKsv78KlZKHVBK3dOcbW7rmvA75bF6vldKWqLtbVkTf4YNVEq9YX3/VaSUOqiUekop1bm5291YMqTQA5RSgcBOoBT4L0ADTwGBQITWurCB8y8CqcAh4HZghdb69eZsc1vXlHuilPojMBl4G0gD+gP/DYQA47TWOc3b+rariffFAvwSSAaOAl2BHwHxwA1a6/ebtfFtVFN/fjm8zlBgF1AIpGutpzVPi9s+N/xO0cDrwN+cntqltS5ye4PbCTfcl0jgK8zPsEQgHwgHgrTWzzVfy9uuJv5OGQAMcNrdGfgM+EBrfWOzNLodaOJ96QzsAPyBx4BsIAp4HPhYa31Tsza+sbTWsrXwBtwDVAJhDvuGABXALxtxvo/1MQzzn3K5p6+ptW9NuSdALxf7BgFVwBOevrbWvDX1e8XF6/kBOcAnnr621rq5654An2Pe4CcDX3v6ulrz5obfKRp4ytPX0da2Jv5e8cH8Ae8DT19HW9qa4XfKUuv3T7ynr601b038XrnGeg+ucdr/O+v5gZ6+Pq21DCn0kEXAVq11hm2H1vow8A2wuKGTtdZVzdi29uqy74nWOtfFviNALqa3S1y+Jn2vONNaV2D+Slzutha2P02+J0qpHwATgEeapYXtj1u/T4TbNOW+xAKjAenJci93f68sA05h/oAkLl9T7ksH6+MFp/15mD9cKHc1sikkcHmGBdjjYn8a5gesaHluvSdKqVGYIYX7mtiu9q7J90Up5aOU8lNK9VFK/TcwHPgfN7axvWnSPVFKBQPPAw9qrc+5uW3tlTt+fv1UKVVqnf/wlVJquvua12415b7YhtgGKKW2KqXKlVKnlVIvKqU6ubWV7YvbftdbhxjOAN62/jFPXL6m3JcvgXTgWaXUaKVUkFJqJqbX7P90I4e5NzcJXJ7RAzjvYv85ILiF2yIMt90TpZQf8H+YHq5Xm960ds0d9+X3mB6tE8CDwM1a6/XuaV671NR78gfgIGbOkHCPpt6Tt4CfAbOBO4GewFdKqVh3NbCdasp96Wd9fBdYB8zB/J1+f3IAAAtYSURBVCy7A/inuxrYDrnz/ddSzPvoN5raKHH590VrXYL5A4VtGO5FYD3wKXC3e5t5+fw83YB2zFW1Eq/o9mzH3HVP/gpMwYzpdvUDRFyapt6XPwPvAH0wRWb+qZRaorX+1B2Na6cu655Ye01uByZo6yB74TaX/X2itV7q8OkmpdRHmL82P4W9p0Vcnsu9L7Y/iL+ltX7U+nGyUsoX+J1SarTWeq9bWtj+uOt3/e3ADq31ria2RxiX+3slAPOHiRBMCM4GrgIexczh+qkb23jZJHB5xnlMmncWjOuEL5qfW+6JUuq3mL8QL9Nar3NT29qzJt8XrfVRTJVCgE+VUsnAHzF//RKXrin35G+YXt+jSqnu1n1+gK/182KtdanbWtp+uPV3itb6olJqNfDDpjasnWvKfTlrffzCaf86TDGAcYAErkvnrt/1VwEjgXvd1K72rin35YeYOY9hWutM676NSql84GWl1P9prXe6raWXSYYUekYaZryqs9HID1BPafI9UUr9GngYuEdr/aYb29aeNcf3Sgqmwqe4PE25J6OAn2B+gdq2qcDV1o+94i+RrVBzfJ8oXP/FWTReU+5LmvXR+R7Y/uIvxbMuj7u+V5Zhek9keKd7NOW+XAmcdwhbNt9ZH0c1sW1uIYHLMz4GrrauQwOAUmow5o3Hxx5qU3vXpHuilPoFZvjNr7XWf2mmNrZHbv1eUUr5YIZIOf9gFo3XlHsyw8W2EzN8bQawyv3NbRfc/X3SFbNe3bdual971ZT7shazJtE8p/1zrY8p7mliu9Pk7xWlVAfgZmCNqyrF4rI05b6cBIKVUs5/SJ1kfTzmpjY2jafr0rfHDbNQXgawG1PuchHmTcchzIKGtuMGYf6C8qjT+THAEsxkQI2ZM7QEWOLpa2utW1PuCeYHbxXmF+TVTttoT19ba96aeF8eA14EbrJ+z9yEGY5ThSmc4fHra41bU39+uXi9ZGQdLo/dE+AB4BXgB5hhOcusr1MGTPf0tbXmzQ2/639j3f8MpqDJw0Ax8Lqnr621bu74+QVcb33vdb2nr6etbE38GTYYUxL+oPXn1wzgV9Z9KVjXrvX0JnO4PEBrXWgtWfk88CZmiMB64F6tdYHDoQrwpXZP5OOYN5A2d1k32zniEjXxnsyz7p9H7b9GbsC8iRGXoYn3ZTtmfP3NQDfMX8F2Yt5EftMCzW+T3PDzS7hZE+/JAeA669YN8yblG+CHWuvvEJfNDd8rT2Aqrv0ME4xPYKp8PtnMTW+z3PTzaxmmep7MA3aTptwXrXWWUupqzB9ZnwKuAHKAl4GntZesXaus6VAIIYQQQgghhJvJXx6FEEIIIYQQoplI4BJCCCGEEEKIZiKBSwghhBBCCCGaiQQuIYQQQgghhGgmEriEEEIIIYQQoplI4BJCCCGEEEKIZiKBSwghxCVRSv1dKaWVUs95ui2XQin1mHWtl3ZNKTXY+m8x1NNtEUKI9kAClxBCiEZTSnUCEqyf3qqU8vNkey7Rb4B2H7iAwZh/CwlcQgjRAiRwCSGEuBTXAV2BNUAIMM+zzREASqmOnm6DEEII1yRwCSGEuBTLgPPAcqAYuN3VQUqpsUqpD5RSZ5VSxUqpA0qpR5yOuU4p9Y1SqkApdUEp9Z1SapHD835KqUeUUvuVUqVKqeNKqT8ppQIcjhlsHd74M6XUc0qp00qpIqXUp0qpwQ7HaeuHv7Yer5VSj1mfi1JKrVJKHXVo6zPW3jzH9iYrpb5WSs1WSm23fp09SqlrL/P6r1dKbbW+Tp5SKkkpNbChG+DQjoVKqR1KqVLgZ9bn7lZKbVFKnbO+5lalVLzDubHAf6yffuHwbxHrcMyPlFI7lVIlSqkzSqlXlVI9GmqXEEII11rTUBAhhBAepJTqB8wGXtZa5yqlPgSuV0oFa63POxx3FZAMZAD3AUeBcCDC4ZifAy8CH2JCXAEwATPczeYtYCHwLLAZGAU8aT3mBqfmPQKkAiswPW/PAOuUUhatdTkwGdgCvA78zXrOUevjQOu5rwMXAQvwKGbI3c1OX2cY8ALwW+AMcD+wSik1UmudcQnX/xPgJeA14AmgC/AYsEEpFaG1vkj9hmP+/Z4EDgHnrPsHA38HsjC/4xcCnyql4rTWa4HtwF3A/wC/ALZZz9trbdfvrNf0IvAroD/wFDBGKTVFa13ZQLuEEEI401rLJptssskmW4Mb8BCggcnWz+daP/+J03EbgRwgsI7X6YoJNu/X87WmW1/7dqf9t1r3j7N+Ptj6+V7Ax+G4qdb9P3TYp4GnGrhGhQkqtwFVQE+H55KBciDcYV8IUAn8v0u4/iAgH0h02j8YKAPubaCNyda2jWvgOB/rtawDPnLYH2v9t5jt4utXAo867bf9W17r6f+Dsskmm2ytcZMhhUIIIRrrdiBda73F+vmXwHEchhUqpQIxb9Df1loX1fE6UzCh4+V6vtY8TPh4zzq00M9aoGOd9flop+NXaa2rbJ9orb/B9CxNbuiilFJdlVLPKqUygVJMqHoTE77CnQ5P11qnO3yd08BpTC9ZY69/MiZ0vu10bUeB/S6uzZUsrXWqi2uZaB1OeQqosF7LHGBEI15zDiakObfrW+BCI9slhBDCiQwpFEII0SClVBQwGnhWKdXd4an3gbuVUsO11geBYMyb9qMuXsamp/WxvmNCgA6YoYb1vYbNKRfHnMIMiWvIa5ihko9ihhYWAldhht0FOB17jtpKHY5rzPWHWB+/rOP583Xsd3TCeYdSKhRYj+nt+zmQjQldT2KGYzbE1q6MOp53/jcXQgjRCBK4hBBCNMYy6+ND1s3Z7cB/YcJCFfUHnTPWx/7AnjqOOQuUYIYWunLc6fPeLo7pjQlQdbIW4FgMPKa1fsFh/5X1nVePxlz/WevjciDNxfMNzd8CM8TP2TygG3Cj1ro68Fl73RrD1q5rcB36zrrYJ4QQogESuIQQQtRLKdUBUzziW+BhF4c8DyxVSv231rpIKfU1cJtS6gmtdbGL4zdjeq7uBD6v48t+hgl23bTW6xvRzCVKqcdswwqVUlOBAZhCGTZlQCen8zoCvpihd46WN+Jr1nIJ138RCNNav3E5X6cOtmBVfS1KqeGYIY6OPW6l1kfnf4svMGFxoNb6Cze2Swgh2jUJXEIIIRqyADOc7H6tdbLzk0qpv2Eq7sViSo4/AGwAtiil/oR5sz8UU+Th51rri9YS6X9RSr0HvI0JIOOAEq31X7TWyUqpf2EqAD4HfIcJA4OBOOAh6xBGmy7Ah9a29MJUEUwH/uFwzF4gXin1GaYH57jW+rhSaitwv1LqBKb3bSWNG4pYl4au/4JS6lfA/yilegFrMUU0+gMxQLLW+p+X8XW/xAwh/If16/YFHscMLXScs33QetxKpdQ5TAA7oLXOVEo9C/xVKTXCeg0lQChmftfftdb/QQghxCWRohlCCCEasgwTiJLqeP5fmDW5lgForbfx/9u7W9wuoigOwy8rYQkIPBaHKoKkFlQTFJDgUCwA0oQE0YRgCAhgB1iCRCEqMDVdw0WcP0lToICYgHgeOTOZj+t+c+49d6oqX6snzSbJ9zpTZVlrPa1uNlWol9Wbaq86PnPf/aZV+l71tnpdHTRB6vyarcfN2qOj6rBpf359TUv47w6a9Vnvm3bod3bHb1WfmjVbR9VJdfeXo/Ebf/j9z6obTTOLF03oetT8CL1wGuQFz/3cdHG8XL2r7jcVyQ/nrjttxuJKE6o+Vld35x4243KtetWM+4MmoH4JgL92aa2fTQMHgP/fbnPj4+r2Wuv5v30bAPiRChcAAMBGBC4AAICNmFIIAACwERUuAACAjQhcAAAAGxG4AAAANiJwAQAAbETgAgAA2IjABQAAsJFvc+WPjam+DIEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.012528   0.0044     0.00634626 0.01358639 0.00729657]\n",
      " [0.03768    0.014152   0.01844604 0.04208963 0.02187568]\n",
      " [0.070736   0.025296   0.03592383 0.05184688 0.03967156]\n",
      " [0.111064   0.03748    0.0743903  0.09538709 0.06074402]\n",
      " [0.157216   0.050992   0.11727442 0.15333915 0.08939233]\n",
      " [0.210904   0.066472   0.16957435 0.19105199 0.12422705]\n",
      " [0.270336   0.088472   0.23676908 0.25936859 0.16822351]\n",
      " [0.338856   0.104784   0.3172705  0.33473775 0.2099604 ]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.10215900000000001\n",
      "0.029165652071375857\n",
      "0.009856070579233042\n",
      "0.06099110801160007\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(beta_Z=1.5)\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": 74,
   "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.014736   0.005968   0.02018619 0.01108025 0.01550995]\n",
      " [0.041928   0.015832   0.04068303 0.04537702 0.04053749]\n",
      " [0.074152   0.027184   0.07695947 0.07481968 0.07537307]\n",
      " [0.115096   0.041808   0.11923079 0.11972134 0.11565205]\n",
      " [0.16168    0.050184   0.15907669 0.17287885 0.16348179]\n",
      " [0.215112   0.0646     0.21469533 0.20447695 0.21589226]\n",
      " [0.275176   0.079216   0.27179524 0.27532854 0.27470643]\n",
      " [0.33916    0.093392   0.34402456 0.327037   0.34278324]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.107357\n",
      "0.0031128409389901916\n",
      "0.005813402284733342\n",
      "0.0013270544948680205\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",
    "\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='probabilities_Y',\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",
    "\n",
    "        #### Contraction\n",
    "        s_f_rate_cont[i] = contraction(s_test_labeled, 'judgeID_J',\n",
    "                                       'decision_T', 'result_Y',\n",
    "                                       'B_prob_0_logreg', 'acceptanceRate_R',\n",
    "                                       r / 10)\n",
    "        #### Causal model\n",
    "\n",
    "        released = bailIndicator(r * 10, s_logreg, s_train.X, s_test.X)\n",
    "\n",
    "        #released = cdf(s_test.X, s_logreg, 0) < r/10\n",
    "\n",
    "        s_f_rate_caus[i] = np.mean(s_test.B_prob_0_logreg * released)\n",
    "\n",
    "        ########################\n",
    "        #percentiles = estimatePercentiles(s_train_labeled.X, s_logreg)\n",
    "\n",
    "        #def releaseProbability(x):\n",
    "        #    return calcReleaseProbabilities(r * 10,\n",
    "        #                                     s_train_labeled.X,\n",
    "        #                                     x,\n",
    "        #                                     s_logreg,\n",
    "        #                                     percentileMatrix=percentiles)\n",
    "\n",
    "        #def integrand(x):\n",
    "        #    p_y0 = s_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",
    "        #s_f_rate_caus[i] = si.quad(lambda x: integrand(np.ones((1, 1)) * x),\n",
    "        #                           -10, 10)[0]\n",
    "\n",
    "    f_rates[r - 1, 0] = np.mean(s_f_rate_true)\n",
    "    f_rates[r - 1, 1] = np.mean(s_f_rate_labeled)\n",
    "    f_rates[r - 1, 2] = np.mean(s_f_rate_human)\n",
    "    f_rates[r - 1, 3] = np.mean(s_f_rate_cont)\n",
    "    f_rates[r - 1, 4] = np.mean(s_f_rate_caus)\n",
    "\n",
    "    f_sems[r - 1, 0] = scs.sem(s_f_rate_true)\n",
    "    f_sems[r - 1, 1] = scs.sem(s_f_rate_labeled)\n",
    "    f_sems[r - 1, 2] = scs.sem(s_f_rate_human)\n",
    "    f_sems[r - 1, 3] = scs.sem(s_f_rate_cont)\n",
    "    f_sems[r - 1, 4] = scs.sem(s_f_rate_caus)\n",
    "\n",