diff --git a/analysis_and_scripts/Analysis_07MAY2019_new.ipynb b/analysis_and_scripts/Analysis_07MAY2019_new.ipynb
deleted file mode 100644
index 0007648dd53cf3a90fd0f78f869260498f3de222..0000000000000000000000000000000000000000
--- a/analysis_and_scripts/Analysis_07MAY2019_new.ipynb
+++ /dev/null
@@ -1,1313 +0,0 @@
-{
- "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 </span>Data sets</a></span><ul class=\"toc-item\"><li><span><a href=\"#Data-without-unobservables\" data-toc-modified-id=\"Data-without-unobservables-1.1\"><span class=\"toc-item-num\">1.1 </span>Data without unobservables</a></span></li><li><span><a href=\"#Synthetic-data-with-unobservables\" data-toc-modified-id=\"Synthetic-data-with-unobservables-1.2\"><span class=\"toc-item-num\">1.2 </span>Synthetic data with unobservables</a></span></li></ul></li><li><span><a href=\"#Algorithms\" data-toc-modified-id=\"Algorithms-2\"><span class=\"toc-item-num\">2 </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 </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 </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 </span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Without-unobservables-in-the-data\" data-toc-modified-id=\"Without-unobservables-in-the-data-3.1\"><span class=\"toc-item-num\">3.1 </span>Without unobservables in the data</a></span></li><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-3.2\"><span class=\"toc-item-num\">3.2 </span>With unobservables in the data</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": 51,
- "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': 20})\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",
- "### 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\\{-X\\}})$"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 52,
- "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=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\n",
- " df = df.assign(probabilities_Y=sigmoid(df.X))\n",
- "\n",
- " # Draw Y ~ Bernoulli(1 - sigmoid(X))\n",
- " # Note: P(Y=1|X=x) = 1 - P(Y=0|X=x) = 1 - sigmoid(X)\n",
- " results = npr.binomial(n=1, p=1 - df.probabilities_Y,\n",
- " size=nJudges_M * nSubjects_N)\n",
- "\n",
- " df = df.assign(result_Y=results)\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": [
- "### 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": 53,
- "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": [
- "## 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": 54,
- "metadata": {},
- "outputs": [],
- "source": [
- "def contraction(df, judgeIDJ_col, decisionT_col, resultY_col, modelProbS_col,\n",
- " accRateR_col, r):\n",
- " '''\n",
- " This is an implementation of the algorithm presented by Lakkaraju\n",
- " et al. in their paper \"The Selective Labels Problem: Evaluating \n",
- " Algorithmic Predictions in the Presence of Unobservables\" (2017).\n",
- "\n",
- " Arguments:\n",
- " -----------\n",
- " df -- The (Pandas) data frame containing the data, judge decisions,\n",
- " judge IDs, results and probability scores.\n",
- " judgeIDJ_col -- String, the name of the column containing the judges' IDs\n",
- " in df.\n",
- " decisionT_col -- String, the name of the column containing the judges' decisions\n",
- " resultY_col -- String, the name of the column containing the realization\n",
- " modelProbS_col -- String, the name of the column containing the probability\n",
- " scores from the black-box model B.\n",
- " accRateR_col -- String, the name of the column containing the judges' \n",
- " acceptance rates\n",
- " r -- Float between 0 and 1, the given acceptance rate.\n",
- "\n",
- " Returns:\n",
- " --------\n",
- " (1) The estimated failure rate at acceptance rate r.\n",
- " '''\n",
- " # Get ID of the most lenient judge.\n",
- " most_lenient_ID_q = df[judgeIDJ_col].loc[df[accRateR_col].idxmax()]\n",
- "\n",
- " # Subset. \"D_q is the set of all observations judged by q.\"\n",
- " D_q = df[df[judgeIDJ_col] == most_lenient_ID_q].copy()\n",
- "\n",
- " # All observations of R_q have observed outcome labels.\n",
- " # \"R_q is the set of observations in D_q with observed outcome labels.\"\n",
- " R_q = D_q[D_q[decisionT_col] == 1].copy()\n",
- "\n",
- " # Sort observations in R_q in descending order of confidence scores S and\n",
- " # assign to R_sort_q.\n",
- " # \"Observations deemed as high risk by B are at the top of this list\"\n",
- " R_sort_q = R_q.sort_values(by=modelProbS_col, ascending=False)\n",
- "\n",
- " number_to_remove = int(\n",
- " round((1.0 - r) * D_q.shape[0] - (D_q.shape[0] - R_q.shape[0])))\n",
- "\n",
- " # \"R_B is the list of observations assigned to t = 1 by B\"\n",
- " R_B = R_sort_q[number_to_remove:R_sort_q.shape[0]]\n",
- "\n",
- " return np.sum(R_B[resultY_col] == 0) / D_q.shape[0]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Causal approach - metrics\n",
- "\n",
- "Generalized performance:\n",
- "\n",
- "$$\n",
- "\\mathbf{gp} = \\sum_{x\\in\\mathcal{X}} f(x) ~ \\delta(F(x) < r)P(X=x)\n",
- "$$\n",
- "\n",
- "and empirical performance:\n",
- "\n",
- "$$\n",
- "\\mathbf{ep} = \\dfrac{1}{n} \\sum_{(x, y) \\in \\mathcal{D}_{test}} f(x) ~ \\delta(F(x) < r)\n",
- "$$\n",
- "\n",
- "where\n",
- "\n",
- "$$\n",
- "f(x) = P(Y=0|T=1, X=x)\n",
- "$$\n",
- "\n",
- "is a predictive model trained on the labeled data and\n",
- "\n",
- "$$\n",
- "F(x_0) = \\int P(x)~\\delta(P(Y=0|T=1, X=x) > P(Y=0|T=1, X=x_0)) ~ dx = \\int P(x)~\\delta(f(x) > f(x_0)) ~ dx.\n",
- "$$\n",
- "\n",
- "NB: in code the direction of inequality was changed. CDF changed to `bailIndicator` algorithm.\n",
- "\n",
- "**Rationale for `bailIndicator`:**\n",
- "\n",
- "* Bail decision is based on prediction $P(Y=0|T=1, X=x)$.\n",
- " * Uniform over all judges\n",
- "* Judges rationing: \"If this defendant is in the top 10% of 'dangerousness rank' and my $r = 0.85$, I will jail him.\"\n",
- "* Overall: this kind of defendant $(X=x)$ is usually in the $z^{th}$ percentile in dangerousness (sd $\\pm~u$ percentiles). Now, what is the probability that this defendant has $z \\leq 1-r$?\n",
- "\n",
- "\n",
- "<!--- **Proposal**\n",
- "\n",
- "1. Train model for $P(Y=0|T=1, X=x)$\n",
- "* Estimate quantile function for $P(T=1|R=r, X=x)$\n",
- "* Calculate $P(Y=0|do(r'), do(x'))=P(Y=0|T=1, X=x') \\cdot P(T=1|R=r', X=x')$ for all instances of the training data\n",
- "* Order in ascending order based on the probabilities obtained from previous step\n",
- "* Calculate $$\\dfrac{\\sum_{i=0}^{r\\cdot |\\mathcal{D}_{all}|}}{|\\mathcal{D}_{all}|}$$--->"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 55,
- "metadata": {},
- "outputs": [],
- "source": [
- "def getProbabilityForClass(x, model, class_value):\n",
- " '''\n",
- " Function (wrapper) for obtaining the probability of a class given x and a \n",
- " predictive model.\n",
- "\n",
- " Arguments:\n",
- " -----------\n",
- " x -- individual features, an array of shape (observations, features)\n",
- " model -- a trained sklearn model. Predicts probabilities for given x. \n",
- " Should accept input of shape (observations, features)\n",
- " class_value -- the resulting class to predict (usually 0 or 1).\n",
- "\n",
- " Returns:\n",
- " --------\n",
- " (1) The probabilities of given class label for each x.\n",
- " '''\n",
- " if x.ndim == 1:\n",
- " # if x is vector, transform to column matrix.\n",
- " f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n",
- " else:\n",
- " f_values = model.predict_proba(x)\n",
- "\n",
- " # Get correct column of predicted class, remove extra dimensions and return.\n",
- " return f_values[:, model.classes_ == class_value].flatten()\n",
- "\n",
- "\n",
- "def cdf(x_0, model, class_value):\n",
- " '''\n",
- " Cumulative distribution function as described above. Integral is \n",
- " approximated using Simpson's rule for efficiency.\n",
- " \n",
- " Arguments:\n",
- " ----------\n",
- " \n",
- " x_0 -- private features of an instance for which the value of cdf is to be\n",
- " calculated.\n",
- " model -- a trained sklearn model. Predicts probabilities for given x. \n",
- " Should accept input of shape (observations, features)\n",
- " class_value -- the resulting class to predict (usually 0 or 1).\n",
- "\n",
- " '''\n",
- " def prediction(x): return getProbabilityForClass(\n",
- " np.array([x]).reshape(-1, 1), model, class_value)\n",
- "\n",
- " prediction_x_0 = prediction(x_0)\n",
- "\n",
- " x_values = np.linspace(-15, 15, 40000)\n",
- "\n",
- " x_preds = prediction(x_values)\n",
- "\n",
- " y_values = scs.norm.pdf(x_values)\n",
- "\n",
- " results = np.zeros(x_0.shape[0])\n",
- "\n",
- " for i in range(x_0.shape[0]):\n",
- "\n",
- " y_copy = y_values.copy()\n",
- "\n",
- " y_copy[x_preds > prediction_x_0[i]] = 0\n",
- "\n",
- " results[i] = si.simps(y_copy, x=x_values)\n",
- "\n",
- " return results\n",
- "\n",
- "\n",
- "def bailIndicator(r, y_model, x_train, x_test):\n",
- " '''\n",
- " Indicator function for whether a judge will bail or jail a suspect.\n",
- " Rationale explained above.\n",
- "\n",
- " Algorithm:\n",
- " ----------\n",
- "\n",
- " (1) Calculate recidivism probabilities from training set with a trained \n",
- " model and assign them to predictions_train.\n",
- "\n",
- " (2) Calculate recidivism probabilities from test set with the trained \n",
- " model and assign them to predictions_test.\n",
- "\n",
- " (3) Construct a quantile function of the probabilities in\n",
- " in predictions_train.\n",
- "\n",
- " (4)\n",
- " For pred in predictions_test:\n",
- "\n",
- " if pred belongs to a percentile (computed from step (3)) lower than r\n",
- " return True\n",
- " else\n",
- " return False\n",
- "\n",
- " Arguments:\n",
- " ----------\n",
- "\n",
- " r -- float, acceptance rate, between 0 and 1\n",
- " y_model -- a trained sklearn predictive model to predict the outcome\n",
- " x_train -- private features of the training instances\n",
- " x_test -- private features of the test instances\n",
- "\n",
- " Returns:\n",
- " --------\n",
- " (1) Boolean list indicating a bail decision (bail = True) for each \n",
- " instance in x_test.\n",
- " '''\n",
- "\n",
- " predictions_train = getProbabilityForClass(x_train, y_model, 0)\n",
- "\n",
- " predictions_test = getProbabilityForClass(x_test, y_model, 0)\n",
- "\n",
- " return [\n",
- " scs.percentileofscore(predictions_train, pred, kind='weak') < r\n",
- " for pred in predictions_test\n",
- " ]\n",
- "\n",
- "\n",
- "def estimatePercentiles(x_train, y_model, N_bootstraps=2000, N_sample=100):\n",
- " '''\n",
- " Estimate percentiles based on bootstrapped samples of original data.\n",
- " Bootstrapping is done N_bootstraps times and size of the sample is\n",
- " N_sample.\n",
- "\n",
- "\n",
- " '''\n",
- "\n",
- " res = np.zeros((N_bootstraps, 101))\n",
- "\n",
- " percs = np.arange(101)\n",
- "\n",
- " for i in range(N_bootstraps):\n",
- "\n",
- " sample = npr.choice(x_train, size=N_sample)\n",
- "\n",
- " predictions_sample = getProbabilityForClass(sample, y_model, 0)\n",
- "\n",
- " res[i, :] = np.percentile(predictions_sample, percs)\n",
- "\n",
- " return res\n",
- "\n",
- "\n",
- "def calcReleaseProbabilities(r,\n",
- " x_train,\n",
- " x_test,\n",
- " y_model,\n",
- " N_bootstraps=2000,\n",
- " N_sample=100,\n",
- " percentileMatrix=None):\n",
- " '''\n",
- " Similar to bailIndicator, but calculates probabilities for bail decisions\n",
- " by bootstrapping the data set.\n",
- "\n",
- " Returns:\n",
- " --------\n",
- " (1) Probabilities for positive bail decisions.\n",
- " '''\n",
- "\n",
- " if percentileMatrix is None:\n",
- " percentileMatrix = estimatePercentiles(x_train, y_model, N_bootstraps,\n",
- " N_sample)\n",
- "\n",
- " probs = np.zeros(len(x_test))\n",
- "\n",
- " for i in range(len(x_test)):\n",
- "\n",
- " if np.isnan(x_test[i]):\n",
- "\n",
- " probs[i] = np.nan\n",
- "\n",
- " else:\n",
- "\n",
- " pred = getProbabilityForClass(x_test[i], y_model, 0)\n",
- "\n",
- " probs[i] = np.mean(pred < percentileMatrix[:, r])\n",
- "\n",
- " return probs"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Performance comparison\n",
- "\n",
- "Below we try to replicate the results obtained by Lakkaraju and compare their model's performance to the one of ours."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 56,
- "metadata": {},
- "outputs": [],
- "source": [
- "def fitLogisticRegression(x_train, y_train, x_test, class_value):\n",
- " '''\n",
- " Fit logistic regression model with given training instances and return \n",
- " probabilities for test instances to obtain a given class label.\n",
- " \n",
- " Arguments:\n",
- " ----------\n",
- " \n",
- " x_train -- x values of training instances\n",
- " y_train -- y values of training instances\n",
- " x_test -- x values of test instances\n",
- " class_value -- class label for which the probabilities are counted for.\n",
- " \n",
- " Returns:\n",
- " --------\n",
- " (1) Trained LogisticRegression model\n",
- " (2) Probabilities for given test inputs for given class.\n",
- " '''\n",
- "\n",
- " # Instantiate the model (using the default parameters)\n",
- " logreg = LogisticRegression(solver='lbfgs')\n",
- "\n",
- " # Check shape and fit the model.\n",
- " if x_train.ndim == 1:\n",
- " logreg = logreg.fit(x_train.values.reshape(-1, 1), y_train)\n",
- " else:\n",
- " logreg = logreg.fit(x_train, y_train)\n",
- "\n",
- " label_probs_logreg = getProbabilityForClass(x_test, logreg, class_value)\n",
- " \n",
- " return logreg, label_probs_logreg"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Without unobservables in the data\n",
- "\n",
- "The underlying figure is attached to the preliminary paper. When conducting finalization, last analysis should be conducted with a preset random seed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 57,
- "metadata": {
- "scrolled": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[1] 0 1 [2] 0 1 [3] 0 1 [4] 0 1 [5] 0 1 [6] 0 1 [7] 0 1 [8] 0 1 "
- ]
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAHwCAYAAACYFJ/XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xl8TNf7wPHPyUIsaVD70gatKhJBIrRILEVrKW3VUsRebVVRW/1aQilV1XypL7XvYt+rtSW2UoRQSy2tqH2XJohIcn5/3Jv5jshKliHP+/Wal5m555773Htm2nlylqu01gghhBBCCCGE+B+7rA5ACCGEEEIIIWyNJEpCCCGEEEIIkYAkSkIIIYQQQgiRgCRKQgghhBBCCJGAJEpCCCGEEEIIkYAkSkIIIYQQQgiRgCRKQogspZSarpQaYj5voJQKy+KQhMg0SqkySqnIZLY7KKW0Uso186LKeEqpbkqp4KyOIzkpxaiU2qmU6pR5EQkhMpskSkKIdKGUClNK3VNKRVo9iqe0n9a6m9b6m8yI8UkppUYqpWZndRyJMZNMrZTql8VxvKSUeupv0JdZCYrW+m+tdV6r42baj29b/jwLIYQtkERJCJGemmmt81o9LmbWgZVSDlm5vw3wA26a/4oUPAPtLVIgbSyEeFKSKAkhMpRSyk4ptUwpdVkpdVspFayUetVq+3yllH8i+z3yF33rsvHD9JRSQ5RSl4Fp5vvNlVKHzGPtVEpVSiKu+Po/VkqdBv403/9RKXVeKfWvUmqfUuo18/2mwEDgA7O3LMR8P59SapZS6pK53wil1CP/bVVKlVJK3VVKuVi956WUumrGUk4ptV0pFa6Uuq6UWpiGa5wXeAf4CKiglPJIsL2OUmqPWfc5pVQH8/3cSqkflFL/mNu2K6VymtteN/e5rZQKVUrVsapvp1JqlFJqv7nfSqVUfnPzdrNMfK+il1LqZaVUkFLqhnlu8xJch/NKqX5KqT/M+hbFx2Fuf8eM4V+l1GmlVMO0XHuz7Eil1GKz7gigvVKqptU5XlJKTVBKOVqfB3DUPI93zXpS+/kapZT6wXyeUykVpZT6Jr69zNcuyqoHTin1LVATmGIeM8Cqykbmud9SSk2wOo6dUmqoUuqs+VmarZR6ztz2yFBW8zr5JvV5TlA2td/BgUqpa0qpi0qpjlZl85nlr5nlvlBKKatD2Cml/mu2+XGlVF2rfbua+0Qopf5WSrWx2tZNKfWneS02KKVKJYjX8p1WxtDeMQnOa71Sqrf5/Euz/gil1FGlVPMElyHJGBO5XknFZWd+tq6a9RxWSlVIqh4hhA3RWstDHvKQxxM/gDCgQSLv2wGdAGfACfgR2G+1fT7gbz5vAISZzx0ADbgmUzYG+AbIAeQCvIAr5r/2QBfgLyBHInHF1/8LkB/IZb7fAShgbh8EXABymttGArMT1LMO+C+QGygKhABdk7hG24HOVq9/AH40ny81j2dnXqfX03DtOwPnzX03AOOttpUGIoD3zXMqCHiY234CtgDFzOtVC3AESgE3gEZmnY2B68Dz5n47gXNABSAPsCr+ugAvGf9reSi+ckB9s50KA7uAcVbbzwN7zOv3PHAS6GZuew24be5vZ8b2ymNc+5FANNDMrCf+8+JtXpcy5nF7JfP5S8vnqyFw0Hxexyy3y2pbSGLXy7y2nRL5nK4GXABXjJ7DBub2HmbcpTG+Y6uBWQm/TwmutW9Sn+ckviMpfQeHmZ+b5sAd4Dlz+0JghRlXGeA04Gdu62bu29vct53ZzvmA54Bw4GWzbDGggvn8PeAE8IoZnz+wI6nvNFAP479NyizzPHAPKGK+ft+s386MIdJqW5IxJmyrFOJqAuw1288O43tTNCv+Oy0PecgjbY8sD0Ae8pDHs/Ewf4xEmj8kbgOrkihX0Pwxk8d8/SSJUhRWP1IxepWGJTjeXySSdFjVXyeZc1IYSUZF8/VDPyyBEuaPrpxW73UANiVRX09go/ncDrgIvGa+XghMBko8xrUPxkw8zONfARzM118BSxPZxx64H39uCbb9H+aPbav3tgAfmM93AiOttrmbbaFIJFFKpP73gH1Wr88Dbaxej+d/CeQM4LtE6kjrtR8JbE0hrv7x1yqJz19aPl95zOubD/gSIwm+iJHUjcJMZhNeL5JOlGpYvbcC6G8+3wb0sNpW0TyuHZmTKEUC9lbbbwKeGIlFDFDOatsnwGbzeTeMZFtZbT8AtMVIlG4DLQGnBDFtwky2rGK8b34eHvlOm9fhAv/7nn2E+R1M4pyPAE1SijFhW6UQV0OMHmtvwC6t3295yEMeWfeQoXdCiPTUQmudz3y0AFBK2SulxprDW/7F+KsyGAnTk7qitY62ev0iMMgcFnVbKXUb46/FJZKp45z1C3MY0Z9KqXDgFsYP3qRifRHICVyxOt4koEgS5ZcCtZVSRYC6QJTW+jdz2+cYPy73K2MIml8yMVvH64rRY7HAfGslkBejFwiMHpi/Etm1CEYPT2LbXgTaJriONQDrxTmsr9tZjOtQIIkYiyqlliilLpifgdk8ek0vWz2/a55DcvGn9donjBmlVHlzGNZlM64RicSV8Jip+nxpre8ABzHapg5GMrsHY2idD0aCkxZJXZ/iGNc/3lmMdi2Uxvof13WtdWwisRXGSMYTxmZ9rc5rrXWC7cW11v9iJEyfAJeVUuuUUuXMMi8Ck6yu/3UgDihpVY+lnbXWccBisz4weoXivysopTqp/w2lvA2U5+HPQKIxJnIdkoxLa70RmILxh5ArSqkpSinnROoQQtgYSZSEEBmtI/AWxhAYF4y/oIPR+5AkrXUMxl9kc1u9XTRhsQSvzwHDrZK1fFrr3FrrJckdKv6JOf+gH/AuRk9Afoy/mKuEZa2OdxcoYHW857TW7kmc0w1gK9AK4wfbIqttl7SxAmAxjB+IU5VSpZOJO15HM74NypirdRrjh3L8XJFzQNlE9ruCMRQtsW3nMHqUrK9jHq31d1ZlSlk9fwGjrW7y6DUC+Nbc7qa1fg5jKGay7Z8glqRiTPW1NyWM7SeMHoSXzLiGknRbxx8zLZ+vbRi9Lm4YwwK3AW8C1YAdqYwxJRcxfqTHewGjXa9hDIOzfH+UsbjB86k9Viq/g0m5CsQmEtsFq9cledgLGOeD1nqD1roBRiJ6GqOtwGiDrgnaIJfW+nfr0BPUuwh43/w+VcX4YwJKqTIYyctHGMNK82H0/Fh/NpOMMYFk49JaB2itqwKVMIbeZenqlEKI1JFESQiR0Zwxfmzd4H/DjlLrEMZkc3ulVBOMOTTJmQp8oowFBJQyJs03U0rlSUOsMRh/DXbEmGdgve8VwDV+QrrW+hzGj99xSqnnzEnbLymrhQ8SsRBjZbp3zOcAKKXeV0rF/7X9NsaPvdhHd39ER4wf+B5Wj9ZAc2UssDAfaKyUetec7F5QKVXZ7AWYDQSYPT72yljAwRGYB7RUSr1hvu+klKqrHl7uvaPZI5MHGA4sMf/yfhXQ5o/QeM4YP9rDzQnu/VNxXvFmAN3M49sppUoqpV55zGufkDPGXJg7ylhg5MP4Deb1uYExtyZeWj9f2zCSwsNm0hGMOadIa30ziX2uJDhmShYB/ZRSrmYvxShgkdmT8ifgrJRqZLZr/Fwi62NZPs9JSOt3EACt9QNgGfCNeZ1KA30xPo/xiimlepmfyzYYCfEvSqli5nXNjZH03eF/34UpwP+Z7RW/YMR7KcSyD6OdpwI/mz1WYPR8aYykUimlumH0KFlLNMZEDpNkXEqp6ubDwTyXaFL33RZCZDFJlIQQGW0Wxl9gLwJHgd+SL/6Q3hjzFG5j9MKsSa6w+dfbjzD+SnwLY5J7+zQc72dgM3AKY87Vv8Alq+2LMXprbiql9prvtcdIpo6Zx1xK8n91X4XxF+V/tNZHrd73BvYppe5gzEH5RGv9D4BS6oRSqnXCipRStTCGAU3SWl+Of2D8xTwMaK21PoOxgMEgjB6fAxg9HGD8cD2O0dtxE2NhDKW1DsO47l9h/Ij8B2NooPX/M+Zh/Oi9hDHEqg+A1joCGA38bg5D8sT4gV4d48fqGmB5MtfnIebQxO7ABHP/IP7Xm5XWa5/Q5xhJawRGj8XiBNuHAQvN83jnMT5fOzH+OBC/gt5h4IHV68QE8L9hj+NTcQ7TzLh3AH+b5/IZgNb6FvApMAejJ+cmDw/hS+zznFCavoMJfIyRFJzBSBrnAHOttv+GMafqJsYfJd41Y7YHBmB8tm5gLOjRyzynpRhz2JaawyUPYyw6kpJFGL17lj9OaK0PY3yu9prHKg/8nmC/pGJ8SApx5cNI+G9jfC8vYSzkIoSwcfGrwAghhBCpopTaCUzXWs/O6liEEEKIjCI9SkIIIYQQQgiRgCRKQgghhBBCCJGADL0TQgghhBBCiASkR0kIIYQQQgghEpBESQghhBBCCCEScMjqANJLwYIFtaura1aHYXHnzh3y5EntrVtEZpA2sU3SLrZH2sQ2SbvYHmkT2yTtYntsrU1CQkKua60LpVTumUmUXF1d2b9/f1aHYREcHIyvr29WhyGsSJvYJmkX2yNtYpukXWyPtIltknaxPbbWJkqps6kpJ0PvhBBCCCGEECIBSZSEEEIIIYQQIgFJlIQQQgghhBAigWdmjlJiHjx4wPnz54mKisr0Y7u4uHD8+PFMP64wODk5UbJkSRwdHbM6FCGEEEII8RR6phOl8+fP4+zsjKurK0qpTD12REQEzs7OmXpMYdBac+PGDc6fP0/p0qWzOhwhhBBCCPEUeqaH3kVFRfH8889nepIkspZSiueffz5LehKFEEIIIcSz4ZlOlIA0J0m+s33xne2bMcGITCPJsRBCCCGEeBLPfKKUlW7cuIGHhwceHh4ULVqUEiVKWF5HR0en23E2b96Mi4uLpW4PDw+CgoLSXE9MTAz58uV77DhmzpzJ5cuXLa87d+7MiRMnHrs+IYQQQgghssozPUcpqz3//POEhoYC4O/vT968eenfv/9DZbTWaK2xs3uynLVu3bqsWrXqiep4UjNnzqRq1aoULVoUgFmzZmVpPEIIIYQQQjwu6VHKAqdPn6ZSpUr07NmTqlWrcu7cuYd6cgIDA+nWrRsAV65c4Z133sHT05Pq1auzZ8+eVB/n888/Z+rUqZbXX375Jf/5z3/4999/qVevHlWrVsXd3Z1169Y9su/mzZtp0aKF5XXPnj2ZP38+AMOGDcPLy8tyDlprFi9eTGhoKK1bt7b0mNWqVcuSKM6fPx83NzcqVarEkCFDgP/1YA0ePJjKlStTs2ZNrl69moYrKYQQQgghRMbINj1KfX7pQ+jl0BTLxZdJzTwlj6IeBDQOeKx4jh07xqxZs5gyZQoxMTFJluvduzcDBw6kRo0ahIWF0bRpU44cOfJIuaCgIDw8PCyvV61aRZs2bRg8eDA9evQAYOnSpQQFBZErVy5Wr16Ns7MzV69e5fXXX6dp06apjv2zzz5j+PDhaK1p164dv/zyC61bt2bixIn8+OOPD8UBxuqDX375Jfv378fFxYUGDRqwbt06GjduTHh4OD4+PowZM4Z+/foxc+ZMBg8enOpYhBBCCCGEyAjZJlGyNWXLlsXLyyvFcps3b35ons+tW7e4d+8euXLleqhcYkPvXF1dOXfuHFeuXOH8+fMULVqU4sWLEx0dzaBBg9i5cyd2dnacO3eO69evp3p+0pYtW/juu++Iiori+vXrVKtWjTfffDPJ8r///jv16tWjYMGCALRr147t27fTuHFjcuXKZdm3WrVq7NixI1UxCCGEEEIIkZGyTaKU2p6f+J6k4E7BGRcMkCdPHstzOzs7tNaW19bLWmut2bt3Lzly5His47z77rssX76csLAw2rRpA8DcuXMJDw/nwIEDODg4ULJkyUeW0nZwcCAuLu6RmO7evUuvXr04cOAAJUqU4Msvv0xxGW7rc0vI+rzs7e2T7V0TQgghhBAis8gcJRtgZ2dH/vz5OXXqFHFxcaxcudKyrUGDBkyaNMnyOn7OT2q1adOGwMBAVqxYwbvvvgtAeHg4hQsXxsHBgU2bNnHhwoVH9nvxxRc5evQo0dHR3Lp1i61btwJw79497OzsKFiwIBERESxfvtyyj7OzMxEREY/UVaNGDYKCgrhx4wYxMTEEBgbi4+OTpvMQQgghhBAiM0miZCO+/fZbGjduTP369SlZsqTl/UmTJrFr1y7c3d2pUKEC06ZNS3T/+DlK8Y/4ZKty5cpcu3aN0qVLU7hwYQA6dOjAb7/9hqenJ0uXLuXll19+pL7SpUvTokUL3Nzc6NixI1WrVgWMlfz8/PyoVKkSLVu2xNvb27JP586d6dat2yPLn5csWZIRI0bg6+uLh4cHNWrUoEmTJk9+0YQQQgghhMggKrlhUU8TT09PvX///ofeO378OK+++mqa6kmvoXcRERE4Ozs/UR3iySRs/+DgYHx9fbMuIJEoaRfbI21im6RdbI+0iW2SdrE9ttYmSqkQrbVnSuWyzRyl1MrouUlCCCGEEEII2ydD74QQQgghhBAiAelREkIIIYQQQmQIX1+4fduDNK5HZhOkR0kIIYQQQgghEpBESQghhBBCCJEhYmLgTuTTmXLI0LuEfM1/g7MwBiGEEEIIIZ5y69bBkV3hKOK49+8Dcj3nmNUhpcnTmd49RfLmzZvqsv7+/owbNy7D6n/cYyQmLCyMhQsXPnE9QgghhBDi2XLjBrRvD82awQuc5Vu7weTKGZfVYaWZJErisUiiJIQQQgghElq+HCpU0CxeFMsw/BlbcCxTK42EnDmzOrQ0k0QpC6xduxZvb2+qVKlCgwYNuHLlimXboUOHqFevHi+//DLTpk2zvP/dd9/h5eWFu7s7w4YNS7TepMqMGjWKV155hQYNGnDixIlE9z179iz169fH3d2d+vXr888//wDQqVMnli1bZikX34M1ePBgduzYgYeHBz/88AOxsbH0798fNzc33N3dmThxIgBbtmyhSpUquLm50aVLF+7fvw+Aq6srQ4YMoWbNmnh6enLgwAEaNWpE2bJlmTJlSrLndOfOHZo0aULlypWpVKkSixcvTv3FF0IIIYQQ6e7KFWjVCt57D0raXWR/XFX8/cIYW2EOMerpGnIXL/vMUeoDpGZZwvgyvqko6wEEpD2UWrVqsWfPHpRSTJ8+nbFjx/L9998DcPjwYfbs2cOdO3eoUqUKTZo04ciRI5w6dYq9e/eitaZ58+Zs376dOnXqWOrcuHFjomXy5MlDYGAgBw8eJCYmhqpVq1KtWrVHYurVqxcdO3bEz8+PmTNn0rt3b1atWpXkOYwZM4Zx48axbt06ACZPnsyZM2c4ePAgDg4O3Lx5k6ioKDp16sSWLVsoV64cHTt2ZPLkyfTp0weAUqVKsXv3bvr27UunTp3YtWsXUVFRVKxYkZ49eyZ5TteuXaN48eKsX78egPDw8LQ3ghBCCCGEeGJaw8KF0Ls3REZqRr++nv67WuDQoytMnsxWOzuCg0NJ3Y9r25J9EiUbcv78eVq3bs2lS5eIjo6mdOnSlm1vv/02uXLlIleuXNStW5e9e/eyc+dONm7cSJUqVQCIjIzk1KlTjyRKiZWJiIigZcuW5M6dG4DmzZsnGtPu3btZsWIFAB06dGDgwIFpOqfNmzfTs2dPHByMj1SBAgU4dOgQpUuXply5cgD4+fkxadIkS6IUH4ubmxuRkZE4Ozvj7OyMk5MTt2/fTvKcateuTf/+/Rk0aBBNmzaldu3aaYpVCCGEEEI8uQsX4KOPYO1aqFFDM9P1a14NHGZkTQEBoFRWh/hEsk+ilNqeH1/z3+CMCQPg008/pV+/fjRv3pzg4GD8/f0t21SCD5RSCq01X3zxBR9++GGSdSZVJiAg4JE6UyN+HwcHB+Li4izHiI6OTvL4CY+jtU72GDnNsap2dnaW5/GvY2Jikj3vkJAQfv75Z7744gsaNmzI0KFDU39yQgghhBDisWkNs2ZBv34QHQ3jx8XR+4/u2M+ZCYMGwejRT32SBBk8R0kp1VgpdUIpdVopNTiR7T2VUn8opUKVUjuVUhXM912VUvfM90OVUlMerf3pFR4eTokSJQCYM2fOQ9tWr15NVFQUN27cIDg4GC8vLxo1asTMmTOJjIwE4MKFC1y9evWh/ZIqU6dOHVauXMm9e/eIiIhg7dq1icb02muvERgYCMCCBQuoVasWYMwlCgkJscT24MEDAJydnYmIiLDs37BhQ6ZMmUJMTAwAN2/epHz58oSFhXH69GkA5s2bh4+PT6qvU1LndPHiRXLnzk379u3p378/Bw4cSHWdQgghhBDi8Z09C40aQdeu4OEBhw/E0PdAByNJGjbsmUmSIAN7lJRS9sAk4A3gPLBPKbVGa33MqthCrfUUs3xzYDzQ2Nz2l9baI6Piyyx3796lZMmSltf9+vXD39+fVq1aUaJECWrUqMGZM2cs26tXr06TJk34559/+OqrryhevDjFixfn+PHj1KxZEzAWVJg/fz6FCxe27NewYcNEy1StWpXWrVvj4eHBiy++mOQwtQkTJtClSxe+++47ChUqxKxZswDo3r07b7/9NtWrV6d+/frkyZMHAHd3dxwcHKhcuTKdOnXi008/5eTJk7i7u+Po6Ej37t3p1asXs2bNolWrVsTExODl5UXPnj1Tfe2SOqfTp08zYMAA7OzscHR0ZPLkyamuUwghhBBCpF1cHEyZYnQYaQ2TJkHPLtHYfdAWVqwwEqTBj/SLPNVUSsOjHrtipWoC/lrrRubrLwC01qOTKN8W6Ki1flMp5Qqs01pXSu3xPD099f79+x967/jx47z66qtpC9zX/Dc4bbslFBERgbOz85NVIp5IwvYPDg7G19c36wISiZJ2sT3SJrZJ2sX2SJvYJmmX9Hf6NHTrBtu2wRtvwNSp4Fo0yljibv16+OEHMOegJ8bW2kQpFaK19kypXEYOvSsBnLN6fd587yFKqU+UUn8BY4HeVptKK6UOKqW2KaUyb7Z+MBk6P0kIIYQQQoinQWyskQO5u0NoKMyYAb/+Cq6F70Lz5kaSNHlysknS0ywje5RaAY201t3M1x2A6lrrT5Mo384s76eUygnk1VrfUEpVA1YBFbXW/ybYpwfQA6BIkSLV4ufYxHNxceGll15K71NLldjYWOzt7bPk2MJw+vTph5YOj4yMtNwHStgOaRfbI21im6RdbI+0iW2SdkkfZ8/mZuzYVzh2zIWaNa/Tt+9JChWKxv7uXdyGDMHl8GFODBzI5caNU6zL1tqkbt26qepRyshV784DpaxelwQuJlM+EJgMoLW+D9w3n4eYPU7lgIfG1mmtpwJTwRh6l7BL7/jx41k2/E2G3mU9Jycny9LiYHvdvsIg7WJ7pE1sk7SL7ZE2sU3SLk8mJga++w78/SFvXpg/H9q1K4hSBSE8HN58E44cgQULKN+2LeVTUefT2iYZOfRuH/CyUqq0UioH0AZYY11AKfWy1csmwCnz/ULmYhAopcoALwN/Z2CsQgghhBBCZGuHD4O3NwwZYoysO3YMPvjAXMTu5k2oXx/274clS6Bt26wON8NlWI+S1jpGKdUL+BWwB2ZqrY8qpUYA+7XWa4BeSqkGwAPgFuBn7l4HGKGUigFigZ5a65sZFasQQgghhBDZVXQ0fPMNjBoFBQrA0qXGOg0WV68aqzicOAErV0KTJlkWa2bK0BvOaq1/Bn5O8N5Qq+efJbHfcmB5RsaWpPhuweDgLDm8EEIIIYQQmWX/fujSBf74w+g9CgiAggWtCly8CA0aQFgYrF1rJEzZRIbecFbwyMS12bNn06tXryyKJmP4+vqScGn21AoODua3336zvJ4yZQpz585Nr9CEEEIIIUQioqKM2x55e8ONG7BmjTEf6aEk6dw58PEx/t2wIVslSZDBPUpCpCQ4OJi8efPy2muvAaTphrRCCCGEECLtfvvN6EU6cQK6doVx4yBfvgSFzpyBevWMuUkbN0LNmo91rAexD7hw78KTB50FpEcpC3Xq1Illy5ZZXsf3PgUHB+Pj48P7779PuXLlGDx4MAsWLKB69eq4ubnx119/AbB27Vq8vb2pUqUKDRo04MqVKwD4+/vTpUsXfH19KVOmDBMmTEj0+Bs3bqRmzZpUrVqVVq1aERkZyYYNG3j//fctZYKDg2nWrBkAH330EZ6enlSsWJFhw4YlWqd1D9qyZcvo1KlTkrGGhYUxZcoUfvjhBzw8PNixYwf+/v6MGzcOgNDQUGrUqIG7uzstW7bk1q1bgNGDNWjQIKpXr065cuXYsWNHmq+9EEIIIUR2c+cO9O0LtWrBvXvGPZGmT08kSTp5EmrXNla527r1sZOk0zdP49TNifbT23P3wd0nP4FMln16lPr0Me6UlZL4MqlZwtDDwxjImYx79+7h4eFheX3z5k2aN2+eYtWHDh3i+PHjFChQgDJlytCtWzf27t3Lf/7zHyZOnEhAQAC1atViz549KKWYPn06Y8eO5fvvvwfgzz//JCgoiIiICF555RU++ugjHB0dLfVfv36dkSNHsnnzZvLkycO3337L+PHjGTJkCB9++CF37twhT548LF68mNatWwMwatQoChQoQGxsLPXr1+fw4cO4u7unfJ0gyVh79uxJ3rx56d+/PwBbtmyx7NOxY0cmTpyIj48PQ4cOZfjw4QSY1zsmJoa9e/fy888/M3z4cDZv3pyqOIQQQgghsqPgYKP36O+/4eOPYcwYSPRONkePGqvbxcUZO6Xyt541rTXzDs/jw+8+JG55HHZxdsbSbY4p7mpTsk+ilEVy5cpFqFWCNnv27FTN5/Hy8qJYsWIAlC1bloYNGwLg5uZGUFAQAOfPn6d169ZcunSJ6OhoSpcubdm/SZMm5MyZk5w5c1K4cGGuXLlCyZIlLdv37NnDsWPHeP311wGIjo6mZs2aODg40LhxY9auXct7773H+vXrGTt2LABLlixh6tSpxMTEcOnSJY4dO5bqRCm5WBMTHh7O7du38fHxAcDPz49WrVpZtr/zzjsAVKtWjbCwsFTFIIQQQgiR3UREwKBBMHkylC1r5D7mz6tHhYYa85AcHSEoCF59Nc3HC48Kp/uK7iz9YSnsh9wKVBJaAAAgAElEQVTOuXmhxAvkzp37ic4jK2SfRCmFnh+LTFz1zsHBgbi4OMDIvKOjoy3bcubMaXluZ2dneW1nZ0dMTAwAn376Kf369aN58+YEBwfj7++f6P729vaWfeJprXnjjTdYtGjRI3G1bt2aSZMmUaBAAby8vHB2dubMmTOMGzeOffv2kT9/fjp16kRUVNQj+yqlLM+ttycX6+OIP7/Ezk0IIYQQQhhD63r0MNZi6NcPvv4aksxX9u2Dhg2NbqatW+Gll9J8vN/O/UarSa24OOsiXIW+/foyZvSYhxbueprIHKUs5OrqSkhICACrV6/mwYMHado/PDycEiVKADBnzpw07VujRg127drF6dOnAbh79y4nT54EjDlABw4cYNq0aZZhd//++y958uTBxcWFK1eusGHDhkTrLVKkCMePHycuLo6VK1emGKuzszMRERGP1OPi4kL+/Pkt84/mzZtn6V0SQgghhBBJu3XLWKyhcWMjMdq1C77/PpkkadcuY7hd/vywfXuak6SYuBiGBw+n1se1uDT+Evnj8rNhwwbGfz+eHDlyPPkJZRFJlLJQ9+7d2bZtG9WrV+f3338nT548adrf39+fVq1aUbt2bQo+tJZjygoVKsTs2bNp27Yt7u7u1KhRgz///BMwemmaNm3Khg0baNq0KQCVK1emSpUqVKxYkS5duliG7CU0ZswYmjZtSr169SxDB5OLtVmzZqxcudKymIO1OXPmMGDAANzd3QkNDWXo0KEIIYQQQoikrVkDFSvC3LnwxRdw8GAKazEEBUGjRlCsmJEkubqm6Xhnb5+l9n9r4/+xP3qdxreOL8f+OEbjxo2f6DxsgdJaZ3UM6cLT01MnnPtz/PhxXk3r2Mp0GnoXERGBc6Iz5ERmSdj+wcHB+KZmkQ6RqaRdbI+0iW2SdrE90ia2Kbu2y/Xr8NlnsHChsf7CzJlQrVoKO/36K7RoYUxe2rwZihZN0zGXHF1Cl4lduBt4F7s7doz+ZjSff/45dnYP98XYWpsopUK01p4plcs+c5RSKxPmJgkhhBBCCJFeli6FTz6B27dh+HDjRrIpjnhbswZatYIKFWDTpgR3mk1eZHQkvdb1Ys7EObANXnB9gWWbluHl5fVkJ2JjJFESQgghhBDiKXT5MvTqBcuXg6cnbNkCbm6p2HHpUmjXDqpUMXqV8udP9TH3X9xPq+mtCJsZBmehbbu2TJk8heeee+6xz8NWyRwlIYQQQgghniJaw/z5xlykdeuMeyLt3p3KJGn+fGjTBry9jeF2qUyS4nQcY3eNxbu/N/98+w9O15yYM2cOC+YveCaTJJAeJSGEEEIIIZ4a589Dz56wfr2xSMPMmVC+fCp3njEDunc35uSvWQN586Zqt4sRF/lg8QcETw2GfVDZozJLFi+hXLlyj3saTwXpURJCCCGEEMLGaQ3Tpxu9SFu3GrcI3bEjDUnSpEnQrZuxwt369alOktacWEMF/wps+3Ib7IO+ffvy+57fn/kkCaRH6RGZeL9ZIYQQQgghUhQWZnQEbd5s/FadPt1YqC7Vvv8e+veH5s1hyRLImTPFXe49uMfnv37O5J8mo35V5HfJz/yf5/Pmm28+7mk8daRHKYNdvnyZNm3aULZsWSpUqMBbb71lubFrWgUEBHD37t10iSssLIyFCxdaXu/fv5/evXunS93WfH19SbhsuxBCCCGESFlcnNERVKkS7NkDkycbCzakKUkaNcpIklq1gmXLUpUkHb5ymCr/qcLkQZNhHdTzqcfRP45mqyQJJFHKUFprWrZsia+vL3/99RfHjh3jm2++4cqVK49VX3KJUmxsbJrqSpgoeXp6MmHChMeKSwghhBBCpK9Tp4zeo169oFYtOHrUmJtkl9pf71rDV1/Bl19Chw7GDZYcHVPYRTPx94l4funJqVGnsD9pz9ixY9n460aKpvEeS88CSZQyUFBQEI6OjvTs2dPynoeHB7Vr10ZrzYABA6hUqRJubm4sXrwY+N8Nud577z3Kly/PBx98gNaaCRMmcPHiRerWrUvdunUByJs3L0OHDsXb25vdu3czYsQIvLy8qFSpEj169CD+ZsKnT5+mQYMGVK5cmapVq/LXX38xePBgduzYgYeHBz/88APBwcE0bdoUgJs3b9KiRQvc3d2pUaMGhw8fBsDf358uXbrg6+tLmTJl0pxYLVq0CDc3NypVqsSgQYMs78+YMYNy5crh6+tL9+7d6dWr1+NfdCGEEEKIp1hsrDFSzt0dDh+GWbNgwwZ44YU0VKI1DBgAI0ca85JmzQKH5GfcXL1zlSYLmtD7i948mPGAUvlL8duu3xgwYMAjN5DNLrLNHKU+fSA0NOVy8WVSc/NgDw9jIl1Sjhw5QrUkbom8YsUKQkNDOXToENevX8fLy4s6deoAcPDgQY4ePUrx4sV5/fXX2bVrF71792b8+PEEBQVR0Lwh2J07d6hUqRIjRowAoEKFCgwdOhSADh06sG7dOpo1a8YHH3zA4MGDadmyJVFRUcTFxTFmzBjGjRvHunXrACNBizds2DCqVKnCqlWr2Lp1Kx07diTUvDB//vknQUFBRERE8Morr/DRRx/hmMJfJwAuXrzIoEGDCAkJIX/+/DRs2JBVq1ZRvXp1vv76aw4cOICzszP16tWjcuXKKdYnhBBCCPGsOXYMunSB33+HZs1gyhQoXjyNlcTFQe/expi9Tz6BCRNS7Ib69fSvtJ/dnhsLbkAYtGvXjsmTJz+zy36nVvZMD23Azp07adu2Lfb29hQpUgQfHx/27dsHQPXq1SlZsiR2dnZ4eHgQFhaWaB329va8++67ltdBQUF4e3vj5ubG1q1bOXr0KBEREVy4cIGWLVsC4OTkRO7cuVOMrUOHDgDUq1ePGzduEB4eDkCTJk3ImTMnBQsWpHDhwqkeRrhv3z58fX0pVKgQDg4OfPDBB2zfvp29e/fi4+NDgQIFcHR0pFWrVqmqTwghhBDiWfHgAXzzjXH/19OnjVFyq1c/RpIUGwsffmgkSf37w8SJySZJ92Pu8/mvn9P4q8bcCriF01UnZs+ezfz587N9kgTZqEcpuZ4fa+m56l3FihVZtmxZotvih8UlJqfVJDt7e3tiYmISLefk5IS9vT0AUVFRfPzxx+zfv59SpUrh7+9PVFRUssdJSmL7KKXSFFtq6kzufSGEEEKI7CA01OhFOnjQWG/hxx+hcOHHqCgmBjp3Nm4o+9VXMHw4mL/fEvPn9T9pHdiaw3MPwz6o5FEpW9wbKS2kRykD1atXj/v37zNt2jTLe/v27WPbtm3UqVOHxYsXExsby7Vr19i+fTvVq1dPtj5nZ2ciIiIS3RYVFQVAwYIFiYyMtCRozz33HCVLlmTVqlUA3L9/n7t37yZbV506dViwYAFgDMkrWLBgin9VqF+/PhcuXEhyu7e3N9u2beP69evExsayaNEifHx8qF69Otu2bePWrVvExMSwfPnyZI8jhBBCCPEsiI6GoUPBywsuXjQWpFuy5DGTpAcPoF07I0kaORJGjEgySdJaMy1kGh5fe3B01FHYB/369cs290ZKi2zTo5QVlFKsXLmSPn36MGbMGJycnHB1dSUgIIA6deqwe/duKleujFKKsWPHUrRoUf78888k6+vRowdvvvkmxYoVIygo6KFt+fLlo3v37ri5ueHq6oqXl5dl27x58/jwww8ZOnQojo6OLF26FHd3dxwcHKhcuTKdOnWiSpUqlvL+/v507twZd3d3cufOzZw5c5I9z7i4OE6fPk2BAgWSLFOsWDFGjx5N3bp10Vrz1ltv8fbbbwMwZMgQvL29KV68OBUqVMDFxQWANWvWsH//fsscLCGEEEKIZ8G+fUYv0pEjxoJ0P/wAzz//mJXdvw/vvw9r1hirQPTrl2TRm/du0m1NN1YuWIndr3bkfy4/c9fP5a233nrMgz/jtNbPxKNatWo6oWPHjj3yXkp8fIzHk/r333+fvJKnxB9//KH79u372PtHRERorbV+8OCBbtq0qV6xYkW6xJWw/YOCgtKlXpG+pF1sj7SJbZJ2sT3SJrbJltvl7l2tBw7U2s5O6xIltF63Lh0qbNRIa9B60qRkiwadCdLFvi6mVUWlAV2/QX198eLFJwwgdWytTYD9OhX5hfQoJZAec5Oym0qVKjF+/PjH3t/f35/NmzcTFRVFw4YNadGiRTpGJ4QQQgiR9XbtMnqRTp6E7t3hu+/AHETzeCIjoXlz48frjBlG5Yl4EPsA/2B/vln4DQ4rHbCLsOObb7+hf//+2XbZ79SSRElkuXHjxmV1CEIIIYQQGeLOHfi//zNW6X7xRdi0CRo0eMJKw8OhSRPYvRvmzYMPPki02F83/6LtsrbsC9yH2qYo+UJJAjcE4u3t/YQBZA+SKAkhhBBCCJEBgoKga1c4cwZ69YLRoyFv3ies9OZNaNzYWCZv8WJ4771Ei807NI+ei3pyf8l9OANt2rZh8uTJlrngImWSKAkhhBBCCJGO/v0XBg0ybhj70kuwbRvUqZMOFV+7Bg0bGnemXbHCuCttAuFR4Xzy8ycsWLoAh7UO5CQnk2ZNws/Pz3K7F5E6kigJIYQQQgiRTn75BXr0gAsXjHu+Dh8OuXOnQ8WXL0P9+vD338YKd40aPVJk97ndtF3cln+W/gN7wa2KG4sWLeKVV15JhwCyH5nBlYCvry++8XedFUIIIYQQIhVu3TLu9/rmm8bwut9+MxZsSJck6fx58PGBs2fh558fSZJi42IZuX0ktcbW4uIPF9F7NX379mX37t2SJD0BSZQy2OXLl2nTpg1ly5alQoUKvPXWW5w8eTLDjxscHEzTpk0z9BhhYWFUqlTpicsIIYQQQjzNVq+GChWMdRX+7/+M6UPptl5CWJgxbu/SJfj1V6hb96HN/4T/g+9sX74a9xVqqsLlgQvr169n/Pjx5MyZM52CyJ5k6F0G0lrTsmVL/Pz8CAwMBCA0NJQrV67InY+FEEIIIZ5y165B794QGAiVKxudPVWqpOMBTp0yhttFRsKWLeDl9dDmZceW0XVJV+4uvwtHwLe+L/PmzaNYsWLpGET2JT1KGSgoKAhHR0d69uxpec/Dw4PatWsTGRlJ/fr1qVq1Km5ubqxevRp4tAdm3Lhx+Pv7AzBhwgQqVKiAu7s7bdq0AWDv3r289tprVKlShddee40TJ04kG9Ps2bNp0aIFzZo1o3Tp0vz444+MHz+eKlWqUKNGDW7evAkYCV2NGjVwd3enZcuW3Lp1C4CQkBAqV65MzZo1mTRpkqXe2NhYBgwYgJeXF+7u7vz0009pulbz58+nevXqeHh48OGHHxIbGwtA3rx5+fzzz6latSr169fn2rVraapXCCGEECK9aQ1LlkDFirB8OYwYAfv2pXOSdOyYMdzu3j3YuvWhJOlO9B26relGq+9bEfVjFPwJY8aMYePGjZIkpaNs06PUp08fQkNDUywXXyY185Q8PDwICAhIcvuRI0eoVq1aotucnJxYuXIlzz33HNevX6dGjRo0b9482eONGTOGM2fOkDNnTm7fvg1A+fLl2b59Ow4ODmzevJkhQ4awfPnyZOs5cuQIBw8eJCoqipdeeolvv/2WgwcP0rdvX+bOnUufPn3o2LEjEydOxMfHh6FDhzJ8+HACAgLo3Lmz5f0BAwZY6pwxYwYuLi7s27eP+/fv8/rrr9OwYcNUra5y/PhxFi9ezK5du3B0dOTjjz9mwYIFdOzYkTt37lC1alW+//57RowYwfDhw/nxxx9TrFMIIYQQIiNcvgwffwwrVxq5y8yZkO6zDA4dgjfeAHt744ayFStaNh24dIA2S9twavUpVLCixIslWLhuITVq1EjnIES2SZRsjdaaIUOGsH37duzs7Lhw4QJXrlxJdh93d3c++OADWrRoQYsWLQAIDw/Hz8+PU6dOoZTiwYMHKR67bt26ODs74+zsjIuLC83MpSXd3Nw4fPgw4eHh3L59Gx8fHwD8/Pxo1arVI+936NCBDRs2ALBx40YOHz7MsmXLLHGdOnUqVUMMt2zZQkhICF7mX0ru3btH4cKFAbCzs6N169YAtG/fnnfeeSfF+oQQQggh0pvWxhykPn3g7l0YOxb69gWH9P41vX+/sQR4njzGcDvzt1ScjmP87vF8sfIL7FbawV/Quk1rpkyZIvdGyiDZJlFKrufHWnxPUnBw8BMfs2LFipbEIaEFCxZw7do1QkJCcHR0xNXVlaioKBwcHIiLi7OUi4qKsjxfv34927dvZ82aNXz99dccPXqUr776irp167Jy5UrCwsJS1RNmPbHPzs7O8trOzo6YmJgk99NaJ9lDpLVm4sSJNEqwCktYWFiK8Wit8fPzY/To0SmWlfX/hRBCCJHZzp+HDz805iC9/jrMmAEZspjc7t3GzWQLFDCG25UuDcCliEv4rfJj04ZN5FiXA4dYB36a9ZPcGymDyRylDFSvXj3u37/PtGnTLO/t27ePbdu2ER4eTuHChXF0dCQoKIizZ88CUKRIEa5evcqNGze4f/8+69atAyAuLo5z585Rt25dxo4dy+3bt4mMjCQ8PJwSJUoAxvyj9ODi4kL+/PnZsWMHAPPmzcPHx4d8+fLh4uLCzp07ASPZi9eoUSMmT55s6dE6efIkd+7ceajeCxcuUL9+/UeOV79+fZYtW8bVq1cBuHnzpuV6xMXFWZLNhQsXUqtWrXQ5RyGEEEKIlGgN06YZI9+Cg+E//zFuHpshSdK2bcZwu8KFYft2S5K09sRa3Ca6sfW/W2ERVChbgQMHDtCpUydJkjJYtulRygpKKVauXEmfPn0YM2YMTk5OuLq6EhAQQMWKFWnWrBmenp54eHhQvnx5ABwdHRk6dCje3t6ULl3a8n5sbCzt27cnPDwcrY218fPly8fAgQPx8/Nj/Pjx1KtXL91inzNnDj179uTu3buUKVOGWbNmATBr1iy6dOlC7ty5H+o96tatG2FhYVStWhWtNYUKFWLVqlUP1Xnp0iUcEumfrlChAiNHjqRhw4bExcXh6OjIpEmTePHFF8mTJw9Hjx6lWrVquLi4sHjx4nQ7RyGEEEKIpJw5A927G6Pf6taF6dOhTJkMOtjGjdCiBbi6GgcsVox7D+4xYNMAJv08CadVTsReiLX8ppRlvzOH0lpndQzpwtPTU+/fv/+h944fP86rr76apnrSa+hdREQEzs7OT1THs+bHH3/khRdeSHHRCmt58+YlMjLysY6XsP2Dg4PlZsI2SNrF9kib2CZpF9sjbWKbnrRd4uJg0iQYPNhYS2HcOCNhyrDOm3Xr4N13oXx52LQJChfmjyt/0GZZG45tPIbDrw7kc87H7NmzadKkSQYFkbFs7builArRWnumVE56lBJIj7lJInG9evXK6hCEEEIIIZJ08iR07Qo7dxpThX76CV54IQMPuGIFtGkD7u6wcSM6f34m7f2Rz1d/jlqv4BD41PeReyNlEZmjJGza4/YmCSGEEEKkVmys0XNUuTIcOQKzZxsLN2RokrRwIbz/Pnh6wpYtXMsZS/PA5nz606fYT7Un5kgMo0ePlnsjZSHpURJCCCGEENnW0aPQpQvs3Qtvvw2TJ0OG5yWzZhldV3XqwNq1bLq6hw4rOnD91+vYBdtRpFQRFq1dJPdGymLPfI/SszIHS6SNtLsQQgghkvPgAYwaBVWrwt9/Q2CgcRPZDE+SpkwxMrM33iB67SoG7B5Bw/82JGJ6BLFbYmn1XitCQ0MlSbIBz3SPkpOTEzdu3OD555+X5ROzEa01N27cwMnJKatDEUIIIYQNCg2Fzp2Nf1u3hokToVChTDhwQIBxl9qmTTk5eRRtF9XnQPABnNY7QQzMnDlTlv22Ic90olSyZEnOnz/PtWvXMv3YUVFR8kM9Czk5OVGyZMmsDkMIIYQQmcjXF27f9iA0NPHt9+/DyJEwZgw8/7yxlkLLlpkU3OjRMGQI+t13mT3gDT6ZUYO4TXGwC8p7lCcwMJBXMuQGTeJxPdOJkqOjI6XNm3VltuDgYKpUqZIlxxZCCCGEEA/bu9cY8Xb0KPj5wfjxUKBAJhxYa/D3hxEjuN/6PTq2iGPJvJ7kXZuXe//c47PPPuPbb7+VeyPZoGc6URJCCCGEENnbvXswbBh8/z0UL26sZvfmm5l0cK2NGzKNHcvl99/C23M35wMv4firI055nVi0dhFNmzbNpGBEWmXoYg5KqcZKqRNKqdNKqcGJbO+plPpDKRWqlNqplKpgte0Lc78TSqlGGRmnEEIIIYR49uzcaSz5/d130K2bsfR3piZJffrA2LH83rwaJUr/zM1F4cStjqP2a7U5dOiQJEk2LsMSJaWUPTAJeBOoALS1ToRMC7XWblprD2AsMN7ctwLQBqgINAb+a9YnhBBCCCFEsiIjoXdvY/XtBw9g82bj5rEuLpkUQFwc9OwJEyaw6I2i1CgYQu5Zebl36B7ffPMNGzdupHjx4pkUjHhcGTn0rjpwWmv9N4BSKhB4GzgWX0Br/a9V+TxA/JrObwOBWuv7wBml1Gmzvt0ZGK8QQgghhHjKRUQ44OYGZ8/Cp58aS4DnzZuJAcTGGpOh5s7lWx9Hhqlb2M2xo2CpgixaLfdGepqojLrfjFLqPaCx1rqb+boD4K217pWg3CdAPyAHUE9rfUop9SOwR2s93ywzA9igtV6WYN8eQA+AIkWKVAsMDMyQc3kckZGR5M3Ub6VIibSJbZJ2sT3SJrZJ2sX2SJvYlnv37OjQwZsbN3JSqtRdBgw4gZtbeKbGoGJieHnUCIoH76DPazD9Wh7unLpD3bp16devX7b9vNjad6Vu3bohWmvPlMplZI9SYgvAP5KVaa0nAZOUUu2ALwG/NOw7FZgK4OnpqX19fZ8k3nQVHByMLcUjpE1slbSL7ZE2sU3SLrZH2sR2HD8O770HN25AoUJRnDiRm1y5Mnn14fv3ufl2IwoE7+BdD/jlSG6I0cyYMYPOnTtn63sjPa3flYxMlM4DpaxelwQuJlM+EJj8mPsKIYQQQohsaN48YzpQnjzg5gZ2dlHkypW597KMvRPJmfrVKPX7SbzL5mRv6H0qV36ZwMBAypcvn6mxiPSTkave7QNeVkqVVkrlwFicYY11AaXUy1YvmwCnzOdrgDZKqZxKqdLAy8DeDIxVCCGEEEI8Re7dM1ay69gRPD0hNDST7ouUwPmLJzhYvRTRv5/k5edzs/ev+3z22Wfs2bNHkqSnXIb1KGmtY5RSvYBfAXtgptb6qFJqBLBfa70G6KWUagA8AG5hDLvDLLcEY+GHGOATrXVsRsUqhBBCCCGeHidOQKtW8McfMGQIDB8ODllwd9DVe+dR8P3OHD8by6eODuQhF2vXLpZlv58RGfqR0lr/DPyc4L2hVs8/S2bfUcCojItOCCGEEEI8bRYtgh49IGdO2LABGjfO/BjuRN9hyPKPafb5XCZcgiVA3Vq1mTdvHiVKlMj8gESGyNAbzgohhBBCCJEeoqKMuUjt2hk3kQ0NzZok6eClg9QfX5mqvebS/RIst7Nj1KhRbNq0SZKkZ0wWdFIKIYQQQgiReqdPG0PtQkNh4EAYORIcHTM3hjgdR8CeAL5fOZD3J2u6RkLJwoXZsWoVNWvWzNxgRKaQREkIIYQQQtispUuha1cjMVq7FrJi+s/lyMv4rfLj0I6NvDzbnoDoON738eGnVavIly9f5gckMoUMvRNCCCGEEDbn/n3o1Qvefx8qVoSDB1NOkoKDISAgNF3jWH9yPe6T3TmyYisx0xUHomOZPnAggUFBkiQ946RHSQghhBBC2JS//zYSpJAQ6NcPRo+GHDkyN4aomCgGbhrIxN8m4ro5P2F7YqhsZ8eiRQt5tU2bzA1GZAlJlIQQQgghhM1YuRI6dwalYNUqePvtzI/h6NWjtF3elj+O/UGx1fkJO3eL3k5OfLt1K04yHynbkKF3QgghhBAiy0VHQ58+8M47UK4cHDiQ+UmS1pr/7vsv1aZWIyw4DKdpOYg+f5s1Li78Z98+SZKyGelREkIIIYQQWSosDFq3hr174bPPYOzYzB9qd/3udbqu6cqaQ2sotq0Yl3ZfwtfBgfmFC1MiOBjKl8/cgESWk0RJCCGEEEJkmTVrwM8P4uJg2TJ4993Mj2HL31vosLID105eo8C6Aly9cpWROXMyuHBh7IOCoGzZzA9KZDkZeieEEEIIITLdgwfQv78xvK5MGWOoXWYnSdGx0QzaNIgGcxoQsz0GZoJzXA6258jB/5Usif2OHZIkZWPSoySEEEIIITLVuXPGULvdu+Hjj+H778HJKXNjOHnjJO2WtyPkZAglNpfgwqELtKpTh6n79pHvxRdh82YoUSJzgxI2RXqUhBBCCCFEpvn5Z/DwgCNHIDAQJk3K3CRJa83MgzOp8lMVTuw5wXMzn+PmyZtM792bxXv2kO+ll4wbMkmSlO1JoiSEEEIIITJcTAwMHgxNmkCpUsY9klq3ztwYbt27RZvlbei6oisFthUgclYkrqVcCfn2W7pOnoyqVAmCgqBIkcwNTNgkGXonhBBCCCEy1IUL0KYN7NwJPXpAQADkypW5Mew4u4P2K9tz4cwFim8ozvlT5/n0008Z6+WFU+fO4OkJv/wC+fJlbmDCZkmiJIQQQgghMsyvv0L79nDvHixYAO3aZe7xY+Ji+Hrb13y9/WsKnixIjlU5iHKKYvXq1TS/dQs6dYLXX4f168HZOXODEzZNht4JIYQQQoh0FxMDX34Jb74JRYvC/v2ZnySduXWGOrPqMGLjCFy3uHJt4TW8q3tz+PBhml++bCRJ9erBhg2SJIlHSKIkhBBCCCHS1aVL0KABjBoFXbrA779n/v1aF/2xCI+fPDgUcohC8wrxz2//MHLkSDZv3kyJ5cvhww/hrbdg7VrIkydzgxNPBRl6J4QQQggh0s2WLUbPUWQkzJkDHTtm7vHvxtzFb5Ufcw/O5YWjL3Bx9QtJYtkAACAASURBVEUKlSjEqu2reO2112DsWBg0CFq2NJbdy5EjcwMUTw1JlIQQQgghxBOLjYWvv4YRI+DVV43F4ypUyNwY9l7YS/eQ7ly6fokyQWX4O+RvWrVqxdSpU8nn4mIEN2yYsbLE3Lng6Ji5AYqniiRKQgghhBDiiVy5wv+zd9/RWRRvG8e/kxCaVAEpgkhTpAgiooIUla6Ciqgo0kFaDGBoUoQgHelFauggvUkHQ+8QpQpIx9BbgJA67x+L748SIEKeNK7POTlJnuzuc89Z4+HKzN7D1187s0m1asHw4TG7mu1W2C26+nWl17pesAdS+6UmICiA0aNHU79+fQxAhw7QsyfUrg1jx4K7e8wVKPGSgpKIiIiIPDY/P6hRA65ccfJH3bpgTMy9//oT66m/oD4HzxzEbY4bEfsjyP5qdqZPn84rr7wC1kKrVk5P8kaNYMQIcNNj+vJo+q9ERERERP6ziAj46Sd4/31InRq2bnUaN8RUSAoMDsRzsSelfEsReCSQbNOzEbE/gnTp0rFlyxYnJEVEQNOmTkj67jv45ReFJIkyzSiJiIiIyH9y/ryzN9Ly5U7jhl9+idnu2ssOL6PRokacuHiCogeLsnPWTrJkyULBggVxc3MjadKkzkNTDRrA+PFO84aePWN2qkviPUVqEREREYmydeugcGFYswZGjoTJk2MuJF0KukSdeXWoOKUibgFu5JyZk+0ztlOnTh327NnDs88+6xwYFgbffOOEpC5dFJLksWhGSUREREQeKSLC6azdsSPkyAG//eYEppgye99smi1uxvlr53nn2DtsmrqJjBkz8ttvv1G5cmUA/Pz8WLNiBXzxBcyZ4wSkdu1irkhJUBSUREREROShLl50utktXgyffw6jR0OqVDHz3gGBATRf0pw5++fwctjLpJ6bmvV711OrVi0GDhxI2rRp/3dwqVIU9/eHwEAYMABatIiZIiVBUlASERERkQfauNGZoDl3DoYNgyZNYmYVm7WWCX9MoOWylty8dZNyJ8vx+4TfSZcuHfPmzaNq1ap3n3DhAuzejUdgoNPZrnFj1xcpCZqeURIRERGR+1gL/fpB6dKQOLETmJo2jZmQdOzKMSpMrkDd+XXJEZKDPHPzsGLsCqpXr87evXvvD0mLF0OBAnD1KjezZVNIkmihGSURERERuculS1CnDixcCJ9+CuPGOS3AXS3CRjBs6zDar2oPEVD1fFWWjF5CqlSpmDVrFtWqVbv7hBs3wNvbabtXoABkzUpIWBjJXV+qPAUUlERERETk/23Z4iy1++cfGDQIPD1jZhbpwIUDNFjQgA0nN1AiWQluzLzB/O3zqVatGsOHD+e55567v9CaNeHvv52w1K0bJE2Kv58fZVxfrjwFtPRORERERLDW2Ze1ZEnn+/XrnT1aXR2SQsND6bGuB4V+KcTes3v58tqXbO+8nRNHTjB9+nRmzpx5d0gKDYXOnaFECQgJgdWroW9fSJrUtYXKU0czSiIiIiJPuStXoF49mDsXqlYFX1+4s5mcq+wK2EW9BfXwP+NPhbQVuDT1EtO3TKdq1ar88ssvZMqU6e4TDhxwZpF27HDa8A0eHDNrAuWppBklERERkafY9u1QpIjzPNLPPzthydUh6VbYLdqvbM8bo98g4FoAdYPrsrbdWg79dYhJkyYxd+7cu0NSRAQMHQqvvQZHj8LMmTBhgkKSuJRmlERERESeQtY67b6//x4yZoR16+Ctt1z/vutPrKf+gvocvHiQzzJ9xj+T/8F3vS+VK1dm9OjRZMmS5e4TTp92pruWL4dKlWDsWMic2fWFylNPM0oiIiIiT5mrV52GDZ6eUK4c7Nrl+pAUGBxI88XNKelbkuDQYJrTnCXfL2HPn3sYN24cixYtuj8kzZgBBQs6D0yNGAG//aaQJDFGM0oiIiIiT5Fdu6B6dTh2DHr3dhrGubn4T+fLDi+j0aJGnLx6kjrZ63Bs4jGG/j6U8uXLM2bMGLJly3b3CVeuQPPmMGUKFCsGkybBSy+5tkiRe2hGSUREROQpYK2z3dDbb8OtW+DnB23auDYkXQq6RO15tak4pSLJEiWjTdI2zPKcxfZt2xk1ahRLly69PyStWuXMIk2fDl27woYNCkkSKzSjJCIiIpLABQbCt9/CtGlQoYIzQZMhg2vfc9a+WTRb3IyLNy/i+bInB3wP0Ht5b9577z3Gjh3Liy++ePcJt27BDz/AgAFOMNq0Cd54w7VFijyEgpKIiIhIAvbnn85Su8OHoXt3aNfOtbNIAYEBNF/SnDn751A4Y2GaeTTj529/JiwsjGHDhtG4cWPc7i1g1y6n7fe+fdCsGfTpA8mTu65IkShQUBIRERFJgKx1GsR5ejrtvlevhtKlXfl+lgl/TKDlspYEhQbxQ6Ef8B/tz4+Lf6RUqVKMGzeOXLly3X1SeLgTin78EdKnh6VLnSkvkThAQUlEREQkgbl+HZo0gcmToWxZ53PGjK57v2NXjtFoYSNWHFlBiWwlqBpclR51exAcHMzAgQPx9PS8fxbpyBFn09gNG5wprxEjIF061xUp8h+pmYOIiIhIArJ3r/Noz5QpTi+EpUtdF5IibARDtgyhwPACbDq1iZ5v9iT9wvS0adqGfPny4e/vj5eX190h6d+prkKFYM8eJ8X9+qtCksQ5mlESERERSSDGj4emTSFVKli5Et57z3Xvtf/8fhosbMDGkxupmLsiHwR/QJeaXbh+/Tp9+/alZcuWuLu7333SuXPQsCEsWADvvusU/MILritS5AloRklEREQknrt5E+rWdT7eegv8/V0XkkLDQ+mxrgeFRxbmwIUDDC01lJTzU+JZ35NcuXKxa9cuvL297w9JCxZAgQKwbBn07+8kOYUkicM0oyQiIiISj+3f7zzis28fdOrk9EW4N6NEl50BO6m/oD7+Z/ypnq86FUMq0u6Ldly9epWePXvi7e1NokT3/PMyMBBatvzfcrvVq53AJBLHaUZJREREJJ6aPNl5HuncOedZJB8f14SkoNAg2q9sT7HRxThz/QwTyk8g0dxE1K9Zn2zZsrFjxw7atWt3f0jasMEJR+PGOX3Jt25VSJJ4w6UzSsaYisAgwB0YY63tdc/PWwENgDDgPFDPWnv89s/Cgd23Dz1hra3iylpFRERE4ougIPjuOxgzBkqWhOnTIUsW17zX+hPrqb+gPgcvHqRu4bqUDSlLq09acenSJbp160bbtm3x8PC4+6SQEOjSBXr3dpbXrV0L77zjmgJFXMRlM0rGGHdgGFAJyAfUMMbku+ewXUBRa+2rwCygzx0/C7LWFr79oZAkIiIiAhw86DyHNGYMtG/vrGRzRUgKDA6k+eLmlPQtSUh4CLM/mk34nHC+/vxrMmXKxLZt2+jYseP9IWnvXnjzTejZ03lo6s8/FZIkXnLljFIx4LC19giAMWY6UBXY9+8B1trf7zh+M1DThfWIiIiIxGvTpztN45IkgcWLoVIl17zPssPLaLSoESevnuS7Yt9ROrQ0nh95cvbsWTp37kyHDh1InDjx3SdFRMDgwc4Su1SpYN48qFrVNQWKxABXPqP0PHDyju9P3X7tQeoDS+74PqkxZrsxZrMx5mNXFCgiIiISH9y65WwgW6MGvPoq7NrlmpB0KegStefVpuKUiiT3SM7Sz5ZyY/YNqlWtRtq0admyZQtdu3a9PySdPAnlyjlNG8qXh927FZIk3jPWWtdc2JjqQAVrbYPb338DFLPWekZybE2gOVDaWht8+7Us1tp/jDE5gdXA+9bav+85rxHQCCBjxoyvT58+3SVjeRzXr18nRYoUsV2G3EH3JG7SfYl7dE/iJt2XuKVFi8KEh4czZMjuRx/8hE6fTkbXrvk4dCglX3xxggYNjpIoUfT/+23N+TUMOjSIa2HXqJGtBvnO52PgzwO5cOECX375JbVr174/IFnLcytX8tKgQZjwcA43b05A5cpgTLTXF1X6XYl74to9effdd3dYa4s+6jhXLr07BWS74/uswD/3HmSMKQt04I6QBGCt/ef25yPGGD/gNeCuoGStHQWMAihatKgtU6ZM9I7gCfj5+RGX6hHdk7hK9yXu0T2Jm3Rf4pY0aeDKlSsuvyezZjkbyLq7w8KF8OGHLwDRu/dQQGAAzZc0Z87+ORTJXITB7w1mUr9J/DDyB/LmzcvChQspVqzY/SdeuuRMc82YAW+/DZMm8XKuXLwcrdX9d/pdiXvi6z1xZVDaBuQxxuQATgNfAl/deYAx5jVgJFDRWnvujtfTAjettcHGmPRACe5u9CAiIiKSYAUHg7c3DB3q9EX49VfInj1638Nay3j/8bRa3oqg0CB6vd+L14Nfp2a5mhw/fhxvb298fHxIlizZ/ScvX+40ajh3Drp3hzZt4N7W4CLxnMueUbLWhuEsp1sG7AdmWGv3GmN8jDH/drHrC6QAZhpj/I0xC26//gqw3RjzB/A70Mtauw8RERGRBO7oUadJ3NChziM/a9dGf0g6duUYFSZXoN6CehR4rgCbvtnEqV9PUa5sOTw8PFi/fj19+/a9PyTdvAmenlChAqRODVu2wA8/KCRJguTS/6qttYuBxfe81vmOr8s+4LyNQEFX1iYiIiIS18yd60zU/Pv1x9HczirCRjB061B+WPUDxhiGVR5G/qD8fPbeZxw9epQWLVrQvXt3kidPfv/J27dDzZrw11/QogX06AGRzTaJJBCu7HonIiIiIlEQEuLMHn36KeTJ43S1i+6QtP/8fkr6lsRrqRcls5dkW+1tHJ52mHfLvAs4z5EMGDDg/pAUFgY+Ps5zSDduwMqVMGCAQpIkeJonFREREYlFx4/DF184q9g8PaFvX2efpOgSGh5K34196bqmKykSp2DixxPJdSMXVd+tysGDB2nWrBm9evWKvCvZoUPwzTdOcV995awHTJs2+ooTicM0oyQiIiISSxYuhNdeg/37YeZMZ7/W6AxJOwN2UmxMMTqs7kDVl6uys95Odk/ZTcmSJQkODmbVqlUMHTr0/pBkLYwcCYULO0vtpk2DKVMUkuSpohklERERkRgWGur0QOjXzwlKM2ZA7tzRd/2g0CB81vjQd2NfMjyTgTmfzyHr9axUKlWJ/fv306hRI/r27UuqVKnuPzkgABo0gMWLnU1kfX3h+eejrziReEIzSiIiIiIx6ORJKFPGCUlNmsDGjdEbktafWE/hkYXptaEXtQvVZlf9XWyfvJ23336bwMBAli1bxsiRIyMPSXPmQMGCsHq1M721dKlCkjy1NKMkIiIiEkOWLHEe+QkOhunTnWeToktgcCDtV7Vn2LZhvJjmRZbXXE66q+koV7Ice/bsoV69evTv35/UqVPff/LVq+DlBRMmwOuvw+TJkDdv9BUnEg9pRklERETExcLCoH17qFzZmaDZsSN6Q9LSw0spMKIAw7cN57ti37Gj/g42TNrAm2++ycWLF1m0aBFjx46NPCStWQOFCsGkSdCpE2zapJAkgmaURERERFzq9GmoUQPWrYOGDWHQoOjrrH3x5kVaLW/FxD8mkjd9XtbXW0+Kyyl4v+T7+Pv788033zBo0CDSRtaEITjYCUb9+kGuXLB+vdMCXEQAzSiJiIiIuMzy5U6zhp07ndVso0ZFX0iatW8W+YbnY+ruqXQo2YFt9bfx+8TfKVq0KP/88w/z5s1j4sSJkYekP/+EN95wepE3auRs3KSQJHIXzSiJiIiIRLPwcOjSBbp3h3z5YNas6FvNFhAYQPMlzZmzfw5FMhdhWc1leFz0oMw7ZdixYwdffvklQ4YMIX369JEX1r8/dOzotPpetAg++CB6ChNJYDSjJCIiIhKNAgKgbFn46SeoUwe2bo2ekGStxXeXL/mG5+O3g7/R6/1ebKizgWUTllGkSBGOHz/OzJkzmTZtWuQh6dgxeO89aNPGCUe7dyskiTyEZpREREREosnq1fDVV3DtGowfD7VrR891j105RqOFjVhxZAUlXyjJmCpjsBcsZUqVYcuWLVSrVo3hw4fz3HPP3X+ytTBxInh6Ot/7+jqFGRM9xYkkUJpREhEREXlC4eHQtaszk/Tss7BtW/SEpPCIcAZvGUyB4QXYdGoTwyoPY9U3q1g0YRGFCxfm0KFDTJs2jZkzZ0Yeki5cgM8+c6a2Chd2nk2qU0chSSQKNKMkIiIi8gTOnoWaNWHlSmePpOHDIUWKJ7/u/vP7abCwARtPbqRi7oqM/HAkweeCebfMu2zYsIEqVaowcuRIMmXKFPkFFi+GevXg0iXo0wdatQJ39ycvTOQpoRklERERkce0Zo3T1W79ehgzxtmv9UlDUmh4KN3XdqfwyMIcuHCAiR9PZNGXi5g/cT6FChVi7969TJw4kXnz5kUekm7cgCZNnOePMmRwprdat1ZIEvmPNKMkIiIi8h9ZC2fPJuG99yB3bli6FF599cmvuzNgJ/Xm1+OPs39QPV91hlQawo1zN3j//fdZs2YNlStXZtSoUTz//PORX2DLFmd66++/wdsbunWDpEmfvDCRp5BmlERERET+g+PHnUd9zpxJxhdfwPbtTx6SgkKDaLeyHcVGF+PsjbPM+XwO06tNZ86kObz66qvs2rWLcePGsWjRoshDUmgodO4MJUpASIjTVaJvX4UkkSegGSURERGRKLDWaRjXogXcvAlZs95kypTkT9wXYf2J9dRfUJ+DFw9Sr3A9+pXvx7Vz1yhfvjyrVq2ifPnyjBkzhmzZskV+gQMHnFmkHTugVi0YPBhSp36yokREM0oiIiIij3LmDFSpAvXrQ5EiULQopEsX8kQhKTA4kOaLm1PStyQh4SGs+GYFY6qMYfaU2RQsWJAtW7YwcuRIli5dGnlIioiAoUOdh6SOHXN2tZ0wQSFJJJooKImIiIg8xIwZkD+/09VuwABnVduTrmhbengpBUYUYPi24Xi96cXuJrvJmzgvlSpVomHDhhQtWpTdu3fTqFEjTGRp7PRpqFTJ2Rvp3XedzWOrVXuyokTkLgpKIiIiIpG4eBFq1IAvvnAaNuza5Sy7c3uCfz1dvHmR2vNqU2lKJZJ7JGd9vfUMqDCA2dNmU6BAAdatW8ewYcNYuXIlL774YuQXmTEDChZ0Wu2NGAG//QaZMz9+USISKT2jJCIiInKPxYudZXYXLsBPP0HbtpDoCf7VZK1l9v7ZNFvcjEtBl+hQsgMdS3Xk8vnLVKlShUWLFlGyZEl8fX3JlStX5Be5cgWaN4cpU6BYMZg0CV566fGLEpGHUlASERERuS0w0NmXdcwYKFAAliyBwoWf7JoBgQE0W9yMuQfmUiRzEZbVXEahjIWYOnUqnp6e3Lp1i4EDB+Lp6Ynbg6arVq2COnUgIAC6doUffniy5CYij6SldyIiIiKAn5/T5nvcOGcGafv2JwtJ1lp8d/mSb3g+Fh9aTK/3e7GlwRYym8xUq1aNmjVrkjdvXvz9/fHy8oo8JAUFQcuWULYsJE8OmzY5bcAVkkRcTr9lIiIi8lQLCoL27WHQIOdZpHXroHjxJ7vm0ctHabSoESuPrKTkCyUZU2UML6V7iRkzZtC0aVOuX79O3759admyJe7u7pFfZNcup+33vn3QrBn06eOEJRGJEZpREhERkafW1q1Od+1Bg5zHf/z9nywkhUeEM3jLYAqMKMDmU5sZVnkYfnX8eNY+y+eff84XX3xBzpw52bVrF97e3pGHpPBw6NkT3nwTLl+GpUudNuAKSSIxSjNKIiIi8tQJCYFu3Zw8kiULrFjhrG57EvvP76fBwgZsPLmRirkrMvLDkbyQ+gXmzp1L48aNuXLlCj179sTb25tED1o6d+SIs2nshg1QvbrT1S5duicrTEQei4KSiIiIPFV273ayiL8/1K7tzCY9yR6toeGh9NnQB5+1PqRInIKJH0+k5qs1uXz5Ml9//TVTp06lSJEirFq1igIFCkR+EWudh6NatAB3d5g8Gb76iifa0VZEnoiCkoiIiDwVwsOhb1+nF0LatDBvHlSt+mTX3Bmwk3rz6/HH2T+onq86QyoNIWOKjCxcuJBGjRpx4cIFfHx8aNeuHR4eHpFf5OxZaNgQFi50No8dPx5eeOHJChORJ6agJCIiIgneoUPO7NGmTfDZZ86KtvTpH/964bs3c+HNERQbPYUMz2Rgzudz+OSVT7hy5Qp16tRhwoQJvPrqqyxZsoTCD2udt2ABNGgA165B//7g5fVkO9qKSLRRUBIREZEEKyIChg+HNm0gSRJnr9YaNR5/Rdu/G8dure1JSOoz1CtUj37l+5E2WVqWLFlCw4YNOXPmDJ06daJjx44kTpw48gsFBjptv8eOhUKFYPVqZ+MmEYkz9CcLERERSZBOnIDy5cHTE0qXhj17nuyxnz/O/MF7E9+j+szqeISkJP/0EYytOhb3UHcaNGhA5cqVSZMmDVu2bMHHx+fBIWnDBiccjRsH7do5rfcUkkTiHAUlERERSVCsdR7zKVgQNm+GkSNh8WJ4/vnHu975G+dpsqgJRUYVYffZ3QyvPJzXp0wlzcmirFy5kgIFCuDr60u7du3YsWMHr7/+euQXCgmBH36AUqWc79euddruPShQiUis0tI7ERERSTDOnoVGjZxHf0qVAl9fyJnz8a4VGh7K8G3D6bKmC4HBgTR/ozk/lvmRZ5M9y5SIDfwdPIBy5Wbz8ssvs3HjRt58880HX2zvXmfzWH9/qF8fBgyAlCkfrzARiREKSiIiIpIgzJoFjRvD9evw889Op+3H7Yuw9PBSWi5ryYELByifqzwDKgwgX4Z8hISEMHToUDZea4klDG9vb3x8fEiWLFnkF4qIcPqPt28PqVJFT6s9EYkRCkoiIiISr1265DyHNHUqFC0KEyfCK6883rUOXjxIq2Wt+O3Qb+R+NjcLvlzAhy99iLWW6dOn06FDB44cOUJq96Jk92hO3761H3yxkyehTh2nUcNHH8Ho0ZAx4+MVJiIxTs8oiYiISLy1ZInzLNKMGeDjAxs3Pl5IunrrKt7LvSkwvABrj6+lT9k+7Gmyh49e/ojVq1dTrFgxatSowTPPPMPixYsp9MwoUrrnj/xi1jrt9QoWhC1bnIA0f75Ckkg8o6AkIiIi8U5gIHz7LVSu7Gweu2ULdOoED9rT9UHCI8IZs3MMeYbkof+m/nzz6jcc9DxI6xKt2bd7HxUqVKBs2bKcP3+eiRMnsmvXLipVqoR5UOu8S5fgyy+d55Hy54c//nD2SXrcVnsiEmu09E5ERETilbVrnRVtx45B69bOTFLSpP/9OutPrMdrqRc7A3ZSPFtxFn+9mKJZinL06FFqNq7JlClTePbZZ/n5559p2rQpSR/1JsuXQ926cO4c9OjhbN7k7v44QxSROCDKQckY84y19oYrixERERF5kKAg6NABBg50OtmtWwclSvz365y4eoI2K9rw695fyZoqK1M/ncqXBb7k4sWLtGjRguHDh5MoUSLat29PmzZtSJMmzX3X8CvcgitXrgD+cPMmtG0LQ4c66/4WLoQiRZ58wCISqx4ZlIwxxYExQArgBWNMIeBba21TVxcnIiIiArB9O9SqBfv3Q9Om0Ls3pEjx365xM/QmfTb0oc+GPlgsP5b+kdbFW0Mo9OjRg969e3Pjxg3q1atHly5deD4qGy9t3+4ss/vrL6fNXo8e8KAOeCISr0RlRmkAUAFYAGCt/cMYU8qlVYmIiIjg7NHavbvzkSkTLFsG5cv/t2tYa/l176+0WdGGk9dO8nn+z+lTtg/Pp3iecePG0aVLFwICAvj444/p0aMHr0SlG0REBEnOnoW333YKW7kS3n//8QYpInFSlJbeWWtP3vPQYrhryhERERFx7NnjzCLt2uV8HjQIIlkF91A7/tmB11IvNpzcQOFMhZn86WRKvlCSuXPnUuGHCvz111+UKFGCWbNmUbx48Udf8NAhGDcOtmwhWUgIfPWVs+QubdrHG6SIxFlR6Xp38vbyO2uMSWyM8Qb2u7guEREReUqFh0OfPvD663DqFMydCxMm/LeQdPb6WRosaMAbo9/g4MWDjPpwFNsbbsecMBQvXpxq1arh5ubG/PnzWbdu3cND0o0bzuZMpUvDSy85xaVIwfUcOZw24ApJIglSVIJSY6AZ8DxwCigM6PkkERERiXaHDzt5pG1b+OADZ1bp44+jfn5IeAj9NvbjpaEvMeGPCbR8qyUHPQ/ydpK3+bjqx5QqVYqTJ08yduxY/vzzT6pUqRJ5q29rYetWpwd55sxQuzYEBEDPns5GsgULEpYqVfQNXETinKgsvXvZWvv1nS8YY0oAG1xTkoiIiDxtrIVffgFvb2cvpEmT4Ouvo779kLWW3w79RqtlrTh06RAf5PmAn8v/TPKg5LRq2ooJEyaQMmVKevXqhaenJ8mTJ4/8QhcuwOTJMHask9KSJYPq1aF+fShZUvshiTxFojKjNCSKr93HGFPRGPOXMeawMaZdJD9vZYzZZ4z50xizyhiT/Y6f1TbGHLr9UTsq7yciIiLxz8mTUKGC083unXecfFKzZtQzyf7z+6k0pRIfTfsIN+PG4q8WM6nSJMb2GUuePHmYMmUKLVu25MiRI7Rt2/b+kBQeDkuXOoEoSxZo2RKSJ4eRI+HMGWfdX6lSCkkiT5kHzigZY94GigMZjDGt7vhRKuCRu6cZY9yBYUA5nCV724wxC6y1++44bBdQ1Fp70xjTBOgDfGGMeRb4ESgKWGDH7XMv/7fhiYiISFxlrTNz9N13EBYGI0Y4K92imkcuB12m65quDN06lBSJUzCgwgDqFajHyBEj+arHV1y9epVatWrRtWtXsmfPfv8Fjh4FX18YP95Ja+nSQbNmzuxRgQLROlYRiX8etvQuMc7eSYmAlHe8fg34LArXLgYcttYeATDGTAeqAv8flKy1v99x/Gag5u2vKwArrLWXbp+7AqgITIvC+4qIiEgcd+6cE4rmzXNmkcaPh1y5onZuiPIGzQAAIABJREFUeEQ4o3eOpuPqjlwKukTDIg3pWrorS2YvIX/1/Jw6dYrKlSvTq1cvChYsePfJt27BnDnO0rrVq51UVqEC9O8PH30ESZJE+1hFJH56YFCy1q4B1hhjxltrjz/GtZ8HTt7x/SngzYccXx9Y8pBzo7Drm4iIiMR1c+Y4IenaNejb11np5v7ItSoOv2N+eC314s+zf1IqeykGVhjI6R2nKVu8LHv37qVYsWJMmjSJMmXK3H3irl1OOJoyBa5cgRdfBB8fqFMHsmWL5hGKSEIQlWYON40xfYH8QNJ/X7TWvveI8yKbOLeRHmhMTZxldqX/y7nGmEZAI4CMGTPi5+f3iJJizvXr1+NUPaJ7ElfpvsQ9uidxU0K4L4GBiRgyJDcrVmQiT55A+vTZT44cN1m37tHnBgQF8MuRX1h7YS0Zk2SkS74upDubjjoV6/Dnn3+SNWtWunTpQqlSpQDw8/MjUWAgGVeuJNPixaQ8fJgIDw/OlypFQOXKXClcGNzc4O+/nY//qPCVK4SHh8f7e5IQJYTflYQmvt6TqASlKcCvwIc4rcJrA+ejcN4p4M4/0WQF/rn3IGNMWaADUNpaG3zHuWXuOdfv3nOttaOAUQBFixa19/31KBb5+fnd/9csiVW6J3GT7kvco3sSN8X3+7JsGTRp4vRG+PFH6NAhJR4exR553vWQ6/Ra34t+O/rh7uZOt3e78dGzH+Hzow9z5swhY8aMjBgxgvr16+Ph4QEREfD7787s0Zw5EBwMr70GQ4fi9tVXZEyblozRMaA0abhy5Uq8vicJVXz/XUmI4us9iUpQSmetHWuM8bpjOd6aKJy3DchjjMkBnAa+BL668wBjzGvASKCitfbcHT9aBvQwxvy7g1t5oH0U3lNERETikOvXoXVrp/V3vnwwf76zkeyjRNgIpu6eStuVbfkn8B++Lvg1LfK3YHT/0bw+9nWSJUuGj48PLVu2JEWKFE4zBl9f5+PYMWcT2IYNoV49JyiJiPxHUQlKobc/BxhjPsCZFcr6qJOstWHGmOY4occdGGet3WuM8QG2W2sXAH1xGkbMvL3Z2wlrbRVr7SVjTDecsAXg829jBxEREYkf1q1zHgE6etTZH6lbN0ia9JGnsfX0VryWerH51GaKZimKbwVf1k5bS6mapQgLC6NZs2Z06NCB51KnhgULnNmj5cudNnrvvw89esAnn0TtzUREHiAqQeknY0xq4Huc/ZNSAS2jcnFr7WJg8T2vdb7j67IPOXccMC4q7yMiIiJxx61b0KkT/Pwz5MgBa9Y4e7U+SkBgAO1XtWfCHxPI+ExGRlUaxY2NN/iq9FdcvHiRGjVq0K1bN3LdvAk9ezq9xS9edJoxdOoEdes6TRpERKLBQ4PS7b2Q8lhrFwFXgXdjpCoRERGJl3bsgFq1YN8+aNzY6WqXIsXDz7kVdouBmwfSfV13QsJDaPN2G/L8k4fuX3Tn2LFjlC1blt4dO1LkwAGoUQO2bQMPD/j4Y2fPo7Jlo942T0Qkih4alKy14caYKsCAGKpHRERE4qHQUOjeHX76CTJmhKVLne2JHsZay/y/5vP98u85cvkIVV6qwseJP2Zw28H08e/Da6+9xqjmzSn3xx9QqRIEBUHBgjBwIHz9NaRPHzODi4yfH/5+fnd1nhKRhCUqS+82GmOG4nS+u/Hvi9banS6rSkREROKNffucWaQdO6BmTRg82Oml8DB7zu2hxdIWrDq6inwZ8jG08FDmDplLvVX1yPHCC0z94gu+2L4dN29vSJXKeYP69aFoUWeTWBERF4tKUCp++7PPHa9Z4FH7KImIiEgCFh4OAwZAx46QMiXMng2ffvrwcy7evMiPfj8yYvsIUidJTeeCnTnw6wGaz2hO+lSpGJQ/P9/u20eSEyegdGmnl3i1apA8ecwMSkTktkcGJWutnksSERGRu/z9t9M7Yd06qFoVRo50ltw9SFhEGL9s/4XOv3fmavBVaueujfs6d3p07EFioFPy5Hhfu0aqS5egXTunrXfu3DE2HhGRe0VlRklERERiUZkycOVKYfz9Y7sSpwP3yJFOu293d5gwAb755uGr4VYeWUmLpS3Ye34vpTKXouD+l5lQbyJBwcE0BDq7u5O5QgVnaV2FCpBI/zwRkdin/xOJiIhIlJw+7WSZZcucRnPjxjmduR/k70t/8/3y75n/13xeTJGdFserMLXXctbeWstnQPecOXmpSRMnaT1sOkpEJBYoKImIiMhDWQtTpoCnJ4SEwLBh0KTJg2eRAoMD6b6uOwM2DyDLDXc67yzM1N/3MjD0OKXc3Fjw0Ue82b49vPWWGjOISJz1yKBkjEmOs9nsC9bahsaYPMDLt/dWEhERkQTs/HlnP6Q5c6B4cWep3YMeHYqwEUz8YyIdl7ejsP9ZBu/KwNgD5/HBnwLJk/Nb06ZU6tYNkzJlzA5CROQxRGVGyRfYAbx9+/tTwExAQUlERCQBmzcPGjWCq1ehTx9o1erB+7puOrmJvhMa8cayPUzyT0Sf69CY82RLmZLx7dtTs00b3LUprIjEI1EJSrmstV8YY2oAWGuDjNE8uYiISEJ15Qp4ecHEifDaa7B6NRQoEPmxp88cYmGP2ryyYBP9j0MnoANhpEmRgn6dOtHsu+9ImjRpjNYvIhIdohKUQowxyXD2TsIYkwsIdmlVIiIiEitWrHA6cwcEQKdOzh5JiRPfc5C13Nq8nr29vif3sm1UD4ZOKZIw1j0MNw8P2nh50bZtW9I+atdZEZE4LCpB6UdgKZDNGDMFKAHUcWVRIiIiErNu3IDWrWHECMibFzZtgjfeuOegCxewkyZx9ZeBpDl4guzu4J0tNb+eC+HGzWDq1KlDly5dyPawVngiIvHEQ4PS7SV2B4BPgbcAA3hZay/EQG0iIiISAzZsgNq14cgR5zmkn36CZMlu/zA8HFauhLFjiZg/D7eQUPZmgd7F0rDpqBsXjl2iSpUq9OjRg/z588fqOEREotNDg5K11hpj5llrXwd+i6GaREREJAbcugU//gh9+0L27PD771C69O0fHj0Kvr4wfjycPMn1lEkZ/VooozIm58ruVJzZeoa3336bObN7U7JkydgchoiIS0Rl6d1mY8wb1tptLq9GREREYsTOnVCrFuzd63S269cPUnrcgmlzYexYWLUKawzH33yZziWT82viINJtzUzAlgDy5n2BEXNHULVqVdTfSUQSqqgEpXeBb40xx4EbOMvvrLX2VZdWJiIiItEuNBR69oRu3SBDBli8GCpl2gXtxzq7yl65Ai++yCGvb2iUfiN+AQfIsDkDITtvQmYYNWoUdevWJVEi7VkvIglbVP4vV8nlVYiIiMiD+fuTIiwMKPpEl9m/35lF2r4dvvosmCFvTOLZDsNh1y5IkgSqVePkZ+VpemMGi3ZOItVvqXDb6kZwimB69OiBl5cXyZMnj54xiYjEcVEJStblVYiIiIjLRETAwIHwww+WFElCmVliOJ8tbAezgp2NkoYO5eqnH9Jt9xAG+TXAbYMbiTYn4ha38PLyokOHDqRLly62hyEiEqOiEpR+wwlLBkgK5AD+AtTaRkREJI47ehTq1LjF2i1J+Sj5KkZdq0mmvcHQsCHUq0d4oVfx9felvW9RLqy5QOKNiQm9EUrNmjXx8fHhxRdfjO0hiIjEikcGJWttwTu/N8YUAb51WUUiIiLyxOytYEZ77abV2Py4h4fgS2Nqv3UK02AAfPIJJE3KuuPr+G5kUfyX+5N4bWK4BO9VfI9evXpRqFCh2B6CiEis+s9PYlprdxpj7t2CTkREROKCPXv4Z9BMGkx4hyWh5Xg/yXrGNd/KC14/Qo4cAJy4eoLWC1szY94MPH73gAB4teir9J7Zm/feey+WByAiEjc8MigZY1rd8a0bUAQ477KKRERE5L+5ehWmT8eOHce0bblozlBuuT/DkKb7aTrwbdw83gHgZuhN+mzoQ8/pPQldFgrHIFuubPT8tSfVq1dXq28RkTtEZUYp5R1fh+E8szTbNeWIiIhIlFgL69Y5ex7NnMn5oGdokmoKsynPW0VDmTDFg5deeuX2oZZf9/5KiyktOLvgLOyD9BnS03VYVxo2bIiHh0csD0ZEJO6JyjNKXWOiEBEREYmCf/6BCRNg3Dg4fBhSpWJBqX403NaQK9cT0asXeHt74O7uHL7jnx00md6EbdO2wU5IliwZbbu05fvvvydFihSxOxYRkTjsgUHJGLOQh7QGt9ZWcUlFIiIichd3G8rbYWvgo66wZAmEh0Pp0lz93ocWG6ozfnIiChWClZOg4O0WTGevn6X1otZMGjEJNoF7hDuNmzSmU6dOZMyYMXYHJCISDzxsRqlfjFUhIiIi9wsPhwkTmB7Yngz2HOzIDG3aQL16rDqem7p14fRp6NABOneGxIkhJDyE/uv706VfF4J/D4Yb8Olnn9K7Z29y584d2yMSEYk3HhiUrLVrYrIQERERuc1aWLrUCUV79nDOvSB9E7WjzwlPbgQnom1bGDYMXn4ZNm6EN990nkNacGAh3/b6ljMLzsBleKvkWwzpP4SiRYvG9ohEROKdhy29m2Gt/dwYs5tIluBZa191aWUiIiJPo507nYC0ahXkzg0zZ9Ksfi7CwsPZtC0RtWo5jya1aAE9ekCyZLD//H5q/VyL7RO3QwDkzJuT4dOGU758eXWyExF5TA9beud1+/OHMVGIiIjIU+34cejYESZPhvTpYfBg+PZbSJyYiPp/cCwkE++8A9mywe+/Q5kycDnoMvWHNmPawGnwNzyb+Vn6T+zPN19/g5ubW2yPSEQkXnvY0ruA25+Px1w5IiIiT5nLl6FnTycYGQPt20PbtpA6NRERMHsm7Lj+MjcjklK/PvTvD8+kCKfbvB781PUnQvxDSJoyKR16d6C1V2uSJEkS2yMSEUkQHvnnJmPMW8aYbcaY68aYEGNMuDHmWkwUJyIikmAFB8OAAc7yun79oEYNOHQIevQgPEVqpk93Oth9/rlz+CtJDjFmDKw6OJeMZTPSuVpnwvaF0cCrAWdOnqFjm44KSSIi0Sgq8/JDgRrAISAZ0AAY4sqiREREEixrYfp0eOUVaNUK3ngDdu0CX1/CM2dlyhQoUMDJTcY4h+ZNvB1SbyT/F/n5tMSnXFxzkbLVynLiyAlGDxxN6tSpY3tUIiIJziM3nAWw1h42xrhba8MBX2PMRhfXJSIikvCsXQve3rBtGxQqBMuXQ7lyhIXB1InQvTscPOjMJM2cCZ9+CpdvXuSr7JWJOB0IM+CVkq8wddhUChcsHNujERFJ0KIyo3TTGJMY8DfG9DHGtASecXFdIiIiCcf+/VClCpQuDQEBMGEC7NhBaJly+PpC3rxQu7bTwW72bPD3hw+qBFHnp1o89+JzRPwVCEkSMW/FPPat3aeQJCISA6ISlL65fVxz4AaQDajmyqJEREQShDNnnM51BQrAmjVO04aDBwn5shZjfN15+WWoVw9Sp4Z585wVeFU/DqfdL21IkyMNk36cRPLkyUmcLgvPXMxP1bJVY3tEIiJPjQcGJWPMC+B0vbPW3rLWXrPWdrXWtrLWHo65EkVEROKZ69ehSxenUYOvL3h6wt9/E9KqHaMmJeOll6BhQ0iXDhYuhO3boWpVGDRzIKlfTk3fZn0hFNr2b8uVo1d4u8Bpchfyi+1RiYg8VR42ozTv3y+MMbNjoBYREZH4LSwMRo2CPHmga1eoXBn27ye490BGzExP7tzOBFOmTLB4MWzdCh9+CDNW/UqGwhlo+UVLbp27RZ0Odbh26hq9WvbC3d09tkclIvJUelgzhzu38s7p6kJERETiLWth0SJn/6P9++Gdd2DePG4VepMxY6BXLzh9GooXhzFjoFw5p6Od304/6rSow/F1xzHJDB80+YBJvSaRNlXa2B6RiMhT72EzSvYBX4uIiMi/tm2Dd991mjVERMC8eQQtW8ugzW+SM6ez6i5nTli5Etavh/LlYe+RPbz64au8+8a7HN98nOI1inP076MsGr5IIUlEJI54WFAqZIy5ZowJBF69/fU1Y0ygNpwVEZGn3pEjzmZHxYo5s0jDh3Nzy276/12VHDkNLVrAyy/D6tVOH4f334fT505R6utSFHylILuX7CZfxXzs3LuTDVM3kD1z9tgekYiI3OGBS++stVoULSIicq+LF50Nj4YOBQ8P6NSJG01bM2JySvq+BOfOwXvvwYwZUKqUc8rVwKvUaV+H+ePmY4MsWd/Jytj+Yyn/RvnYHYuIiDxQVNqDi4iIyK1b0Lcv5MoFgwZB7doE7jpM72d8eLFgSlq3dvaQXbcOVq1yQlJwcDCNOjUi3fPpmDdsHmleSsOEZRM4ue6kQpKISBynoCQiIvIwEREwebKzjq5NGyhRgmsbdtMjx2hefDsz7dpB0aKwcSMsX+70cQgPD6fTwE6kzpqa0T+NJnHGxPSa2ouLuy5Sq3yt2B6RiIhEwcO63omIiDzdVq2C1q2dnWCLFOHqkIkM/qM0AyrD5cvwwQfQubPzmBKAtZbhU4bT/of2BJ4MxON5D7yGeNG3SV883D1idywiIvKfKCiJiIjca88eZ/ZoyRLInp3Lo2Yw6NRnDKxluHrVaXDXqZMzk/SvWUtm0axVM84dOIdbOje+/PFLRrcfTYokKWJvHCIi8tgUlERERP51+rQzRTR+PKRKxSWfoQy4+S2DvRNx7Rp88okTkF577X+nrN28ljrf1eHotqOQEsp6lWVi14lkTp051oYhIiJPzqXPKBljKhpj/jLGHDbGtIvk56WMMTuNMWHGmM/u+Vm4Mcb/9scCV9YpIiJPuWvXoGNHyJMHJk/mwrcd+KHOP2Tv04yfeiWifHnw94c5c/4Xkvbs38NrZV+j9NulObrnKEVqFWH/X/tZMXCFQpKISALgshklY4w7MAwoB5wCthljFlhr991x2AmgDuAdySWCrLWFXVWfiIgIoaEwejR06QLnz3P+k0b0y9CbYRPTcPMmVK/uzCAVKPC/U46fOE7tlrVZM28NuEPOqjkZ32c8JV8qGWvDEBGR6OfKpXfFgMPW2iMAxpjpQFXg/4OStfbY7Z9FuLAOERGRu1kLc+dCu3Zw6BBni39CvwrDGT4nE0FB8OWXzgRTvnz/O+XChQs0bteYORPnYMMtGUpnYHiv4XxW7LMHv4+IiMRbrlx69zxw8o7vT91+LaqSGmO2G2M2G2M+jt7SRETkqbVpE5QsCdWqEWAz0arq3+TYNZv+UzPx6aewbx9Mnfq/kHT9+nUat2lMphcyMXvsbJ4p/AyDFw/mzKozCkkiIgmYK2eUTCSv2f9w/gvW2n+MMTmB1caY3dbav+96A2MaAY0AMmbMiJ+f32MXG92uX78ep+oR3ZO4Svcl7kmo9yTZqVPkHD2aDGvXciRNfrq8tpZf9xYn7Igb5cqdpWbN42TNGsSZM3DmDISEhDBl7hSmTZlGaGAoHq948GXtL6n9Rm083DxYu2ZtjNV+5UphwsPDE+R9ic8S6u9KfKf7EvfE13viyqB0Csh2x/dZgX+ierK19p/bn48YY/yA14C/7zlmFDAKoGjRorZMmTJPVnE08vPzIy7VI7oncZXuS9yT4O7J+fPQrRuMGMEpjxw0L7aFMX+8Qdifhtq14YcfIFeuTEAmwNksdvjY4XTo1IHAc4G45XSjXs96DGgwgFRJUsXKENKkgStXriSs+5IAJLjflQRC9yXuia/3xJVBaRuQxxiTAzgNfAl8FZUTjTFpgZvW2mBjTHqgBNDHZZWKiEjCExQEAwdCr16cuP4sPfOuYtzhkkTsNNStC+3bQ44c/zvcWsv0WdPxauPF+WPnIQt82O1DRnmNInNKdbETEXnauCwoWWvDjDHNgWWAOzDOWrvXGOMDbLfWLjDGvAHMBdICHxljulpr8wOvACNvN3lwA3rd0y1PREQkcuHhMGkSdOrEsVPu9Mw+A9+g8nDIUL++078he/a7T1mxcgWNWjbi2J5jkA7eavUW49uP5+X0L8fKEEREJPa5dMNZa+1iYPE9r3W+4+ttOEvy7j1vI1DQlbWJiEgCtGwZtGnDkT8D6ZFhKBPcP8ItwI2GDZ2AlC3b3Ydv27aNBl4N+HPTn5AK8tTNg29nX0q8WCJ26hcRkTjDpUFJREQkRvj7Q5s2HF5xhO4pejHJ7VMSXTM0aWpo0way3vMnuQMHDtC4VWPWLFkDySBTtUyM6DKCqvmrYkxkvYhERORpo6AkIiLx14kT0KkTBydu5qfEPkwx1UkcZvD8ztC6NWTJcvfhJ0+exKudF3OnzQUPSFk+Jb079aZR8Ua4u7nHzhiiwM8P/Pz8gTKxXImIyNNDQUlEROKfq1ehZ0/291/CT+HtmW58SeJuaOlp8PaGTJnuPvzChQu079KecaPGERERQZLiSWjbri3tKrQjmUey2BmDiIjEaQpKIiLy/8qUcfbs8feP7UoeICQERoxg748z6HbVkxn0IFky+L65G97e8Nxzdx8eGBhI997dGTBgACFBIbi95sa3Lb+lZ7WepE2WNnbGICIi8YKCkoiIxH3WwsyZ7P7eF59T9ZjFBlIkD6ftd260agUZMtx9+K1btxgybAhdu3XlxtUb8Ap80vQTBn0ziGyps0X+HiIiIndQUBIRkbht3Tr8m4yk295PmMMSUiYPo0MLS8tW7qRLd/ehYWFhjB8/nrad2nLpzCXICe94v8OIRiMo8FyB2KlfRETiJQUlERGJmw4cYEfj0XRbU5L5TCZ1smA6fx9Bi1aJSHvPqjlrLbNnz6Zl25acOnIKskDeVnn5xfMXSr9YOnbqFxGReE1BSURE4pazZ9nW1BefOQVYxM+kSRpEV+8Qvvs+CWnS3H/4ypUr+c77O/b/sR/SQ+YGmRncYjDV8lVTq28REXlsCkoiIhI33LjBlpbT6TouK0vC2/Fskhv81OoGzds+Q+rU9x++detWvLy92LxuM6SGVJ+nomernjQs2hAPd4+Yr19ERBIUBSUREYldYWFs7LiYrgNSsTykPukSX6Nni/M0+zEDKVPef/i+ffvwbufNkoVL4BlI/EFi2nm1o3Xp1qRInCLm6xcRkQRJQUlERGKHtazrs4mu3QyrblQhQ6LL9G56jKa9XyRFJHnn+PHjdOjUgalTpmI9LG7vutGwWUN8Kvrw3DPP3X+CiIjIE1BQEhGRGOc38i+6truJ35XiPOd+gX61/6Tx0II8k+L+vY3OnTtHt5+6MeKXEYTbcHgTPmn4CX2r9iXXs7lioXoREXkaKCiJiEiMsBZ+n3aGri0us/b8K2RyO8uAautoNPYtkqdOf9/xV69epV+/fvTr349bt25BYShRswSDvhjE61lej4URiIjI00RBSUREXMpaWDnnGl2/u8iGf3KQhQgGl19Eg4mlSJax5H3HBwUFMXz4cHy6+3Dt8jXIB3k/z8ugmoMol7OcOtmJiEiMUFASERGXsBaWLQqhq+cFNh/PQlauMvStydSfVIakuT+87/h/N4vt0LkD5wLOQS7IXC8zfWv1pUbBGrgZt1gYhYiIPK0UlEREJFpZC4sXReDT8hJb/07PC4QyIt8Q6k58lySv17zv+IiICGbPnk3bH9py9PBRyAqpGqWia92uNCnahCSJksTCKERE5GmnoCQiItHCWli4EHxaX2PHwVS8SCCjsg2n9sgSJK7kGcnxluXLl9OmXRv+9P8TnoPEXyfm+zrf0/adtqROGsnmSSIiIjFEQUlERJ5IRATMnw8+PwThfyAZOTnP2LQ+fPNzYTxqdwS3+5fMbd68mTbt2rBuzTpMWoP51FDvm3r4vO9DlpRZYmEUIiIid1NQEhGRxxIRAXPmQLfOofy534PcnGJ8sv581SkXHi1/gqRJ7ztnz549dOjQgQULFuCWwg0qwYdffUjvCr15JcMrsTAKERGRyP0fe/cdHmWxt3H8O5tGCZEqvRcRFVAQEAFDCU2aiiIgRFDQo4j1taGoWLEXOCrYCCooKooCQlByBBQFld57lxogCWm78/7xJGZT0KBsdpPcn+vaK8lmHjLjuEnu/OaZUVASEZEz4nbDZ5/Bk0+4Wbs+iPPMNqYGPcv1t1cgeOxTUKFCrmu2b9/OY489xocffogJM9AJLr3mUl7q9RKX17rcD6MQERH5awpKIiKSL243fPopPDnOsn6D4fygLXzM41zXH4KefQrq5z789Y8//uCpp57irbffwo0be5mlQZ8GvNjvRXo36q2tvkVEJGApKImIyF9KT4fp0+GppywbNxouCN3MdB6l/2V/EPTS89CqVa5r4uPjefHFF3n5lZdJTk7GXmypfGVlnu77NNHNowl26cePiIgENv2kEhGRPKWnw0cfwdNPw+bNcFGpbczgAa6uuw7X889B796QoyKUlJTEhAkTeObZZzgefxwuhNLdSvNIv0cY3Xo0pUJK+Wk0IiIiZ0ZBSUREsqxYQak0N++914Knn4Zt26B52e18wT30DV+K6+XH4abpEJz9x0daWhrvvfceTzzxBPv378fVyEXwwGDu6HsHY9qPoUKp3PctiYiIBDIFJRERAZwK0v7U8uxMrsxNN8EllXbzVdCd9E6Zh3ns/+DeGChTJts1Ho+HTz/9lEcefYStW7YSVDsIboTBfQYzruM46pSt45exiIiI/Fu5D7cQEZFixeOBadOgSRPYdKoWlTnANyWvZfnhOvQZXhGzdQs8/ni2kGStZe7cubRo0YKBAweyK3EXDIQuT3VhxbMriLkqRiFJREQKNVWURESKKWudg2IffRTWrIGLKu3nY+7hejsd07kXjF/tpKcclixZwkMPPcSiRYsIrRgKV8NFURfxQrcX6FS3kx9GIiIicvapoiQiUsxYC/PnQ+vWcNVVkLJjP9PMIFYcrknV4MP8p8Q78PXXuULSqlWr6NWrF+3atePnVT9DT6j+UHWmPzGdZbcsU0gSEZEiRRUlEZGtm2qtAAAgAElEQVRiZNEiGPOwZdFiQ63Q/bzLGIa6viL43uEwaiuPNztGenp6tmu2bt3K2LFjmTZtGsGlgqEzRHSM4LGoxxjZYiShQaF+Go2IiIjvKCiJiBQDy5bBow+mMe/7EKq4DjGBJ7i5Zhxhd/0Hol/zuv/o2J/X7N+/nyeffJLJkydDENAOQq4I4aFOD3Ff2/soE1Ymz68lIiJSFCgoiYgUYatXw9h7TvLlgjJU4Dgv8By3tV9HqXv/A1e+Aa4cK7CbNyf+8A4eeughXnvtNVJSUwhqGYS7vZtbI29l7BVjqRJexT+DERERKUAKSiIiRdDmTZbHbv2D6QvPpQwexgU9zp3XHyTi/luhadM8rzl48CBLl7YiJWUP69Z5CG0eiqe9h6vbXc3TnZ6mUYVGBTwKERER/1FQEhEpQnZuTGbcTTuZsqQ+YZThgVIT+L9Rpyh/z3+gcuU8r9m0aRMvvfQSU6ZMISUlBeq5sF0tbVq3YXyX8bSu0bqARyEiIuJ/CkoiIkXA/hV/8PSI7UxafgmGOoyq+AkPPRpM5VtugbCwXO2ttfz444+88MILzJo1C1ewi+CLg6EVuFwN+HrUK/Ro0ANjjB9GIyIi4n8KSiIihdjh71YyfvReJqzrSDotGF77ex55PoKa1w6CPEKO2+3myy+/5MUXX2Tp0qWEhodCB/C08tCjRQ9iJ16J3deMnq9d6ofRiIiIBA4FJRGRwsbt5vjHs3n5kSO8susaEriIGxov57GJlanfqVuelyQlJfHBBx/w0ssvsW3rNsIqhUFPKNG6BHe0uYPbL72duuXqEvkmxIfHF/CAREREAo+CkohIYXH8OIlvxvDG+CSejx/BMcrTv9kmnni7Kk1at8rzkkOHDjFx4kQmTJjAkSNHCKkZAtdC7Xa1ufOyOxnabCjhoeEFPBAREZHAp6AkIhLotm4l+ZU3efudIJ5JuYeDVKbnJQd48s10LmmV9050mzZt4uWXX+aDKR+QkpyCq7EL+kCnTp24q81ddK3fFZdx5XmtiIiIKCiJiAQma+GHH0h7+Q3en1WBJ3mEPdSkY8sTzHwN2rbN+yyjH3/8keeff55Zs2ZBENimlpIdSjKsyzDuaH0HjSs2LuCBiIiIFE4KSiIigSQlBT75BPcrr/PxivN53PUC26hLm0tSmfICdOoUkesSt9vNrFmzeHb8syz7eRmuUi5se0vNqJrc2elObrrkJsqWKOuHwYiIiBReCkoiIoHg4EF46y08E99k5sG2jA2bzjoa0PxCD988Az17hubaxO7UqVNMmTKF5154jp3bdmLKGegBl/e7nLvb302f8/oQ5Aryz3hEREQKOQUlERF/WrUKXnsN++FHzE3txCMRi/idBjSua/l0HFxzjQtXjluJDh06xIQJE3j1jVc5cewEVIPgAcHccN0N3NX2LppVaeafsYiIiBQhCkoiIgXN44E5c+CVV+D771kY1p1Hyq/lxwP1qVsBprwBgwcbgnIUgzZv3sz4F8YTExNDWkoaNIIKAytw13V3cUvLW6hUupJ/xiMiIlIEKSiJiBSUhAT44AN4/XXYvJmllXrzSIPtfLelDtWD4K23YNgwCA3NftlPP/3E4888zvzZ88EFNIOm/ZryYL8HuabJNYQGheb11URERORfUFASEfG1nTthwgSYPBmOH2fFhTfw6CUL+ea36lTCKSzdcguULJl1SeYGDY8+/Shrf10LJcC0N/Qd0pcHuz9I6xqt/TYcERGR4kBBSUTEF6yFn36CV1+FL74AYH3X0TyWMoYZ31egbFl4+mkYPRrCvc57PXXqFO+8/w5PjX+Kg7sOQlko3bc0t424jTvb30n1iOp+GpCIiEjx4tPTBo0x3Y0xG40xW4wxD+bx+Q7GmN+MMenGmP45PhdtjNmc8Yj2ZT9FRM6atDSYNg1at4bLL4fYWLbd9DTR/eK5cN7LzP2lAo88Atu3w8MPZ4Wkw4cPc+/D91KhagVG3z6ag+kHqXVzLSbNn8Thzw7z/JXPKySJiIgUIJ9VlIwxQcBEIArYAywzxsyy1q7zarYLuBG4L8e15YHHgJaABX7NuPaYr/orIvKvHDkCkybBxImwdy80asSepz7gqW2DePe9EIKD4e674YEHoJLXngubN2/mgScfYNYns3CnuqERtLuzHeNuHEdknUhMzj3BfSwuDuLiVgCRBfp1RUREAo0vl961ArZYa7cBGGOmA32BP4OStXZHxuc8Oa7tBsRaa49mfD4W6A5M82F/RUTO3Pr18NprEBMDp05Bly4cfP4DnlvWmf8+afB4YORIp3pU3asgtGjJIu597F6Wfb8MXBBycQhDRg5hbP+x1C1X13/jEREREcC3Qak6sNvr4z1Afu8+zutarTkRkcBgLcyf79x/9O23EBYGQ4Zw7Ma7eXFOE14b6WSm6GgYOxbq1HEu83g8TJ0xlbFPjWXXml1QAspHlee+u+7jjs53EB4a/pdfVkRERAqOL4NSXutF7Nm81hgzEhgJULlyZeLi4vLdOV9LSEgIqP6I5iRQFaZ5cSUnUzk2lhqff07pnTtJKV+efcOHs6XLVUxfcAGfdKtJYiJ07HiQG2/cTq1ap9ixAzZuTGHqrKnM/GwmSQeToCzUuroWN199M5dXuxyXcbH8x+X+Ht6fCtOcFCeal8CjOQlMmpfAU1jnxJdBaQ9Q0+vjGsC+M7g2Mse1cTkbWWsnAZMAWrZsaSMjI3M28Zu4uDgCqT+iOQlUhWJe9u517j16+204ehQuvhiefBJPnwF88U4oz42Gw4ehTx948klo2vRc4FwOHDzAXePu4ouYL0g7mYarmouo+6N4+e6XubDKhf4e1WkVijkphjQvgUdzEpg0L4GnsM6JL3e9WwY0NMbUNcaEAtcDs/J57TygqzGmnDGmHNA14zkRkYKzbBkMHuysnXvuObjiCvjhB1J/+pX/nhxC/fNDue8+JzctXQpffQVNm8Jva3/j8msup1qNanwy8ROCawZz6xu3cnjLYeaPnx/QIUlEREQcPqsoWWvTjTGjcAJOEPCetXatMWYcsNxaO8sYcykwEygH9DbGPGGtvcBae9QY8yRO2AIYl7mxg4iIT6Wnw5dfOqfA/vgjlCkDd9wBo0aRXqseH34ITwyFHTuc3b+nTXPyE8D0b6cz5skxbPtpG7igStsqPHjfg4zqNYogV5BfhyUiIiJnxqcHzlpr5wBzcjw31uv9ZTjL6vK69j3gPV/2T0TkT/Hx8O678MYbsHMn1KvnbNYwbBie8AhmzIDHesLGjdCiBbz5JnTrBm5POmPfGscbr7xB/KZ4KAFNr27KS4++RJdmXfw9KhEREfmHfBqUREQC3ubN8Prr8P77kJjolIdefRV698a6gvj6a3j0UVi1Ci64AL74Avr1g8MnDjFozGg+f/dz0g6mEVQuiJ539GTCmAnUraztvUVERAo7BSURKX6shYULnUD0zTcQHAyDBsGdd8LFF2MtLFgAjzwCv/wC9evDhx/C9dfDih2/cvmNd7D0i6XYBEupWqW4ZfwtjL9zPKXCSvl7ZCIiInKW+HIzBxGRwJKc7FSOmjeHzp2dHRgefRR27YIPPoCLL2bxYujYEbp2hf37YfJkWLfOYmt8SIOedWnZuCU/xfxE1UZVmfjJRBJ2JPDG/W8oJImIiBQxqiiJSNH3xx/OTUVvvgkHD8JFFzn3Iw0aBCVKALB8uZOZvv0WKld2VuMNGXaKF754ikptJnBixQlwQdOoprzy+Ct0at3Jz4MSERERX1JQEpGia8UKZ3ndtGmQmgq9esFdd0GnTmCcc63XrIGxY2HmTChfHsaPh7437OaR9+7hnqZfkr49HVdJFz1v7Mkbj79BvVr1/DwoERERKQgKSiJStLjdzn1Hr74KcXFQqhSMGAGjR0OjRn8227IFHnvMyVDh4fDYY5ZL+yzm8cn38ECz5XAYSlYsyS2P3sIz9z1DRESE/8YkIiJSGKQCB4D9Xm+fgzbJbZyPCxkFJREpGk6edO4/ev112LoVatWCF16Am26CcuX+bLZrFzz5pNM0NBTuuddNlQ5TePXdsTzx4l5IhHMbnMvDzz7M7TfeTnCwvk2KiEgxZoETOKHHOwAdyOO505x6GhIWUgAdPfv0G4CIFG7btztnH737Lpw4AW3bwrPPwlVXObvZZThwAJ55Bt5+2/n4xhFJmKZP8eZHr5H0WhKkQZO2TXh+7PP07NoTk7E0T0REpEhKBw6RvwCUnMf1YUBVoArQCLgi4/2qXm+rApVg0ZJFRBLpw8H4hoKSiBQ+1sLixc7yui+/BJcLrr3Wuf+oVatsTY8cgeefd7JUair0GXCY+DqjeX/WJ3je9mBchqi+Ubz4+Is0vaipnwYkIiJyliSSd9jJ+dwhwJPH9eXICjttyR58vAPQOUAR/5uigpKIFB6pqfDpp05A+vVXZ0nd/ffD7bdDjRrZmp44AS+/7DwSEiyX99zJgQpDmfm/RfAxhJYOZeiooTzx4BNUq1bNTwMSERHJBw9whL+u+mS+PZnH9cFAZZyAUxNoRd4BqApOpUgABSURKQwOH3bWzE2c6Bxu1LgxvPUWDBnibNbgJTERJkxwqkhHj0KT9qvZU3oAi39eD4ehbOWy/N/4/+OO/9xBmTJl/DQgERERIAUn4PxdADqAs1QupzJkhZzmQA/yDkAV0Omp/4CCkogErrVr4bXXYOpU57DYbt3gvfec02Bd2b/jp6Q4WeqZZ5xjk6o1W0Jww0Gs+20XJELdxnUZ98o4BgwYQEhI4bypVERECgELHOfv7/s5QN6bHxjgXLJCzoVkLXfzDkBVgHAfjkMUlETEjyIjaR4f75x3lMnjcU59ffVViI11DoQdOhTuvBOaNMn1T6SlwZQpMG6cZfduQ0S9OXD+zexbvx9S4fKOl/PEmCfo1KmTNmgQESnqIqF5fHNY8bctz1w6cJD8BaC8Nj8oQVbIaez0Nc8AdC76DT1AaBpEJDAkJkJMjFNB2rgRqlVzykMjRkDFirmau90wfTqMfczDtq0uQqpMg9p3c2L7QYKCgug/YABjHhjDRRdd5IfBiIhIoZFI/nZ+O4RTLcqpPFkhpx3ZNzzwDkDFYPODokZBSUT8yqSmwoMPwqRJcOwYtGwJH30E/fs7Bx3lYC3MnAkPjkll84ZgTNk3odJjpB04Qsnwktx2773cfdfdVK9e3Q+jERGRgJC5+cHfbXywH0jI4/pgspa31QJak3cAqow2PyjCFJREpOB5PPD997BuHRGHDjkVpKuvdrb3btsW8lgiZy3MnWu564GTbF4TBqVfhDLPY+NPULlaZe5/6SVuvvlmIiIi/DAgEREpcMeAzTkev0FEcoQTXk63+UFm0LmE0299XR5tfiAKSiJSgPbuhQ8+cA6H3b4dgoNJqVSJEr/8AnXqnPayeQtSGHXfMbasDIMSz2BK/BebmMQFF13AQw88xHXXXacNGkREiqIT5A5DmY8jXu0MUBsIgrTwNML+E5b31telC7DvUugpKImIb6Wnw5w58M47MHu2U03q1AmefhrefJPkEycocZqQ9PX3Bxn9f8fZ8VsIhDyFCZ6KTU6lS9co7v+/++ncubM2aBARKewSgS1kBaBNXu8fzNG2BtAQuCbjbaOMt/VwqkiRcCr+FGFPaz2c/HsKSiLiG9u2OZWj9993zj6qUgUeeACGD4cGDZw2b7+d6zJrLTHzV/LwmHT2/Wog6CkwXxFkXQweNJh7772Xpk2bFvBgRETkXzkFbCXvytC+HG2r4oSf3hlvMx/1gVKIFBgFJRE5e1JS4MsvYfJk+O4756yjHj2cnet69oS/WB6X6k7l1W++5dknw4j/1Q2uZ4HFhJcqw39uvY/Ro0dTo0aNghuLiIicmVRgG9krQpmPPWTfMa4STviJIqsq1BBogM4GkoChoCQi/966dc7SupgYOHIEateGceNg2DD4i3ATSRyHwjbRdfrrvPVCOZJ/SwXzIrCBqlWqc+89LzJixAht0CAiEijSgB3kXRnaibPbXKbyOOHnCrJXhhribJXtC3GwIm4FkUT66AtIcaKgJCL/TGIifPqpE5B+/NGpFvXt61SPunRxqkmn4bEeFm5fyJJKU0nffBHrBiWDfQ7YzwVNmvHgg1MZMGCANmgQEfEHN07oySsM7SD7bnIROMGnNTCE7GGofIH1WMQnFJREJP+shd9+c5bWffwxnDwJ550HL7wAQ4fCuef+5eW/79rIcx/9yOxvU0lcfQ4cKwM8BiRyxRVdGTNmCl26dNEGDSIivubBWQ6XVxjahrOMLlNpnOBzMXAd2cNQJXSIqhRZCkoi8vfi451gNHkyrFgBJUvCtdc61aPLL8/z3CNwNrhb+FM8r320nrjvQzi5uQJ4DgMfAOuAYIKCqvHrr0to1qxZAQ5IRKQYsDgbJeQVhrYCyV5tS+DcH3Q+0Ifs9w1VQWFIiiUFJRHJm7WweLGztG7GDDh1Cpo3h4kTYdAgKFs2z8t27oS589L5cOYfLFtShtSTocAOXGH/Bfsj4KF168sYNuwt7r8/BrfbKCSJiPxTFmcLbe8QlLmZwhYgyattKM7OcQ2B7mSvDFVHB6yK5KCgJCLZHToEU6Y4AWnjRihTBqKj4eaboUWLXM2PH4eFC2H+fMvsb1PYtb0E4IKSPxNUagJBoT/hTk2mRuVaDB36MEOHDqVhw4YATJt2C/Hx8QU8QBGRQsbiHK56uoNXT3q1DQbq4oSfTmQPQzWBoALrtUihp6AkIs4auQULnKV1X30FaWnQtq1zBtK110LprKPM09Lgl18gNtZ5/Pyzxe02mNBT2KofYxq8R4mjazl19AQlg8LpP+h6oqOj6dChA64cGzzExUFc3ArQ7kQiInCM04ch778puYA6OOGnLdnDUB30253IWaKXkkhxtmePE4befddZM1ehAowa5VSPmjQBnBV4mzc5oWj+fKd6dPIkGGMpU3cj7lYfA58QfugAJ7ecAGO4vHNnoqOjueqqqyjtFbJERIq9k5w+DB32amdwKkCNgIFkD0N1cZbRiYhPKSiJFDdpaTB7tlM9+vZbp5rUpQuMHw/9+kFYGIcPw3efZFWNdu1yLq1S4xRVL/uZ1HKTSHF/TfpWD8G/ppKemk71xo2JfvYhbrjhBh0MKyLFWyLO/UF5haE/crStjhN+riJ7GKqPs8GCiPiNgpJIcbFli1M5+uADOHAAqlaFhx6C4cNJqV6PJUsg9nGnavT7704l6ZxzoFW7BC646ntWln6JfUd/4MiaEIKXBcOxU5QoX55hI4YRHR1Ny5Ytta23iBQfHeCSg5fAc+TeSGFfjrZVcMLPleQOQyq6iwQsBSWRoiw5GWbOdKpHCxc6h8BeeSX25hGsrtGD2IXBxN4GP/zgbGoXHAxt2sADY07hqfctP6S9TOzmxZg1hvD14bATbLCl65VdiY6O5sorryQ0VOs/RKQISwE24pxosNbr7UaIIMKpBAFUxAk/XcgehhrgHMoqIoWOgpJIUbRmjbNr3dSpcPQo1K3LvvtfZUG1IcQuL0/sSPgjY/lH48bOLUkdO6WTViuWz7a+z8trvyJ1birhG8JxrXPhcXto1KIR0fdGM3DgQCpWrOjf8YmInG2Zgcg7DK3DWULnzmjjwgk+FwCnIJFESn9W2glEeZ+YICKFmIKSSFGRkACffOIEpKVLSQwpy//aPEBspUHEbqzJ2uedZXEVKzq3JHXtCp07W46GrmTKiincsvojDn1ziBJrS2DWGEiAiGoR3HbvbQwdOpQLLrjAzwMUETkLknGWx3kHorU4gciT0cY7EF0LNMl4vxHZ7htaFreMyEsjC6bfIlLgFJRECjNrYflymDwZ98ef8FtiI2IrDSa2/qcs2VWDtEWGsDBo3x6GDoWoKGjWDP5I3M/Hqz+m1+wprN60GtdqF6XWlYL9YEoarr7qaqKjo+ncuTNBQTp0Q0QKoWTyXjLnHYiCyApE12W8bQKcB4QVcH9FJOAoKIkURseOwUcfsX3iHGI31CDW1Z3vQ17mKOFwCJpVgzvvdIJR+/ZQsiScSjvFVxu/4uFpU5i3bh52nSVifQRmk8FjPVzS4RKin4qmf//+RERoQb2IFBKZgSivJXM5A9GFZAWizAqRApGInIaCkkhhYS3xs5ew8IXlxC4uSaynG1sYBUD1Kh76dHURFQWdO0PlypmXWJbsXsKUFVP4ZM0nnNx4klLrShG8Jpi05DQq1a/EvY/fy5AhQ6hbt64fByci8jfyCkRrga3kHYgGkH3JnAKRiJwhBSWRAJaWBj/PPUrs6+uZv6QUvyRfhod2lA5OIbJtMqP6O1Wj88934b0z97Zj25i6cioxq2LYtnkbIatDCFkbAochOCKYwUMGEx0dTdu2bbWlt4gElmRgA7mXzOUMRA2BpsD1ZC2ZUyASkbNIQUmKhchIiI9vzooV/u7JX7MWNm6E2HkeYqcdIu7XMpxML4+LNlxaZgMPd11L1O2NaBNZgtDQ7L8NHE8+zox1M4hZGcOiDYtgDURsiIBt4Ha56dKtC9HR0fTp04eSJUv6aYQiIhkyA1HOJXOnC0QDyaoQNUSBSER8TkFJxM8OHYLvvnMOel0wL53d+4IBF/VIYFCJuUT1MHQacxnlWufedS7dk86CbQuYsnIKM9fOJGV9CuHrwwlaF4Q7zU3ti2oT/WI0gwcPpkqVKgU/OBGRU+S9ZG4bWYEomOyByLtCpKPaRMRPFJREClhyMixeDLGxzuP3353nywafpHP6PMawgKh2p6g3uhf0HQR5HOi6+o/VxKyMYeqqqfyx+Q/C1oQ5W3qfgJKVSnLz7TcTHR1Ns2bNtLRORArGKfJeMpdXIGoODCJrU4WGKBCJSMBRUBLxMY8HVq/OCkY//OCEpeBgS9sq23my9KdEJc6k5bn7CbrpRhj+INSpk+vf+SPhD6atmcaUlVNYsWkFrjUuSq8rDXvAhlp69+lNdHQ03bp1IyQkpIBHKSLFRmYgyrlk7nSBaDDZl8wpEIlIIaGgJOIDe/dmBaMFC+DgQef58xt7uOWKjUTtncIVayYQvj8ZevWCEWOhWzcIzv6STE5P5uuNXxOzKoY5a+fg2eAhYkMEZr3B4/FwQZsLiB4TzYABAyhXrpwfRioiRZZ3IMpZIbIZbYJxlsddjBOIMpfMKRCJSBGgoCRyFiQkwP/+lxWO1q1znj/3XOjSBaIa76bLtknU+HICbIiHevXgmTFw441QtWq2f8tay9I9S5mycgrT10zn+KbjlFrrbOmdmpRK2VplueOhOxg6dCiNGjUq+MGKSMGLhObxzcEXG9IkkX3JnHeFKGcgugQYQlaFqAEKRCJSZCkoifwDbjf8+quzAUNsLPz0k7OVd4kS0KEDDBsGUW0TuWj1x7jenQwfL3PuNbrmGrj5ZmcbPpcr27+5M34nU1dNJWZlDJu3bCZ4dTAl1paAg2BKGwZeO5Do6GiuuOIKXDmuFRH5W5mBKOemCtvJHojOI3cgaghoRa+IFDMKSiL5tG1bVsXo++/h2DHn+Ysvhrvvds4zane5pcTKn+Gdd+Dx6ZCYCBdcAK++CjfcABUqZPs3T6ac5LN1nxGzKoa4DXGwFs7ZeA5sArdx06ZzG4YOHcrVV19N6dKlC37QIlL4eAci71DkHYhCcCpELYGhZF8yp0AkIgIoKImcVny8E4gyq0bbtjnP16gB/fo5wahzZ2d5HUePwtSpcPc7sGYNlC4N11/vVI9at8b7NFi3x833279nysopfL7mc5I3JRO+PpzgNcGkp6ZT5bwqPPDMA9xwww3UrFnTP4MXkcCXBKwn95K50wWiaLIvmVMgEhH5SwpKIhlSU2Hp0qyq0bJlzo514eHQsSPcdZcTjs47LyP3eDzOjUl3TYYvvoCUFLj0Upg0CQYMgIiIbP/+ukPriFkZw4erPmTvlr2ErQ0jaHUQHIOQciEMvXko0dHRXHrppdrSW0SynABOQsjREHiQrFC0g+yB6DzgUpxAlFkhUiASEfnHfBqUjDHdgddwztZ+x1r7XI7PhwExQAvgCDDAWrvDGFMH5+9kGzOaLrXW3urLvkrxYy1s2OCEovnzIS7OWSnnckGrVjBmDHTt6hSEsu22vX8/TJniLK/buhXKloURI5zqUbNm2b7G4aTDTFs9jZhVMSzftByzxlBmQxnYAe5gN916diM6Oporr7ySsDAdMy9SbKXibJ6wKeOx0ev9A06T0pSGl3ECUStgGFkVovooEImInGU+C0rGmCBgIhAF7AGWGWNmWWvXeTW7CThmrW1gjLkeGA8MyPjcVmttc1/1T4qngwed7bozq0Z79zrPN2gAQ4c6FaOOHZ3sk43bDd9+64Sjr792Pu7QAR5/3NmgoWTJP5umulOZvWk2U1ZO4Zv13+Be7yZiYwSutS48bg8NWzRk6N1DGThwIJUqVSqwsYuIn3mAfeQOQptwlsu5vdpWwglEPXGWzk2FE+kniFgTobUgIiIFxJffblsBW6y12wCMMdOBvjgrqDP1BR7PeP8zYILRmiM5yw4dgt27Yd++cCpXdp4rV865vygqynnUrXuai3fsgPfecx5790KlSnDPPU71yGtrbmsty/YtI2ZlDB+v/phjm49Rcl1JQlaH4E5wU7pqaW655xaGDh3KhRde6PMxi4gfHSN7CMoMRZtx7ivKVIqsLbevxwlGjXA2VMh5LNpc8MR7FJJERAqQsdb+fat/8g8b0x/obq29OePjIUBra+0orzZrMtrsyfh4K9AaCMdZgb0JZ3X2I9baRXl8jZHASIDKlSu3mD59uk/G8k8kJCQQHh7u724UWx4P/P57Wb75phqLF1ckPd1FyZJpDBq0m5Ytj9Gw4UmCgvK+1qSlUfHHH6n6zTeU+/VXAI5eein7e/bkSNu2WK91eAeTDxJ7MJb5f8xn175dBK0OImxNGEl/JBEaGkq7du3o1q0bLbyRDHQAAB/XSURBVFq0IOh0X7CY02sl8GhO/p4r1UWJvSUotacUpXaXouTukpTaU4qSe0oSGp91sJB1WU5VPcWpmqdIqpGU7W1KxRTI558Gm9/VHLfbzeo3VvtoRPJP6LUSmDQvgSfQ5qRjx46/Wmtb/l07X/5tKq9v/zlT2ena7AdqWWuPGGNaAF8aYy6w1p7I1tDaScAkgJYtW9rIyMh/3+uzJC4ujkDqT3Fx4AB88EHW7UPlysGoUbD4nQ2E2QTeeecvXhMbNsC77zr3Hx06BDVrwtixMGwYFWrXJnNj74TUBL5Y/wUxK2P4bsN3sN7Z0ttsMLitmxbtWxD9dDTXXnstETk2dJDc9FoJPJqTDB5gN7mXyW0EdpL9J1pVnGrQZRlvM6pDpq6hVGgpSlGKCmQ/HuCMlIX4+HjNS4DRayUwaV4CT2GdE18GpT2A997GNXBWZ+fVZo8xJhg4BzhqnTJXCoC19teMSlMjYLkP+yuFlMfj3G80eTJ89RWkp8MVV8ATTzi3D5UoAZHvJ5OensfFSUnw2WdOslq0CIKDoU8fZ2ld165klp081kPcjjhiVsYwY80MkjYnEb4+nJDVIaQlp1GhXgXufuxuhgwZQr169Qr2P4CI/DuHyXup3BYg2atdGbLC0I0Z72culdPfREREihxfBqVlQENjTF1gL84K7EE52szC2cj0J6A/8L211hpjKuEEJrcxph7Oj6FtPuyrFEL79sH77zsZZ8cOqFgR7rzTyTiNG//NxStWOMnqo4/g+HFo2BDGj3d2dKhS5c9mGw9vJGZlDFNXTWX3tt2ErgklZE0IHAZXhIvoG6KJjo7m8ssv15beIoEsCSf45KwObQKOerULwdlBrhHQnWzVISqT76VyZ10crIhbQSSRfuqAiEjx47OgZK1NN8aMAubhbA/+nrV2rTFmHLDcWjsLeBeYaozZgvOj6vqMyzsA44wx6Tj7AN1qrT2a+6tIceN2w7x5zlFF33zjfNypEzz3nHMI7F/tsF3KJsDbbzsB6ddfncb9+ztbe3fo8OehsEdPHeWTNZ8wZeUUft78M2atIWJDBGyFdFc6nbp2Ijo6mr59+1LSa7c7EfEzN87ZQnlVh3bnaFsDJ/xcR1YQagTUQRsmiIgI4OMfB9baOcCcHM+N9Xo/Gbg2j+s+Bz73Zd+kcNm929l47t13nffPPRfuu8+pHjVo8BcX7twJc+fyVOJ0WqT/DLcmw0UXweuvww03ODcxAWnuNOZumcuUlVP4ev3XpG1II2JjBEFrgnCnual5YU0eeeERBg8eTNWqVQtm0CKSmwUOkvd5Q1txziPKdA5OCIokKwhlLpUrXWA9FhGRQkp/N5OAlZ4Oc+Y4BaA5c5x7kbp2hVdegd69ITQ0j4tSUmDxYpg713msc3ajr2+qMTe4F1cv+T+49FIwBmstv+37lZiVMXy0+iOObD1CyXUlCV4dTNrxNMIqhTHstmFER0fTvHlzLa0TKUgJ5F4ilxmKvLf1CcUJPo2BPmRfKlcR/y2VExGRQk9BSQLOzp1O5ejdd537kKpUgQcfhJtugjz3Sdi1ywlFc+bAd99BYqKToq64wik59ejBwNanSHe7ubpVS/ad3MeHqz4kZmUMa7etJWhNEKXXlYbd4A5107t3b6Kjo+nevTshITrqXsRn0nAOWs2rOuS99Y8BauGEn6Fkrw7VwlncLSIicpYpKElASEtz7jmaNMm5Bwmge3eYOBGuvBKy5ZXTVI2oU8fZjKFHD+jYEbz2608PW8Sh2v+j24djiN0Yi11vKbuxLGadwe1xc37r84l+KJoBAwZQvnz5Ahu3SJGXeeBDziC0CWeLHu/dKCvgVIO6khWEzsPZXEG3A4qISAFTUBK/2rbN2bXu/fedM5CqV4dHH4Xhw6F2ba+Gp6sadejwZ9WI8877c0MGay3rDq5lzuY5zNkyhyUjf4B9HvZNDCd0dSgpiSmUqVmG2x68jaFDh3Leeef55z+ASFFxnNMvlUv0alcSZ6lcU5y9TjOXyTWEf3PMkIiIyNmmoCQFLjXVOe9o8mTn/COXy6kajRjh5J3g4IxG3y06o6pRYmoiC3csZPam2czZModdO3bBVjhn3zmwGkgDW9oy4JoBREdHExkZicvl8sd/ApHCKQWnCpRXdegPr3YunN3jGuHsYeq9VK5GxudFREQCnIKSFJjNm7OqR4cOQa1azqGww4dDjRo4VaN3M4LRd99BQkJW1eimm5xw1Ljxn1UjgC1HtzhVo81zWLh+IalbUwneHkzYrjA44LQpXa00Jcr3IyysHWvXXk+4V7gSkRw8EHYwDBaQuzq0w/n8nyrjhJ9eZF8qVw/4i636RURECgMFJfGplBSYOdO592jhQggKcnasGzkSukamEvTTYngtY0ldZtWodm0YMiTPqlFKego/7PyB2ZtnM3vDbLas2gJbocSuEqTtSnN+ySsdRmRkJFFRUURFRXH++efTsaMhPj5eIUkEnMNXt+Nsp70tx9tNcJm9LKttaZwAdClwA9m32C5bkJ0WEREpWApK4hMbNjhL66ZMgSNHnBVzTz8Nw6L2UPW32fD2XLguf1WjXcd3MXfzXGZvnk3sz7Ekb0zGtd2F2WkgGVwuF80ubUbUDU4watOmDaE59g6Pi4O4uBWgU+2lOMg8ayivILQNZ3MFb2VwNky4EEiEJJIoFVPKqQ5VRVtsi4hIsaSgJGfNqVPw+edO9WjRIudeo359PIxovYouBz/G9dFsGONVNbrhBujZM1fVKM2dxo+7f2TO5jnM+n0WG37ZAFshaEcQ7ni3c3m92nS7sRtRUVF07NiRchkHx4oUG6k4S+G8A5D3+94bKBigOk4Y6p7xtp7X2wpkC0O/xP1CZGSkb/svIiIS4BSU5F9bu9YJR1OnwrFjUL92GuOv+pXopDepPP8L+OLvq0YHEg7w7ZZv+Xrt13z7/bckbUhyftnLuM8o4pwIorpE/bmcrl6eByqJFDHHyF4N8n5/D9nvFyqJE3rqAZ3JHoTqACUKqtMiIiJFg4KS/CNJSTBjhhOQfvwRQoI9XF1/FSMjXidy5we4dtqsqlGPHtCpU7aqkdvjZtneZczeOJvPF37O+p/XO78A7gLSITg4mDaXtaH7qO5ERUXRokULgoJ0qqQUMek4gSev5XFbgfgc7SvjBJ8OZA9C9YEqaImciIjIWaSgJGdk5Urn3qMPp3o4fsJFo9J7eTF0IkNTJ1Np23GnajT6xTyrRkeSjjB/63xmLJ1BbGwsCesTnBvKM5YI1T+vPr1u70XXrl3p0KGDNl6QoiGB0wehHWQ/cDUEp/pTH2hN9iBUF9BLQkREpMAoKMnfSkiATz5KZ9Krifyy4RzCTAr97QxGMon2FXZhevaAHu/mqhpZa1mx/3dmrpzJjDkz/rzXiMPO58+pcA5RvaPo1b0XXbp0oXr16v4ZoMi/4cFZInq6jRMO5mhfDif4XAJcS/bKUA1AhVMREZGAoKAkp/XbnANMGn+Uj3+sw8n0UjRhD6+6nmBIu+2U79MOer6dq2p0IuUE8zbNI2ZuDHHfxZGwIeHPeymCw4Jp2aYlV/e6mm5du3HRRRdhjNYKSSGQjFP9zCsIbcv4fCYXUAsn+PQlexCqhxOUREREJOApKEmW1FROxi5l2msHmbTofH5NvoASnMOA0t8w4sodtB12HqbzuFxVo3UH1zI1biozZ89k87LN2G0WUgADdRrXofddvel3ZT/atm1LiRK6o1wCkMWpdJ5uidzeHO3DccLPeUBPsoeh2jhL6ERERKRQU1Aq7nbvxs6Zy/Jpm5m05AKmpfcnkXAuCt/GG/2+Y/D91SnXpn+2qlFSWhKzfp/F+zPf58f//ejca5Rx03nEuRG079eegX0H0i2qGxUrVvTTwERySMPZLOR0S+RO5mhfHSf4RJF744SKaOMEERGRIk5BqbhJTYUlS2DuXI5//QMfbbiESYxkJSMpFZzC9Z0PMPJhQ6uO9TAmawvudfvX8ebMN5nz7Ry2/7Ydu9cCEFwymGatmtG/V3+u63MdDRs21HI68Z/jnD4I7QLcXm3DyAo+V5A9CNXB2W5bREREii0FpeJg926YOxfmzsXGLmBp4oVMMrfyiRnHKUrQvPEp3hxtGTgojHPOqQ1AcloyUxdM5aMvP2LZomUkbUly/iLvgmqNq9H5ms4Mv2Y47dq2IzhY/xvJPxQJzeObw4p8tnfjLIM73RK5oznaV8IJPpcBN5C9MlQV534iERERkTzoN9yiyKtqxNy5sGYNxyjL1HKjmRw2gTWJ1QkvbRkyyDBiBLRoURJjYPnG5fz3tf8SuyCWvSv2Yk86VaNSVUrRvm97BvcbzMDeA4mIiPDzAKVIS8TZOOF022mnerUNxqn+1AMGkHvjhDIF1GcREREpchSUigqvqhELFkBCAjY4hMVNb2Nyi+nMWHM+ycdctGwJk56D6683eDjOpM8n8Z/nPmX1T6tJ2ZcCgKu0i/qX1KdHtx7cNuA2Gjdo7OfBSZGSDuzDCT0HoER8CRhKViA6kKP9OTjhpxlwFdmXyNVA38VERETEJ/QrRmGVR9UIgFq1OHLNSGKCbmTS4iZs+C2IMmVg2HAYPtzNkaQFTJ4xmTGv/cChDYecpUzBUK5ROTr37cywa4ZxVeRVBAXpMBf5h9JxtoTfAezMeOv92EO2Q1bDCIP/4QSfK8kehOoB5Quk1yIiIiLZKCgVJnv2OKFozhz47js4eRJCQqB9e+zzL/C/itcwKbYOn08zpKZCmzbw3PhtHE59lzkLvmRS5Ebcic7d7MHVgrmw94X069mP2665jarlq/p5cFJopJEVhLwfmaFoD9k3TTA4O8jVAS7PeJv5eBiOJx+n7Kqyvu61iIiIyBlRUApkp6sa1awJgwZBjx4cvKgzUz4PZ/Jk2LwZIiLi6dBxHglMZe2qH1j6QMaex2WgUrNKXNHpCm659hY6XdQJl9Gd7JKHVGA3uQNQ5mMv4PFq7yIrCHUgKwTVznhbEwg9zdd6iuz3HImIiIgECAWlQJNZNcq818irasQLL0CPHngaN2FhnGHSJPjiizTS0xdTpdpsylefydF9G1kwDwiBkPohtOjeguv6XMfwqOFULK0zjQTnMGDvIJT5yAxEe3EOYM3kwgk7dYCOZK8I1cG5T0gHrIqIiEgRo6Dkb2lpTtVozpzcVaOBA6FnT+jUCcqU4cABeP99y3+7b2TPnliCgudhWQgkcWA/UA2q9KhC16iu3NznZtrWaUuQS/caFTvJOGcG7SDvitB+sgehILKCUBdyV4Sq47sgFAcr4lYQSaSPvoCIiIjIP6Og5A/5qBrRpAkYg8cDM2Yc4qWXvmb58lisXYBzEwi4wyGkUQit2rVhcJ/B9G/RnyrhVfw7NvG9U2QPQpmPzEC0P0f7YKAWTujpRu6KUDX0nUBEREQkB/16VBAyq0aZGzHkrBr16AGdO0MZ59CX5ORkvvzkO96Y8C2//BJLetoqp31QSagTRLVW1ejVvReDOgyibc22hARp3VORkkRW6Mlr17g/crQPISsI9SR3RagaTtVIRERERPJNQckHIiMh9GAlIu+enLtq1K5dHlUjD6tWrWLevFhiPvqG9Wt/xnpSgBAocT5BjZvT+qpzGNzzOno17kWtc2r5e4jybySSdwDKfO5gjvahZIWe3uSuCFVBQUhERETkLFNQ8oEXl7ShZfrPMJLTVo327NlD7AcfMG/+POZ+O48T8fEZVzeB4KGENw2jz4iyRHdrT4faHSgRXMJv45EzdJLsQShnKDqco30YWUGoH7krQlVwNlQQERERkQKjoOQDy4Pb8LNpze2/j/yzanTy5Eni4uKIjY1l7ry5bNm0xWkcVA7cPYGulG1ciauGWu69sREXVG3o1zHIXzhB3hWhHRnPH8nRvgRZ4acFuStC56IgJCIiIhJgFJR8YHrrVzl27DAtTm4h9qmnmB87n59++gl3uhsT4sKG14OwRyGlPyUjatJ7wCHG3lWDC84r5e+uC8Bx8l4Sl/k4lqN9SbJCT2tyV4TOxTl0VUREREQKDQUlH9i4cTgHD33GZZedBAOuqkF4GtSHE8Ow+0Zj4kvSrnMCd98WTq9ehpCQcv7uctEXCc3jm8PvQDx/XRGKz3FtabLCz2XkrghVREFIREREpIhRUPKBY5W+x1P1JFSuRMmEO2HNKE7tO4dq1TzcPNbF8OFQu3YZf3ez6DmFszV2zscBYBWUOVUGyuIsnfMWTlboaU/uilAFFIREREREihkFpbPMWogo9xLHNzYj9fcGpLgsV15pGDkSund3Eaz/4mfG4iyFyysAeQeh/RntcgoGKgPp4An1EBQdlLsiVA4FIRERERHJRr+2n2XGQMqKa7CnPIwbB8OGGWrU8HevApAbOET2oHO6EJScx/WlgKoZjwuBKK+PvR8VcDZKiITE+ETKvl7WZ0MSERERkaJDQckHmjSBpKQTPPpoMfylPIXcwSevIHQQJyzlVI6skNMOZ2vsvAJQGc6sChQHK+JWEEnkmY5IRERERIohBSUfCAuDU6f83Yuz7CR/v/RtP3A0j2tdODu/ZYaci73er5LjfR0XJSIiIiIBQEGpOPPgnPnzV0vfMoNQYh7Xh5IVchoBV5C96pMZgs4Fgnw4DhERERGRs0xBqShKA/7gr5e+7c9ok5bH9RFkBZ1LyXvpW1WcHeS0CYKIiIiIFEEKSoVJEn+/9G0/cBhnt7icKpEVci4g7/t/quCcGyQiIiIiUowpKPmbxTngND/bX+c8/wecGcwMPHVwDkTN6/6fykCI74YhIiIiIlKUKCj5QFwcxH23AvZH5m/765Q8/hHv7a+bAt3I+/6fzO2vRURERETkrFFQ8oWOcMUPVzibJeRUnqyg057T3/8Tju7/ERERERHxEwUlX+gNO2vupE6bOrmrQGF+7ZmIiIiIiOSDgpIv3AM74nZQJ7KOv3siIiIiIiL/gO5uERERERERycGnQckY090Ys9EYs8UY82Aenw8zxnyS8fmfjTF1vD73UMbzG40x3XzZTxEREREREW8+C0rGmCBgItADaAIMNMY0ydHsJuCYtbYB8AowPuPaJsD1OKf9dAf+m/HviYiIiIiI+JwvK0qtgC3W2m3W2lRgOtA3R5u+wJSM9z8DOhtjTMbz0621Kdba7cCWjH9PRERERETE53wZlKoDu70+3pPxXJ5trLXpwHGck4Hyc62IiIiIiIhP+HLXu7xOAbL5bJOfazHGjARGAlSuXJm4uLgz7KLvJCQkBFR/RHMSqDQvgUdzEpg0L4FHcxKYNC+Bp7DOiS+D0h6gptfHNYB9p2mzxxgTDJwDHM3ntVhrJwGTAFq2bGkjIyPPVt//tbi4OAKpP6I5CVSal8CjOQlMmpfAozkJTJqXwFNY58SXS++WAQ2NMXWNMaE4mzPMytFmFhCd8X5/4Htrrc14/vqMXfHqAg2BX3zYVxERERERkT/5rKJkrU03xowC5gFBwHvW2rXGmHHAcmvtLOBdYKoxZgtOJen6jGvXGmM+BdYB6cDt1lq3r/oqIiIiIiLizZdL77DWzgHm5HhurNf7ycC1p7n2aeBpX/ZPREREREQkLz49cFZERERERKQwUlASERERERHJQUFJREREREQkBwUlERERERGRHBSUREREREREclBQEhERERERyUFBSUREREREJAcFJRERERERkRyMtdbffTgrjDGHgJ3+7oeXisBhf3dCstGcBCbNS+DRnAQmzUvg0ZwEJs1L4Am0Oaltra30d42KTFAKNMaY5dbalv7uh2TRnAQmzUvg0ZwEJs1L4NGcBCbNS+AprHOipXciIiIiIiI5KCiJiIiIiIjkoKDkO5P83QHJRXMSmDQvgUdzEpg0L4FHcxKYNC+Bp1DOie5REhERERERyUEVJRERERERkRwUlP4lY0x3Y8xGY8wWY8yDeXy+gzHmN2NMujGmvz/6WNzkY07uMcasM8asMsZ8Z4yp7Y9+Fjf5mJdbjTGrjTErjDGLjTFN/NHP4uTv5sSrXX9jjDXGFLodiwqbfLxObjTGHMp4nawwxtzsj34WN/l5rRhjrsv42bLWGPNxQfexuMnHa+UVr9fJJmNMvD/6WdzkY15qGWMWGmN+z/g9rKc/+plfWnr3LxhjgoBNQBSwB1gGDLTWrvNqUweIAO4DZllrPyv4nhYf+ZyTjsDP1tokY8x/gEhr7QC/dLiYyOe8RFhrT2S83we4zVrb3R/9LQ7yMycZ7coAs4FQYJS1dnlB97W4yOfr5EagpbV2lF86WQzlc14aAp8Cnay1x4wx51prD/qlw8VAfr9/ebW/A7jYWju84HpZ/OTztTIJ+N1a+2bGH0TnWGvr+KO/+aGK0r/TCthird1mrU0FpgN9vRtYa3dYa1cBHn90sBjKz5wstNYmZXy4FKhRwH0sjvIzLye8PiwN6K84vvW3c5LhSeB5ILkgO1dM5XdOpGDlZ15GABOttccAFJJ87kxfKwOBaQXSs+ItP/NicQoIAOcA+wqwf2dMQenfqQ7s9vp4T8Zz4j9nOic3AXN92iOBfM6LMeZ2Y8xWnF/MRxdQ34qrv50TY8zFQE1r7TcF2bFiLL/fv67JWLLymTGmZsF0rVjLz7w0AhoZY5YYY5YaY1QN9618/6zPWF5fF/i+APpV3OVnXh4HbjDG7AHmAHcUTNf+GQWlf8fk8Zz+Cu5f+Z4TY8wNQEvgBZ/2SCCf82KtnWitrQ88ADzi814Vb385J8YYF/AKcG+B9Ujy8zr5GqhjrW0KLACm+LxXkp95CQYaApE41Yt3jDFlfdyv4uxMfv+6HvjMWuv2YX/EkZ95GQh8YK2tAfQEpmb8vAlIAduxQmIP4P3XvBoEeAmxGMjXnBhjugBjgD7W2pQC6ltxdqavlelAP5/2SP5uTsoAFwJxxpgdQBtgljZ08Km/fZ1Ya494fc+aDLQooL4VZ/n5/rUH+Mpam2at3Q5sxAlO4htn8jPlerTsrqDkZ15uwrmfD2vtT0AJoGKB9O4fUFD6d5YBDY0xdY0xoTgvxll+7lNx97dzkrGc6G2ckKR15AUjP/Pi/UvFlcDmAuxfcfSXc2KtPW6trWitrZNxo+1SnNeMNnPwnfy8Tqp6fdgHWF+A/Suu8vOz/kugI4AxpiLOUrxtBdrL4iVfv38ZY84DygE/FXD/iqv8zMsuoDOAMeZ8nKB0qEB7eQYUlP4Fa206MAqYh/PD6lNr7VpjzLiMXbswxlyasQ7zWuBtY8xa//W46MvPnOAstQsHZmRsG6pw62P5nJdRGdvqrgDuAaL91N1iIZ9zIgUon3MyOuN1shLnPr4b/dPb4iOf8zIPOGKMWQcsBP7PWnvEPz0u+s7g+9dAYLrVFs8FIp/zci8wIuN72DTgxkCeH20PLvL/7d1ZqJVVGIfx529RIdpgg9lgRrNUhDSZDRYiBAVNBAZhlERE2GwXFWhEeSEVdNFw0UQjDYIFlRUWZRaZpTbRTdFwlRRlNlzE28VehzZfHjscy1P0/G722u+3pu+ci82719rrkyRJkjpcUZIkSZKkDhMlSZIkSeowUZIkSZKkDhMlSZIkSeowUZIkSZKkDhMlSdJmSXJmkkpy8BYc84oko7fUeMORZHqS40Z6HpKk4TFRkiRtrlnAG/QeLrilXAGMeKKUZOtNXJ4OmChJ0n+UiZIkadiSjAGmARfRSZSSzEuyNsnqJAtbbP8kL7fYqiT7tfi1Sd5JsibJghablOSTJA+2+FNJRieZC+wBLEuyrNW9K8nK9jDWBX1z+DzJgjbW2oFVryRjktzfYmuSnN3iM5OsaPWfbPfXvedXk9yS5DXg8iSnJ3k7yXvt3sYnmQRcAlzZHmx9QpJdkzzd7vOdJNP+3v+GJOnvtKlvwiRJ+itnAC9U1adJvk0ypapWJTm1XTumqn5KMq7VfwRYWFWLk2wHjEoyEzgAOBoIsCTJicAXwEHARVW1PMl9wKVVtSjJVcDJVbWu9Xt9VX2bZCvglSSHV9Wadm1dVU1JcilwDTAHuBH4vqoOA0iyU5JdgBuAGVW1Icl1wFXATRu57x2r6qSBtsCxVVVJ5gDzqurqJHcDP1bVolbvUeD2qnojyUR6T68/ZDP//pKkf4iJkiRpc8wC7mjlx9v7VcAM4P6q+gmgJTFjgT2ranGL/QK9VRxgJvBe62cMvcTpC+DLqlre4g8Dc4FFG5nHuUkupve5NgGYDAwkSs+013eBs1p5Bn0rYFX1XZLTWrvlSQC2AVYMct9P9JX3Ap5IMqG1+WyQNjOAya1vgO2TjK2q9YPUlySNIBMlSdKwJNkZOAU4NEkBWwGVZB69laHqNhmsK+DWqrqn0/+kjfTRfU+SfemtFB3VEp4HgO36qvzaXn/jj8+9web3UlXNGmSe/Tb0le8EbquqJUmmA/MHaTMKmFpVPw+hf0nSCPM3SpKk4ToHeKiq9qmqSVW1N73VlOOBpcCFAyfTJRlXVT8AXyU5o8W2bddfbHXHtPieSXZrY0xMMrWVBw6NAFgPjG3l7eklLt8nGQ+cOoS5LwUuG3jTts+9BUxLsn+LjU5y4BD62gH4upVn98X757ixMY8YQt+SpBFioiRJGq5ZwOJO7GngvKp6AVgCrEzyPr0VH4DzgblJ1gBvArtX1VLgUWBFkrXAU/yRYHwMzG71xwF3tfi9wPNJllXVanrb9j4E7gMGtuptys3ATkk+SLKa3u+dvgEuAB5r470FDOXI8/nAk0leB9b1xZ8Fzhw4zIHetsEj2+ERH9E77EGS9C+Vqj/tYpAkacS1rXfPVdWhIzwVSdL/kCtKkiRJktThipIkSZIkdbiiJEmSJEkdJkqSJEmS1GGiJEmSJEkdJkqSJEmS1GGiJEmSJEkdJkqSJEmS1PE7QaZDpZv3DdQAAAAASUVORK5CYII=\n",
- "text/plain": [
- "<Figure size 1008x576 with 1 Axes>"
- ]
- },
- "metadata": {
- "needs_background": "light"
- },
- "output_type": "display_data"
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[[0.01526 0.00628 0.01889946 0.01396761 0.01605884]\n",
- " [0.04178 0.01518 0.04507529 0.05034328 0.04077152]\n",
- " [0.07558 0.02656 0.08102275 0.075079 0.07462003]\n",
- " [0.11526 0.0389 0.12120447 0.12251311 0.11627801]\n",
- " [0.1648 0.05258 0.1714974 0.16779408 0.16470203]\n",
- " [0.21774 0.06782 0.20684378 0.23026316 0.21417139]\n",
- " [0.27726 0.08108 0.27048099 0.29930628 0.27578153]\n",
- " [0.3431 0.08988 0.35903947 0.35946718 0.34240791]]\n",
- "\n",
- "Mean absolute errors:\n",
- "0.10906249999999998\n",
- "0.007329259700714057\n",
- "0.008942559709348354\n",
- "0.0012028047169419824\n"
- ]
- }
- ],
- "source": [
- "f_rates = np.zeros((8, 5))\n",
- "f_sems = np.zeros((8, 5))\n",
- "\n",
- "nIter = 2\n",
- "\n",
- "#npr.seed(0)\n",
- "\n",
- "for r in np.arange(1, 9):\n",
- "\n",
- " print(\"[\", r, \"]\", sep='', end=\" \")\n",
- "\n",
- " s_f_rate_true = np.zeros(nIter)\n",
- " s_f_rate_labeled = np.zeros(nIter)\n",
- " s_f_rate_human = np.zeros(nIter)\n",
- " s_f_rate_cont = np.zeros(nIter)\n",
- " s_f_rate_caus = np.zeros(nIter)\n",
- "\n",
- " for i in range(nIter):\n",
- "\n",
- " print(i, end=\" \")\n",
- "\n",
- " s_train_labeled, s_train, s_test_labeled, s_test, s_df = dataWithoutUnobservables()\n",
- "\n",
- " s_logreg, predictions = fitLogisticRegression(\n",
- " s_train_labeled.dropna().X,\n",
- " s_train_labeled.dropna().result_Y, s_test.X, 0)\n",
- " s_test = s_test.assign(B_prob_0_logreg=predictions)\n",
- "\n",
- " s_logreg, predictions_labeled = fitLogisticRegression(\n",
- " s_train_labeled.dropna().X,\n",
- " s_train_labeled.dropna().result_Y, s_test_labeled.X, 0)\n",
- " s_test_labeled = s_test_labeled.assign(\n",
- " B_prob_0_logreg=predictions_labeled)\n",
- "\n",
- " #### True evaluation\n",
- " # Sort by actual failure probabilities, subjects with the smallest risk are first.\n",
- " s_sorted = s_test.sort_values(by='B_prob_0_logreg',\n",
- " inplace=False,\n",
- " ascending=True)\n",
- "\n",
- " to_release = int(round(s_sorted.shape[0] * r / 10))\n",
- "\n",
- " # Calculate failure rate as the ratio of failures to successes among those\n",
- " # who were given a positive decision, i.e. those whose probability of negative\n",
- " # outcome was low enough.\n",
- " s_f_rate_true[i] = np.sum(\n",
- " s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
- "\n",
- " #### Labeled outcomes\n",
- " # Sort by estimated failure probabilities, subjects with the smallest risk are first.\n",
- " s_sorted = s_test_labeled.sort_values(by='B_prob_0_logreg',\n",
- " inplace=False,\n",
- " ascending=True)\n",
- "\n",
- " to_release = int(round(s_test_labeled.dropna().shape[0] * r / 10))\n",
- "\n",
- " # Calculate failure rate as the ratio of failures to successes among those\n",
- " # who were given a positive decision, i.e. those whose probability of negative\n",
- " # outcome was low enough.\n",
- " s_f_rate_labeled[i] = np.sum(\n",
- " s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
- "\n",
- " #### Human error rate\n",
- " # Get judges with correct leniency as list\n",
- " correct_leniency_list = s_test_labeled.judgeID_J[\n",
- " s_test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
- "\n",
- " # Released are the people they judged and released, T = 1\n",
- " released = s_test_labeled[\n",
- " s_test_labeled.judgeID_J.isin(correct_leniency_list)\n",
- " & (s_test_labeled.decision_T == 1)]\n",
- "\n",
- " # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
- " s_f_rate_human[i] = np.sum(\n",
- " released.result_Y == 0) / correct_leniency_list.shape[0]\n",
- "\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",
- "x_ax = np.arange(0.1, 0.9, 0.1)\n",
- "\n",
- "plt.figure(figsize=(14, 8))\n",
- "plt.errorbar(x_ax,\n",
- " f_rates[:, 0],\n",
- " label='True Evaluation',\n",
- " c='green',\n",
- " yerr=f_sems[:, 0])\n",
- "plt.errorbar(x_ax,\n",
- " f_rates[:, 1],\n",
- " label='Labeled outcomes',\n",
- " c='magenta',\n",
- " yerr=f_sems[:, 1])\n",
- "plt.errorbar(x_ax,\n",
- " f_rates[:, 2],\n",
- " label='Human evaluation',\n",
- " c='red',\n",
- " yerr=f_sems[:, 2])\n",
- "plt.errorbar(x_ax,\n",
- " f_rates[:, 3],\n",
- " label='Contraction, log.',\n",
- " c='blue',\n",
- " yerr=f_sems[:, 3])\n",
- "plt.errorbar(x_ax,\n",
- " f_rates[:, 4],\n",
- " label='Causal model, ep',\n",
- " c='black',\n",
- " yerr=f_sems[:, 4])\n",
- "\n",
- "plt.title('Failure rate vs. Acceptance rate without unobservables')\n",
- "plt.xlabel('Acceptance rate')\n",
- "plt.ylabel('Failure rate')\n",
- "plt.legend()\n",
- "plt.grid()\n",
- "plt.show()\n",
- "\n",
- "print(f_rates)\n",
- "print(\"\\nMean absolute errors:\")\n",
- "for i in range(1, f_rates.shape[1]):\n",
- " print(np.mean(np.abs(f_rates[:, 0] - f_rates[:, i])))"
- ]
- },
- {
- "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": 74,
- "metadata": {
- "scrolled": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[1] 0 1 [2] 0 1 [3] 0 1 [4] 0 1 [5] 0 1 [6] 0 1 [7] 0 1 [8] 0 1 "
- ]
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAHwCAYAAACYFJ/XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xt8zvX/x/HHe8yc5hQq9I0OKmyGzTmbw88h5xxDSEh9VZTiq9LoJEki6eiYUylnSmpzTBjLt4iUFWLOaw4z296/Pz7X9p3ZZsO1XXjeb7fr1nV9Pu/P+/2+Pu9rul7X+2SstYiIiIiIiMj/eOV2BURERERERDyNAiUREREREZE0FCiJiIiIiIikoUBJREREREQkDQVKIiIiIiIiaShQEhERERERSUOBkohcE4wxnxhjhrueNzHGROVylURyjDHmDmPMqUzO5zXGWGNM+ZyrlefWIzOXqqMxpq8xJjxHKyUiHkmBkojkKGNMlDHmrDHmVKpHmUtdZ63ta619PSfqeKWMMa8aY6bldj3S4woyrTHmmVyux13GmGt+I7+cCgystX9YawunKnedMaa3O8sUEbnRKVASkdzQ2lpbONXj75wq2BiTNzev9wC9gOOu/8olXAftfV0yxuTJ7TqIyPVPgZKIeARjjJcxZr4x5pAx5qQxJtwYc1+q858ZY0LTue6iX/RTp00epmeMGW6MOQR87Drexhjzk6usdcaYKhnUKzn/J4wxe4BfXcffM8bsN8b8Y4zZbIyp6zreCnge6O7qLYtwHS9mjJlqjDnoum6UMeaif4ONMbcZY84YY4qmOhZkjDnsqktFY8waY0yMMeaoMWZ2Nu5xYeBB4HGgkjEmIM35BsaYja689xljHnYdL2iMeccY85fr3BpjjI/rXD3XNSeNMZHGmAap8ltnjHnNGLPFdd0CY0xx1+k1rjTJvYpBxpi7jTFhxphjrvc2M8192G+MecYY819XfnOS6+E6/6CrDv8YY/YYY5pm59670r5qjJnnyjsW6GGMqZPqPR40xkwwxninfh/AL6730cGVT1Y/X68ZY95xPfcxxsQZY15Pbi/X66ImVQ+cMeZNoA7wgavM8amybOZ67yeMMRPSK9OVxwV/TybNcNYs3OsBrnKOGWMWGmNuTVNEa2PMXlc7jk6+35l9fo0xlYwxq4wxx40xvybfy1T1nWSM+doYcxr4jzHmQOp2NMZ0MsZsdT3PrM0yrWM69yqzerUyxuw0xsS67tngjO65iFyDrLV66KGHHjn2AKKAJukc9wJ6A75AfuA9YEuq858Boa7nTYAo1/O8gAXKZ5I2AXgdyAcUAIKAaNd/8wB9gN+BfOnUKzn/r4HiQAHX8YeBEq7zQ4EDgI/r3KvAtDT5LAXeBwoCtwARwKMZ3KM1wCOpXr8DvOd6/oWrPC/XfaqXjXv/CLDfde0KYFyqcxWAWKCz6z2VBAJc5z4EvgNudd2v+oA3cBtwDGjmyrM5cBS4yXXdOmAfUAkoBCxMvi/AXc7/gi6oX0WgsaudSgPrgbGpzu8HNrru303AbqCv61xd4KTrei9X3e65jHv/KhAPtHblk/x5qeW6L3e4yh2YyecvO5+vpsA21/MGrnTrU52LSO9+ue5t73Q+p4uAokB5nJ7Di/7W0v6NpP2bysK9bgocBgJwPoPvA9+nqccqnL+X8sCe5LqSwecX5+/+ANDTlUcNnM/WPanqewInQPQCfHD+LWmYqs4LgCGp2uBSbZZRHfsC4Vms1xGgrut5CaB6bv8bq4ceely9h3qURCQ3LHT90nvSGLMQwFqbZK2dZq2NtdbGAaFADWNMoatQXgLOl8J4a+1ZoD/wvrV2s7U20Vo7xZUuKJM8XrfWnnBdj7V2prX2uLU2ARgDFMH5MnsRY0xZnC/wg621Z6y1h4DxQNcMypoNPOS61gvo4joGcB7ni92t1to4a+36rNwAl17AXGttkiu/7uZ/Q8t6AF9baz+31iZYa49aayONM8SpN/CUtfag636ts9aex/nyuNha+42r/b4GfsIJmJJNt9busNaeBkYAXY0xJr3KWWt3W2u/c7XTYZwAMThNsvHW2kPW2mM4AVByr9ijwMeu65Ostfustbsu494DrLPWLnHlc9b1OfnRdV/+AD5Kp16pZefztR6nd68YTqD0EVDBGFPQVcbqTMpJzxvW2hhrbRQQzv/uz+XI6F53Bz6x1ka6/laHAcHGmHKprh3t+nuJAibg+jyT8ee3DbDbWjvDdZ8jcALrjqnyXGCt/cHVLueAufzv76QYTsA+FyCLbZZRHVO7VL3O47Sfr+vfg62XuKcicg1RoCQiuaGdtbaY69EOnDkHxpgxxpg/jDH/4PzCC07PxpWKttbGp3p9OzA0VbB2Eqe3pGwmeexL/cIY87xrGE4Mzi/dhTKp6+04v4BHpypvEnBzBum/AO43xtwMNATirLUbXOeexenN2eIaFpWluUbGGZrYAJjlOrQAKMz/gprbcHoz0roZp4cnvXO3Aw+luY+1gdSLc6S+b3/i3IcSGdTxFmPM564hVf8A07j4nh5K9fyM6z1kVv/s3vu0dcYYc68xZplxhoX+A4xKp15py8zS58sVQG7DaZsGOMHNRpyek8sJlDK6P5cjo7zK4LQlANbaf3D+BlK/v7TtnvyZyOjzeztQL80964Jz39LLE5xgv4NrSF0H4Edr7X7IcptlVMfULlWv9jjB1F/GGS5cK508ROQapUmqIuIpegIPAI1wvrTchDOsJd3eh2TW2gRjzDmcYVXJbuF/gRY4w2xS2weMtNa+mY36peRhjGkIPIPTU7HDdTgmVV3TK+8MUMLVm5N5QdYeM8Z8D3QCqgFzUp07iDM0COPMB/rWGLPGWrv3Etn2dNVvRaoOnXyu40tddfRP57ponKFodwK/pPO+plprH8+k3NtSPf8XcA5nSFixdNK+6TrvZ609bozpCIzNJO+0dbkzg+NZvvcuadvvQ5zgpYu19pQxZgjQKoO0yWVm5/O1Gmfomx/OsMDVQAucYV5rs1jH7DrNxX8zWfU3TgABgDHGF2cI24FUaW4Ddrme/8t1TYafX5x79p21tkUm5V7wnq21240xB3F6krrxv15XyLzNMq1jGpnWy1r7I9DGFaw9jdOjVSGT9yAi1xD1KImIp/DF+ZJ8DOcL3GvZuPYnnGFkeYwxLXHm0GTmI+DfxllAwBhn0nzrbAzz88UZzncU59fxUJwepWTRQPnkIWbW2n04X37HGmOKGGfhirtMqoUP0jEbZ6jcg6T6AmiM6ewaTgbOnBwLJGahzj1xhr4FpHp0wfmSVxxnDkhzY0wH4ywaUdIYU9Vam4jTszPe1eOTxzgLOHgDM4H2xpj/cx3Pb4xpaC5c7r2n69f9QsBI4HNrrcWZ42KNMXekSuuL8wU+xhhzGzAkC+8r2adAX1f5XsaYcsaYey7z3qflixMInzbOAiOPJZ9w3Z9jOPNgkmX387UaZ3jjdtdQznCc4Xu7rbXHM7gmOk2Z2RUJtDTGFDfOQgxPZePaOcCjxhh/4yzw8AawNrk3x+V54yyi8S9X3vMg08/vYqCyMaabMcbb9ahpjLknC3UZjNMDNz/V8Qzb7FJ1TCPDehljCriOF3ENRY0la3+LInKNUKAkIp5iKs4vun/j9FxsyDz5BZ7CGQJzEqcXZnFmiV2/Aj8OTMYZMrQbZ45OVi3HmQj+G86E8n+Ag6nOz8PprTlujNnkOtYDJ5ja4SrzCzL/FX8hziIIf1lrU/fk1AI2G2flr6+Af1tr/wIwxuwyxnRJm5Expj7OsKJJrjknh1xzdRa46t/F1SPVGmei/XFgK04PBzhfRHfi9HYcx1kYw7jmdrQHXsLp/fsLZ2hV6v+3zMQJwg7iLGwwCMBaG4vzBftH15CmQOBloCbOF9zFwJeZ3J8LuIYm9sOZaxIDhPG/3qzs3vu0nsUJWmNxeirSfqF+GZjteh8PXsbnax3OjwPJK+htx5n7sibDK5x5VsnDHsdl470km4bTpn/iLFQyN6sXuuaijcL5/BzE6Y3pnibZEpxgbJsr3TTX8XQ/v9baGJyeoR6uPA/hfD58yNxsnF7ob621J1Idv1SbZVbH1O/1UvXqBfzpGt73KM4iLyJynTDOD3siIiJXlzFmHc6k/2m5XRcREZHsUo+SiIiIiIhIGgqURERERERE0tDQOxERERERkTTUoyQiIiIiIpKGAiUREREREZE0rpsNZ0uWLGnLly+f29VIcfr0aQoVyuqWLJIT1CaeSe3iedQmnknt4nnUJp5J7eJ5PK1NIiIijlprS10q3XUTKJUvX54tW7bkdjVShIeHExISktvVkFTUJp5J7eJ51CaeSe3iedQmnknt4nk8rU2MMX9mJZ2G3omIiIiIiKShQElERERERCQNBUoiIiIiIiJpXDdzlNJz/vx59u/fT1xcXI6XXbRoUXbu3Jnj5Yojf/78lCtXDm9v79yuioiIiIhcg67rQGn//v34+vpSvnx5jDE5WnZsbCy+vr45WqY4rLUcO3aM/fv3U6FChdyujoiIiIhcg67roXdxcXHcdNNNOR4kSe4yxnDTTTflSk+iiIiIiFwfrutACch2kBQyLYSQaSHuqYzkGAXHIiIiInIlrvtAKTcdO3aMgIAAAgICuOWWWyhbtmzK6/j4+KtWzqpVqyhatGhK3gEBAYSFhWU7n4SEBIoVK3bZ9ZgyZQqHDh1Kef3II4+wa9euy85PRERERCS3XNdzlHLbTTfdRGRkJAChoaEULlyYIUOGXJDGWou1Fi+vK4tZGzZsyMKFC68ojys1ZcoUqlevzi233ALA1KlTc7U+IiIiIiKXSz1KuWDPnj1UqVKFAQMGUL16dfbt23dBT87cuXPp27cvANHR0Tz44IMEBgZSs2ZNNm7cmOVynn32WT766KOU1y+++CLvvvsu//zzD40aNaJ69er4+/uzdOnSi65dtWoV7dq1S3k9YMAAPvvsMwBefvllgoKCUt6DtZZ58+YRGRlJly5dUnrM6tevnxIofvbZZ/j5+VGlShWGDx8O/K8Ha9iwYVStWpU6depw+PDhbNxJERERERH3uGF6lAZ9PYjIQ5GXTJecJivzlAJuCWB88/GXVZ8dO3YwdepUPvjgAxISEjJM99RTT/H8889Tu3ZtoqKiaNWqFT///PNF6cLCwggICEh5vXDhQrp27cqwYcPo378/AF988QVhYWEUKFCARYsW4evry+HDh6lXrx6tWrXKct2ffvppRo4cibWWbt268fXXX9OlSxcmTpzIe++9d0E9wFl98MUXX2TLli0ULVqUJk2asHTpUpo3b05MTAzBwcGMHj2aZ555hilTpjBs2LAs10VERERExB1umEDJ09x5550EBQVdMt2qVasumOdz4sQJzp49S4ECBS5Il97Qu/Lly7Nv3z6io6PZv38/t9xyC2XKlCE+Pp6hQ4eybt06vLy82LdvH0ePHs3y/KTvvvuOt956i7i4OI4ePUqNGjVo0aJFhul//PFHGjVqRMmSJQHo1q0ba9asoXnz5hQoUCDl2ho1arB27dos1UFERERExJ1umEApqz0/yT1J4b3D3VcZoFChQinPvby8sNamvE69rLW1lk2bNpEvX77LKqdDhw58+eWXREVF0bVrVwBmzJhBTEwMW7duJW/evJQrV+6ipbTz5s1LUlLSRXU6c+YMAwcOZOvWrZQtW5YXX3zxkstwp35vaaV+X3ny5Mm0d01EREREJKdojpIH8PLyonjx4vz2228kJSWxYMGClHNNmjRh0qRJKa+T5/xkVdeuXZk7dy5fffUVHTp0ACAmJobSpUuTN29evv32Ww4cOHDRdbfffju//PIL8fHxnDhxgu+//x6As2fP4uXlRcmSJYmNjeXLL79MucbX15fY2NiL8qpduzZhYWEcO3aMhIQE5s6dS3BwcLbeh4iIiIhITlKg5CHefPNNmjdvTuPGjSlXrlzK8UmTJrF+/Xr8/f2pVKkSH3/8cbrXJ89RSn4kB1tVq1blyJEjVKhQgdKlSwPw8MMPs2HDBgIDA/niiy+4++67L8qvQoUKtGvXDj8/P3r27En16tUBZyW/Xr16UaVKFdq3b0+tWrVSrnnkkUfo27fvRcuflytXjlGjRhESEkJAQAC1a9emZcuWV37TRERERETcxGQ2LOpaEhgYaLds2XLBsZ07d3LfffdlK5+rNfQuNjYWX1/fK8pDrkza9g8PDyckJCT3KiTpUrt4HrWJZ1K7eB61iWdSu3geT2sTY0yEtTbwUulumDlKWeXuuUkiIiIiIuL5NPROREREREQkDfUoiYiIiIiIe4SEEHDyJGRzQTJPoB4lERERERGRNBQoiYiIiIiIpKFAKa0Q10NERERERG5YCpTcrHDhwllOGxoaytixY92W/+WWkZ6oqChmz559xfmIiIiIiHgiBUpyWRQoiYiIiMj1TIFSLliyZAm1atWiWrVqNGnShOjo6JRzP/30E40aNeLuu+/m448/Tjn+1ltvERQUhL+/Py+//HK6+WaU5rXXXuOee+6hSZMm7Nq1K91r//zzTxo3boy/vz+NGzfmr7/+AqB3797Mnz8/JV1yD9awYcNYu3YtAQEBvPPOOyQmJjJkyBD8/Pzw9/dn4sSJAHz33XdUq1YNPz8/+vTpw7lz5wAoX748w4cPp06dOgQGBrJ161aaNWvGnXfeyQcffJDpezp9+jQtW7akatWqVKlShXnz5mX95ouIiIhIjok8FMmeU3tyuxqX5cZZHnwQkJVVCZPThGQhbQAwPvtVqV+/Phs3bsQYwyeffMKYMWN4++23Adi+fTsbN27k9OnTVKtWjZYtW/Lzzz/z22+/sWnTJqy1tGnThjVr1tCgQYOUPFeuXJlumkKFCjF37ly2bdtGQkIC1atXp0aNGhfVaeDAgfTs2ZNevXoxZcoUnnrqKRYuXJjhexg9ejRjx45l6dKlAEyePJm9e/eybds28ubNy/Hjx4mLi6N379589913VKxYkZ49ezJ58mQGDRoEwG233cYPP/zA4MGD6d27N+vXrycuLo7KlSszYMCADN/TkSNHKFOmDMuWLQMgJiYm+40gIiIiIpKJGydQ8iD79++nS5cuHDx4kPj4eCpUqJByrm3bthQoUIACBQrQsGFDNm3axLp161i5ciXVqlUD4NSpU/z2228XBUrppYmNjaV9+/YULFgQgDZt2qRbpx9++IGvvvoKgIcffpjnn38+W+9p1apVDBgwgLx5nY9UiRIl+Omnn6hQoQIVK1YEoFevXkyaNCklUEqui5+fH6dOncLX1xdfX1/y58/PyZMnM3xP999/P0OGDGHo0KG0atWK+++/P1t1FREREZGcsbhCPBElz7PQWowxuV2dbLlxAqWs9vyEuP4b7p5qADz55JM888wztGnThvDwcEJDQ1POpf0AGWOw1vKf//yHxx57LMM8M0ozfvz4y/pQJl+TN29ekpKSUsqIj4/PsPy05VhrMy3Dx8cHAC8vr5Tnya8TEhIyfd8REREsX76c//znPzRt2pQRI0Zk/c2JiIiIiFtZa3lj3Ru8XPssQQe9OJtwloLeBXO7WtmiOUq5ICYmhrJlywIwffr0C84tWrSIuLg4jh07Rnh4OEFBQTRr1owpU6Zw6tQpAA4cOMDhw4cvuC6jNA0aNGDBggWcPXuW2NhYlixZkm6d6taty9y5cwGYNWsW9evXB5y5RBERESl1O3/+PAC+vr7ExsamXN+0aVM++OADEhISADh+/Dj33nsvUVFR7NnjjEudOXMmwcHBWb5PGb2nv//+m4IFC9KjRw+GDBnC1q1bs5yniIiIiLhXYlIiTyx7ghe+f4FuO/Mydan3NRckwY3Uo5RLzpw5Q7ly5VJeP/PMM4SGhtKpUyfKli1L7dq12bt3b8r5mjVr0rJlS/766y9eeuklypQpQ5kyZdi5cyd16tQBnAUVPvvsM0qXLp1yXdOmTdNNU716dbp06UJAQAC33357hsPUJkyYQJ8+fXjrrbcoVaoUU6dOBaBfv360bduWmjVr0rhxYwoVKgSAv78/efPmpWrVqvTu3Zsnn3yS3bt34+/vj7e3N/369WPgwIFMnTqVTp06kZCQQFBQEAMGDMjyvcvoPe3Zs4fnnnsOLy8vvL29mTx5cpbzFBERERH3OXP+DN2+7MaiXYuYXKQbfebPwdgEOHMGCl5bwZK51PCoa0VgYKDdsmXLBcd27tzJfffdl72MQlz/Db+y+sTGxuLr63tlmcgVSdv+4eHhhISE5F6FJF1qF8+jNvFMahfPozbxTGqX3HP0zFFaz2nNj/s2svZYW+pNXgr58vHPbbdRJIOVl3ODMSbCWht4qXTqUUorPLcrICIiIiJybdl7Yi/NZzUn5mAU+38IokzYIujYEQ4eJMk1jeJaozlKIiIiIiJy2bYe3EqdT+tQZtdBombeRJm12+Ddd+HzzyHvtdsvc+3WXEREREREctU3e76h4+cdeHJbPl5dHIdX6aKwZg245phfyxQoiYiIiIhItk2PnM7T8x9l7re+tNx0Apo1g88+g5Ilc7tqV4UCJRERERERybLkPZI+m/sCPy0syL8OxsArr8Dw4eB1/czsUaCUVvIqKeHhuVkLERERERGPk5iUyMDlA4mZ+gFbl+XBp0ghzMpF0KRJblftqrt+Qj4PVbhw4QteT5s2jYEDB+ZSbdwjJCSEtEuzZ1V4eDgbNmxIef3BBx8wY8aMq1U1EREREblKzpw/Q5dZ7fAb+QGzvwKfoDqYbduuyyAJ1KMkuSw8PJzChQtTt25dgGxtSCsiIiIiOePomaP0n/B/DJ8QSeBB4LnnMK+9Bt7euV01t1GPUi7q3bs38+fPT3md3PsUHh5OcHAwnTt3pmLFigwbNoxZs2ZRs2ZN/Pz8+P333wFYsmQJtWrVolq1ajRp0oTo6GgAQkND6dOnDyEhIdxxxx1MmDAh3fJXrlxJnTp1qF69Op06deLUqVOsWLGCzp07p6QJDw+ndevWADz++OMEBgZSuXJlXn755XTzTN2DNn/+fHr37p1hXaOiovjggw945513CAgIYO3atYSGhjJ27FgAIiMjqV27Nv7+/rRv354TJ04ATg/W0KFDqVmzJhUrVmTt2rXZvvciIiIikjV7T+zlpcFV+XRkJP6nCsLChTBmzHUdJMGN1KM0aBBERl46XXKarOzoHBAA48dnmuTs2bMEBASkvD5+/Dht2rS5ZNY//fQTO3fupESJEtxxxx307duXTZs28e677zJx4kTGjx9P/fr12bhxI8YYPvnkE8aMGcPbb78NwK+//kpYWBixsbHcc889PP7443in+jAfPXqUV199lVWrVlGoUCHefPNNxo0bx/Dhw3nsscc4ffo0hQoVYt68eXTp0gWA1157jRIlSpCYmEjjxo3Zvn07/v7+l75PkGFdBwwYQOHChRkyZAgA3333Xco1PXv2ZOLEiQQHBzNixAhGjhzJeNf9TkhIYNOmTSxfvpyRI0eyatWqLNVDRERERLJu675NbOjZkMnhZzhV+W7yLf4a7rgjt6uVI26cQCmXFChQgMhUAdq0adOyNJ8nKCiIW2+9FYA777yTpk2bAuDn50dYWBgA+/fvp0uXLhw8eJD4+HgqVKiQcn3Lli3x8fHBx8eH0qVLEx0dTbly5VLOb9y4kR07dlCvXj0A4uPjqVOnDnnz5qV58+YsWbKEjh07smzZMsaMGQPA559/zkcffURCQgIHDx5kx44dWQ6UMqtremJiYjh58iTBwcEA9OrVi06dOqWcf/DBBwGoUaMGUVFRWaqDiIiIiGRd+PrZePd4mIFRSZzo2ZniH06H/PmzmUk4keHhhLilhu514wRKl+j5SZGDq97lzZuXpKQkwFlmMT4+PuWcj49PynMvL6+U115eXiQkJADw5JNP8swzz9CmTRvCw8MJDQ1N9/o8efKkXJPMWsv//d//MWfOnIvq1aVLFyZNmkSJEiUICgrC19eXvXv3MnbsWDZv3kzx4sXp3bs3cXFxF11rjEl5nvp8ZnW9HMnvL733JiIiIiJX5puPhhLwzBiKnPfixEcTKN7vydyuUo7THKVcVL58eSIiIgBYtGgR58+fz9b1MTExlC1bFoDp06dn69ratWuzfv169uzZA8CZM2fYvXs34MwB2rp1Kx9//HHKsLt//vmHQoUKUbRoUaKjo1mxYkW6+d58883s3LmTpKQkFixYcMm6+vr6Ehsbe1E+RYsWpXjx4inzj2bOnJnSuyQiIiIi7mETEwnv9380GTCGuCIFSdy44YYMkkCBUq7q168fq1evpmbNmvz4448UKlQoW9eHhobSqVMn7r//fkpmcwfkUqVKMW3aNB566CH8/f2pXbs2v/76K+D00rRq1YoVK1bQqlUrAKpWrUq1atWoXLkyffr0SRmyl9bo0aNp1aoVjRo1Shk6mFldW7duzYIFC1IWc0ht+vTpPPfcc/j7+xMZGcmIESOy9R5FREREJOsSjxzml1oVCPlkFT/Wu51bd+6jcLVauV2tXGOstbldh6siMDDQpp37s3PnTu67777sZXSVht7Fxsbi6+t7RXnIlUnb/uHh4YRkZZEOyVFqF8+jNvFMahfPozbxTGqXyxO3fjWxbVtQ5ORZlv+7KW3fWY6XV56rkrentYkxJsJaG3ipdOpRSis8PEfmJ4mIiIiI5DprOfX2G+QJbsipxLMs+vQ52r/7zVULkq5lN85iDiIiIiIi8j///MOpng9ReNFylt3jRdK0aXSu3TO3a+Ux3NqjZIxpbozZZYzZY4wZls75AcaY/xpjIo0x64wxlVKd+4/rul3GmGburKeIiIiIyA3lv/8lrpofBRYvJ7R5AYp+HUZrBUkXcFugZIzJA0wCWgCVgIdSB0Ius621ftbaAGAMMM51bSWgK1AZaA6878pPRERERESuxPTpJNYM4uSRfTz0RGm6zIigfvkGbikqIgIWL7710gk9kDt7lGoCe6y1f1hr44G5QNvUCay1/6R6WQhIXlmiLTDXWnvOWrsX2OPKT0RERERELsfZs9C3L/TuzZpb4+n+wn2Mf2Mb95XK5uJnWfTtt1CrFkyadBenT7ulCLdy5xyn/eviAAAgAElEQVSlssC+VK/3AxetL2iM+TfwDJAPaJTq2o1pri2bzrX9gf7g7N8TnmYRhqJFi6a7R09mHnigAADLl5/N1nVpJSYmZrtsubri4uIu+EycOnXqos+I5D61i+dRm3gmtYvnUZt4JrVL+grs30+l0FB8f/+d1+6HRe0CeNn/FXZH7GY3u696ed9+W5o337yX8uXPMGLED2ze7H3Vy3A3dwZKJp1jF61Fbq2dBEwyxnQDXgR6ZePaj4CPwFkePO2ygzt37sz2Et15XAP8rnRp7+TlwQ8dOsSgQYPYvHkzPj4+lC9fnvHjx1OxYsVs5zl+/Hj69+9PwYIFr6huAFFRUWzYsIFu3boBsGXLFmbMmMGECROuOO/UQkJCGDt2LIGBl1yB8arLnz8/1apVS3ntaUtTikPt4nnUJp5J7eJ51CaeSe2Sjq++wv7735y253igG5To0J11baeQL0++q16UtfD22/D669CoEXz1VWG2bfO+JtvEnUPv9gO3pXpdDvg7k/RzgXaXea1HstbSvn17QkJC+P3339mxYwevv/460dHRl5Xf+PHjOXPmTLrnEhMTs5VXVFQUs2fPTnkdGBh41YMkEREREclF8fEweDB06MBvpbyo/Og5/B8Zyoz2M9wSJCUlwbPPwnPPQZcusHw5FC161YvJMe4MlDYDdxtjKhhj8uEszrA4dQJjzN2pXrYEfnM9Xwx0Ncb4GGMqAHcDm9xYV7cICwvD29ubAQMGpBwLCAjg/vvvx1rLc889R5UqVfDz82PevHnA/34F6dixI/feey/du3fHWsuECRP4+++/adiwIQ0bNgSgcOHCjBgxglq1avHDDz8watQogoKCqFKlCv379yd5M+E9e/bQpEkTqlatSvXq1fn9998ZNmwYa9euJSAggHfeeYfw8HBatWoFwPHjx2nXrh3+/v7Url2b7du3AxAaGkqfPn0ICQnhjjvuyHZgNWfOHPz8/KhSpQpDhw5NOf7pp59SsWJFQkJC6NevHwMHDrz8my4iIiIisG8fhITA+PF83ugW/B46yXMPTWR0k9F4masfApw7B927wzvvwKBBMHs2+Phc9WJylNuG3llrE4wxA4FvgDzAFGvtL8aYUcAWa+1iYKAxpglwHjiBM+wOV7rPgR1AAvBva232ukzSGDQIIiMvnS45TVZ6BwMCYPz4jM///PPP1KhRI91zX331FZGRkfz0008cPXqUoKAgGjRwVhvZtm0bv/zyC2XKlKFevXqsX7+ep556inHjxhEWFkbJkiUBOH36NFWqVGHUqFEAVKpUiREjRgDw8MMPs3TpUlq3bk337t0ZNmwY7du3Jy4ujqSkJEaPHs3YsWNZunQpwAVjeV9++WWqVavGwoUL+f777+nZsyeRrhvz66+/EhYWRmxsLPfccw+PP/443t6XHnP6999/M3ToUCIiIihevDhNmzZl4cKF1KxZk1deeYWtW7fi6+tLo0aNqFq16iXzExEREZEMfPMNdO9O0rk4nul9Kx/ceZw5Hb7kwfsedEtx//wD7dvD99/DW285vUomvYk01xi3bjhrrV0OLE9zbESq509ncu1rwGvuq13uWrduHQ899BB58uTh5ptvJjg4mM2bN1OkSBFq1qxJuXLlAKcHKioqivr161+UR548eejQoUPK67CwMMaMGcOZM2c4fvw4lStXJiQkhAMHDtC+fXvAmbeTlbp9+eWXADRq1Ihjx44RExMDQMuWLfHx8cHHx4fSpUsTHR2dUtfMbN68mZCQEEqVKgVA9+7dWbNmDQDBwcGUKFECgE6dOrF799WfUCgiIiJy3UtMhFGj4JVXOHvPHTRpfZKdN8Wx6qFV1P/Xxd8lr4aDB+GBB+Dnn2HmTOjRwy3F5Aq3BkqeJLOen9SSe5KuxmIplStXZv78+emeSx4Wlx6fVP2UefLkISEhId10+fPnJ49r9Ym4uDieeOIJtmzZwm233UZoaChxcXGZlpOR9K4xrp8Fslq3rOSZ2XERERERyYbDh52xb6tWcaB9E6pV/YECRW9iffev3bb8965d0Lw5HDkCy5ZB06ZuKSbXuHOO0g2vUaNGnDt3jo8//jjl2ObNm1m9ejUNGjRg3rx5JCYmcuTIEdasWUPNmplvFeXr65vhkuNxcXEAlCxZklOnTqUEaEWKFKFcuXIsXLgQgHPnznHmzJlM82rQoAGzZs0CnCF5JUuWpEiRIpnWrXHjxhw4cCDD87Vq1WL16tUcPXqUxMRE5syZQ3BwMDVr1mT16tWcOHGChISElJ4sEREREcmi9euhWjVYu5YNLz1C+YAwytx8Fz88+oPbgqQff4R69eD0aaeD4XoLkkCBklsZY1iwYAHffvstd955J5UrVyY0NJQyZcrQvn17/P39qVq1Ko0aNWLMmDHccsstmebXv39/WrRokbKYQ2rFihWjX79++Pn50a5dO4KCglLOzZw5kwkTJuDv70/dunU5dOgQ/v7+5M2bl6pVq/LOO+9ckFdoaChbtmzB39+fYcOGMX369EzrlZSUxJ49e1KGz6Xn1ltv5Y033qBhw4Ypi0q0bduWsmXLMnz4cGrVqkWTJk2oVKkSRV3LoyxevDhlzpWIiIiIpJG8FndwMLZAAT55vy/18kwluHwIax5ZQxnfMm4pdtkyZ+nvYsVgwwbIhV1gcoa19rp41KhRw6a1Y8eOi45dSnCw87hS//zzz5Vnco3473//awcPHnzZ18fGxlprrT1//rxt1aqV/eqrr65KvdK2f1hY2FXJV64utYvnUZt4JrWL51GbeKYbpl1OnLC2XTtrwSa1a2cHzX3EEort/mV3ey7hnNuKnTLF2jx5rK1Rw9ro6Kxd42ltgrOw3CXjixtmjlJWaSPn7KtSpQrjxo277OtDQ0NZtWoVcXFxNG3alHbt2l36IhEREZEb1bZt0LEj/PUX8WPeoHO5H1j061SG1hvK641fd8vy39Y6m8i++KIzzO7LL6Fw4atejEdRoCS5buzYsbldBRERERHPZy18/DE89RSULMnJbxbRYu8r/Lj7Rya2mMjAmu7ZizIx0Sny/fedVe0+/RTyXf39aj2O5iiJiIiIiHi606ehVy947DEIDubPsIXU2jGYbQe3Mb/zfLcFSXFx0LmzEyQ9/zxMn35jBEmgHiUREREREc/266/OULsdOyA0lK2PPsADc1sRnxjPqp7u2yPp5Elo2xbWrnW22nk6wx1Qr08KlEREREREPNXcudCvH+TPD998wzcVkug4sxElCpQgrFeY25b/3r8fWrSA3bthzhzo0sUtxXg0Db1LIyQkhJDkXWdFRERERHLDuXMwcCA89BD4+8O2bUwv9Tet5rTizuJ3unWPpB07oG5d+PNPWLHixgySQIGS2x06dIiuXbty5513UqlSJR544AF2797t9nLDw8Np1aqVW8uIioqiSpUqV5xGRERERFKJioL774dJk+DZZ7FhYby+dwa9F/Um+PZgt+6RtH491K8P58/DmjXOfkk3Kg29cyNrLe3bt6dXr17MnTsXgMjISKKjo6lYsWIu105EREREPM6yZfDww85Sc19+SWK7tjy54kkmb5lMd7/uTGk7hXx53LOawsKFTgfWv/4F33wD5cu7pZhrhnqU3CgsLAxvb28GDBiQciwgIID777+fU6dO0bhxY6pXr46fnx+LFi0CLu6BGTt2LKGhoQBMmDCBSpUq4e/vT9euXQHYtGkTdevWpVq1atStW5ddu3ZlWqdp06bRrl07WrduTYUKFXjvvfcYN24c1apVo3bt2hw/fhxwArratWvj7+9P+/btOXHiBAARERFUrVqVOnXqMGnSpJR8ExMTee655wgKCsLf358PP/wwW/fqs88+o2bNmgQEBPDYY4+RmJgIQOHChXn22WepXr06jRs35siRI9nKV0REROSakJAAw4dDq1Zw++0QEcHZ1i3o+EVHJm+ZzNB6Q5nRfobbgqQPP4QOHaBqVadX6UYPkuAG6lEaNGgQkZGRl0yXnCYr85QCAgIYP358hud//vlnatSoke65/Pnzs2DBAooUKcLRo0epXbs2bdq0ybS80aNHs3fvXnx8fDh58iQA9957L2vWrCFv3rysWrWK4cOH8+WXX2aaz88//8y2bduIi4vjrrvu4s0332Tbtm0MHjyYGTNmMGjQIHr27MnEiRMJDg5mxIgRjBw5kvHjx/PII4+kHH/uuedS8vz0008pWrQomzdv5ty5c9SrV4+mTZtijMm0LgA7d+5k3rx5rF+/Hm9vb5544glmzZpFz549OX36NNWrV+ftt99m1KhRjBw5kvfee++SeYqIiIhcMw4dgq5dYfVqZ+GGd9/lmD1D6xmN2bh/o1v3SLIWQkNh1Cho2RLmzYNChdxS1DXnhgmUPI21luHDh7NmzRq8vLw4cOAA0dHRmV7j7+9P9+7dadeuHe3atQMgJiaGXr168dtvv2GM4fz585csu2HDhvj6+uLr60vRokVp3bo1AH5+fmzfvp2YmBhOnjxJcHAwAL169aJTp04XHX/44YdZsWIFACtXrmT79u3Mnz8/pV6//fZbloYYfvfdd0RERBAUFATA2bNnKV26NABeXl50cc0g7NGjBw8++OAl8xMRERG5ZoSHO+PdYmKcTYp69mTvib20mNWCqJNRzO88nwfvc8/3n4QEePxx+OQT6NPH6VXKq+ggxQ1zKzLr+UktuScpPDz8isusXLlySuCQ1qxZszhy5AgRERF4e3tTvnx54uLiyJs3L0lJSSnp4uLiUp4vW7aMNWvWsHjxYl555RV++eUXXnrpJRo2bMiCBQuIiorKUk+Yj49PynMvL6+U115eXiQkJGR4nbU2wx4iay0TJ06kWbNmFxyPioq6ZH2stfTq1Ys33njjkmmz0kMlIiIi4vGSkuDNN+HFF+Huu2HlSvDzY+vBrTww6wG375F05ozTibVkiVOFUaNAX7MupDlKbtSoUSPOnTvHxx9/nHJs8+bNrF69mpiYGEqXLo23tzdhYWH8+eefANx8880cPnyYY8eOce7cOZYuXQpAUlIS+/bto2HDhowZM4aTJ09y6tQpYmJiKFu2LODMP7oaihYtSvHixVm7di0AM2fOJDg4mGLFilG0aFHWrVsHOMFesmbNmjF58uSUHq3du3dz+vTpC/I9cOAAjRs3vqi8xo0bM3/+fA4fPgzA8ePHU+5HUlJSSrA5e/Zs6td3zz8WIiIiIjnm+HFo08aZk9SpE2zeDH5+rPx9JcHTgvHJ68P6PuvdFiQdOwZNmsDSpfD++/DKKwqS0nPD9CjlBmMMCxYsYNCgQYwePZr8+fNTvnx5xo8fT+XKlWndujWBgYEEBARw7733AuDt7c2IESOoVasWFSpUSDmemJhIjx49iImJwVrL4MGDKVasGM8//zy9evVi3LhxNLqK6zdOnz6dAQMGcObMGe644w6mTp0KwNSpU+nTpw8FCxa8oPeob9++REVFUb16day1lCpVioULF16Q58GDB8mbTn9upUqVePXVV2natClJSUl4e3szadIkbr/9dgoVKsQvv/xCjRo1KFq0KPPmzbtq71FEREQkx23e7ARHf/8N770HTzwBxjDjpxk8uvhRKpeqzPLuy922/Peff0Lz5rB3L8yfD5rVkDFjrc3tOlwVgYGBdsuWLRcc27lzJ/fdl72NuK7W0LvY2Fh8fX2vKI/rzXvvvce//vWvSy5akVrhwoU5derUZZWXtv3Dw8O1mbAHUrt4HrWJZ1K7eB61iWfy2Hax1um+GTwYbr0VvvgCatbEWssb697ghe9foHGFxnzV5SuK+BRxSxW2b4cWLZxhd4sXO1s15QRPaxNjTIS1NvBS6dSjlMbVmJsk6Rs40D2rtYiIiIh4tNhY6N8f5s6FBx6AGTPgpptITErMsT2SwsOhbVvw9YW1ayHVbjSSAc1REo92ub1JIiIiIh7h558hKAg+/xxef91ZPeGmmzh7/myO7ZH0xRfQrBmUKwc//KAgKavUoyQiIiIi4g4zZ8Jjj0GRIrBqFTRsCMCxM8doPae12/dIApg4EZ5+GurVg0WLoEQJtxV13bnue5SulzlYkj1qdxEREck1cXHOULuePaFmTdi2LSVI2ntiL/Wm1GPrwa3M7zzfrRvJ/uc/8NRT0K6ds/q4gqTsua4Dpfz583Ps2DF9ab7BWGs5duwY+fPnz+2qiIiIyI3m99+hbl34+GMYNszpSbr1VgC2HtxKnU/rcPj0YVb1XOW2jWTPn4fevWH0aBgwwBl6V6CAW4q6rl3XQ+/KlSvH/v37OXLkSI6XHRcXpy/quSh//vyUK1cut6shIiIiN5KFC50IxcvLmYvUqlXKqZW/r6TD5x0oUaAEYb3CuK9U9lZmzqpTp5zVx7/+2tkf6YUXtEfS5bquAyVvb28qVKiQK2WHh4dTrVq1XClbRERERHLQ+fPOOLe334bAQKcLp3z5lNM5tUfSkSPQsiVERDgdWn37uqWYG8Z1HSiJiIiIiLjVgQPQpQusX+9sHjtuHPj4AOToHkl//OGsbHfggNOx1bq1W4q5oShQEhERERG5HKtWQbduzg6us2fDQw+lnMrJPZK2bnW2Zzp/Hr7/HmrXdksxN5zrejEHEREREZGrLjERRo6Epk2hVCnYvPmCICkn90j69lsIDob8+Z1OLQVJV496lEREREREsurIEejRw1lvu0cP+OADKFQo5XRO7pE0a5azdkSlSrBiBZRxz9SnG5YCJRERERGRrNiwATp3hqNH4cMPoV+/C5aU23tiLy1mtSDqZBTzO8932/Lf4KwbMWQIhIQ4c5KKFnVbUTcsDb0TEREREcmMtfDOO84Yt3z5nICpf/8LgqSc2iMpKQmefdYJkjp3dpYBV5DkHgqUREREREQyEhMDHTvCM884a29v3QrVq1+QZOXvKwmeFoxPXh/W91lP/X/Vd0tV4uOd0X7jxsFTT8GcOSkL7IkbKFASEREREUlPZKSzL9KiRfDWW7BgARQrdkGSGT/NoOXsltxZ/E5+ePQHt20k+88/zsp2c+bAm2/C+PHOvrbiPpqjJCIiIiKSmrUwZQoMHAglSkB4ONSvnyZJzu2RdOgQtGgBP/8M06dDz55uKUbSUKAkIiIiIpLszBln49jp06FxY2d/pNKlL0iSk3sk7d4NzZvD4cOwZInzXHKGAiUREREREXCiko4dna6bl16Cl1+GPHkuSHL2/Fm6fdWNhb8uZGi9obze+HW8jHvGwG3a5EyLMsbp1AoMdEsxkgEFSiIiIiIin38Ojz7qrI6wYgU0a3ZRkpzcI2n5cujUCW65Bb75Bu66y21FSQY0BUxEREREblzx8c4Scl26QJUqsG1bukHS3hN7qTelHlsPbmV+5/luDZKmTYM2beDee52VyBUk5Q4FSiIiIiJyY/rrL2jQACZOhEGDYPVquO22i5Ll1B5J1sIbb8Ajj0CjRs5wu5tvdktRkgUaeiciIiIiN54VK5xNic6fh/nzoUOHdJOt/H0lHT7vQIkCJQjrFea25b8TE51Y7b33oHt3Z9G9fO5ZH0KySD1KIiIiInLjSEyEF190NiUqVw4iIjIMknJqj6S4OOja1QmSnnsOZsxQkOQJ1KMkIiIiIjeG6Gjo1g2+/x769HEikwIFLkqWk3sknTwJbdvCmjUwbhwMHuyWYuQyKFASERERkevfmjVOt82JE864tkceSTdZTu6RdOCAsy/Srl0wZ45TPfEcGnonIiIiItevpCQYM8ZZHaFwYfjxxwyDpLPnz9Lxi45M3jKZofWGMqP9DLcFSTt3Qp068OefznQpBUmeRz1KIiIiInJ9CAkh4ORJiIx0Xp84Ab16wZIlzkayn34KRdIfQpeTeyRt2ACtWjlbNq1ZAwEBbitKroACJRERERG5/kREOMHRgQPw7rvw5JNgTLpJ957YS4tZLYg6GcX8zvPdtvw3wKJFTu/Rbbc5G8lWqOC2ouQKaeidiIiIiFw/rIXJk6FuXWeFuzVrnA1lMwiScmqPJICPPoIHHwR/f1i/XkGSp1OgJCIiIiLXh8RECv71FzzxhDMnads2qF07w+Qrf19J8LRgfPL6sL7Peur/q75bqmUtjBwJjz3mLN7w/fdQqpRbipKrSIGSiIiIiFz7/vgDtm7F++RJePVVWLYMbropw+Q5tUdSQgIMGAChoc4aEgsXQqFCbilKrjIFSiIiIiJybfvxR6fnKD6e03fcAS+8AF7pf8211vL62tfptbAXwbcHs+aRNZTxLeOWap054+xl+9FHTpU+/RS8vd1SlLiBWwMlY0xzY8wuY8weY8ywdM4/Y4zZYYzZboz5zhhze6pzicaYSNdjsTvrKSIiIiLXqAULICQEfH2hWjUSfH0zTJqYlMi/l/+bF75/ge5+3VnefbnbNpI9fhz+7/+cBfcmTXI6uTKYJiUeym2BkjEmDzAJaAFUAh4yxlRKk2wbEGit9QfmA2NSnTtrrQ1wPdq4q54iIiIicg2yFt55x+myqVoVfvgBChbMMHlO7pH0119Qv76z8N4XXzhTpuTa487lwWsCe6y1fwAYY+YCbYEdyQmstWGp0m8EerixPiIiIiJyPUhMhEGD4L33nGXkPvsMChTIMHlO7pH03/86CzacPg0rV0KDBm4rStzMnUPvygL7Ur3e7zqWkUeBFale5zfGbDHGbDTGtHNHBUVERETkGnP6NLRv7wRJzz7rdNlkEiTtPbGXelPqsfXgVuZ3nu/WIGn1arj/fmeI3dq1CpKudcZa656MjekENLPW9nW9fhioaa19Mp20PYCBQLC19pzrWBlr7d/GmDuA74HG1trf01zXH+gPcPPNN9eYO3euW97L5Th16hSFCxfO7WpIKmoTz6R28TxqE8+kdvE8apOcl+/YMfyGD6fwnj38NnAgf7dvf1Ga1O2yO3Y3w/47jASbwGtVXsOvqJ/b6rZ6dSlee+0+ypQ5y5gx2yld+pzbyrrWeNrfSsOGDSOstYGXSufOoXf7gdtSvS4H/J02kTGmCfACqYIkAGvt367//mGMCQeqARcEStbaj4CPAAIDA21ISMjVfQdXIDw8HE+qj6hNPJXaxfOoTTyT2sXzqE1y2C+/QK9ecPQoLFpExVatqJgmSci0EE6ePEnkoEhW/r6SZz9/lhIFS/B196/dtvw3OJ1bI0c6e9wuXlyIEiXquK2sa9G1+rfizqF3m4G7jTEVjDH5gK7ABavXGWOqAR8Cbay1h1MdL26M8XE9LwnUI9XcJhERERG5gXz/PdSrB/HxsGYNtGqVafKc2iPJWmfZ7yefhDZt4NtvoUQJtxQlucBtgZK1NgFnON03wE7gc2vtL8aYUcaY5FXs3gIKA1+kWQb8PmCLMeYnIAwYba1VoCQiIiJyo5k+HZo1g3LlYONGqFEjw6TWWqLjonNkj6Tz56FPH3j9dejfH+bPz3SqlFyD3Dn0DmvtcmB5mmMjUj1vksF1GwD3DSIVEREREc9mrTOebeRIaNzYiUSKFcsw+fnE8+w5vodD5w7R3a87U9pOcdvy36dPQ6dOsGKFU72XXtIeSdcjtwZKIiIiIiLZFh8PffvCzJnQuzd8+CHkyzjoiT4VTef5nfn71N+U8inFjPYz8DLuGTh15Ai0bOnskfTxx0415fqkQElEREREPMeJE84msmFhMGoUvPhipt01G/ZtoNMXnThx9gT3lrwXn/M+bguS/vjD2SNp3z5YsMCZlyTXL3cu5iAiIiIiknVRUc6iDevWOb1JmYxps9YyadMkQqaFUCBvATb23cjNhW52W9W2bXNWtTt2DL77TkHSjUA9SiIiIiKS+7ZscVazO3cOVq6ETJaTPnP+DAOWDmDm9pm0qtiKme1nUix/xvOXrtSqVfDgg1C8uNPRdZ/7VhoXD6IeJRERERHJXYsWQXCws2zchg2ZBkl/nPiDup/W5bPtnzEqZBSLui5ya5A0Zw488ACULw8//KAg6UaiHiURERERyT0TJsCgQRAYCEuWwM0ZD59b8dsKun/VHYBl3ZbR4u4WF5wP7x1OeHj4VavauHHw7LNODLdwYaaL7sl1SD1KIiIiIpLzEhOdAOnpp50JP+HhGQZJSTaJkeEjaTm7JbcXu50t/bdcFCRdTUlJMGSIEyR17Ahff60g6UakHiURERERyVlnzkD37k43zdNPw9tvQ5486SY9cfYEDy94mGW/LaNn1Z5MbjmZgt4F3Va1+Hh45BGYPRsGDoTx4zOsmlznFCiJiIiISM6JjobWrZ3FG8aPdwKlDGyP3s6D8x7kr5i/eP+B9xkQOADjxp1dY2OdRRtWrYI33oChQ7WR7I1MgZKIiIiI5IydO52VEaKjnY2I2rbNMOms7bPot6QfxQsUZ3Xv1dS5rY5bq3bokFO17dth2jTo1cutxck1QIGSiIiIiLhfeDi0bw/58sHq1RAUlG6y+MR4hqwcwsRNEwm+PZh5Hedxc2H37Y8E8Ntv0KyZE78tWQIt3Df9Sa4hCpRERERExL0++wz69IG77oLly521ttNxMPYgnb7oxPp963mm9jOMbjIa7zzebq3a5s1OTxI4eyTVrOnW4uQaolXvRERERMQ9rIVXXoGHH4Z69WD9+gyDpHV/raP6R9WJPBTJ3A5zebvZ224Pkr7+2tmyydfX2b5JQZKkpkBJRERERK6+8+fh0UdhxAgnUPrmGyhe/KJk1lom/DiBhtMb4pvPlx/7/kiXKl3cXr3p0501Je65xwmS7r7b7UXKNUaBkoiIiIhcXTExzni2qVPh5ZedqCRfvouSnY4/TY8FPXj666dpeXdLNvfbTOXSld1aNWth9Gjo3dvpTVq9Gm65xa1FyjVKc5RERERE5Or5809o2RJ27cp0+bg9x/fw4LwH+fnwz7zW6DWG1R+Gl3Hvb/iJiTB4MEycCN26OXFcOvGbCKBASURERESulogIaNUKzp51JgA1bpxusiW7lmqFpIsAACAASURBVPDwgofJ45WHr3t8TdM7m7q9anFx0LMnfPEFPPssjBkDXhpb5XYhISGcPHmSyMjI3K5KtunjISIiIiJXbulSaNDA6aJZvz7dICkxKZGXvn+JNnPbcFeJu4joH5EjQVJMjLPk9xdfwNtvw9ixCpJykrU2t6twWdSjJCIiIiJX5v334cknISDACZhuvfWiJMfPHuf/2bvv+Brv/o/jr0sQmw6jLW21VR16K0XtxqraasQqam9BrdoUrdWYtVdqx95brJpBqb1iK0LEzPz+/rjc/WnvlrR1zpXxfj4eHhLnnFzv3gd33r7f6/Ots7AOq0+tpuGHDRlTbgzJEidzebRLl+ySdOwYzJoFtWq5/JLySGRkJGfOnOHmzZtERkaSOHHcqh7q0iIiIiLyz0RHQ8eO0KqVPbxh8+Y/LUn7r+wnz4Q8bDy7kfHlxzOp4iS3lKSjR6FgQTh71j6+SSXJfa5evUrJkiW5cOECyZIlIzo62ulIf1vcqnUiIiIiEjs8eGCP/V6wwC5KI0aAh8f/PG36gek0X9GcF1O8yNYGW8n3insOK9qxw75dKkkS2LIFcuVyy2UF2LZtG97e3oSEhPDOO+/g6elJ0jg4NUMrSiIiIiLy91y7BsWLw8KF8P339hi5P5Sk8KhwWq5oyZdLvqRA5gIENg10eUny8oJ27T5k2TL7FqkXXrDPSFJJcg9jDL6+vnh5eZEyZUp27dpFxowZnY71j2lFSURERERi7vhxe5vd5cswfz5UqfI/T7kUeolq/tXYeXEnnQt2ZkCJASRO5J5vO4ODk1K5Mnz0EaxYAenTu+WyCV5oaCiNGjVi/vz5fP7550ydOpW0adMSEBBAQECA0/H+ERUlEREREYmZrVuhUiVInBgCAuDjj//nKZuDNuM935v7EfeZX30+Vd+r6pZoxkBQEFy8mOK3CXcpU7rl0gne4cOHqVq1KqdOnWLIkCF89dVXWJbldKx/TVvvREREROTpZs+GkiUhQwbYufN/SpIxhu93fE8JvxI8l+w5djfe7baSFBYGX35pn3X73HPhLFmikuQus2bNIl++fISEhLBhwwY6duwYL0oSqCiJiIiIyJMYA99+C7VrQ/789k0/b7zxu6fcDb9LzQU1+WrtV1R+pzK7m+zm3fTvuiXejRt2f/Pzg9dfhyxZ7pMkiVsunaCFh4fTpk0b6tSpQ+7cudm/fz+ffPKJ07GeKRUlEREREflzERHQpAl062YXpbVr4fnnf/eU4zeO8/Gkj5l/ZD6DSg7Cv7o/aTzTuCXe0aP2wtbevTBnDrz2GsSTxYxY7cKFCxQtWpTRo0fz1VdfsXHjRl76k7HwcZ2KkoiIiIj8r9BQKFcOJk+GHj1gxgzw9PzdUxYfW0zeiXm5du8aa79YS+dCnd227WrdOihQAO7ds2+XqlHDLZdN8NavX0/u3Lk5cuQI/v7+DB06lCTxdAlPRUlEREREfu/CBShcGDZuhEmT4JtvfrdUExUdRbcN3fh87ue88+I7BDYNpMQbJdwWb9w4KFMGXn0Vdu36/9ulAgJg+PADbsuRkERHRzNgwAA+/fRTMmbMyJ49e6hWrZrTsVxKU+9ERERE5P8dOGCvJN25AytXwqef/u7hG/dvUHtBbdadWUfT3E0ZUWYEyRInc0u0qCjo2BGGD7cjzp4NqVO75dIJ2q1bt6hbty4rVqygdu3aTJgwgZQJYFqGipKIiIiI2FatAm9vSJcOtm+HDz743cOBlwOpMq8Kv979lckVJ9MwV0O3RbtzB2rVss9GatcOhg79nzNuxQX27dtHtWrVuHjxIqNHj6Zly5bxZqrd02jrnYiIiIjA+PFQoQK89Za9n+0PJWnyvskUmlIIgG0Nt7m1JJ0/D4UKwerVMHYs+PqqJLnD5MmTKViwIBEREWzZsoVWrVolmJIEKkoiIiIiCVt0NHTpAs2bQ+nSsGULvPzybw+HRYbRdFlTGi9rTJHXihDYNJA8L+dxW7xduyBfPrssrVplxxTXevDgAY0aNaJx48YUKVKEffv2kT9/fqdjuZ2KkoiIiEhC9fAh1KwJgwfbDWTJkt/d9HPh9gWKTC3CxH0T+brw16yus5oXU7zotnjz5oGXl3147I4dUKqU2y6dYJ05c4aCBQsyZcoUevTowerVq0mfPr3TsRyhe5REREREEqIbN6BSJfsA2SFD4KuvfjfZbuPZjdSYX4OwyDAW1VhE5Xcquy2aMdC/P/TqZQ/fW7QIXnRfP0uwli1bRr169QBYvnw55cqVcziRs7SiJCIiIpLQnDxpH0IUGGgv23Ts+FtJMsYwePtgSv1YigwpM7CnyR63lqSwMKhXzy5JdevC+vUqSa4WFRVF9+7dqVixIlmzZmXfvn0JviSBVpREREREEpbt2+2VJMuyz0kqWPC3h0LDQmmwpAELjy6k+nvVmVJpCqmSpnJbtOvX4fPP7YgDBsDXX/9ukUtc4Nq1a9SuXZsNGzbQuHFjRo0aRbJk7hn3HtupKImIiIgkFPPm2cs1r75qn5H01lu/PXT0+lGqzKvCyeCTDPt0GO3zt3frhLMjR6B8ebhyBfz9IZ6fZRor7Nixg+rVqxMcHMzkyZNp2NB9kwzjAm29ExEREYnvjIFBg6BGDciTx56M8FhJWnBkAfkm5ePmg5usr7eeDgU6uLUkrVlj7wR88MAeuqeS5FrGGEaNGkXRokXx9PTkp59+Ukn6EypKIiIiIvFZZCS0aAFdu9pFaf16eOEF+6HoSDqv60w1/2rkyJCDwKaBeL3u5dZ4P/wA5cpB1qywezfkzevWyyc4d+/epXbt2rRt25YyZcqwd+9ecuXK5XSsWElb70RERETiqzt3wNvbPqm1a1f7xp9E9r+TX7t3jZrza7IpaBMt8rTAt7Qvnok93RYtMtIetDdypL3lbtas300mFxc4duwYVapU4fjx4wwYMICuXbuSKJHWTf6KipKIiIhIfHTpkr1U88svMH48NG3620O7L+2m6ryq3Lh/g2mVplH/w/pujRYaah/ftGoVdOhgH+Pk4eHWCAmOv78/DRs2JFmyZKxZs4aSJUs6HSnWU4UUERERiW8OHoSPP4bTp2H58t9KkjGGCYETKDK1CIkTJeanhj+5vSQFBUGhQrBund3fhg1TSXKliIgIOnTogLe3Nzly5GD//v0qSTGkFSURERGR+GTNGqheHdKkgW3bIGdOAB5EPKDVylZMPTCVz976jJlVZvJ88ufdGm3nTnsyeXi4vRuwRAm3Xj7BuXz5Mt7e3mzfvp02bdowdOhQkiZN6nSsOEMrSiIiIiLxxaRJ/z8ZYefO30pSUEgQhacWZuqBqfQs2pPltZa7vSTNmQNeXvZ9SDt2qCS5WkBAALly5WL//v3MmjWLkSNHqiT9TSpKIiIiInFddDR07w5NmkDJkrB1K2TODMDa02v5aMJHnL55mqU1l9KvWD88Erlvr5sx0Lcv1KoF+fLZ/e2dd9x2+QTHGMPgwYMpUaIEzz33HLt376ZWrVpOx4qTVJRERERE4rKwMPjiCxg40C5Ky5ZBmjREm2gGbh3IZzM+4+XUL7OnyR4qZK/g1mgPH0KdOtCnD9Svb9+X9OKLbo2QoNy+fZsqVarQpUsXqlatyp49e3j//fedjhVn6R4lERERkbgqOBg+/9xeQfruO+jcGSyL2w9vU39xfZYcX0KtHLWYWGEiKZOmdGu0X3+1o+3YAd9+C126gBvPsE1wDh48SNWqVQkKCsLX1xcfHx+3HhocH6koiYiIiMRFp09D2bL2GLk5c+zDZIFfrv1ClblVOBtyluGlh9P247Zu/4b5l1/ss5GuXYMFC6BKFbdePsHx8/OjefPmpEuXjk2bNlG4cGGnI8ULKkoiIiIicc2OHVCxon1v0oYN8Ogb47m/zKXh0oakTpqajfU2UuS1Im6Ptnq1fcZtqlSwZQvkyeP2CAnGw4cPadeuHePHj8fLy4s5c+aQMWNGp2PFG7pHSURERCQuWbAAiheHtGntwlS4MBFREXRY04GaC2qSK1Mu9jXb50hJGj3aHrr35puwe7dKkisFBQVRpEgRxo8fT5cuXVi3bp1K0jOmFSURERGRuMAY+P576NQJ8ueHJUsgfXp+vfsr3vO92XJuC23ytWHop0NJ6uHeMdCRkdCuHYwZYy90zZxpryiJa6xevZo6deoQGRnJokWLqFy5stOR4iWXrihZlvWZZVnHLcs6ZVlW1z95vINlWUcsyzpoWdYGy7Jee+yx+pZlnXz0w71HRouIiIjEJpGR0Lo1dOwIVava2+3Sp2fHhR3knpCbPZf28OPnPzKyzEi3l6Tbt+37kcaMsTvcwoUqSa4SFRVFnz59KFu2LJkzZyYwMFAlyYVctqJkWZYHMAYoBVwE9liWtdQYc+Sxp+0H8hhj7luW1QIYDNSwLOt5oDeQBzBA4KPX3nJVXhEREZFY6e5dqFkTVqywm8h332Esi7F7fqDd6nZkSZuFHY12kDNTTrdHO3vWLkknTsDEidC4sdsjJBjBwcHUqVOHNWvWUK9ePcaOHUuKFCmcjhWvuXLrXT7glDHmDIBlWXOASsBvRckYs+mx5+8Evnj0cWlgnTHm5qPXrgM+A2a7MK+IiIhI7HL5st1Efv4ZfvgBWrTgfsR9Wqxogd/PfpTLVo4fP/+R55I/5/ZoP/0ElStDRASsWWPfNiWusWfPHqpVq8bVq1cZP348TZo00ehvN3Dl1rtXgAuPfX7x0a/9lUbAqn/4WhEREZH45Zdf7HuRTpywD5Ft0YIzt85QcHJBfvz5R/p69WVpraWOlKRZs/5/nsSuXSpJrmKMYfz48RQuXBjLsti+fTtNmzZVSXITyxjjmi9sWdWB0saYxo8+rwvkM8a0+ZPnfgG0Bj4xxoRZltUJ8DTG9H/0eE/gvjFm2B9e1xRoCpAxY8aP5syZ45L/ln/i7t27pNIG3VhF70nspPcl9tF7EjvpfYl9XPmePBcYyPu9exOVLBmHvv2Wu9mysSt4FwOODcBg6P5Od/K/kN8l134SY2DatNfx83udnDlD6Nv3F9KmjXR7jieJL39WHj58iK+vL2vXriVfvnx069aNtGnTOh3rH4lt70mxYsUCjTFPn8lojHHJD6AAsOaxz78Gvv6T55UEjgIZHvu1WsD4xz4fD9R60vU++ugjE5ts2rTJ6QjyB3pPYie9L7GP3pPYSe9L7OOy92TKFGMSJzYmRw5jzp83UdFRpm9AX2P1sUzOsTnNqeBTrrnuU9y/b0yNGsaAMQ0bGhMW5kiMp4oPf1ZOnDhhPvjgA2NZlunbt6+JiopyOtK/EtveE2CviUGfceU9SnuAbJZlZQUuATWB2o8/wbKsXI9K0GfGmGuPPbQGGGhZ1n/Xkj/FLloiIiIi8ZMx0Ls3fPMNlCoF/v7cShpN3dkVWXFyBXX/U5dx5ceRIon7b+D/9VeoVMk+G2nQIHumhHZ/ucbixYupX78+iRMnZtWqVZQuXdrpSAmWy4qSMSbSsqzW2KXHA5hijDlsWVY/7Ba3FBgCpAL8H+21PG+MqWiMuWlZ1jfYZQugn3k02EFEREQk3gkLs0fGzZgBDRvCuHEcvHmUKtOrcO72OUaXGU3LvC0duTfl0CF7nsSNG/ZZt59/7vYICUJkZCTdu3dn8ODB5M2bF39/f1577bWnv1BcxqUHzhpjVgIr//BrvR77uOQTXjsFmOK6dCIiIiKxwK1bdvvYvBn694du3Zh5aBZNljUhXbJ0bP5yMwWzFHQk2sqVUKMGpEkDW7dC7tyOxIj3rl69Ss2aNdm8eTMtWrTA19cXT09Pp2MleC4tSiIiIiLyBGfPQtmycOYMzJhBeM3qdFztw6jdoyjyahHmVZ9HplSZ3B7LGBg1Ctq3hw8/hKVL4RXNH3aJbdu24e3tTUhICH5+ftStW9fpSPKIK8eDi4iIiMhf2b3bHv/966+wdi1XKhan+PTijNo9ivb527Oh3gZHSlJEBLRqBT4+9n1JW7aoJLmCMQZfX1+8vLxImTIlu3btUkmKZbSiJCIiIuJuixZBnTqQKROsXMm2FDeoPiE3oWGhzK46m5o5ajoSKyQEvL1h3Tro0gUGDoRE+mf1Zy40NJRGjRoxf/58KleuzLRp0+Ls6O/4TL/1RURERNxp+HCoWhU++ACzYwcjb6+l2PRipE6aml2NdzlWks6cgYIFYdMmmDwZvvtOJckVDh8+TL58+Vi4cCGDBw9m4cKFKkmxlFaURERERNwhKgo6dICRI+Hzz7k3ZTxNN7Zj1qFZVMxeEb/KfqRN5sw3zNu22fMkoqPt1SQvL0dixHuzZ8+mcePGpE6dmg0bNuCl/6FjNf07gYiIiIir3bsHVarYJalDB06N/5YCs0sw+9Bs+hfrz6IaixwrST/+CCVKwPPPw86dKkmuEB4eTps2bahduza5c+dm3759KklxgFaURERERFzp6lWoUAH27YNRo1j+6et8MfljPBJ5sKrOKkq/5cyBotHR0KsXDBgAxYrB/Pl2WZJn68KFC3h7e7Nz5046dOjAd999R5IkSZyOJTGgoiQiIiLiKkeO2OO/r18nauEC+qbZxzez25ArUy4W1ljI6+ledyTWgwdQvz74+9vn3P7wA+h792dv/fr11KpVi4cPH+Lv70+1atWcjiR/g7beiYiIiPxdXl582K7dk5+zaZM9HSEsjNtrl1H+7ni+2fINX374JdsbbnesJF29am+vmz8fhg6FCRNUkp616OhoBgwYwKeffkqGDBnYu3evSlIcFOMVJcuyUhpj7rkyjIiIiEi84OdnL9Vky8Yv0wZT8afGXAy9yNhyY2n2UTMsy3Ik1s8/27sAg4PtCeWVKjkSI167desWdevWZcWKFdSqVYsJEyaQKlUqp2PJP/DUFSXLsgpalnUEOPro85yWZf3g8mQiIiIicY0x0Levva+tSBFmj2tN3rXVCI8KZ2uDrTTP09yxkrR8ORQubN+btG2bSpIr7Nu3j48++oi1a9cyevRoZs6cqZIUh8Vk650vUBoIBjDG/AwUdWUoERERkTgnPBy+/BL69CGqXl3atslG7Y0tyZ85P/ua7ePjzB87EssY8PWFihXhnXdg927IlcuRKPHa5MmTKViwIBEREWzZsoVWrVo5Vorl2YjR1jtjzIU/vNFRrokjIiIiEgeFhNjjvzdtIrTbV5TOuo2dP++iY4GOfFvyWxIncmZ+VkQEtG5t34dUpYo9CjxFCkeixFsPHjygdevWTJkyhZIlSzJr1izSp0/vdCx5BmLyp/aCZVkFAWNZVlKgLY+24YmIiIgkeEFBUK4cnDzJsaFf84mZzL1r95hXbR7V36/uWKyQEKheHdavh6+/hv79IZHGeD1TZ86coWrVqhw4cIAePXrQp08fPDw8nI4lz0hMilJzYATwCnARWAu0dGUoERERkThh714oXx7z8CHzhzWi1q3BvPX8W2yqv4n30r/nWKzTp6F8efvnadPsW6bk2Vq2bBn16tUDYPny5ZQrV87hRPKsxeTfFbIbY+oYYzIaYzIYY74A3nV1MBEREZHYLPHt2/DJJ0Qn8+Sr3vnxvjmOitkrsrvJbkdL0pYt8PHHcO2avZqkkvRsRUVF0b17dypWrEjWrFkJDAxUSYqnYlKURsXw10RERETiv8hIOHeOlEFBPHj7DYo1S8aIO+v4rsR3LPBeQBrPNI5Fmz4dSpaEF1+EXbugqMZvPVPXr1+ndOnSDBw4kEaNGrF9+3beeOMNp2OJi/zl1jvLsgoABYH0lmV1eOyhNIA2X4qIiEjCc/SoPdkuKIjj6RPhVTmISA9P1tRYQ8k3SjoWKzoaevSAb7+FEiXA3x+ee86xOPHSzp07qV69OtevX2fSpEk0atTI6UjiYk9aUUoKpMIuU6kf+xEK6GhhERERSTiiomDYMMiVi+hTJxlRyIN3W0WT5eV32Ndsn6Ml6f598Pa2S1LTprBqlUrSs2SMYfTo0RQtWpQkSZKwY8cOlaQE4i9XlIwxm4HNlmVNM8acc2MmERERkdjj1Clo0AC2beOi10eULXqeX6woahxNzLTuW0mWOJlj0a5csc9HCgyE77+Hdu1AR/c8O3fv3qVp06bMnj2b8uXL4+fnx3NqoQlGTKbe3bcsawjwPvDb3wTGmOIuSyUiIiLitOhoGDsWOncmKrEHw5q8R5eXA/no5Y/YvSwLb12IcrQkHTgAFSrArVuwZIn9sTw7x44do2rVqhw7dowBAwbQtWtXEmm+eoISk3d7JnAMyAr0BYKAPS7MJCIiIuKsc+egVClo3ZpT779EtqYPGfDGRUaXHc2uxrvIcye1o/GWLoXChe2Pt29XSXrW/P39yZs3L9euXWPNmjV069ZNJSkBisk7/oIxZjIQYYzZbIxpCOR3cS4RERER9zMGJk2CDz4gctcOutdMT7ayp8mfvxrHWh2jVb5WeCRybqaVMfatUpUrw3vvwe7dkDOnY3HinYiICDp06IC3tzc5cuRg//79lCzp3P1n4qyYbL2LePTzFcuyygGXgcyuiyQiIiLigEuXoEkTWLWKw+9noFzJayR9MzPrys1ydFjDf0VEQKtWMHEiVKtmjwJPkcLpVPHH5cuX8fb2Zvv27bRp04ahQ4eSNGlSp2OJg2JSlPpblpUW+Ar7/KQ0QHuXphIRERFxF2NgxgxM27ZEPrhHt/KejM4bwtef9KVzoc6O3of0X7du2eVo40Z7DHjfvqCdYM9OQEAANWrU4O7du8yaNYtatWo5HUligScWJcuyPIBsxpjlwG2gmFtSiYiIiLjDr79Cs2awZAk/v5mS6mUjeCPfpxwqO4a3nn/L6XQAnDwJ5ctDUBD4+UHduk4nij+MMQwZMoSvv/6abNmysXHjRt5//32nY0ks8cSiZIyJsiyrIuDrpjwiIiIi7uHvT3SL5kSF3qZbKZhdKjXfl51C9feqYz1lxrYXAYQQwgEXR9y8GapUsUd+b9jw/wMc5N+7ffs2X375JYsXL6ZatWpMmTKF1KmdHdIhsUtMtt79ZFnWaGAucO+/v2iM2eeyVCIiIiKuEhyMadUKa+5cDmZOzBc1oylZ3ocjxfqRxjON0+l+M3Wqvdj15puwfLn9szwbBw8epGrVqgQFBeHr64uPj89Ty7EkPDEpSgUf/dzvsV8zgM5REhERkbhl6VIiGzfC3AymbzHYWCMXfhXHkful3E4n+010NHTrBoMG2RPK582DdOmcThV/+Pn50bx5c9KlS8emTZsorGU6+QtPLUrGGN2XJCIiInFbSAiRbVqTeMZMjmS0aNkqJV/UHcLW3E0cHff9R/fu2fcgLVoEzZvDyJGQJInTqeIOLy8vQkJCOHDgfzdFhoWF0a5dO8aNG4eXlxezZ88mU6ZMDqSUuCImK0oiIiIicdeaNTysX4fE14P5piicblWTBWV9yZgqo9PJfufSJahYEQ4cgBEjoE0b+94k+ffOnTtHtWrV2Lt3L126dKF///4kTqxvg+XJ9DtERERE4qc7d7jXpjkpp8/izIvQq8OrtGw5lZ5ZY9/dA/v2QYUKEBoKS5dCuXJOJ4o/Vq9eTZ06dYiMjGTRokVUrlzZ6UgSR2gCv4iIiMQ7URvWczv76yT3m8X3hT1YOqs3M789QfFYWJIWL4YiRSBxYti+XSXpWYmOjqZv376ULVuWzJkzs3fvXpUk+VueWpQsy0phWVZPy7ImPvo8m2VZ5V0fTURERORvunePKw298ShZimthN+nUMz+Vl56ga6k+eCb2dDrd7xgDQ4bY478/+AB27YL//MfpVPFDcHAw5cqVo0+fPtStW5cdO3aQLVs2p2NJHBOTrXdTgUCgwKPPLwL+wHJXhRIRERH5u0I3reZhnRq8dCWUyUVS8oLvBIbmrhUrxz6Hh0OLFjBlCtSoYY8CT57c6VTxw/3798mdOzdXr15l/PjxNGnSJFb+HpDYLyZb7940xgwGIgCMMQ8A/W4TERGRWME8eMDh+mVJVaIM9x6E8sOganivu0Llj2rHym+Qb96E0qXtktSzJ8yapZL0LBhjuHz5MqdOncKyLLZv307Tpk1j5e8BiRtisqIUbllWcuyzk7As600gzKWpRERERGLg7Np5WA0a8P7l+ywumoE3Jy+i5VsFn/5Ch5w4AeXLw7lzMGMG1KnjdKL4Yc+ePfj4+HDy5ElSp05NYGAgL7zwgtOxJI6LyYpSb2A1kMWyrJnABqCzS1OJiIiIPMH9eyFs/KIQWcrUIOndB6wc1ZaKAVf4IBaXpE2bIH9+CAmBjRtVkp6Fq1ev0rBhQ/Lly8eZM2fInj07WbNmVUmSZ+KJRcmy1yqPAVWAL4HZQB5jTIDLk4mIiIj8iS1LRxH0dgaKz/yJnZ+8SZIjxynbegSJrNg7zHfyZPj0U3jpJXtoQ6FCTieK28LCwhgyZAhvv/02M2bMoFOnTpw4cYJMmTJpq508M0/cemeMMZZlLTbGfASscFMmERERkf9xIfgsW1uWo9r8o4Sm9OCXCQMo3KSb07GeKCoKvv7anm5XujTMnQtp0zqdKu4yxrBixQrat2/PqVOnKF++PMOGDePtt992OprEQzH5p5edlmXldXkSERERkT8RERXB1JmduJbzLWrPO8qpYv8hzakL5IjlJenuXaha1S5JrVrB8uUqSf/GsWPHKFOmDBUqVMDDw4NVq1axbNkylSRxmZgMcygGNLMs6xxwD3vinTHGaNK/iIiIuNRPQVvZ2cGblkuvEp48CdemjuS9L1s5HeupLl6EChXg4EEYORLatHE6UdwVEhJCv379GDVqFClSpOD777+ndevWJEmSxOloEs/FpCiVcXkKERERkccE3w/me78WlB3oT4cLcLnEx7w0YzFpMmVyOtpTBQbaJenuXXsVqYy+k/pHoqKimDJlCt27d+fGjRs0btyY/v37kyFDBqejSQIRk6JkXJ5CREREBPselOn7fHPf3wAAIABJREFUp3K8X1t6rrwHnp48nDqal+s3gjhwk/7ChfDFF5AhA/z0E+TI4XSiuGnr1q20bduWAwcOULhwYdasWUOuXLmcjiUJTEyK0grssmQByYCswHHgfRfmEhERkQTm8LXD9J3egOY/7OHLIAgtXpg0fnPglVecjvZUxsCgQfbghvz5YfFiyJjR6VRxz/nz5+ncuTNz584lS5YszJkzB29v7xhPsgsICCAgIMC1ISXBeGpRMsZ88PjnlmXlBpq5LJGIiIgkKPfC79EvoC+hY4YxZXU0SZMkI3riSNI0ahwnVpHCw6FZM5g2DWrVgilTIFkyp1PFLffv32fIkCEMGjQIYwy9evWiS5cupEiRwulokoDFZEXpd4wx+zQFT0RERJ6FpceXMmB2C/rOuMxnpyH8kyIknf4jvPaa09FiJDgYqlSBLVugTx/o1StOdLtYwxiDv78/nTp14vz583h7ezN48GBeiyPvv8RvTy1KlmV1eOzTREBu4LrLEomIiEi8d/72edqubEPaeUtZtyYRKUkGo4eStEULSBR7D4593MOHifj4Y3vC3axZ9mqSxNyBAwfw8fFhy5Yt5MyZEz8/Pz755BOnY4n8JiYrSqkf+zgS+56lBa6JIyIiIvFZRFQEvjt9Gbe8D6MWh1PuGEQXKkCiadPgrbecjhcjUVHw669w6lQqXngBNm2CAgWcThV3XL9+nZ49ezJx4kSee+45xo0bR+PGjfHw8HA6msjvxOQepb7uCCIiIiLx27bz22ixogXvbfyFA6uTkDrCA4YNJpGPD8SBb5Kjo8HfH/r2hWPHIHnyaHbtSsTrrzudLG6IiIjghx9+oE+fPty5c4c2bdrQu3dvnnvuOaejifypvyxKlmUt4wmjwY0xFV2SSEREROKVG/dv0HldZ5Zun8q0tSko/zOQLxdMnw7vvON0vKeKjob58+2CdOQIvPcevPsuJElyl9dfT+d0vDhh7dq1tGvXjqNHj1KqVCmGDx/Oe++953QskSd60orSULelEBERkXgn2kQzdf9UOq/vjNeBEM6uSkGqexEwcCB06gSJ//ZMKbeKjrbPRerbF375xe50s2dD9epQogSEhDidMPY7deoUHTp0YNmyZbz55pssWbKEChUqxHjct4iT/vJvKGPM5n/7xS3L+gwYAXgAk4wx3/3h8aLAcOA/QE1jzPzHHosCDj369LxWsEREROKOQ78eovmK5hw58RNztmSg9I5oyJXdXkX64IOnfwEHRUfb5yD17QsHD0L27DBzJtSoESd2CMYKd+7coX///vj6+uLp6cl3331Hu3bt8PT0dDqaSIw9aevdPGOMt2VZh/iTLXjGmP886QtbluUBjAFKAReBPZZlLTXGHHnsaeeBL4GOf/IlHhhjPnz6f4KIiIjEFnfD79I3oC++O32pdi4la5elI8XNYOjdG7p3hyRJnI74l4yBJUvsgnTgAGTLBj/+aE+zU0GKmejoaH788Ue6du3K1atXqV+/Pt9++y0vvfSS09FE/rYnrXn7PPq5/D/82vmAU8aYMwCWZc0BKgG/FSVjTNCjx6L/4TVEREQkFjDGsPjYYnxW+xBy7QKb9r5NkfUn4P33YdV0+OgjpyP+JWNg2TL7HKT9++3he9OnQ+3asX53YKyyc+dOfHx82L17N/ny5WPx4sV8/PHHTscS+cf+8qACY8yVRz+f+7MfMfjarwAXHvv84qNfi6lklmXttSxrp2VZlf/G60RERMSNgkKCqDinIlXmVaF0UGKu/ZiRIhtPQZcuEBgYa0uSMbB8OeTNC5Uqwe3bMHUqHD0K9eqpJMXU5cuXqVevHgUKFODChQv4+fmxY8cOlSSJ8yxj/nKwnf0Ey8oPjALeBZJi3290zxiT5imvqw6UNsY0fvR5XSCfMabNnzx3GrD8D/covWyMuWxZ1hvARqCEMeb0H17XFGgKkDFjxo/mzJnzlP9c97l79y6pUqVyOoY8Ru9J7KT3JfbRexI7xcb3JSI6gnkX5/HjuR9JGQ4LdmbDa/0v3M+ShWNduxIaS6eaGQO7dj3P9Omvc+xYGl566QFffHGOTz/9lcSJn/x90X+1a/chUVFRjBp16OlPjqfCw8Px9/dnxowZREVFUb16derUqUOKFCkczRUb/6wkdLHtPSlWrFigMSbP054Xk38rGQ3UBPyBPEA9ICYnwl0Esjz2eWbgcgxeB4Ax5vKjn89YlhUA5AJO/+E5E4AJAHny5DFeXl4x/fIuFxAQQGzKI3pPYiu9L7GP3pPYKba9L5uDNuOzwoejN47SzSpKn5nnSBJ0GNq1I8WAAeR2+JvlP2MMrFljb7HbtQteew0mToT69ZOTJMk7QMxHladLByEhIbHqPXEXYwxLlizhq6++4syZM1SqVIlhw4bx5ptvOh0NiH1/ViTuvid/ufXuccaYU4CHMSbKGDMVKBaDl+0BslmWldWyrKTYZWtpTK5nWdZzlmV5Pvr4RaAQj93bJCIiIs64du8a9RfXx2u6F9H373H6XGUG9NlKEhJBQAD4+kIsK0nGwNq1UKgQlCkDV67A+PFw4gQ0bhyr50vEOocPH+bTTz/l888/J1myZKxdu5bFixfHmpIk8izFpCjdf1R0DliWNdiyrPZAyqe9yBgTCbQG1gBHgXnGmMOWZfWzLKsigGVZeS3LughUB8ZblnX40cvfBfZalvUzsAn47g/T8kRERMSNok00EwIn8M7od5h9aDY/vFCfI5OT88bUxdCsmT1Hu2hRp2P+jjGwfj0UKQKlS8OFCzB2LJw8CU2bQtKkTieMO27evEnbtm3JmTMne/fuZeTIkRw4cIBSpUo5HU3EZWKy9a4udqFqDbTH3k5XNSZf3BizElj5h1/r9djHe7C35P3xdT8BsfuQBRERkQTi56s/02JFC3Zc3EHJl4sw+/A7vNhnMrzyir1UEwu/Wd60yZ5IvnWrHXPMGGjUCHSMz98TGRnJxIkT6dmzJ7du3aJZs2b069ePF1980eloIi73pHOUXjXGnH9swt1DoK97YomIiIjT7oTdoXdAb0buGsnzyZ9n2Tv9KDfAH+vQRGjQwN5mlzat0zF/Z/NmuyBt3gwvvwyjRtnb65IlczpZ3BMQEICPjw8HDx7kk08+YcSIEeTMmdPpWCJu86Std4v/+4FlWQvckEVERERiAWMMC44s4N0x7zJ853Ca/qcBQaGNKP9FP6zr1+1Dh6ZMiVUlaetWKF4cvLzg+HEYMQJOn4bWrVWS/q6goCCqV69OsWLFuH37Nv7+/mzatEklSRKcJ229sx77+A1XBxERERHnnbl1htYrW7Pq1Co+zPQhK3IOJmeX7+3zkGrXtpdonn/e6Zi/2b7dXkHasAEyZrQXuZo1g+TJnU4W99y7d49BgwYxZMgQLMuiX79+dOzYkeT6H1MSqCcVJfMXH4uIiEg8ExYZxtCfhtJ/a38SJ0rM8JLDaL01DI+yDeyVo/nzoWqMblF2ix077IK0bh1kyADDhkHz5rFu4F6cYIxh9uzZdO7cmUuXLlGrVi0GDRpElixZnv5ikXjsSUUpp2VZodgrS8kffcyjz83TDpwVERGRuGHT2U20WNGC48HHqfZeNUa/2ZaMrTrDzp12OfrhB7uNxAK7dtkFac0aSJ8ehgyBFi0g5VPn8cqfCQwMxMfHh+3bt5M7d27mzJlD4cKFnY4lEiv85T1KxhgPY0waY0xqY0ziRx//93OVJBERkTju17u/UndRXYr7FSciOoJVtVbgf6kQGQt9at/oM2sW+PvHipK0ezeULQv589u7AAcNgrNnoWNHlaR/4tq1azRu3Ji8efNy4sQJJk6cyO7du1WSRB4Tk/HgIiIiEo9ERUcxIXAC3TZ24174PXoU6UH3V2qRrEkL2LIFypWDCRPssXEO27sX+vSBFSvsW6O+/dYe0JAqldPJ4qbw8HBGjRpFv379uH//Pu3bt6dXr16kjUWDOURiCxUlERGRBGT/lf00X9Gc3Zd2UzxrcX4oM4bsCwKgYj7w8LCn2X35JVjW076US+3bZxekZcvguedgwABo0wZSp3Y0Vpy2cuVK2rdvz4kTJyhTpgy+vr5kz57d6VgisZaKkoiISAIQGhZKz409Gb1nNC+meJEZn8+gdroiWHUa2xMRSpWCSZPg1VcdzXnggF2QliyBdOngm2+gbVtIo03//9jx48fp0KEDK1eu5O2332bFihWULVvW6Vgisd6TzlESERGROM4Yw7zD83hn9DuM2j2K5h8153irY9QJDMf64AP46ScYO9aejuBgSTp4EKpUgVy5ICAA+vaFoCDo0UMl6Z+6ffs2HTt2JEeOHGzdupWhQ4dy6NAhlSSRGNKKkoiISDx16uYpWq1sxdrTa8n9Um6W1FxC3kSZwbseLF8ORYvC1KnwhnPHJR46ZJeiBQvsQtS7N7RrZ68myT8TFRXFtGnT6NatG9evX6dBgwYMHDiQjBkzOh1NJE5RURIREYlnwiLDGLR9EAO3DiSpR1JGfjaSlnla4DHPH1qVhgcPYPhw+6afRM5sLjl82C5I/v72fUc9e0L79vb9SHFBQAAEBBwAvBxO8nvbt2+nbdu27Nu3j4IFC7JixQry5MnjdCyROElFSUREJB5Zf2Y9LVe05OTNk9R4vwbfl/6elx8khho17WWb/Plh2jRw6Cb+I0egXz+YN88e6929O3ToYE+0k3/u4sWLdO7cmdmzZ/PKK68wc+ZMatWqheXwUA6RuEz3KImIiMQDV+9epfaC2pT6sRQGw5ov1jCn2hxeXrcTcuSwx8d99x1s2+ZISTp2DGrXtqMsXw5du9r3IPXvr5L0bzx48ID+/fuTPXt2Fi5cSI8ePTh+/Di1a9dWSRL5l7SiJCIiEodFRUcxbu84um3sxsPIh/T+pDddC3clWeh9qFPHPjQ2d27YuNFuKW524oS9gjR7NiRPDp0724fEvvii26PEK8YYFi5cSMeOHQkKCqJq1aoMGTKErFmzOh1NJN5QURIREYmj9l7eS4sVLdh7eS8l3yjJmLJjePuFt+3TWZs0gevX7RuBvv4akiRxa7aTJ+3R3jNnQrJk8NVX0KkTpE/v1hjx0sGDB/Hx8SEgIIAcOXKwYcMGihcv7nQskXhHW+9ERETimNsPb9NmZRvyTczHxdCLzK46m7VfrOXtxBmhYUMoX95estm9G3r1cmtJOn3aPq/23Xdh/nx7QMPZszB4sErSvxUcHEzLli3JlSsXBw8eZMyYMezfv18lScRFtKIkIiISRxhjmPPLHDqs7cC1e9dolbcV/Yv3J22ytPahsY0awaVL0K2bXZA8Pd2W7cwZ+34jPz+7l7Vta2+zy5TJbRHircjISMaOHUvv3r0JDQ2lZcuW9O3bl+d1c5eIS6koiYiIxAEX7l/g0xmfsv7MevK8nIfltZbz0csfwd270LKlfWhs9uz2AbIff+y2XP8dyDB9Onh4QOvW0KULvPSS2yLEa+vXr6ddu3YcPnyYEiVKMHz4cHI4cK+ZSEKkoiQiIhKL3Y+4z3tj3uP87fOk9kzNmLJjaPZRMzwSecCWLdCggb23rUMHu7EkT+6WXOfOwYAB9nm1Hh7QooU9ye7ll91y+Xjv9OnTdOzYkcWLF5M1a1YWLVpEpUqVNMlOxI1UlERERGIhYwzzDs+j07pOXAi9QLok6Tja+iiZUmWyD4zt1g1GjIA33oDNm6FIEbfkOn8eBg6EKVPAsqBZM3tWxCuvuOXy8d7du3cZOHAgw4YNI0mSJAwcOJD27duTLFkyp6OJJDgqSiIiIrHM/iv78Vntw9bzW/kw04fMrDKTqLNRdknauRPq17fnbrdqBYMG2Se3utjFi3ZBmjTJ/rxxY7sgZcni8ksnCNHR0cycOZMuXbpw5coV6taty7fffssraqAijlFREhERiSWu37tOj409mLhvIi+keIEJ5SfQMFdDPIqXIOTmTShbFoYMgcyZYf16KFHC5ZkuXYJvv4WJE8EYe6het27w6qsuv3SCsXv3bnx8fNi5cyd58+ZlwYIFFChQwOlYIgmeipKIiIjDIqIiGLNnDH0C+nAv4h7t8rej1ye9SJcsnf2EO3dIffKkvXrUuDEMGwZp0rg00+XL8N13MGECREXZt0J17w6vvebSyyYoV65coVu3bkybNo2MGTMydepU6tWrR6JEOr1FJDZQURIREXHQ6lOrab+mPcduHKP0m6XxLe3Lu+nftR88ftw+MHbfPqzEiWHlSihTxqV5rlyx+9j48RARYZ+J1L07ZM3q0ssmKGFhYQwfPpz+/fsTFhZG586d6d69O2lcXH5F5O9RURIREXHAyeCTdFjbgeUnlvPW82+xrNYyymUrZ081O30a+vWDGTPsKXZZsnAnTRrSurAkXb1qF6Rx4+yCVK8e9Ohhz4qQZ8MYw/Lly+nQoQOnTp2iQoUKDBs2jGzZsjkdTUT+hNZ2RURE3Cg0LJTO6zrz/g/vszloM0NKDeFwy8OUf7s81vnz0KSJfR7SvHnQvr19kusbb2ASu+bfNn/9Fb76yi5EI0dCjRpw7Jg91U4l6dk5evQon332GRUrViRx4sSsXr2apUuXqiSJxGJaURIREXGDaBPN9APT+XrD11y7d40GHzZgQIkB9iS7S5fsQ4kmTbJnbrdsaY+Ue3RqqxcBhBDCgWeY5/p1GDwYfvgBHj6EOnWgZ0/Q9+3P1q1bt+jbty+jR48mVapU+Pr60qpVK5IkSeJ0NBF5ChUlERERF/vpwk+0XdWWwCuBFMhcgOW1l5Pn5Tz2frce7ez9btHR0KiRfUNQ5swuy3Ljhj04b/Ro+zim2rXtgpQ9u8sumSBFRUUxadIkevToQXBwME2aNKF///6kT5/e6WgiEkMqSiIiIi5yMfQiXdd3Zeahmbyc+mVmfD6D2h/UxrpxAzp1gjFjIDzcnpjQowe8/rrLsgQHw9ChMGoU3L8PNWtCr17wzjsuu2SCtWXLFtq2bcvPP/9MkSJFGDFiBLly5XI6loj8TSpKIiIiz9jDyIcM+2kYA7cNJCo6iu5FutO1cFdS3Q23C9GIEfZyTp06dlt56y2XZbl5054mPnIk3LsH3t72Jd97z2WXTLDOnTtH586dmTdvHlmyZGHu3LlUr17dHtAhklB5wYchH/JM9w67iYqSiIjIM2KMYdGxRXy19iuCQoKo+m5VhpQaQtZEz8PAoeDrC3fu2G2lTx+XLufcugXff293sjt3oHp1uyDlyOGySyZY9+/fZ/DgwQwaNAiA3r1707lzZ1KkSOFwMhH5N1SUREREnoFDvx7CZ7UPm4I2kSNDDjbU20DxF/PaSzlDh0JICFSpYhekDz5wWY6QEBg+3O5koaFQtSr07u3SSyZIXl5e3Lp1i27dutGpUycuXLiAt7c3Q4YM4dVXX3U6nog8AypKIiIi/0Lw/WB6berFuMBxpEuWjjFlx9D03S9IPHY8DK5hT0+oUME+ONaF96ncvm2vHn3/vf3x55/bBSlnTpddMsEyxnD79m1Onz5NzZo1yZkzJzNmzKBo0aJORxORZ0hFSURE5B+IjI5k3N5x9NrUi9CwUFrmaUnfAl/zvJ8/VHjbPqCodGn74Nh8+VyWIzTUXrQaNsxeTapUyS5Imh3w7IWHh+Pv78/w4cM5cOAAHh4ejB8/nkaNGuHh4eF0PBF5xlSURERE/qYNZzbgs9qHw9cPUyJrCUYUG8z7y3ZCk7xw+TIULw4LFkChQi7LcOeOPcFu2DB7YEOFCvauvty5XXbJBCs4OJjx48czZswYLl++TPbs2cmWLRuenp40bdrU6Xgi4iIqSiIiIjF05tYZvlr7FYuPLSZruqwsruJPxR03sQp/DufPQ+HCMHMmeHm5LMPdu/YZSEOH2iO/y5WzC1KePC67ZIJ19OhRRowYgZ+fHw8ePKBUqVJMmjSJ0qVLkyhRIgICApyOKCIupKIkIiLyFHfD7zJw60CG7RhGkkRJ+LboN3Q4m4mklbvAmTPw8ccwaRKULAkuGgUdFQWDB9uHxd64AWXK2AXJhbv6EiRjDOvWrcPX15fVq1fj6elJ3bp18fHxIYdGBookKCpKIiIifyHaRDPz4Ey6rO/ClbtXqPd+HYbfLsBzzUfCiRP2Prfly6FsWZcVpPBwuHABzp9PQ5cu9m1PffpA/vwuuVyC9eDBA2bMmMHw4cM5cuQIGTNmpF+/fjRv3pz06dM7HU9EHKCiJCIi8id2X9qNz2ofdl7cyccv5SUgVWve7j0Tjsy0Z20vXAiVK7usIAFs3AitWtmLVqlSRbFmTSIKFnTZ5RKkK1euMGbMGMaNG0dwcDAffvgh06dPp0aNGnh6ejodT0QcpKIkIiLymCt3rvD1hq+Z/vN0MqXMyIY0bSn2w2asn7vbB8TOnQvVqkGiRC7LcOkSdOwIc+ZA1qz2IbEeHvcoWDCdy66Z0Ozbtw9fX1/mzp1LZGQkFStWpH379hQtWhTLheVXROIOFSUREREgLDKM4TuH039rf8Ijw5icpBr155zGI3AkvPUW/Pgj1KoFLhwDHRFhj/ru08f+uE8f6NzZvh8pJMRll00woqKiWLp0KcOHD2fLli2kSpWKFi1a0LZtW958802n44lILKOiJCIiCZoxhmUnltFhTQdO3zxNz4gCfL3uIcn3zIfXX4cpU6BuXUjs2v/LDAiwt9kdOWLf8jRyJOh792cjNDSUKVOmMHLkSM6ePctrr73GsGHDaNSoEWnTpnU6nkj8F+10gH9GRUlERBKsI9eP0G51O9adWccXIa+xe/sHPL9nB2TODOPGQYMGkDSpSzNcuQKdOtlTxV97DZYssc9E0u6vf+/s2bOMGjWKSZMmcefOHQoVKsSQIUOoVKkSiV1cfEUSvAfAAuAApA5LDQaIY3+v6W8JERFJcG49uEWfgD6M2TOG4leTc27v27y65wS89JJ9imuTJuDiG/kjI+3zkHr1grAw6NkTunaFFClcetl4zxjDtm3bGD58OIsXLyZRokR4e3vTrl078ubN63Q8kfhvHzAZmAncBpJBeLpwkkcmhyTORvu7VJRERCTBiIqOYuK+ifTY2IM3Tt/kQGBmcgRegAwh8P330Lw5JE/u8hxbt9rb7A4dssd9jxoF2bK5/LLxWnh4OP7+/vj6+hIYGMjzzz9Ply5daNmyJZkzZ3Y6nkj8dguYhV2Q9gOeQDWgEdAHwm6HkTyJ6/9ufdZUlEREJEEICArAZ7UP/HyQxTtfoPABA8/fg+++g9atIWVKl2f49Vd7OIOfH7z6qlsmjMd7N27cYMKECYwZM4bLly+TPXt2xo4dS7169Uih5TkR14kGNmOXowXAQyAXMBqoDTz36Hl9HUn3TKgoiYhIvHYu5Bwd13XkSMB8Bm9PQbmfwaSNhH79wMcH0qRxeYbISBg7Fnr0gAcPoFs3+4cbulm8dfToUYYPH46fnx8PHz6kVKlSTJo0idKlS5PIhaPbRRK8S8B07IJ0BkgLNMRePcrtYC4XUFESEZF46V74PQZtH8SipYPovjGKeYcsSOUBPXtidegA6dxzJtH27fY2u59/hlKl7G122bO75dLxjjGGtWvX4uvry5o1a/D09KRu3br4+PiQI0cOp+OJxF8RwApgErAKezXJC+gHVAHi3q66GFFREhGReMUYw5xf5jB6bgeaLL/Kz4csSJYMq4uPfYrrCy+4Jce1a9ClC0ybZg/R8/eHqlW1ze6fePDgAT/++CMjRozgyJEjZMqUiW+++YZmzZqRPn16p+OJxF/HsVeO/IBfgZeArkAD4C0Hc7mJipKIiMQbgZcDGTijGZ/NDWTzAbCSJCVRu9Z2Y8mQwS0ZoqLsyeI9esDdu/ale/SAVKnccvl45fLly/zwww+MGzeO4OBgcuXKhZ+fH97e3ni6eCqhSIJ1D/DHLkjbsNtCeeytdZ+RoNpDAvpPFRGR+OravWsMnufDG2PnMHsfeCRKjNWiGYm6dYOXX3Zbjp07oWVL2L8fihe3x3+/+67bLh9vBAYGMnz4cObOnUtkZCSVKlWiXbt2FC1aFEtLciLPngH2YJej2cAd4G1gEFAPyORcNCe59G5Hy7I+syzruGVZpyzL6vonjxe1LGufZVmRlmVV+8Nj9S3LOvnoR31X5hQRkbgpPCqcsct6M//TLPRvOodm+xJhGjTA4/QZEo0e7baSdP06NG4MBQrYk+3mzIH1659dSQoIgOHDDzybLxZLRUVFsWjRIooWLUqePHlYvHgxLVq04OTJkyxatIhPPvlEJUnkWQsGRgD/AT4GZmDfc7QVOAZ0JsGWJHDhipJlWR7AGKAUcBHYY1nWUmPMkceedh74Euj4h9c+D/QG8mB33MBHr73lqrwiIhK3rN81m6Durai/+Rae0RZ3a1Qh2YCheGTN6rYMUVEwcaI9we7OHfsWqF69IHVqt0WI80JDQ5kyZQojR47k7NmzvPbaawwbNoxGjRqRNm1ap+OJxD/RwHrs1aPFQDiQFxgP1ARcPwg0znDl1rt8wCljzBkAy7LmAJWA34qSMSbo0WPRf3htaWCdMebmo8fXYe+KnO3CvCIiEgecPLmLfZ3qUHbVaYpHwJUKxXhl6HjSuvnE1j177G12e/fCJ5/AmDHw/vtujRCnnT17lpEjRzJ58mTu3LlDoUKFGDJkCJUqVSJxYt0ZIPLMnQf+j707j4u63v44/hpAFgURcEVwxQ1TUHArFwQDqdSyxUzFbHHNtnvvr27rLdtut662aXa1ZdTKSstriXgNMTU3UNQEU0RTARdUQHaY+f7++DAMm4kLMwyc5+MxD5b5Dnxw7o15c87nfD4ru/0BeAKzUHuP+lhxXfWYTtO0uvnCqpVutKZpj5R9PAUYpGnaYzVc+znwo6Zp35V9/FfAWdO018o+fhEo0DTtnSqPmw5MB2jTpk3Q119/XSc/y7XIzc3FVXbu1ivynNRP8rzUP/X1OSnMPkPOp6/KLjyxAAAgAElEQVQSEZOEexEkDOxK0cy/U9y5q0XXkZ3twJIlXfjpp3Z4eBQza9ZRwsLO1vk0u/r6vFwNTdM4cOAA3333Hdu2bUOn0xESEsI999xDz549rb28q9YQnpOGSJ4XM12xjpa/tqTdunZ4xKsTYC8GXSQjMoPMoZlojnWTAyoKfDIQg8HAgQ8O1Pn3qq2RI0cmaJoWfKXr6vJPNjX9yqjts1Grx2qa9gnwCUBwcLAWEhJS68XVtbi4OOrTeoQ8J/WVPC/1T317Tgw52ex57kECPl2DR4HGnsEd6bjgc4IGhVh0HUYjLF0Kzz4L2dnw5JPwj3840by5P+Bf59+/vj0vV6O4uJhvvvmGBQsWkJCQgKenJ8888wyzZ8/Gx8fH2su7Zrb8nDRk8rwABzGP9T4P+AIvAtPAs5Mnnnhabi0tICsryyafk7oMSqdQT4uJD5B+FY8NqfLYuBuyKiGEELYhP59jr/+NFu9/woDcUrb19cDj7Q/oHzHJ4ktJSFBtdrt2wbBhqs2uj7SqXFFmZiaLFy/mo48+IiMjgx49erBo0SKioqJo2rSptZcnRMNyCfgaFZB2Ak1Qm14eRk0MsLfSuuIgMS6RkEov7W1DXQal3UA3nU7XGUhDbQ97oJaPjQHe0Ol0HmUfhwN/v/FLFEIIUe8UFnJxwVvo/vlPOmcVsrmHE0UvvsStD7xg8alnFy6oM5A+/lgdw7RsGUyaJIfGXklSUhLvvfceer2ewsJCwsPDWbp0KREREdjZ1enAXSEaFw34FRWOvkGdgeQPvAtMAeQ85utSZ0FJ07RSnU73GCr02AOfapp2UKfTvQrEa5r2X51ONwD4HvAAxuh0ulc0TeutadoFnU43DxW2AF41DXYQQgjRQBUXU/zJIgpfeQmPzBw2d7Yj5ZUHuX/mhzRzbGbRpRiN8Pnn6rDYCxdg7lx45RVo0cKiy7ApmqYRExPDggULiImJwcnJiSlTpvDkk0/SW6ZcCHFjnUW11S1FjfF2BSaiqkeDqHkTi7hqdTpWRtO0dcC6Kp97qcL7u1FtdTU99lPg07pcnxBCiHqgpATt88/Jf/k5mmVksssXfn5pBFOf+pwRLTpZfDl798KcObB9O9x8MyxcCAEBFl+GzcjPz2f58uUsWLCA5ORk2rZty7x585gxYwatWsmfs4W4YQyo8sNS4L9AKXBz2cf3ocKSuKFk/qYQQgjrKC2FL7+k6KXncfrjFAe94bO5nZnw1FJe7jzS4svJyoIXX1TByMtLVZSmTAHpFKtZWloaCxcuZPHixZw/f55+/fqh1+uZMGECjo6O1l6eEA1HKqp08DlqM0sr4AlU9egGHWotaiZBSQghhGUZjbByJaX/eAmHwykcbAfvPOjG8Nn/5MOg6djbWXbHsaaBXg//93+QmQmzZsG8eeDhceXHNkYJCQnMnz+flStXYjAYGDduHE899RTDhg2z+B4yIRqsQmA1qloUC9ihThl9H7gDkL9FWIQEJSGEEJZhNML336O9/BK6g0kcbmPHSxPs8Jn6GB+F/AMPF8snk/37VZvd1q0weDBER0P//hZfRr1nMBhYs2YNCxYsYMuWLbi6ujJnzhzmzp1L166WPcdKiAYtERWOVgAXgU7APOBBLrNZRdQlCUpCCCHqlqbB2rXw0kuwbx+pbRx57h7IuiOU+be9h3+ruj+DqKrsbHj5ZfjwQ1U5WroUHnxQ2uyqysnJYenSpbz//vscP36cjh078u677/Lwww/j7u5u7eUJ0TBkAV+hAlIC4ASMR7XWjURVk4RVSFASQghRNzQNYmJUQNq9m4w2Tfm/u2DncB/eiZzPmO5jLN6qpWmwYgX89a9w9izMmAGvvw6eFjx70RakpqbywQcfsHTpUi5dusQtt9zCO++8w7hx43BwkJcOQlw3DfgFWAJ8h2q1C0C11k0CS54HKy5P/msnhBDixtI0iI1VAenXX7nYpjnP3mnPN0E6ng15iyWDn8TJwcniy/rtN9Vm98svMGAA/PgjBAdbfBn1lqZpbNmyhQULFrBmzRrs7Oy47777ePLJJxkwYIC1lydEw5AOfIEazpACNEe11T0C9EfGetczEpSEEELcOFu2qNFxmzeT19qDV8c3Z75/DpOCHyQp9A3aubWz+JJyctQZSO+9B+7u8Mkn8PDD0mZnUlxczDfffMP8+fPZs2cPnp6ePPPMM8yZM4f27dtbe3lC2L4S1GE5S8veGoDhwEvA3UBT6y1N/DkJSkIIIa7fjh0qIG3cSHFrL96/vwMvdD1BYKdBbI18n4HtB1p8SZoGX38Nf/kLnD4NjzwCb7wBLVtafCn1UmZmJosXL+ajjz4iIyODnj178vHHHzNlyhSaNpVXbkJct8OoytEXwGmgLfA34CGgmxXXJWpNgpIQQohrl5CgWuzWrcPg5cnKqUE80j6BFp6O/GeUnkl9J2Gns3zpJikJHnsMNm2CoCD4/nsYNMjiy6iXkpKSWLBgAcuWLaOwsJDw8HA+/fRTwsPDsZMymxDXJx+152gJsAWwB25HDWa4DXnlbWPk6RJCCHH19u1TY+PWrEHz8CBuegT3t91CVpMD/GXI33lu2HO4Olr+mPjcXHj1VZg/H9zcYNEiePRRsLfs0Uz1jqZpxMTEMH/+fDZs2ICzszNTpkzhiSeeoHfv3tZenhC2TUNNq1uCml6XA/gBbwJTAct3HIsbRIKSEEKI2ktKUgHpu+/Q3N059Nj93O+7g/0FMdzZ807eDX+XLh5dLL4sTYNvv4Wnn4a0NHjoIXjrLWjVyuJLqVfy8/NZtmwZ7733HsnJybRr147XXnuN6dOn06qx/+MIcb0uAMtRe4/2Ay7APajBDMOQwQwNgAQlIYQQV3b4sJqI8NVX0KwZZ5+azvRuh1hz9mt6u/bmf/f8j1FdRlllaYcOwdy5sHEjBAaqwDRkiFWWUm+kpaXx0UcfsXjxYi5cuEC/fv3Q6/VMmDABR0dHay9PCNtlBGJR4Wg1UAwEA4uAiYAcL9agSFASQghxeampMG8e6PXg7EzBU4/xSnA+7xxZSvOc5nwQ+QEzg2fiYGf5Xyd5efDaa/Duu9C0qTo8dubMxt1mFx8fz4IFC1i5ciUGg4Fx48bx1FNPMWzYMIufWSVEg3IS+Bw1nOE44AHMQO09CrDaqkQdk6AkhBDCLCSEwKws+O9/VQr57DOwt8f4+Fy+iGjLX/f/i6wjWcwMmsmrI1/Fq6mXxZeoabB6NTz1FJw8CVOnwj//CW3aWHwp9YLBYOCHH35gwYIFbN26FVdXV+bMmcPjjz9Oly6Wb4MUosEoBtaiqkcxqGpSGPAGcBfgbL2lCcuQoCSEEMKsoACXU6egW9ns2hkz2DZ5BLP2zuPAzgOEdArhvdHv0bdNX6ss78gR1WYXEwN9+8KXX8LQoVZZitXl5OSwdOlS3n//fY4fP06nTp3497//zUMPPYS7u/T/iEYqBAKzAiHxOr5GMioc6YFzQHvgOWAaIH97aFQkKAkhRGNXUKBKNEuWwK5dOAJMn86Jx6bwVPJ8VsfcR6cWnVh13yru6nmXVVq48vPVGUj/+hc4O6vDY2fPBodG+FssNTWV999/n08//ZRLly4xdOhQ3n33XcaOHYtDY/wHEeJGyAVWogLSdtQr5HGo1rpw1Jhv0ejIf1GFEKKx2rsXli6FFSsgKws6d4ZOnTjt6sRHE1rxzppR2NvZ89rI13h6yNO4NHGx+BI1DdasgSeegBMnYPJkePttaNfIxu2OGDGCtLQ0+vTpw5o1a7C3t2fChAk8+eSTBAcHW3t5QtgmDdiBCkcrUWGpF/AOMAVobb2lifpBgpIQQjQmWVmqX23JEhWUnJzg7rvh4Ye5OCiAL2YM4l8+qaRveZ1JfSbx1qi38GnuY5WlpqTA449DdDT07g2bN8Pw4VZZitWcPXuWr776ij179pCbm8vFixd59tlnmTNnDu3bt7f28oSwTeeAZaiAlAQ0AyagqkdDkLHeopwEJSGEaOg0TaWMJUtg1SooLISAAPjgA3jgARIKj7Fw90K+WnAHBd0KuKn5TXx7z2Ju9r3ZKsstKIA331QDGpyc4N//hscegyZNrLIciyssLGTt2rXo9Xqio6MxGAy4urri4+PD77//TtOmTa29RCFsjwH4H+pQ2P8CJcBg4D+okORmvaWJ+kuCkhBCNFTp6fDFF6q97uhRcHeHadPg4YfJ79OTlQe/YdGq0exO303TJk2Z0ncKswbMIutQltVC0tq1qop0/Dg88IDak+TtbZWlWJSmafz666/o9XpWrlxJdnY23t7e/OUvf2HKlCncdNNNxMXFSUgS4modR430/hw14rslMBd4COhttVUJGyFBSQghGpKSEvjpJxWO1q0DoxFGjICXX4a77+ZwwSk+jv+Yz+d/zsXCi/Rq2YsPIj9gSt8puDurSWlxh+IsvuzUVLUP6ccfwd8fNm2CkBCLL8PiUlNTWbZsGXq9ntTUVJo2bcr48eOJiooiNDQU+8Z8KJQQ18oIfI1qrfu57HMRwL+BsYCcuSxqSYKSEEI0BIcPq3D0xRdw5gy0bQv/93/w0EOUdu3M2t/XsnDVODambsTBzoHxvcYzO3g2wzsOt+pBpIWFajjDm2+qg2L/9S8VmBpym11WVhbffvster2erVu3otPpGDlyJC+99BLjx4/HzU16gIS4KudRe42SgcPQ/GxzmAh0BP4BPAh0sNrqhA2ToCSEELYqLw+++04FpC1bVNK4/XZ45BGIjCS94CxL9izhk7WfkHYpDd/mvrw28jUe7v8wbV3bWnv1rFunzkRKTYUJE+Cdd8DHOnMj6lxJSQkbNmxAr9ezZs0aioqK6NmzJ2+88QaTJk2iQwd5FSfEn9KAM6hAZLoll709W+E6OyhtXorjN47qcFg7i69UNCASlIQQwpZoGiQkqMEMX30FOTng5wdvvQVRUWht2xJ3PI6F30/kh0M/UGosJaJrBAtvX8ht3W7Dwc76/9k/fhyefFKN/e7ZEzZuhLAwa6/qxtM0jcTERPR6PV9++SVnz57Fy8uL6dOnExUVRVBQkFWreULUSxpqL5EpBFW8ZVW4zh3wB8agRnr7l92iID87H8dbpb9OXD/r/8YUQghxZRcuwPLlqnq0fz+4uMA996jq0bBhZBVl80XiF3y8+mMOZR7C08WTJwc9yYzgGfh5+ll79QAUFamq0euvg06nst1TT4FjA3s9k56ezooVK9Dr9fz22280adKEMWPGMHXqVEaPHo1jQ/uBhbgWBtSgharVoWTUeUYmLVEB6H7MYagX0I6ax3jL3x7EDSRBSQgh6iujEWJjVThavRqKiyE4GBYtgokTwd2dPRl7WLj2Ub488CUFpQUM9hnMF3d+wb3+91rlgNjLiYlRI75TUlS++/e/wdfX2qu6cfLy8vj+++9ZtmwZGzduxGg0MmTIEBYtWsR9992Hp6entZcohHWUAEep3jJ3CCiscJ03KgRNo3IgamXJxQpRmQQlIYSob06ehM8/h08/VX1qHh4wYwY8/DAEBFBQUsA3B79hYfxCdqXtommTpkzuO5lZwbPo166ftVdfyYkTqmq0ejV066YCU3i4tVd1YxiNRuLi4tDr9axatYrc3Fw6duzI888/z5QpU+jWrZu1lyiE5RQCh6neMncEFZZMOqJCUBjmMNQLaGHJxQpROxKUhBCiPiguVocILV2q0oTRqDbuvPEG3HUXODuTciGFjzf8lc8SP+NCwQV6tuzJ+6PfZ0rAFFo4169XGcXFqmo0b57aVvX66/CXv6gDZG3doUOHWLZsGcuWLePkyZO4ubkxYcIEoqKiGDp0KHZ2sntcNGB5qGpQ1Za5o6ix3KAGKHRFBaCxmCtEPQBXC69XiOsgQUkIIawpOVmFI70ezp2D9u3huefUwbBdulBqLOXHwz+yKH4RG45uwMHOgbt63sXsAbMZ0XFEvRwGsHGjarP7/XeV8ebPh44drb2q65OZmcnKlSvR6/Xs2rULOzs7IiIiePvttxk7dqwcBCsanmyqV4eSUfuKTByA7kAAahy3aahCd8DZgmsVoo5IUBJCCEvLzYVvvlGT67ZvBwcHGDtWtdZFRIC9PRmXMliyeR6f7PmEUzmn8Gnuw6shr/JI/0do59bO2j9BjU6dgqefhm+/ha5d1fjvyEhrr+raFRUV8dNPP7Fs2TJ++uknSkpKCAgI4N1332XixIm0a1c/nwchrkom1atDSUB6hWucgZ7AEOBhzBWirkADPvNMCAlKQghhCZoGO3eqcLRypQpLPXuqE1anTIE2bdA0jc1/bGbh7oV8f+h7So2lhHcN54PID7ij+x31YrR3TYqL4b334JVXwGCAV1+Fv/0NnG3wL8qaprFz5070ej1ff/01Fy9epG3btjz++ONMmTKFgIAAay9RiKunAaep+QyicxWua4YKQLdSeeR2J8Decsu9LnGQGJdICCHWXoloAOrnb10hhGgoMjNh2TIVkJKSoGlTdbrqI4/AkCGg05FdmI1+5wcsil9EcmYyHs4ePDHoCWYEzaCbV/0eCBAbq9rskpNVUWzBAujc2dqrunrHjx9n+fLl6PV6jhw5grOzM3fddRdRUVGMGjUKBwf5dSlsgBF1BlHV6lASqpXOpAUqAI2j8oQ5X2S8thAVyH/5hRDiRjMY1EadJUvUqaolJTBoEPznPyokubkBsDdjL4viF7HiwAryS/IZ2H4gn4/7nPt631evRnvXJC0N/vpX+PprFYzWroU77rD2qq5OTk4O3333HXq9ns2bNwMwYsQInn32We655x6aN29u5RUKcRkG4Bg1n0GUV+G61qgQNInKFaI2SCASohYkKAkhxI1y/Dh89pm6nTwJXl4wZ47ae3TTTQAUlhbyzT49i+IXsePUDlwcXHigzwPMCp5FkHeQdddfCyUl8MEH8PLL6v2XX4ZnnlHn39qC0tJSNm7ciF6v5/vvv6ewsJBu3boxb948Jk+eTKdOnay9RCHMSoAUKleGkoDfgaIK17VHBaBHqFwh8rLkYoVoeCQoCSHE9Sgqgh9+UJPrNm5UnwsPh3ffVb1oZfOwj144ysfxH/NZ4mecLzhPD68eLIhYQFRAFB4uHlb8AWpv82aV+w4ehNtug/ffV0MbbMH+/fvR6/WsWLGC06dP4+HhwbRp04iKimLQoEH1cnqgaEQKUeGnasvcEaC0wnWdUSEoHHMg6gm4W3KxQjQeEpSEEOJaHDigwtHy5XD+PHTooMorDz5YPgvbYDTw0+//ZeHuhcQcjcFeZ89dve5iVvAsRnYaWS9fnIeEQFZWIImJ5s9lZKjhDCtWqB/thx9UBqyHy6/k9OnTfPnll+j1evbt24eDgwO33347UVFR3H777Tg1hEOdhG3JpeYziFKpfAaRHyoE3YW5OtQDNWxBCGExEpSEEKK2cnLUppylS2HXLmjSRB0U9PDD6nBYezUW6nTuaZbuWcrihMWczDmJt5s3r4S8wiP9H8HbzdvKP0TtlZbCRx/BSy9BYSG88AL8/e9qHkV9VVBQwJo1a9Dr9cTExGA0GhkwYAAffvghEyZMoGXLltZeomgoQiAwKxASa7gvi5oHKpyocE0TVPjph9pDZKoQdQMkwwtRL0hQEkKIP6NpsG2bCkfffAP5+Wq/0fz5MHkylL3w1jSNX45vZlH8IlYlr6LUWMqoLqN4b/R7jOkxpt6O9r6crVth9mxVOIuIUPuSutXTAXxGo5GtW7ei1+v59ttvycnJwdfXl2effZYpU6bQs2dPay9RNFC6Uh1spnooyqhwkQuqPW4Y5uqQ6Qwi2/rPghCNjvxfVAghanLmDOj1KiD9/ju4usKkSap6NHBged9ZdmE2y/YvY1H8IpLOJeHh7MHcgXOZGTyT7l7drfxDXL3CQjhxoinDhoGvL6xapYpm9bHN7siRIyxbtoxly5Zx/PhxXF1dueeee4iKimLEiBHY2dlZe4miocgHDgIHKtx+BfcSd8qP63FDBaAIzNUhf6Ajqp1OCGFzJCgJIYRJaSnExKhwtHat+viWW9RYt3vvVWGpTOLpRBbtVqO980ryGOA9gE/HfsqEmybQtEk97k2rgdGo5lB8+KE6E1ena8Lf/w7PPw/N6tmeiAsXLvDNN9+g1+vZvn07Op2OW2+9lddee40777yTZvVtwcK2GICjVA5EB1CT57Sya5oCvQEvKLArwOUzFxWI2iMjt4VoYCQoCSFEaip8+qka652eDq1bw5NPqupRhbatwtJCvkv6joW7F7L91HacHZx54KYHmDVgFsHewVb8Aa5NVhZ8/jksXAhHjkCrVmomRbNmObzxRv0Zo1VcXMz69evR6/WsXbuW4uJievfuzdtvv80DDzxA+/btrb1EYYvOAvupHIgOAgVl95uGKvRF7SHqC/QBupTdFwJFWUW4hNvIbHwhxFWToCSEaJwKC2H1anUo7KZNYGcHo0erssodd6hBDWVSL6ayOH4xS/cu5XzBebp7dWd+xHymBky1mdHeFR04oIY0LFumtlwNHqwG9t1zj9qPlJWlXfmL1DFN00hISECv1/PVV1+RmZlJq1atmD17NlFRUQQGBtbLqYGiHspH7RuqGorOVrimDSoEzSx72xdVJZIMJESjJkFJCNG4JCaax3pnZUHnzjBvnhrr7eNTfpnBaGDdkXUsjF9ITEoMdjo7xvUcx+zg2YR2DrW5F+klJfD99yog/fILODvDxInqXKSgenTO7cmTJ1mxYgV6vZ7k5GScnJwYN24cUVFRhIeH06RCgBWiEgNqzLYpCJmCUcW2ORfgJuAOVCAy3Vpfw/eLg8S4RELKNykJIRoaCUpCiIYvKwu+/FIFpD171CGwd9+tWutCQlQ1qcyZ3DMs3atGe5/IPoG3mzcvjXiJR/s/SvvmttfilZEBn3wCixer9zt3hn/9C6ZNAy8va69Oyc3NZfXq1ej1emJjY9E0jaFDh/LJJ59w77330qJFC2svUdQ3Z6keiCq2zemo3DZnCkRdAHtLL1YIYaskKAkhGiZNU6WTJUvgu+9Uq11AgJpz/cAD4OlZ4VKNrSe2sjB+IauSVlFiLCGscxj/Dv83Y3uMpYm9bVUxTBPNP/xQTa0rLVVdhf/5j3pr/ycvFOPiIC4uEer4r+QGg4FNmzah1+tZtWoV+fn5dOnShZdffpnJkyfTtWvXOv3+wkaY2uaqhqKKbXOtqdw21wfVNmdbM1WEEPWQBCUhRMOSng5ffKGGM6SkQPPmqnzy8MPQv3+lOdc5RTks26dGex88dxB3J3fmDJjDzOCZ9GjZw4o/xLXJy4MVK1R73f790KIFzJ0Ls2bVnzOQkpKS0Ov1LF++nLS0NNzd3Zk8eTJRUVHcfPPNNtfSKG6Qqm1zplBUtW2uN3A75n1E19o2J4QQtSBBSQhh+0pLYd06VT1atw4MBhgxAl56SbXYNa38p+V9p/exKH4Ry/cvJ68kj6B2QSwdu5T7b7rf5kZ7g5pYt3ChGtqXna0KZ598ogpn9WFa9tmzZ/n666/R6/UkJCRgb29PZGQk8+fPZ8yYMTg7O1t7icKSKrbNmW6/Ub1trg/wAOZQJG1zQggLk6AkhLBdR46ofUdffAGnT0PbtvC3v8FDD1UroRSVFqnR3vEL+fXkrzg7ODPxponMCp7FgPYDrPQDXDuDAaKjVXtdTAw4OKipdXPmqKOfrF2YKSws5Mcff0Sv1xMdHU1paSn9+/dnwYIFTJw4kdatpQzQ4BVQ87S5MxWuaYUKQTOo3DZXDwK+EEJIUBJC2Jb8fLXnaOlStQfJ3h5uv1211t12m0oMFRy7eIzFCWq0d2Z+Jt08u/Fu+Ls8GPggni6el/km9df586qrcOFCOH4c2rWDV16BRx9V71uTpmls374dvV7PypUrycrKwtvbm6effpqoqCh69+5t3QWKumHE3DZXMRSllN0H4Ixqm7uNytPm2lh6sUIIUXsSlIQQ9Z+mQUKCCkdffgk5OeDnB2++CVOnVksIBqOB9SnrWRi/kOgj0eh0Osb1GMes4FmEdQnDTmd3mW9UfyUkqL1HX32l5lIMHw5vvw133lnpyCerSE1NZfny5ej1eo4ePUrTpk0ZP348UVFRhIaGYv9n0yOEbTlHzdPm8svu1wFdUSFoIuZA1BVpmxNC2BwJSkKI+uvCBTWdYOlS2LcPXFxUf9kjj8CwYdX6y87mnWXpHjXa+4/sP2jr2pYXh7/Io0GP4tPc5zLfpP4qKoJvv1UBaccOtdVq6lTVXtenj3XXlp2dzbfffoter2fLli3odDpCQ0N58cUXGT9+PG5ubtZdoLg+pra5qqGoattcH+BRzIMVpG1OCNGA1GlQ0ul0o4H3UH9HWqJp2ltV7ncC9EAQcB6YoGnacZ1O1wlIBn4vu3SHpmkz63KtQoh6wmiETZtUOFq9WqWFoCDVazZxohrlVoGmaWw7uY2FuxfyXdJ3lBhLGNlpJO+Ev8O4HuNsbrQ3wMmT8PHHapz3uXPQvTssWKBCkjWPFCotLWXDhg3o9Xp++OEHioqK6NmzJ2+++SaTJk3C19fXeosT16Zi21zVaXNV2+YiMVeI+iJtc0KIBq/OgpJOp7MHPgJuBU4Bu3U63X81TUuqcNnDwEVN0/x0Ot39wD+BCWX3HdU0LbCu1ieEqGdOnYLPP1cbcI4dAw8PmD5d7T0KCKh2+aWiSyzfv5yF8Qv57exvuDu5M3vAbGYGz6Rny56WX/910jSVDz/8ENasUR+PGQOPPQZhYZXOxLXwujQSExNZtmwZK1as4OzZs3h5eTF9+nSioqIICgqSkd62omLbXMVpczW1zd2PORT5IW1zQohGqS4rSgOBFE3TUgF0Ot3XwDhUMd9kHPCPsve/Az7UyW9cIRqP4cMZcOIE+Pur0W1GI4SGwuuvw113QQ1jow+cOcCi+EUs27+M3OJc+rXtx5IxS7j/pvtp5mh7PXNhkF8AACAASURBVD85ObBsmWqvS04GLy81uG/mTOjUyXrrSk9PZ8WKFej1en777TccHR0ZM2YMUVFRjB49GkdHR+stTvy5qm1zptvpCte0xNw2ZwpEvZG2OSGEqKAug1J74GSFj08Bgy53jaZppTqdLhvwKruvs06n2wvkAC9omralDtcqhLCUU6dUKFq/HrZvp1lpqToH6bnn1MGwXbpUe0hRaRGrklexKH4RW09sxcneiftvup9ZwbMY2H6gTVY0kpJUONLrITcXgoNVQW3ChBrzYZ3TNI1Dhw4xduxYTp8+TX5+PkajkSFDhrBo0SLuu+8+PD1tb0pgg2YEjlF9/PYRKrfN+QMRmPcRmabN2d7/bYQQwqJ0mqZd+apr+cI63b1AhKZpj5R9PAUYqGna3ArXHCy75lTZx0dRlahcwFXTtPM6nS4I+AHorWlaTpXvMR2YDtCmTZugr7/+uk5+lmuRm5uLq6urtZchKpDnxDrsiotx378fz9278dy1i2bHjwNQ1LIlGI0UubmxZ+lSNea7itOFp1mbvpZ1p9eRVZJFe5f2jG03loi2Ebg3cbfwT3L9DAYd27Z58cMP7dm714MmTYyMHHmWO+9Mo1evSxZfz+nTp0lISGDv3r3s3buXCxcuANCkSRPuv/9+wsPD8fGxvSEYDZFDjgP2v9nTMqMlrqmuNEttRrPjzbAvVP+/0XQahe0Kye2SS17nPPK65JHbJZeC9gXSNleH5PdK/STPS/1T356TkSNHJmiaFnyl6+qyonQKqLiz1wdIv8w1p3Q6nQPgDlzQVHorAtA0LaEsQHUH4is+WNO0T4BPAIKDg7WQkJA6+DGuTVxcHPVpPUKeE4vRNHUQ7Pr1qnK0aRMUFICjo5pp/dhjEBGBU+/eMHIkBVlZhISFlT/cYDQQczSGhbsXsu7IOnQ6HWN7jGVW8CxGdRllk6O9z55Vgxk+/lgV1Dp0UJPNH37Yjlat2gJtLbKOjIwMNm3aRGxsLLGxsRw7dgyANm3aEBERQWhoKGFhYfzxxx/y/xVrMqBGbm+vcDtc4X4vVHUonPIKka63DhdXF1xwoRWtLL3iRkt+r9RP8rzUP7b6nNRlUNoNdNPpdJ2BNNTW0AeqXPNfYCrq18A9QKymaZpOp2uFCkwGnU7XBeiGmssjhKiPLl2C2FgVjtavVyehghrX9sgjMHo0jBgBzapsgIiLIzEujhDgXN45Pt37KR8nfMzxrOO0dW3LC8Nf4NH+j+LrbnvT1DRNjfT+6CM14ru4GEaNgg8+gDvuqHYubp24cOECmzdv5ueffyY2Npbk5GQAWrRowciRI3n66acJDQ2lV69eldoX//jjj7pfnDC7COzAHIp2AqYCY0vgZmAa7LPfR8DkAJWrpW1OCCHqXJ39qi7bc/QYEIMq/H+qadpBnU73KhCvadp/gaXAMp1OlwJcQIUpgOHAqzqdrhT1t7WZmqZdqKu1CiGuktGozjUy7TXatk3tM3J1VSPa/u//ICKixv1GFWmaxoHsAyxZvYRvk76l2FBMSKcQ3h71Nnf2vNMmR3sXFKhDYT/6CPbsATc3mDEDZs+GnnU8jC83N5ctW7aUV4z27t2Lpmk0a9aMYcOGMW3aNMLCwggICJBDYK3FiDr8omK1KLnsPjtUpWgyMKTs1pXyUHQx7iJUPltZCCFEHarTv2lqmrYOWFflcy9VeL8QuLeGx60CVtXl2oQQV+ncOfjf/1Qw2rABzpSdPBkYCH/9q6oaDRmiWuz+RLGhmK0ntrLuyDoW7V5Efmk+zZ2aMyNoBjODZ+Lfyt8CP8yNl5oKixap6eYXLkDv3urop8mTVViqC4WFhezYsaO8YrRr1y5KS0txdHTk5ptv5pVXXiE0NJQBAwbIlDpryUZViEyhaEfZ5wA8UWFoUtnbAYCc0yuEEPWGBZo/hBA2qbRU9Y6ZqkYJCaqfzMsLwsNVMAoPh7ZX3l9zIvsE0UeiiU6J5udjP5NbnIujvSPDOw4nwCGAV+5+xSZHexuNKjN++CGsW6fOOrrrLpgzR3Ua3uhhfKWlpcTHx5dXjLZt20ZhYSF2dnYMGDCAv/3tb4SGhnLLLbfg4uJyY7+5uDINdUx6xWrRwbLP64CbUCcFmqpF3ZEWOiGEqMckKAkhzE6cUMEoJgY2boTsbPXqf8gQePVV1U7Xv3+NE+oqMlWNTOHo4LmDAHR078jkPpO5rdttjOw8EldHV+Li4mwuJF28qEZ5L1wIKSnQpg288II6H/dGDokzGo0cOHCA2NhYfv75Z3755RcuXVKbV/r27cusWbMIDQ1l2LBhuLvb3hRAm3cJ2EXlapGpSbwFMBjVMzEENc9VniIhhLApEpSEaMwKCmDLFvMQhrLN/vj4wL33qqpRWBi0aHHFL3Uy+yTRKSoYbUzdSG5xLk3smjC843CmBU7jtm630bNlT5s888hk3z6192j5cvVPd/PNKj/effcVOw5rRdM0Dh8+XF4x2rRpE+fPnwege/fuTJo0idDQUEJCQmjVSiabWZQGpFC5WnQA83lF/sBdmKtFPVF7joQQQtgsCUpCNCaaBr//bm6ni4uDwkJwclK9YqYJdb16XbFvrMRQwraT21h3ZB3RKdH8dvY3ADq4d2BSn0lE+kUS2jkUNyfb3nRRXAyrV6uAtHUruLjApEmqvS4w8Pq//okTJ8qDUWxsLGlpaQD4+voyZswYQkNDGTlypJxnZGl5qNmtFYNRZtl9bqhq0QuoUDQI8LDCGoUQQtQpCUpCNHQ5OfDzz+ZzjUyjn3v0UOPYIiJUSGra9Ipf6lTOKdanrGfdkXVsTN3IpeJLNLFrwrCOw/jXrf8i0i8S/1b+Nl01MklPh8WL4ZNP4PRpNcDv3Xdh2jTwuI4XxWfOnKl0ltHRo0cBaNWqFaGhoeW3rl27Noh/R5ugAceoHIr2oWauAvQA7sBcLfJHDnEVQohGQIKSEA2N0QiJieZ2uu3b1WAGNzfVRvf3v6tw1KnTFb9UiaGEX0/+Wl41OnD2AAC+zX2ZeNNEIrtFEtY5zOarRiaapjoRP/wQvv8eDAaIjCw/Ixe7a2ilysrKYvPmzeXB6LffVOWtefPmhISE8PjjjxMaGkrv3r0lGFlKAer48orBqGyII81QFaJnUaFoMOqAVyGEEI2OBCUhGoKzZ9X4NdMghnPn1Of79zefaTRkCDS58rlEaTlpqmqUoqpGOUU5ONg5MKzDMN4e9TaR3SLp3aphvajPzVX7jj76CH77TVWMnngCZs2Crl2v7mvl5eWxdevW8mC0Z88ejEYjLi4uDBs2jMmTJxMaGkq/fv1wsMSps42dBpygcijaC5SW3e8HhGOuFt2E/GYUQggByK8DIWxTSYka3W2qGu3Zoz7fsqUKRaNHw623qnFsV/pShhK2n9pO9JFo1qWsY/+Z/QD4NPdhQu8JRPpFEtYljOZOzevyJ7KKw4fV5LrPPlMdioGBsGQJTJxYq05EAIqKiti5c2d5MNqxYwclJSU0adKEwYMH8+KLLxIWFsbAgQNxcnKq2x9IQCGwh8rBKL3svqaos4r+irla1NoKaxRCCGETJCgJYSv++MO8z+jnn9Ure3t7NXrttddUOOrXr1b9YemX0sv3Gv0v9X/lVaOhHYbyz1H/JNIvkpta39SgqkYmBgP89JOqHm3YoIps996rhjMMGXLls49KS0vZs2dPeTDaunUrBQUF2NnZERQUxNNPP11+llGzZrY19twmnaJyKNoDFJfd1xkIwVwt6gtcuagqhBBCABKUhKi/Cgpg82ZzODp0SH2+Qwe4/35VOQoLg1qcn1NqLGX7ye1Ep0Sz7sg69p3ZB0B7t/bc538fkd0iGdVlVIOsGplkZsLSpbBokcqc7dvDvHnw6KN/XngzGo0cPHiwPBht3ryZ7OxsAG666SYeffRRQkNDGTFiBC1qMUZdXIdiVNtcxWB0suw+J1S16AnMwejKZyELIYQQlyVBSYj6QtPUOUam0d2//KJGdzs7q6l0pgl1PXteuewBZFzKKN9r9L+j/yO7KBt7nT1DOwzlrbC3iOwWSZ/WfRpk1aii3btV9ejrr6GoCEJC1PS6sWNr3rKlaRpHjx4tP+R106ZNnCvb8+Xn58eECRPKzzJqU4vWRnEdMqgciuKBorL7OgA3Yw5FgcANOMtKCCGEMJGgJBqFkBDIygokMdHaK6kiK0u10ZnC0cmyP4/36gUzZ6p2uuHD1eE9V1BqLGXHqR3le40ST6sf1tvNm3v87yHST1WN3J2vXIGydYWF8M03KiDt2gXNmsFDD6n2ut69q19/6tSpSmcZnSx7Hry9vRk9enT5WUYdO3a08E/SiJSgRnJXDEbHy+5zBIKAOZiDUXvLL1EIIUTjIkFJCEsyGtXgBVM73fbtatNM8+YwahS88IKqGtXyBfnp3NOV9hplFWZhr7Pnlg638GbYm0T6RdK3Td8GXzUy+eMP+PhjNZAhM1MdFfXBBxAVpf6JTc6dO0dcXFx51ejIkSMAeHl5ERoaynPPPUdoaCjdunVrNP92FneWyqFoN2psN4A3qlo0FxWK+qNa64QQQggLkqAkRF07fdo8unvDBvUKHiAoCJ59VlWNBg2q1ejuUmMpO0/tLN9rtPf0XgDaubZjfM/x5XuNWjg3nr0ymqaKch9+CGvXqs+NHavOPgoNVV2K2dnZrF37S3nFaP9+NdnPzc2NESNGMGvWLEJDQ+nTpw9213JYkvhzpcABKgejo2X3NQH6AdMxV4t8AcmnQgghrEyCkhA3WnGxqhSZqkZ7VZihdWsVikyju1vXbi7xmdwzrE9ZT3RKNBuObuBi4UXsdfYM8R3CG6FvENktkoA2AY2u8pGdDXq9aq/7/Xc1Gf2ZZ1THYsuW+fz66688/7yqGMXHx2M0GnF2duaWW27hjTfeIDQ0lKCgIDnLqC5kAjswh6JdQF7ZfW1RYWhG2dsg4MqdpUIIIYTFySsEIW6EY8fM+4xiY+HSJXBwUKO733hDtdMFBtZqdLfBaGBn2k6ij0QTnRJNQkYCAG1d23JnzzuJ9Ivk1q63NqqqUUUHD6pwpNdDXp4qxn36aTEdOuxi27ZYoqJi2b59O8XFxTg4ODBo0CCef/55QkNDGTx4MM7Oztb+ERoWA3CQytWiw2X32aOGLEzDXC3qhFSLhBBC2AQJSkJci/x8iIszh6PDZa8MO3aEBx5QVaPQ0MobY/7E2byz5VWjmJQYLhZexE5nxxCfIbwe+jqRfpEEtA3ATtc428JKSmDNGhWQ4uLA0dFAeHgiXbrEcvhwLHPnbiEvLw+dTke/fv14/PHHCQsLY+jQobi6ulp7+Q3LRSpXi3YCl8rua4UKQ6ZgFAzIUVJCCCFslAQlIWpD0yApydxO98svata0szOMHAmzZ6tw1L17rUZ3G4wGdqXtIjpFVY3i0+MBaNOsDWN7jOW2brdxa5db8XDxqOufrF47fRr+8x/4+GON9PRkPDx+pnfvWE6diuPHH7MA8Pf3Z9q0aeVnGXl6elp51Q2IETgE/Io5GCWX3WeHOsB1MioU3Qx0QapFQgghGgwJSqJR0DQoKrIjNRUcHavf7O1ryDcXL6opAaZwdOqU+ry/v5ozHREBw4bVanQ3qKpRTEqMqhodjeFCwQXsdHYM9hnMvJHzuK3bbQS2DWxUVaOaxrZrGmzbpvH228dYty4WgyEWR8dY4AwXL0KLFp255567CQsLIyQkhHbt2llr+Q1LHpACHIGOP3WEt1DVoqyy+z1RgWhS2duBgBTrhBBCNGASlESDdeaMGjIXHQ2//gqlpc3p2rXma3U6cHTUaGJvxFErwrE0H8eSPBwJwNGuN45uz+PYuRmOLd1xdHPCMQkcU8DxPzUHL0dHcGhi5FzhKVKyD3E46zdO5h4F+yLcmnoS2H4eA3z7EuwbgJebG45GKDwGe9Iu//X+NNQ1AEePpvPWW5tYvfpnLlyIBf4AoFWrdoSHjyo/y6hz587WXagtM4WhskDEkQrvZ5gv60Qn6APch7la1A2pFgkhhGhUJCiJBqO0FHbuVAWg6GhIUDMQaN0avLygSZN83nijKcXFmG+ZORQnpVD8+zGKj56kON9AMU4Ut/KmuF0nitv4Utzci+ISu0qPy82l8tcpvxnJLyqluBiMJY5Ah7JbePk6LwFbym7XQqdTk8SvFKiu5Xajv+7lQp3BYODIkSOcPZtIRsbPeHlt5cKFQwDY23vQr99IJk/+G7fdFkaPHj0a3US/65KHGr1dNQilAOlVrm2DCkARZW+7AX6w9fRWhkUOs9iShRBCiPpIgpKwaRkZKhitX6+qR1lZ6sX5kCHw2msQGamGzYV6JlKaW8qUCX1h2zbzEIZ9+9QXatMG7oswj+5u2bJW399gNBCfHl++12h32m40NFo1bUVE19FEdL6NEb634ubgdZlgdfW3kpKru/7yoa7yrS7odODgcAkHh/3odPvQtH0YDImUlBxA00yni7qi0w0nIOAR5s4N5cEHA7C3bzzth9ckn8oBqOLbmsKQHyqrlwUhugFdgcvMGjHEGepg0UIIIYRtkaAkbEpJiTqiKDpa3Uw5p107GD9e5ZxRo8DDAzVs4fBh+DaJBws34VeaBF57VXJwcIChQ+HNN9WD+vat1ehugMz8zEp7jTLzM9GhY5DPIP4R8g8i/SIJ8g6yqb1GmqYqctcaxoqLoahI48yZkxw/vo8TJxJJS9tHRkYiFy8epaREfR8nJw88PQNxd5+Bm1sgR44E4OTUlb173fD2tu6/Qb1jCkM1tclVDUOtUeEnHHMQukIYEkIIIcSfk6Ak6r1Tp8ztdBs3Qk6Oyjm33AJvvQWjh+fT1yEJXXIS7EmG5UmQnAxHj4LRCMAU7EjT+cCUKWoIQ2gouLnV6vsbNaOqGpWda7QrbRcaGi2btmS032gi/SIJ7xpOy6a1q0LVR6Z2viZNoFktxjkXFRWRlJTEvn37SExMZN++fezbt4+LFy+WX+Pn50dYWD8CAh4kMDCQgIAAfHx8KrXRqWEOWY03JOVz+Ta5tCrXmsLQrVRqk8MPCUNCCCFEHZCgJOqd4mLYulUFo/Xr4bff1Od9vI1MGHGWSJ8DhOliaZ6aCAuT4NkT5gc3aQLdukFAAEycCL16gb8/kcMKyDfYs3VhcK3WcD7/PDFHY8rPNTqXfw4dOga2H8jLI14mslskwd7BNlU1ulbnzp0rD0KmUJScnExpaSkATZs2pU+fPtx3330EBAQQGBhInz595Pwik4phqGqbXE1hyA8YReU2OQlDQgghhMVJUBL1wh9/mNrpNH7eqJGXb0cTewPD2x1hatc4IrO+wj/9F3SmliMXF+jZU43nLgtD9OoFXbuqsFRFcT/Izcqq9nkTo2YkIT2hfK/RrrRdGDUjLZu2JKJrRHnVqFWzVnX0L2B9pgELVUNRerq5z6t9+/YEBAQwZswYAgICCAgIwM/PD3t7eyuuvB4whaGqQaimMNQKFX5GUb1Nzt1C6xVCCCHEFUlQElZRWKDxy6pzrF+dT/Q2Nw6d9QKgk90Joow/MZr1hBpicc2xVyFoeC/wH2MORR071npP0eWczz/PhqMbiE6JZn3K+vKq0YD2A3hx+ItE+qmqkb1dwwsBly5d4sCBA+VhKDExkQMHDlBQoAYsODg44O/vT1hYWHnbXEBAAC1rOeSituLiIC4uEQi5oV+3ThRQvTJkev9UlWtNYSiM6m1yEoaEEEIImyBBSdQtgwFSUyE5maNb0one3JT1hzuzKbs/+bTGiUJGsJkZzbYwutcf9AhyReffC/wfh16LwNv7hh0apFF5r9HOtJ0YNSNeLl5E+KmqUUTXiAZVNdI0jZMnT1aqECUmJnL06NHyazw8PAgMDGTGjBnlrXO9evXCycnJiiu3ElMYqmmAQk1hyA8IpXqbnIQhIYQQwuZJUBI3RnExHDkCSUnqlpxM/m+pbP69LdGlo4gmkhTGAtDVJY2H+iYQOSyXkHHuNO0XBC0jbviSzuSeIT49noSMBNxnJrA/dQsD/qOGDQzwHsALw14gslskA7wHNIiqUW0HLPTr148HH3ywPBRVHbDQ4BUAqdQ8QOFklWtbosJPKJWDkB/QwkLrFUIIIYRVSFASVyc/Hw4dKg9D5W9TUtAMBg7TnfVEEu0ym81Fgyg0OuHiWMrI4Es8Pq6AyPEu+Pm1B9rf0GWdyT1DQkYCCekJxGfEk5CeQNoltTlEh47uXt0J9ghmys1TiPCLoHWz1jf0+1va1Q5YCAgIoE+fPrjVctKfzSvkz9vktArXmsJQCNXb5CQMCSGEEI2WBCVRs6wsFYAqhqGkJDh+3HyNgwN5XfsS6zmV9YGhRJ/ozbFzatJZjw4wM1Id+DpsmAMuLh43bGkVQ1FCRgLx6fHVQtGITiMIbhdMkHcQ/dr2w83Jjbi4OEICQm7YOizBYDCQkpJSqUKUmJhY44CFO+64o3w/UaMYsGAKQ5drk6sahvwwh6GK1SEJQ0IIIYSogQSlxkzT4Ny56mEoKQkyMszXOTmpCXNDhqBNe4jk5oOITu9LdHxrtmyzo/h3dfZOaCj8LVKd39q5841Z4tm8s6pKVNZCl5CRwKkc82aRHl49GNFpBEHtgghqF0S/dv1o7mSbc5SrDljYt28fBw4cID8/H6g8YMHUNlcXAxbqlUL+vE2uYhjywlwZqtomd+NyuhBCCCEaCQlKjYGmQVpa9TCUnAznz5uvc3VVE+XCw83jtv39yfHsROxme3Wu0VI4UXZsUe/eMHeuqhoNHary1PUwhSJTlahqKOru1Z1hHYYR7B1s06GopgEL+/btIyUlpfwaDw8PAgICmD59eoMfsGBXbAdJ1HzO0OXC0HCqV4YkDAkhhBDiBpKg1JAYDKo1rur+oeRkuHTJfJ2npwpCd99tHrft7w/t24NOh6bBgQPqsNfof6vDX0tLwc0NRo2C559XVaMOHa59qRVDkamN7mSOeSe9KRQFtQsi2DvYZkNRxQELFYNR1QELAQEBTJ06tWENWDAC54H0sltGhfdNt30wrHhY5cd5oYLPcCqfMyRhSAghhBAWJEHJFhUXQ0pK9Za533+HwkLzde3aqQA0dao5DPXqBa1aVRu5nZUFG1epQ1/XrwfTFpi+feEvf1HB6OabwdHx6pd7Lu9ctUELVUPR0A5DVftc2Z4id2fbm6+cmZlZbQx3TQMW7r333vK2OZscsKABF7h8+Mmo8Lakhsd7Ad5ltwfgOMfpfGtncyiSMCSEEEKIekCCUn1WUKDCT9WWuZQUVeIx6dRJBaBRo8xhqFcvaHH5XepGI+zbp4JRdDRs364KUu7ucOutqp1u9Gh1jNHVqBiKTNWiE9knyu/v5tmNWzrcUmnQgq2FItOAhaqhqOKABW9vbwIDA21rwIIGZPHn4cd0K67h8R6YA1BIhfcr3toCVboH/4j7g84hN2hTmxBCCCHEDSJBqS6EhBCYlQWJibW7Pien8oQ5UzA6dkztLwKwtwc/PxWAxo83t8z16KEmKdTChQuwYYOqGK1fD2fOqM/37w/PPKPC0eDB4FDL/1Vk5mdW21NUNRTd7HszcwfOVe1zNhiKTAMWKoaiqgMWevXqVb8HLGjAJa4cftJRwxOqckeFnHbAUKqHn3ZlN5e6/CGEEEIIISxLgpIlZWZWD0NJSWrQgomjowo/AwZAVJS5QtSt21VPSzAaISHB3E63c6f6nKenmtcwejREREDbtrVYeoVQZApGFUORn6dfeSgKahdE/3b9bSoUVRywUDEU/dmAhYCAAPz9/a07YCGXK4efDCCvhse6oQKONzCY6uHH9LZ2OVwIIYQQokGRoFQXiopwuHQJ3n+/8j6ic+fM1zRrpgJQaGilCXN07lz7kk4Nzp1TVaPoaIiJUdlMp4PgYHjhBRWOBg5UBarLOZ9/vlKVKCE9gT+y/yi/38/TjyE+Q8pDUb92/WjhbDuH0RQVFZGcnFypbe5KAxYCAgLw9fW13ICFfK4cftJRlaKqmmIOPMFUDz+m921sa5QQQgghhCVJUKoLBw7gmpcHTzyh9gn5+8O4cZUnzPn4gJ3ddX8rgwF27SqbUBcN8fGqW69lS1UtioxU1aNWrWp+vCkUVRy0UDUUDfYZzJwBc8qnz9X3UKRpGhcvXuTUqVOVbjt27OCJJ54gKSmpfMCCi4sLffv25d577y1vnavTAQsFqJBTU/ipGICya3isM+agEwCMpuZ9QG6AjQ/ME0IIIYSwNglKdaFLF3Lz83HduhXatKk2Ye56nTlj3me0YYPae2RnB4MGwT/+ocJRUFD1HFYxFJla6I5nHS+/v6tH1/JQFOSt2ufqWyjSNI3MzMxqIejkyZOVPi4oKKj0ODs7O7y8vBgwYAC33357eSi6YQMWioDTXHkf0MUaHuuIOeT4A6OoeR9QCyQACSGEEEJYiASluuDpSamdXe02/9RCaSns2GHea7Rnj/p8mzYwZoxqp7v1VvDyMj/mQsGFaoMWqoaige0HMjt4dr0JRUajkTNnzlQLQVVvxcWVR645ODjg7e2Nj48P/fr1Y8yYMfj6+uLj41N+a9u2LVu3biUkJOTqFlVC9QBUUzXofA2PbYJ50EF3qk+CM7XCeSIBSAghhBCinpGgVE+lpak9RtHR8L//QXa22lc0ZAi8/rqqGgUEqKpReShKNgejmkLRrOBZ5YMWPFwse1hNaWkpp0+fvmz4OXnyJOnp6eUtcSaOjo7lYWfw4MGVwo/p1rp166uvCpUCZ7jyPqCzNTzWHjXm2hvoQuVJcBX3AXkB199dKYQQQgghrECCUl2IiyMxLo6Qq3hISQls22bea7R/v/q8tzfcfbcKRqNGgdHpAnsy9hCTHs8bq1Qb3bGsY+Vfp4tHF4uHouLiYtLT0/+0CpSRkYHRaKz0OBcXl/KwM2LEiGoByNfXl5YtW9Z+gEIhcA4Vbiq+LXu/T3Ifdf5POiokC41dSgAAD2ZJREFUaVUebwe0QYWcDpgnwVUMP95AS1RYEkIIIYQQDZYEJSs6edJ84OvPP8OlS2rg3dCh8M9/ws0hORR47WJPRgIrM+L5vy+qh6Jg72BmBs+ss1BUWFhIWlran4agM2fOoGmVU0ezZs3w9fXF19eX8PDwGitBHh4efx6CioA0Lht8qn2upglwoPYAtQLHpo6qBa4/NQ9BaI0EICGEEEIIAUhQsqiiIti61RyOkpLU5319Yfy9RXQecAg6x3IwZzuLMxJ4Jjq1/LGmUDQjaEb5niJPF8/rWk9eXh5paWnVBiFUvGVmZlZ7XIsWLcrDTmBgYI0hqHnz5tVDUDHmcBPPlQPQ5YJPE6AVKti0ArpWeL/q21ZAc0AHCXEJV79HSQghhBBCNEoSlOpASAhkZQWSmAjHjpmHMMTGQl4eODpq9A6+yO1z9lHa9b8ctvsvX2SlqnawM9C5RWeCvIOY3n/6NYeinJycKw5FqHhukImXl9ef7glq3749rq6u6mJT8KkYcpK5fPDJucxiHagcbrpgDjk1BR93ZPiBEEIIIYSoUxKU6sCFC5CR4ULPnvD77+pzHu2yaHvLLnI7fsuZll+x1ymPvUBnu7JQFPQowd7BVwxFmqaRlZV12bHYptulS9XLMW3atMHHx4cuXbowfPjw6iGodXtccl2qh5zDwDaqB6CazvoBc/Ax3QZQPexUDEASfIQQQgghRD0jQakO/H979x9kVXnfcfz9YfnhIGCARVw5q8sophhrIG40idViAo4xVk1jInTSkQnGSQ3SVBPTTmxHbdPa1qnttI5KUxOTVolibTeUCNVAWg1YQBACUUrU4pJxgvJDkUIC/faPc1Yux93lLMu996z38/qHc5/7nHO/l++ce+93n+c858dbXyHeHM9bzf8BlzwKpz/OzrGbOWF0Gxec3M45Lbe8fU3R2OGH1vTuukfQ2ufX9joStHfv3sNeTxItLS0kScLkyZOZMWNGWvyclNA6spVkWEJLtDBs97DDC6BngEUcatvVwxtq4vDC5xx6L3x8vx8zMzMzG+BcKFWBPnEDMW4Dl35kKu0nt3NOy98xZfwUDu45+Hax88K6F3iy88nDRoS2bdvG/v37DztWU1MTEyZMSK8Hev8ULrvoMpJRCclxCcnghISEk/adxJAdQ9Ji5+fAxuzf7m5uCunqbpUFzlR6nubWVfh4mWszMzMzayAulKrgtDWXsmtHK4Nf3c6izkXc23kv27Zte8c9goYMGULSkpA0J5zXdh7J+xKSoQmJEpKDCcm+hPFvjqdpexM8D/yohxccRLpkdVdh8356Hu0ZB4zGhY+ZmZmZWS9cKFXBuOEPsPWna1jzw1aSkQkXjLqA1jGtJJGQ/DIheSsh2Z3QvLOZQVsHwdbcAQaR3qy0q7g5m94LnzG48DEzMzMzO4aqWihJugT4G9KrXL4REXfknh8GfJv0qpfXgasj4uXsuT8A5gAHgXkRsaSasR5LSzcvZfiB4ehVwauk1+uM5VBhM5mep7l1FT6+n4+ZmZmZWd1UrVCS1ATcDcwAOoFVkjoiYlNFtznAzog4XdJM4M+BqyWdCcwE3kd6K9AnJJ0REQerFe+xdPzi41m3Zh1TLp6SFj5jceFjZmZmZjaAVHPC1rnAloh4MSJ+ASwArsj1uQJ4INteCHxM6V1KrwAWRMT+iHgJ2JIdb2C4EHZN3ZWWeSfiIsnMzMzMbICpZqE0AXil4nFn1tZtn4g4QHpnnrEF9zUzMzMzM6uKal6j1N2ddKJgnyL7Iuk64DpIb6a6fPnyPoZYPXv27ClVPOaclJXzUj7OSTk5L+XjnJST81I+AzUn1SyUOoHWiscJ8LMe+nRKGgycAOwouC8RMR+YD9De3h7Tpk07VrH32/LlyylTPOaclJXzUj7OSTk5L+XjnJST81I+AzUn1Zx6twqYJGmipKGkizN05Pp0ANdk21cBP4iIyNpnShomaSIwCfivKsZqZmZmZmb2tqqNKEXEAUlzgSWkyxncHxEbJd0OrI6IDuAfgO9I2kI6kjQz23ejpIeBTcAB4IsDZcU7MzMzMzMb+Kp6H6WIWAwszrX9UcX2PuDTPez7deDr1YzPzMzMzMysO9WcemdmZmZmZjYguVAyMzMzMzPLcaFkZmZmZmaW40LJzMzMzMwsx4WSmZmZmZlZjgslMzMzMzOzHBdKZmZmZmZmOS6UzMzMzMzMclwomZmZmZmZ5bhQMjMzMzMzy3GhZGZmZmZmluNCyczMzMzMLEcRUe8YjglJ24H/qXccFZqB1+odhB3GOSkn56V8nJNycl7KxzkpJ+elfMqWk1MjYtyROr1rCqWykbQ6ItrrHYcd4pyUk/NSPs5JOTkv5eOclJPzUj4DNSeeemdmZmZmZpbjQsnMzMzMzCzHhVL1zK93APYOzkk5OS/l45yUk/NSPs5JOTkv5TMgc+JrlMzMzMzMzHI8omRmZmZmZpbjQqmfJF0i6QVJWyT9fjfPXyjpWUkHJF1VjxgbTYGc3Chpk6T1kp6UdGo94mw0BfLyBUkbJK2T9JSkM+sRZyM5Uk4q+l0lKSQNuBWLBpoC58lsSduz82SdpGvrEWejKXKuSPpM9t2yUdKDtY6x0RQ4V+6qOE82S9pVjzgbTYG8nCJpmaS12e+wS+sRZ1GeetcPkpqAzcAMoBNYBcyKiE0VfdqAUcCXgY6IWFj7SBtHwZxcBDwTEXsl/Q4wLSKurkvADaJgXkZFxBvZ9uXA9RFxST3ibQRFcpL1Gwn8GzAUmBsRq2sda6MoeJ7MBtojYm5dgmxABfMyCXgY+GhE7JR0YkT8vC4BN4Cin18V/W8ApkbE52oXZeMpeK7MB9ZGxD3ZH0QXR0RbPeItwiNK/XMusCUiXoyIXwALgCsqO0TEyxGxHvi/egTYgIrkZFlE7M0ergSSGsfYiIrk5Y2Kh8cD/itOdR0xJ5k/Bv4C2FfL4BpU0ZxYbRXJy+eBuyNiJ4CLpKrr67kyC3ioJpE1tiJ5CdIBBIATgJ/VML4+c6HUPxOAVyoed2ZtVj99zckc4PtVjcigYF4kfVHST0l/mM+rUWyN6og5kTQVaI2IRbUMrIEV/fz6VDZlZaGk1tqE1tCK5OUM4AxJT0taKcmj4dVV+Ls+m14/EfhBDeJqdEXycivwWUmdwGLghtqEdnRcKPWPumnzX8Hrq3BOJH0WaAf+sqoRGRTMS0TcHRGnAV8Fbql6VI2t15xIGgTcBdxUs4isyHnyPaAtIs4GngAeqHpUViQvg4FJwDTS0YtvSHpPleNqZH35/TUTWBgRB6sYj6WK5GUW8K2ISIBLge9k3zelVNrABohOoPKveQklH0JsAIVyImk68DXg8ojYX6PYGllfz5UFwJVVjciOlJORwFnAckkvAx8COrygQ1Ud8TyJiNcrPrP+HjinRrE1siKfX53Av0bELyPiJeAF0sLJqqMv3ykz8bS7WimSlzmk1/MRESuA44DmmkR3FFwo9c8qYJKkiZKGkp6MHXWOqdEdMSfZdKL7SIskzyOvjSJ5qfxR8Qngv2sYXyPqNScRsTsimiOiLbvQdiXpOePFHKqnyHnSUvHwcuAnNYyvURX5rv8X4CIASc2kU/FerGmUjaXQ7y9J7wVGAytqHF+jKpKXrcDHACRNJi2Uttc0yj5wodQPEXEAmAssIf2yejgiNkq6PVu1C0kfzOZhfhq4T9LG+kX87lckJ6RT7UYAj2TLhrq4rbKCeZmbLau7DrgRuKZO4TaEgjmxGiqYk3nZefIc6XV8s+sTbeMomJclwOuSNgHLgK9ExOv1ifjdrw+fX7OABeElnmuiYF5uAj6ffYY9BMwuc368PLiZmZmZmVmOR5TMzMzMzMxyXCiZmZmZmZnluFAyMzMzMzPLcaFkZmZmZmaW40LJzMzMzMwsx4WSmZn1i6RPSgpJv1LD1/ySpOG1er2jIWmapI/UOw4zMzs6LpTMzKy/ZgFPkd5csFa+BNS9UJI0uJenpwEulMzMBigXSmZmdtQkjQDOB+aQK5Qk3Sxpg6TnJN2RtZ0u6Yms7VlJp2XtX5G0StJ6SbdlbW2Snpf0QNa+UNJwSfOAk4FlkpZlfe+RtDq7GettFTG8LOm27LU2dI16SRoh6ZtZ23pJn8raL5a0Iuv/SPb+8u95uaQ/lfRD4Hcl/YakZyStzd7beEltwBeA38tubH2BpHGSHs3e5ypJ5x/bbJiZ2bHU21/CzMzMjuRK4PGI2Cxph6QPRMSzkj6ePXdeROyVNCbr/0/AHRHxmKTjgEGSLgYmAecCAjokXQhsBd4LzImIpyXdD1wfEXdKuhG4KCJey477tYjYIakJeFLS2RGxPnvutYj4gKTrgS8D1wJ/COyOiF8FkDRaUjNwCzA9It6S9FXgRuD2bt73eyLi17v2BT4UESHpWuDmiLhJ0r3Anoi4M+v3IHBXRDwl6RTSu9dP7uf/v5mZVYkLJTMz649ZwF9n2wuyx88C04FvRsRegKyIGQlMiIjHsrZ9kI7iABcDa7PjjCAtnLYCr0TE01n7PwLzgDu7ieMzkq4j/V5rAc4Eugqlf87+XQP8ZrY9nYoRsIjYKemybL+nJQEMBVb08L6/W7GdAN+V1JLt81IP+0wHzsyODTBK0siIeLOH/mZmVkculMzM7KhIGgt8FDhLUgBNQEi6mXRkKPK79HQo4M8i4r7c8du6OUb+MZImko4UfTAreL4FHFfRZX/270EOfe/1FN+/R8SsHuKs9FbF9t8CfxURHZKmAbf2sM8g4MMR8b8Fjm9mZnXma5TMzOxoXQV8OyJOjYi2iGglHU35NWAp8LmulekkjYmIN4BOSVdmbcOy55dkfUdk7RMknZi9ximSPpxtdy0aAfAmMDLbHkVauOyWNB74eIHYlwJzux5k0+dWAudLOj1rGy7pjALHOgHYlm1fU9FeGWN3rzmlwLHNzKxOXCiZmdnRmgU8lmt7FPitiHgc6ABWS1pHOuID8NvAPEnrgR8BJ0XEUuBBYIWkDcBCDhUYPwGuyfqPAe7J2ucD35e0LCKeI522txG4H+iaqtebPwFGS/qxpOdIr3faDswGHspebyVQZMnzW4FHJP0n8FpF+/eAT3Yt5kA6bbA9WzxiE+liD2ZmVlKKeMcsBjMzs7rLpt4tioiz6hyKmZk1II8omZmZmZmZ5XhEyczMzMzMLMcjSmZmZmZmZjkulMzMzMzMzHJcKJmZmZmZmeW4UDIzMzMzM8txoWRmZmZmZpbjQsnMzMzMzCzn/wGN6SBA17fdogAAAABJRU5ErkJggg==\n",
- "text/plain": [
- "<Figure size 1008x576 with 1 Axes>"
- ]
- },
- "metadata": {
- "needs_background": "light"
- },
- "output_type": "display_data"
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[[0.0055 0.00276 0.01342565 0.00618992 0.00381115]\n",
- " [0.02222 0.00974 0.02697824 0.02987324 0.01296137]\n",
- " [0.04612 0.01816 0.05032907 0.02793117 0.02842223]\n",
- " [0.08052 0.0301 0.08272431 0.0629776 0.0499887 ]\n",
- " [0.12892 0.04876 0.12535567 0.11325511 0.08063283]\n",
- " [0.18022 0.0635 0.18180218 0.15531875 0.11735564]\n",
- " [0.24572 0.07712 0.25421899 0.22589487 0.16578486]\n",
- " [0.31992 0.1095 0.31794241 0.30081773 0.23036298]]\n",
- "\n",
- "Mean absolute errors:\n",
- "0.0836875\n",
- "0.004340044672262239\n",
- "0.015445989730460349\n",
- "0.04247753106139743\n"
- ]
- }
- ],
- "source": [
- "failure_rates = np.zeros((8, 5))\n",
- "failure_sems = np.zeros((8, 5))\n",
- "\n",
- "nIter = 2\n",
- "\n",
- "for r in np.arange(1, 9):\n",
- "\n",
- " print(\"[\", r, \"]\", sep='', end=\" \")\n",
- "\n",
- " f_rate_true = np.zeros(nIter)\n",
- " f_rate_label = np.zeros(nIter)\n",
- " f_rate_human = np.zeros(nIter)\n",
- " f_rate_cont = np.zeros(nIter)\n",
- " f_rate_caus = np.zeros(nIter)\n",
- "\n",
- " for i in range(nIter):\n",
- "\n",
- " print(i, end=\" \")\n",
- "\n",
- " # Create data\n",
- " train_labeled, train, test_labeled, test, df = dataWithUnobservables()\n",
- "\n",
- " # Fit model and calculate predictions\n",
- " logreg, predictions = fitLogisticRegression(\n",
- " train_labeled.dropna().X,\n",
- " train_labeled.dropna().result_Y, test.X, 0)\n",
- "\n",
- " # Attach the predictions to data\n",
- " test = test.assign(B_prob_0_logreg=predictions)\n",
- "\n",
- " logreg, predictions_labeled = fitLogisticRegression(\n",
- " train_labeled.dropna().X,\n",
- " train_labeled.dropna().result_Y, test_labeled.X, 0)\n",
- "\n",
- " test_labeled = test_labeled.assign(B_prob_0_logreg=predictions_labeled)\n",
- "\n",
- "# # Regress T on X\n",
- "# lr_t, __ = fitLogisticRegression(train_labeled.X,\n",
- "# train_labeled.decision_T, np.ones(1),\n",
- "# 1)\n",
- "# # Calculate the residuals from previous regression\n",
- "# residuals_T = train_labeled.decision_T - \\\n",
- "# lr_t.predict(train_labeled.X.values.reshape(-1, 1))\n",
- "# train_labeled = train_labeled.assign(residuals_T=residuals_T)\n",
- "\n",
- "# # Convert residuals from -1, 0 and 1 values to one-hot-encoded.\n",
- "# # this way there will be separate betas for each type of residual.\n",
- "# enc = OneHotEncoder(categories='auto', drop='first')\n",
- "# resid_tf = train_labeled.residuals_T.values.reshape(-1, 1)\n",
- "# tmp = enc.fit_transform(resid_tf).toarray()\n",
- "# train_labeled = train_labeled.assign(residuals_1=tmp[:, 0],\n",
- "# residuals_2=tmp[:, 1])\n",
- "\n",
- "# # Regress Y on X and residuals from step 2.\n",
- "# lr_y, __ = fitLogisticRegression(\n",
- "# train_labeled.dropna()[['X', 'residuals_1', 'residuals_2']],\n",
- "# train_labeled.dropna().result_Y, np.ones((1, 3)), 0)\n",
- "# # With the test data, predict Y by\n",
- "# # repeating steps 1 and 2\n",
- "# # (Regress T on X)\n",
- "# lr_t, __ = fitLogisticRegression(test.X,\n",
- "# test.decision_T, np.ones(1),\n",
- "# 1)\n",
- "\n",
- "# # (Calculate the residuals from previous regression)\n",
- "# residuals_T = test.decision_T - \\\n",
- "# lr_t.predict(test.X.values.reshape(-1, 1))\n",
- "# test = test.assign(residuals_T=residuals_T)\n",
- "\n",
- "# # (Convert residuals from -1, 0 and 1 values to one-hot-encoded.\n",
- "# # this way there will be separate betas for each type of residual.)\n",
- "# enc = OneHotEncoder(categories='auto', drop='first')\n",
- "# resid_tf = test.residuals_T.values.reshape(-1, 1)\n",
- "# tmp = enc.fit_transform(resid_tf).toarray()\n",
- "# test = test.assign(residuals_1=tmp[:, 0], residuals_2=tmp[:, 1])\n",
- "\n",
- "# # by using the model from step 3 with X and the residuals from 4.a. as input\n",
- "\n",
- "# preds = getProbabilityForClass(\n",
- "# test[['X', 'residuals_1', 'residuals_2']], lr_y, 0)\n",
- "\n",
- "# test = test.assign(preds=preds)\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(\n",
- "# r * 10, lr_y, train_labeled[['X', 'residuals_1', 'residuals_2']],\n",
- "# test[['X', 'residuals_1', 'residuals_2']])\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": "code",
- "execution_count": null,
- "metadata": {
- "scrolled": true
- },
- "outputs": [],
- "source": [
- "# import pystan\n",
- "\n",
- "# code = \"\"\"\n",
- "# data {\n",
- "# int<lower=0> N_obs;\n",
- "# int<lower=0> N_mis;\n",
- " \n",
- "# int y_obs[N_obs];\n",
- "# vector[N_obs] x_obs;\n",
- "# int t_obs[N_obs];\n",
- " \n",
- "# vector[N_mis] x_mis;\n",
- "# int t_mis[N_mis];\n",
- " \n",
- "# // int<lower = 1, upper = N_obs + N_mis> ii_obs[N_obs];\n",
- "# // int<lower = 1, upper = N_obs + N_mis> ii_mis[N_mis];\n",
- "# }\n",
- "\n",
- "# transformed data {\n",
- "# int N = N_mis + N_obs;\n",
- "# // vector[N] X;\n",
- "# // X[ii_obs] = x_obs;\n",
- "# // X[ii_mis] = x_mis;\n",
- "# // real[N] T;\n",
- "# // T[ii_obs] = t_obs;\n",
- "# // T[ii_mis] = t_mis;\n",
- "# }\n",
- "\n",
- "# parameters {\n",
- "# real a_;\n",
- "# real b_;\n",
- "# real c_;\n",
- "# real d_;\n",
- "# real e_;\n",
- "# real f_;\n",
- "# vector[N_obs] z_obs;\n",
- "# vector[N_mis] z_mis;\n",
- "# }\n",
- "\n",
- "# // transformed parameters {\n",
- "# // vector[N] Z;\n",
- "# // Z[ii_obs] = z_obs;\n",
- "# // Z[ii_mis] = z_mis;\n",
- "# // }\n",
- "\n",
- "# model {\n",
- "# z_obs ~ normal(0, 1);\n",
- "# z_mis ~ normal(0, 1);\n",
- "# //Z ~ normal(0, 1);\n",
- "# y_obs ~ bernoulli_logit(d_ * x_obs + e_ * z_obs + f_);\n",
- "# t_obs ~ bernoulli_logit(a_ * x_obs + b_ * z_obs + c_);\n",
- "# t_mis ~ bernoulli_logit(a_ * x_mis + b_ * z_mis + c_);\n",
- "# //t_obs ~ bernoulli_logit(d_ * X + e_ * Z + f_);\n",
- "# }\n",
- "# \"\"\"\n",
- "\n",
- "# dat = dict(N_obs = int(train_labeled.dropna().shape[0]/5), \n",
- "# N_mis = int(train_labeled[train_labeled.decision_T==0].shape[0]/5),\n",
- "# y_obs = train_labeled.dropna().result_Y[::5].astype(int),\n",
- "# x_obs = train_labeled.dropna().X[::5],\n",
- "# t_obs = train_labeled.dropna().decision_T[::5],\n",
- "# x_mis = train_labeled.X[train_labeled.decision_T==0][::5],\n",
- "# t_mis = train_labeled.decision_T[train_labeled.decision_T==0][::5])\n",
- "\n",
- "# sm = pystan.StanModel(model_code=code)\n",
- "# fit = sm.sampling(data=dat, iter=8000, chains=4)\n",
- "\n",
- "import pystan\n",
- "\n",
- "code = \"\"\"\n",
- "data {\n",
- " int<lower=0> N_obs; \n",
- " int y_obs[N_obs];\n",
- " vector[N_obs] x_obs;\n",
- "}\n",
- "\n",
- "parameters {\n",
- " real d_;\n",
- " real e_;\n",
- " vector[N_obs] Z;\n",
- "}\n",
- "\n",
- "model {\n",
- " Z ~ normal(0, 1);\n",
- " y_obs ~ bernoulli_logit(d_ * x_obs + e_ * Z);\n",
- "}\n",
- "\"\"\"\n",
- "\n",
- "# dat = dict(N_obs = int(train_labeled.dropna().shape[0]/18), \n",
- "# y_obs = train_labeled.dropna().result_Y[::18].astype(int),\n",
- "# x_obs = train_labeled.dropna().X[::18])\n",
- "\n",
- "# sm = pystan.StanModel(model_code=code)\n",
- "# fit = sm.sampling(data=dat, iter=10000, chains=4, control=dict(max_treedepth=17))"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.7.3"
- },
- "toc": {
- "base_numbering": 1,
- "nav_menu": {},
- "number_sections": true,
- "sideBar": true,
- "skip_h1_title": true,
- "title_cell": "Table of Contents",
- "title_sidebar": "Contents",
- "toc_cell": true,
- "toc_position": {
- "height": "calc(100% - 180px)",
- "left": "10px",
- "top": "150px",
- "width": "300.7px"
- },
- "toc_section_display": true,
- "toc_window_display": true
- },
- "varInspector": {
- "cols": {
- "lenName": 16,
- "lenType": 16,
- "lenVar": 40
- },
- "kernels_config": {
- "python": {
- "delete_cmd_postfix": "",
- "delete_cmd_prefix": "del ",
- "library": "var_list.py",
- "varRefreshCmd": "print(var_dic_list())"
- },
- "r": {
- "delete_cmd_postfix": ") ",
- "delete_cmd_prefix": "rm(",
- "library": "var_list.r",
- "varRefreshCmd": "cat(var_dic_list()) "
- }
- },
- "position": {
- "height": "352.85px",
- "left": "1070px",
- "right": "20px",
- "top": "120px",
- "width": "350px"
- },
- "types_to_exclude": [
- "module",
- "function",
- "builtin_function_or_method",
- "instance",
- "_Feature"
- ],
- "window_display": false
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/analysis_and_scripts/Analysis_07MAY2019_old.ipynb b/analysis_and_scripts/Analysis_07MAY2019_old.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..afd68c061c69998237840fac2a892b6ef9aae3b8
--- /dev/null
+++ b/analysis_and_scripts/Analysis_07MAY2019_old.ipynb
@@ -0,0 +1,1237 @@
+{
+ "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 </span>Data sets</a></span><ul class=\"toc-item\"><li><span><a href=\"#Data-without-unobservables\" data-toc-modified-id=\"Data-without-unobservables-1.1\"><span class=\"toc-item-num\">1.1 </span>Data without unobservables</a></span></li><li><span><a href=\"#Synthetic-data-with-unobservables\" data-toc-modified-id=\"Synthetic-data-with-unobservables-1.2\"><span class=\"toc-item-num\">1.2 </span>Synthetic data with unobservables</a></span></li></ul></li><li><span><a href=\"#Algorithms\" data-toc-modified-id=\"Algorithms-2\"><span class=\"toc-item-num\">2 </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 </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 </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 </span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Without-unobservables-in-the-data\" data-toc-modified-id=\"Without-unobservables-in-the-data-3.1\"><span class=\"toc-item-num\">3.1 </span>Without unobservables in the data</a></span></li><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-3.2\"><span class=\"toc-item-num\">3.2 </span>With unobservables in the data</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": 11,
+ "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': (10, 6)})\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",
+ "### 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\\{-X\\}})$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "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=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\n",
+ " df = df.assign(probabilities_Y=sigmoid(df.X))\n",
+ "\n",
+ " # Draw Y ~ Bernoulli(1 - sigmoid(X))\n",
+ " # Note: P(Y=1|X=x) = 1 - P(Y=0|X=x) = 1 - sigmoid(X)\n",
+ " results = npr.binomial(n=1, p=1 - df.probabilities_Y,\n",
+ " size=nJudges_M * nSubjects_N)\n",
+ "\n",
+ " df = df.assign(result_Y=results)\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": [
+ "### 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": 13,
+ "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": [
+ "## 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": 14,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def contraction(df, judgeIDJ_col, decisionT_col, resultY_col, modelProbS_col,\n",
+ " accRateR_col, r):\n",
+ " '''\n",
+ " This is an implementation of the algorithm presented by Lakkaraju\n",
+ " et al. in their paper \"The Selective Labels Problem: Evaluating \n",
+ " Algorithmic Predictions in the Presence of Unobservables\" (2017).\n",
+ "\n",
+ " Arguments:\n",
+ " -----------\n",
+ " df -- The (Pandas) data frame containing the data, judge decisions,\n",
+ " judge IDs, results and probability scores.\n",
+ " judgeIDJ_col -- String, the name of the column containing the judges' IDs\n",
+ " in df.\n",
+ " decisionT_col -- String, the name of the column containing the judges' decisions\n",
+ " resultY_col -- String, the name of the column containing the realization\n",
+ " modelProbS_col -- String, the name of the column containing the probability\n",
+ " scores from the black-box model B.\n",
+ " accRateR_col -- String, the name of the column containing the judges' \n",
+ " acceptance rates\n",
+ " r -- Float between 0 and 1, the given acceptance rate.\n",
+ "\n",
+ " Returns:\n",
+ " --------\n",
+ " (1) The estimated failure rate at acceptance rate r.\n",
+ " '''\n",
+ " # Get ID of the most lenient judge.\n",
+ " most_lenient_ID_q = df[judgeIDJ_col].loc[df[accRateR_col].idxmax()]\n",
+ "\n",
+ " # Subset. \"D_q is the set of all observations judged by q.\"\n",
+ " D_q = df[df[judgeIDJ_col] == most_lenient_ID_q].copy()\n",
+ "\n",
+ " # All observations of R_q have observed outcome labels.\n",
+ " # \"R_q is the set of observations in D_q with observed outcome labels.\"\n",
+ " R_q = D_q[D_q[decisionT_col] == 1].copy()\n",
+ "\n",
+ " # Sort observations in R_q in descending order of confidence scores S and\n",
+ " # assign to R_sort_q.\n",
+ " # \"Observations deemed as high risk by B are at the top of this list\"\n",
+ " R_sort_q = R_q.sort_values(by=modelProbS_col, ascending=False)\n",
+ "\n",
+ " number_to_remove = int(\n",
+ " round((1.0 - r) * D_q.shape[0] - (D_q.shape[0] - R_q.shape[0])))\n",
+ "\n",
+ " # \"R_B is the list of observations assigned to t = 1 by B\"\n",
+ " R_B = R_sort_q[number_to_remove:R_sort_q.shape[0]]\n",
+ "\n",
+ " return np.sum(R_B[resultY_col] == 0) / D_q.shape[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Causal approach - metrics\n",
+ "\n",
+ "Generalized performance:\n",
+ "\n",
+ "$$\n",
+ "\\mathbf{gp} = \\sum_{x\\in\\mathcal{X}} f(x) ~ \\delta(F(x) < r)P(X=x)\n",
+ "$$\n",
+ "\n",
+ "and empirical performance:\n",
+ "\n",
+ "$$\n",
+ "\\mathbf{ep} = \\dfrac{1}{n} \\sum_{(x, y) \\in \\mathcal{D}_{test}} f(x) ~ \\delta(F(x) < r)\n",
+ "$$\n",
+ "\n",
+ "where\n",
+ "\n",
+ "$$\n",
+ "f(x) = P(Y=0|T=1, X=x)\n",
+ "$$\n",
+ "\n",
+ "is a predictive model trained on the labeled data and\n",
+ "\n",
+ "$$\n",
+ "F(x_0) = \\int P(x)~\\delta(P(Y=0|T=1, X=x) > P(Y=0|T=1, X=x_0)) ~ dx = \\int P(x)~\\delta(f(x) > f(x_0)) ~ dx.\n",
+ "$$\n",
+ "\n",
+ "NB: in code the direction of inequality was changed. CDF changed to `bailIndicator` algorithm.\n",
+ "\n",
+ "**Rationale for `bailIndicator`:**\n",
+ "\n",
+ "* Bail decision is based on prediction $P(Y=0|T=1, X=x)$.\n",
+ " * Uniform over all judges\n",
+ "* Judges rationing: \"If this defendant is in the top 10% of 'dangerousness rank' and my $r = 0.85$, I will jail him.\"\n",
+ "* Overall: this kind of defendant $(X=x)$ is usually in the $z^{th}$ percentile in dangerousness (sd $\\pm~u$ percentiles). Now, what is the probability that this defendant has $z \\leq 1-r$?\n",
+ "\n",
+ "\n",
+ "<!--- **Proposal**\n",
+ "\n",
+ "1. Train model for $P(Y=0|T=1, X=x)$\n",
+ "* Estimate quantile function for $P(T=1|R=r, X=x)$\n",
+ "* Calculate $P(Y=0|do(r'), do(x'))=P(Y=0|T=1, X=x') \\cdot P(T=1|R=r', X=x')$ for all instances of the training data\n",
+ "* Order in ascending order based on the probabilities obtained from previous step\n",
+ "* Calculate $$\\dfrac{\\sum_{i=0}^{r\\cdot |\\mathcal{D}_{all}|}}{|\\mathcal{D}_{all}|}$$--->"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def getProbabilityForClass(x, model, class_value):\n",
+ " '''\n",
+ " Function (wrapper) for obtaining the probability of a class given x and a \n",
+ " predictive model.\n",
+ "\n",
+ " Arguments:\n",
+ " -----------\n",
+ " x -- individual features, an array of shape (observations, features)\n",
+ " model -- a trained sklearn model. Predicts probabilities for given x. \n",
+ " Should accept input of shape (observations, features)\n",
+ " class_value -- the resulting class to predict (usually 0 or 1).\n",
+ "\n",
+ " Returns:\n",
+ " --------\n",
+ " (1) The probabilities of given class label for each x.\n",
+ " '''\n",
+ " if x.ndim == 1:\n",
+ " # if x is vector, transform to column matrix.\n",
+ " f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n",
+ " else:\n",
+ " f_values = model.predict_proba(x)\n",
+ "\n",
+ " # Get correct column of predicted class, remove extra dimensions and return.\n",
+ " return f_values[:, model.classes_ == class_value].flatten()\n",
+ "\n",
+ "\n",
+ "def cdf(x_0, model, class_value):\n",
+ " '''\n",
+ " Cumulative distribution function as described above. Integral is \n",
+ " approximated using Simpson's rule for efficiency.\n",
+ " \n",
+ " Arguments:\n",
+ " ----------\n",
+ " \n",
+ " x_0 -- private features of an instance for which the value of cdf is to be\n",
+ " calculated.\n",
+ " model -- a trained sklearn model. Predicts probabilities for given x. \n",
+ " Should accept input of shape (observations, features)\n",
+ " class_value -- the resulting class to predict (usually 0 or 1).\n",
+ "\n",
+ " '''\n",
+ " def prediction(x): return getProbabilityForClass(\n",
+ " np.array([x]).reshape(-1, 1), model, class_value)\n",
+ "\n",
+ " prediction_x_0 = prediction(x_0)\n",
+ "\n",
+ " x_values = np.linspace(-15, 15, 40000)\n",
+ "\n",
+ " x_preds = prediction(x_values)\n",
+ "\n",
+ " y_values = scs.norm.pdf(x_values)\n",
+ "\n",
+ " results = np.zeros(x_0.shape[0])\n",
+ "\n",
+ " for i in range(x_0.shape[0]):\n",
+ "\n",
+ " y_copy = y_values.copy()\n",
+ "\n",
+ " y_copy[x_preds > prediction_x_0[i]] = 0\n",
+ "\n",
+ " results[i] = si.simps(y_copy, x=x_values)\n",
+ "\n",
+ " return results\n",
+ "\n",
+ "\n",
+ "def bailIndicator(r, y_model, x_train, x_test):\n",
+ " '''\n",
+ " Indicator function for whether a judge will bail or jail a suspect.\n",
+ " Rationale explained above.\n",
+ "\n",
+ " Algorithm:\n",
+ " ----------\n",
+ "\n",
+ " (1) Calculate recidivism probabilities from training set with a trained \n",
+ " model and assign them to predictions_train.\n",
+ "\n",
+ " (2) Calculate recidivism probabilities from test set with the trained \n",
+ " model and assign them to predictions_test.\n",
+ "\n",
+ " (3) Construct a quantile function of the probabilities in\n",
+ " in predictions_train.\n",
+ "\n",
+ " (4)\n",
+ " For pred in predictions_test:\n",
+ "\n",
+ " if pred belongs to a percentile (computed from step (3)) lower than r\n",
+ " return True\n",
+ " else\n",
+ " return False\n",
+ "\n",
+ " Arguments:\n",
+ " ----------\n",
+ "\n",
+ " r -- float, acceptance rate, between 0 and 1\n",
+ " y_model -- a trained sklearn predictive model to predict the outcome\n",
+ " x_train -- private features of the training instances\n",
+ " x_test -- private features of the test instances\n",
+ "\n",
+ " Returns:\n",
+ " --------\n",
+ " (1) Boolean list indicating a bail decision (bail = True) for each \n",
+ " instance in x_test.\n",
+ " '''\n",
+ "\n",
+ " predictions_train = getProbabilityForClass(x_train, y_model, 0)\n",
+ "\n",
+ " predictions_test = getProbabilityForClass(x_test, y_model, 0)\n",
+ "\n",
+ " return [\n",
+ " scs.percentileofscore(predictions_train, pred, kind='weak') < r\n",
+ " for pred in predictions_test\n",
+ " ]\n",
+ "\n",
+ "\n",
+ "def estimatePercentiles(x_train, y_model, N_bootstraps=2000, N_sample=100):\n",
+ " '''\n",
+ " Estimate percentiles based on bootstrapped samples of original data.\n",
+ " Bootstrapping is done N_bootstraps times and size of the sample is\n",
+ " N_sample.\n",
+ "\n",
+ "\n",
+ " '''\n",
+ "\n",
+ " res = np.zeros((N_bootstraps, 101))\n",
+ "\n",
+ " percs = np.arange(101)\n",
+ "\n",
+ " for i in range(N_bootstraps):\n",
+ "\n",
+ " sample = npr.choice(x_train, size=N_sample)\n",
+ "\n",
+ " predictions_sample = getProbabilityForClass(sample, y_model, 0)\n",
+ "\n",
+ " res[i, :] = np.percentile(predictions_sample, percs)\n",
+ "\n",
+ " return res\n",
+ "\n",
+ "\n",
+ "def calcReleaseProbabilities(r,\n",
+ " x_train,\n",
+ " x_test,\n",
+ " y_model,\n",
+ " N_bootstraps=2000,\n",
+ " N_sample=100,\n",
+ " percentileMatrix=None):\n",
+ " '''\n",
+ " Similar to bailIndicator, but calculates probabilities for bail decisions\n",
+ " by bootstrapping the data set.\n",
+ "\n",
+ " Returns:\n",
+ " --------\n",
+ " (1) Probabilities for positive bail decisions.\n",
+ " '''\n",
+ "\n",
+ " if percentileMatrix is None:\n",
+ " percentileMatrix = estimatePercentiles(x_train, y_model, N_bootstraps,\n",
+ " N_sample)\n",
+ "\n",
+ " probs = np.zeros(len(x_test))\n",
+ "\n",
+ " for i in range(len(x_test)):\n",
+ "\n",
+ " if np.isnan(x_test[i]):\n",
+ "\n",
+ " probs[i] = np.nan\n",
+ "\n",
+ " else:\n",
+ "\n",
+ " pred = getProbabilityForClass(x_test[i], y_model, 0)\n",
+ "\n",
+ " probs[i] = np.mean(pred < percentileMatrix[:, r])\n",
+ "\n",
+ " return probs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Performance comparison\n",
+ "\n",
+ "Below we try to replicate the results obtained by Lakkaraju and compare their model's performance to the one of ours."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def fitPredictiveModel(x_train, y_train, x_test, class_value, model_type=None):\n",
+ " '''\n",
+ " Fit a predictive model (default logistic regression) with given training \n",
+ " instances and return probabilities for test instances to obtain a given \n",
+ " class label.\n",
+ " \n",
+ " Arguments:\n",
+ " ----------\n",
+ " \n",
+ " x_train -- x values of training instances\n",
+ " y_train -- y values of training instances\n",
+ " x_test -- x values of test instances\n",
+ " class_value -- class label for which the probabilities are counted for.\n",
+ " model_type -- type of model to be fitted.\n",
+ " \n",
+ " Returns:\n",
+ " --------\n",
+ " (1) Trained predictive model\n",
+ " (2) Probabilities for given test inputs for given class.\n",
+ " '''\n",
+ "\n",
+ " if model_type is None or model_type in [\"logistic_regression\", \"lr\"]:\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\n",
+ " \n",
+ " elif model_type in [\"random_forest\", \"rf\"]:\n",
+ " # Instantiate the model \n",
+ " forest = RandomForestClassifier(n_estimators=100, max_depth=3)\n",
+ "\n",
+ " # Check shape and fit the model.\n",
+ " if x_train.ndim == 1:\n",
+ " forest = forest.fit(x_train.values.reshape(-1, 1), y_train)\n",
+ " else:\n",
+ " forest = forest.fit(x_train, y_train)\n",
+ "\n",
+ " label_probs_forest = getProbabilityForClass(x_test, forest, class_value)\n",
+ "\n",
+ " return forest, label_probs_forest\n",
+ " \n",
+ " elif model_type == \"fully_random\":\n",
+ " \n",
+ " label_probs = np.ones_like(x_test) / 2\n",
+ " \n",
+ " model_object = lambda x: 0.5\n",
+ " \n",
+ " return model_object, label_probs\n",
+ " else:\n",
+ " raise ValueError(\"Invalid model_type!\", model_type) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Without unobservables in the data\n",
+ "\n",
+ "The underlying figure is attached to the preliminary paper. When conducting finalization, last analysis should be conducted with a preset random seed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1] 0 1 2 3 4 5 6 7 [2] 0 1 2 3 4 5 6 7 [3] 0 1 2 3 4 5 6 7 [4] 0 1 2 3 4 5 6 7 [5] 0 1 2 3 4 5 6 7 [6] 0 1 2 3 4 5 6 7 [7] 0 1 2 3 4 5 6 7 [8] 0 1 2 3 4 5 6 7 "
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 720x432 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[0.015455 0.005975 0.02128927 0.01824005 0.01504878]\n",
+ " [0.041615 0.01541 0.04449708 0.04952796 0.04207918]\n",
+ " [0.075705 0.02737 0.07408005 0.07451198 0.07586959]\n",
+ " [0.114615 0.03845 0.11454849 0.1089716 0.11612646]\n",
+ " [0.161915 0.055585 0.16090506 0.170813 0.16261346]\n",
+ " [0.214345 0.067335 0.21142173 0.21125308 0.21550736]\n",
+ " [0.275515 0.079615 0.27699615 0.271816 0.27544641]\n",
+ " [0.340255 0.091685 0.34350266 0.33641304 0.33994187]]\n",
+ "\n",
+ "Mean absolute errors:\n",
+ "0.10724937500000001\n",
+ "0.00238372897518402\n",
+ "0.004633164376337144\n",
+ "0.0005986237333166415\n"
+ ]
+ }
+ ],
+ "source": [
+ "f_rates = np.zeros((8, 5))\n",
+ "f_sems = np.zeros((8, 5))\n",
+ "\n",
+ "nIter = 8\n",
+ "\n",
+ "#npr.seed(0)\n",
+ "\n",
+ "for r in np.arange(1, 9):\n",
+ "\n",
+ " print(\"[\", r, \"]\", sep='', end=\" \")\n",
+ "\n",
+ " s_f_rate_true = np.zeros(nIter)\n",
+ " s_f_rate_labeled = np.zeros(nIter)\n",
+ " s_f_rate_human = np.zeros(nIter)\n",
+ " s_f_rate_cont = np.zeros(nIter)\n",
+ " s_f_rate_caus = np.zeros(nIter)\n",
+ "\n",
+ " for i in range(nIter):\n",
+ "\n",
+ " print(i, end=\" \")\n",
+ "\n",
+ " s_train_labeled, s_train, s_test_labeled, s_test, s_df = dataWithoutUnobservables()\n",
+ "\n",
+ " s_logreg, predictions = fitPredictiveModel(\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_model=predictions)\n",
+ "\n",
+ " s_logreg, predictions_labeled = fitPredictiveModel(\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_model=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='B_prob_0_model',\n",
+ " inplace=False,\n",
+ " ascending=True)\n",
+ "\n",
+ " to_release = int(round(s_sorted.shape[0] * r / 10))\n",
+ "\n",
+ " # Calculate failure rate as the ratio of failures to successes among those\n",
+ " # who were given a positive decision, i.e. those whose probability of negative\n",
+ " # outcome was low enough.\n",
+ " s_f_rate_true[i] = np.sum(\n",
+ " s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
+ "\n",
+ " #### Labeled outcomes\n",
+ " # Sort by estimated failure probabilities, subjects with the smallest risk are first.\n",
+ " s_sorted = s_test_labeled.sort_values(by='B_prob_0_model',\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_model', '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_model * 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",
+ "x_ax = np.arange(0.1, 0.9, 0.1)\n",
+ "\n",
+ "plt.errorbar(x_ax,\n",
+ " f_rates[:, 0],\n",
+ " label='True Evaluation',\n",
+ " c='green',\n",
+ " yerr=f_sems[:, 0])\n",
+ "plt.errorbar(x_ax,\n",
+ " f_rates[:, 1],\n",
+ " label='Labeled outcomes',\n",
+ " c='magenta',\n",
+ " yerr=f_sems[:, 1])\n",
+ "plt.errorbar(x_ax,\n",
+ " f_rates[:, 2],\n",
+ " label='Human evaluation',\n",
+ " c='red',\n",
+ " yerr=f_sems[:, 2])\n",
+ "plt.errorbar(x_ax,\n",
+ " f_rates[:, 3],\n",
+ " label='Contraction, log.',\n",
+ " c='blue',\n",
+ " yerr=f_sems[:, 3])\n",
+ "plt.errorbar(x_ax,\n",
+ " f_rates[:, 4],\n",
+ " label='Causal model, ep',\n",
+ " c='black',\n",
+ " yerr=f_sems[:, 4])\n",
+ "\n",
+ "plt.title('Failure rate vs. Acceptance rate without unobservables')\n",
+ "plt.xlabel('Acceptance rate')\n",
+ "plt.ylabel('Failure rate')\n",
+ "plt.legend()\n",
+ "plt.grid()\n",
+ "plt.show()\n",
+ "\n",
+ "print(f_rates)\n",
+ "print(\"\\nMean absolute errors:\")\n",
+ "for i in range(1, f_rates.shape[1]):\n",
+ " print(np.mean(np.abs(f_rates[:, 0] - f_rates[:, i])))"
+ ]
+ },
+ {
+ "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": 18,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1] 0 1 2 3 4 5 6 7 [2] 0 1 2 3 4 5 6 7 [3] 0 1 2 3 4 5 6 7 [4] 0 1 2 3 4 5 6 7 [5] 0 1 2 3 4 5 6 7 [6] 0 1 2 3 4 5 6 7 [7] 0 1 2 3 4 5 6 7 [8] 0 1 2 3 4 5 6 7 "
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 720x432 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[0.00543 0.002235 0.01173347 0.00462072 0.00371409]\n",
+ " [0.02073 0.00829 0.02260202 0.02491425 0.01286922]\n",
+ " [0.046295 0.01716 0.05069571 0.04167522 0.02791597]\n",
+ " [0.081615 0.030765 0.0848586 0.0723175 0.05149991]\n",
+ " [0.12755 0.048135 0.12889808 0.12994054 0.08148183]\n",
+ " [0.18077 0.06486 0.18545546 0.16258617 0.11982914]\n",
+ " [0.24507 0.083195 0.25131055 0.23464198 0.16797487]\n",
+ " [0.319775 0.11032 0.32569484 0.30929089 0.23272432]]\n",
+ "\n",
+ "Mean absolute errors:\n",
+ "0.082784375\n",
+ "0.0042517158692163435\n",
+ "0.007549662902501246\n",
+ "0.0411532050110707\n"
+ ]
+ }
+ ],
+ "source": [
+ "failure_rates = np.zeros((8, 5))\n",
+ "failure_sems = np.zeros((8, 5))\n",
+ "\n",
+ "nIter = 8\n",
+ "\n",
+ "for r in np.arange(1, 9):\n",
+ "\n",
+ " print(\"[\", r, \"]\", sep='', end=\" \")\n",
+ "\n",
+ " f_rate_true = np.zeros(nIter)\n",
+ " f_rate_label = np.zeros(nIter)\n",
+ " f_rate_human = np.zeros(nIter)\n",
+ " f_rate_cont = np.zeros(nIter)\n",
+ " f_rate_caus = np.zeros(nIter)\n",
+ "\n",
+ " for i in range(nIter):\n",
+ "\n",
+ " print(i, end=\" \")\n",
+ "\n",
+ " # Create data\n",
+ " train_labeled, train, test_labeled, test, df = dataWithUnobservables()\n",
+ "\n",
+ " # Fit model and calculate predictions\n",
+ " logreg, predictions = fitPredictiveModel(\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_model=predictions)\n",
+ "\n",
+ " logreg, predictions_labeled = fitPredictiveModel(\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_model=predictions_labeled)\n",
+ "\n",
+ "# # Regress T on X\n",
+ "# lr_t, __ = fitPredictiveModel(train_labeled.X,\n",
+ "# train_labeled.decision_T, np.ones(1),\n",
+ "# 1)\n",
+ "# # Calculate the residuals from previous regression\n",
+ "# residuals_T = train_labeled.decision_T - \\\n",
+ "# lr_t.predict(train_labeled.X.values.reshape(-1, 1))\n",
+ "# train_labeled = train_labeled.assign(residuals_T=residuals_T)\n",
+ "\n",
+ "# # Convert residuals from -1, 0 and 1 values to one-hot-encoded.\n",
+ "# # this way there will be separate betas for each type of residual.\n",
+ "# enc = OneHotEncoder(categories='auto')\n",
+ "# resid_tf = train_labeled.residuals_T.values.reshape(-1, 1)\n",
+ "# tmp = enc.fit_transform(resid_tf).toarray()\n",
+ "# train_labeled = train_labeled.assign(residuals_1=tmp[:, 0],\n",
+ "# residuals_2=tmp[:, 1])\n",
+ "\n",
+ "# # Regress Y on X and residuals from step 2.\n",
+ "# lr_y, __ = fitPredictiveModel(\n",
+ "# train_labeled.dropna()[['X', 'residuals_1', 'residuals_2']],\n",
+ "# train_labeled.dropna().result_Y, np.ones((1, 3)), 0)\n",
+ "# # With the test data, predict Y by\n",
+ "# # repeating steps 1 and 2\n",
+ "# # (Regress T on X)\n",
+ "# lr_t, __ = fitPredictiveModel(test.X,\n",
+ "# test.decision_T, np.ones(1),\n",
+ "# 1)\n",
+ "\n",
+ "# # (Calculate the residuals from previous regression)\n",
+ "# residuals_T = test.decision_T - \\\n",
+ "# lr_t.predict(test.X.values.reshape(-1, 1))\n",
+ "# test = test.assign(residuals_T=residuals_T)\n",
+ "\n",
+ "# # (Convert residuals from -1, 0 and 1 values to one-hot-encoded.\n",
+ "# # this way there will be separate betas for each type of residual.)\n",
+ "# enc = OneHotEncoder(categories='auto')\n",
+ "# resid_tf = test.residuals_T.values.reshape(-1, 1)\n",
+ "# tmp = enc.fit_transform(resid_tf).toarray()\n",
+ "# test = test.assign(residuals_1=tmp[:, 0], residuals_2=tmp[:, 1])\n",
+ "\n",
+ "# # by using the model from step 3 with X and the residuals from 4.a. as input\n",
+ "\n",
+ "# preds = getProbabilityForClass(\n",
+ "# test[['X', 'residuals_1', 'residuals_2']], lr_y, 0)\n",
+ "\n",
+ "# test = test.assign(preds=preds)\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_model', 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_model',\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_model',\n",
+ " 'acceptanceRate_R', r / 10)\n",
+ "\n",
+ " # Causal model - empirical performance\n",
+ "\n",
+ "# released = bailIndicator(\n",
+ "# r * 10, lr_y, train_labeled[['X', 'residuals_1', 'residuals_2']],\n",
+ "# test[['X', 'residuals_1', 'residuals_2']])\n",
+ " \n",
+ " released = bailIndicator(r * 10, logreg, train_labeled.X, test.X)\n",
+ " \n",
+ " #released = cdf(test.X, logreg, 0) < r / 10\n",
+ "\n",
+ "# released = npr.choice([True, False], size = test.X.shape, p=[r/10, 1-r/10])\n",
+ " f_rate_caus[i] = np.mean(test.B_prob_0_model * 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.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])))"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": true,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": true,
+ "toc_position": {
+ "height": "1084px",
+ "left": "228px",
+ "top": "111.133px",
+ "width": "300.7px"
+ },
+ "toc_section_display": true,
+ "toc_window_display": true
+ },
+ "varInspector": {
+ "cols": {
+ "lenName": 16,
+ "lenType": 16,
+ "lenVar": 40
+ },
+ "kernels_config": {
+ "python": {
+ "delete_cmd_postfix": "",
+ "delete_cmd_prefix": "del ",
+ "library": "var_list.py",
+ "varRefreshCmd": "print(var_dic_list())"
+ },
+ "r": {
+ "delete_cmd_postfix": ") ",
+ "delete_cmd_prefix": "rm(",
+ "library": "var_list.r",
+ "varRefreshCmd": "cat(var_dic_list()) "
+ }
+ },
+ "position": {
+ "height": "352.85px",
+ "left": "1070px",
+ "right": "20px",
+ "top": "120px",
+ "width": "350px"
+ },
+ "types_to_exclude": [
+ "module",
+ "function",
+ "builtin_function_or_method",
+ "instance",
+ "_Feature"
+ ],
+ "window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb b/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..3f501023444e62555540e0a8378515e2be1d76c2
--- /dev/null
+++ b/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb
@@ -0,0 +1,1145 @@
+{
+ "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-generation-modules\" data-toc-modified-id=\"Data-generation-modules-1\"><span class=\"toc-item-num\">1 </span>Data generation modules</a></span></li><li><span><a href=\"#Decider-modules\" data-toc-modified-id=\"Decider-modules-2\"><span class=\"toc-item-num\">2 </span>Decider modules</a></span></li><li><span><a href=\"#Evaluator-modules\" data-toc-modified-id=\"Evaluator-modules-3\"><span class=\"toc-item-num\">3 </span>Evaluator modules</a></span><ul class=\"toc-item\"><li><span><a href=\"#Convenience-functions\" data-toc-modified-id=\"Convenience-functions-3.1\"><span class=\"toc-item-num\">3.1 </span>Convenience functions</a></span></li><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-3.2\"><span class=\"toc-item-num\">3.2 </span>Contraction algorithm</a></span></li><li><span><a href=\"#Evaluators\" data-toc-modified-id=\"Evaluators-3.3\"><span class=\"toc-item-num\">3.3 </span>Evaluators</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-4\"><span class=\"toc-item-num\">4 </span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Without-unobservables-in-the-data\" data-toc-modified-id=\"Without-unobservables-in-the-data-4.1\"><span class=\"toc-item-num\">4.1 </span>Without unobservables in the data</a></span></li><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-4.2\"><span class=\"toc-item-num\">4.2 </span>With unobservables in the data</a></span></li></ul></li></ul></div>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Refer to the `notes.tex` file for explanations about the modular framework."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "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': (10, 6)})\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 generation modules"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "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 coinFlipDGWithoutUnobservables(N_total=50000):\n",
+ "\n",
+ " df = pd.DataFrame()\n",
+ "\n",
+ " # Sample feature X from standard Gaussian distribution, N(0, 1).\n",
+ " df = df.assign(X=npr.normal(size=N_total))\n",
+ "\n",
+ " # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\n",
+ " df = df.assign(probabilities_Y=sigmoid(df.X))\n",
+ "\n",
+ " # Draw Y ~ Bernoulli(1 - sigmoid(X))\n",
+ " # Note: P(Y=1|X=x) = 1 - P(Y=0|X=x) = 1 - sigmoid(X)\n",
+ " results = npr.binomial(n=1, p=1 - df.probabilities_Y, size=N_total)\n",
+ "\n",
+ " df = df.assign(result_Y=results)\n",
+ "\n",
+ " return df\n",
+ "\n",
+ "\n",
+ "def thresholdDGWithUnobservables(N_total=50000):\n",
+ "\n",
+ " df = pd.DataFrame()\n",
+ "\n",
+ " # Sample the variables from standard Gaussian distributions.\n",
+ " df = df.assign(X=npr.normal(size=N_total))\n",
+ " df = df.assign(Z=npr.normal(size=N_total))\n",
+ " df = df.assign(W=npr.normal(size=N_total))\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",
+ " return df\n",
+ "\n",
+ "\n",
+ "def coinFlipDGWithUnobservables(N_total=50000,\n",
+ " beta_X=1.0,\n",
+ " beta_Z=1.0,\n",
+ " beta_W=0.2):\n",
+ "\n",
+ " df = pd.DataFrame()\n",
+ "\n",
+ " # Sample feature X, Z and W from standard Gaussian distribution, N(0, 1).\n",
+ " df = df.assign(X=npr.normal(size=N_total))\n",
+ " df = df.assign(Z=npr.normal(size=N_total))\n",
+ " df = df.assign(W=npr.normal(size=N_total))\n",
+ "\n",
+ " # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\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",
+ " # Draw Y from Bernoulli distribution\n",
+ " results = npr.binomial(n=1,\n",
+ " p=1 - df.probabilities_Y,\n",
+ " size=N_total)\n",
+ "\n",
+ " df = df.assign(result_Y=results)\n",
+ "\n",
+ " return df"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Decider modules"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def humanDeciderLakkaraju(df,\n",
+ " result_Y,\n",
+ " featureX_col,\n",
+ " featureZ_col,\n",
+ " nJudges_M=100,\n",
+ " beta_X=1,\n",
+ " beta_Z=1,\n",
+ " hide_unobserved=True):\n",
+ "\n",
+ " # Assert that every judge will have the same number of subjects.\n",
+ " assert df.shape[0] % nJudges_M == 0, \"Can't assign subjets evenly!\"\n",
+ "\n",
+ " # Compute the number of subjects allocated for each judge.\n",
+ " nSubjects_N = int(df.shape[0] / nJudges_M)\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",
+ " probabilities_T = sigmoid(beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\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",
+ " if hide_unobserved:\n",
+ " df.loc[df.decision_T == 0, result_Y] = np.nan\n",
+ "\n",
+ " return df\n",
+ "\n",
+ "\n",
+ "def coinFlipDecider(df,\n",
+ " featureX_col,\n",
+ " featureZ_col,\n",
+ " nJudges_M=100,\n",
+ " beta_X=1,\n",
+ " beta_Z=1,\n",
+ " hide_unobserved=True):\n",
+ "\n",
+ " # Assert that every judge will have the same number of subjects.\n",
+ " assert df.shape[0] % nJudges_M == 0, \"Can't assign subjets evenly!\"\n",
+ "\n",
+ " # Compute the number of subjects allocated for each judge.\n",
+ " nSubjects_N = int(df.shape[0] / nJudges_M)\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",
+ " # No real leniency here???\n",
+ " acceptance_rates = np.ones(nJudges_M)*0.5\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",
+ " probabilities_T = sigmoid(beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\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",
+ " # Draw T from Bernoulli distribution\n",
+ " decisions = npr.binomial(n=1, p=1 - df.probabilities_T, size=df.shape[0])\n",
+ "\n",
+ " df = df.assign(decision_T=decisions)\n",
+ " \n",
+ " if hide_unobserved:\n",
+ " df.loc[df.decision_T == 0, 'result_Y'] = np.nan\n",
+ " \n",
+ " return df"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Evaluator modules\n",
+ "\n",
+ "### Convenience functions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 94,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def fitPredictiveModel(x_train, y_train, x_test, class_value, model_type=None):\n",
+ " '''\n",
+ " Fit a predictive model (default logistic regression) with given training \n",
+ " instances and return probabilities for test instances to obtain a given \n",
+ " class label.\n",
+ " \n",
+ " Arguments:\n",
+ " ----------\n",
+ " \n",
+ " x_train -- x values of training instances\n",
+ " y_train -- y values of training instances\n",
+ " x_test -- x values of test instances\n",
+ " class_value -- class label for which the probabilities are counted for.\n",
+ " model_type -- type of model to be fitted.\n",
+ " \n",
+ " Returns:\n",
+ " --------\n",
+ " (1) Trained predictive model\n",
+ " (2) Probabilities for given test inputs for given class.\n",
+ " '''\n",
+ "\n",
+ " if model_type is None or model_type in [\"logistic_regression\", \"lr\"]:\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,\n",
+ " class_value)\n",
+ "\n",
+ " return logreg, label_probs_logreg\n",
+ "\n",
+ " elif model_type in [\"random_forest\", \"rf\"]:\n",
+ " # Instantiate the model\n",
+ " forest = RandomForestClassifier(n_estimators=100, max_depth=3)\n",
+ "\n",
+ " # Check shape and fit the model.\n",
+ " if x_train.ndim == 1:\n",
+ " forest = forest.fit(x_train.values.reshape(-1, 1), y_train)\n",
+ " else:\n",
+ " forest = forest.fit(x_train, y_train)\n",
+ "\n",
+ " label_probs_forest = getProbabilityForClass(x_test, forest,\n",
+ " class_value)\n",
+ "\n",
+ " return forest, label_probs_forest\n",
+ "\n",
+ " elif model_type == \"fully_random\":\n",
+ "\n",
+ " label_probs = np.ones_like(x_test) / 2\n",
+ "\n",
+ " model_object = lambda x: 0.5\n",
+ "\n",
+ " return model_object, label_probs\n",
+ " else:\n",
+ " raise ValueError(\"Invalid model_type!\", model_type)\n",
+ "\n",
+ "\n",
+ "def getProbabilityForClass(x, model, class_value):\n",
+ " '''\n",
+ " Function (wrapper) for obtaining the probability of a class given x and a \n",
+ " predictive model.\n",
+ "\n",
+ " Arguments:\n",
+ " -----------\n",
+ " x -- individual features, an array of shape (observations, features)\n",
+ " model -- a trained sklearn model. Predicts probabilities for given x. \n",
+ " Should accept input of shape (observations, features)\n",
+ " class_value -- the resulting class to predict (usually 0 or 1).\n",
+ "\n",
+ " Returns:\n",
+ " --------\n",
+ " (1) The probabilities of given class label for each x.\n",
+ " '''\n",
+ " if x.ndim == 1:\n",
+ " # if x is vector, transform to column matrix.\n",
+ " f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n",
+ " else:\n",
+ " f_values = model.predict_proba(x)\n",
+ "\n",
+ " # Get correct column of predicted class, remove extra dimensions and return.\n",
+ " return f_values[:, model.classes_ == class_value].flatten()\n",
+ "\n",
+ "\n",
+ "def cdf(x_0, model, class_value):\n",
+ " '''\n",
+ " Cumulative distribution function as described above. Integral is \n",
+ " approximated using Simpson's rule for efficiency.\n",
+ " \n",
+ " Arguments:\n",
+ " ----------\n",
+ " \n",
+ " x_0 -- private features of an instance for which the value of cdf is to be\n",
+ " calculated.\n",
+ " model -- a trained sklearn model. Predicts probabilities for given x. \n",
+ " Should accept input of shape (observations, features)\n",
+ " class_value -- the resulting class to predict (usually 0 or 1).\n",
+ "\n",
+ " '''\n",
+ "\n",
+ " def prediction(x):\n",
+ " return getProbabilityForClass(\n",
+ " np.array([x]).reshape(-1, 1), model, class_value)\n",
+ "\n",
+ " prediction_x_0 = prediction(x_0)\n",
+ "\n",
+ " x_values = np.linspace(-15, 15, 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",
+ " print(\"en loop\")\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",
+ " print(\"jlk loop\")\n",
+ " return results\n",
+ "\n",
+ "\n",
+ "def bailIndicator(r, y_model, x_train, x_test):\n",
+ " '''\n",
+ " Indicator function for whether a judge will bail or jail a suspect.\n",
+ " Rationale explained above.\n",
+ "\n",
+ " Algorithm:\n",
+ " ----------\n",
+ "\n",
+ " (1) Calculate recidivism probabilities from training set with a trained \n",
+ " model and assign them to predictions_train.\n",
+ "\n",
+ " (2) Calculate recidivism probabilities from test set with the trained \n",
+ " model and assign them to predictions_test.\n",
+ "\n",
+ " (3) Construct a quantile function of the probabilities in\n",
+ " in predictions_train.\n",
+ "\n",
+ " (4)\n",
+ " For pred in predictions_test:\n",
+ "\n",
+ " if pred belongs to a percentile (computed from step (3)) lower than r\n",
+ " return True\n",
+ " else\n",
+ " return False\n",
+ "\n",
+ " Arguments:\n",
+ " ----------\n",
+ "\n",
+ " r -- float, acceptance rate, between 0 and 1\n",
+ " y_model -- a trained sklearn predictive model to predict the outcome\n",
+ " x_train -- private features of the training instances\n",
+ " x_test -- private features of the test instances\n",
+ "\n",
+ " Returns:\n",
+ " --------\n",
+ " (1) Boolean list indicating a bail decision (bail = True) for each \n",
+ " instance in x_test.\n",
+ " '''\n",
+ "\n",
+ " predictions_train = getProbabilityForClass(x_train, y_model, 0)\n",
+ "\n",
+ " predictions_test = getProbabilityForClass(x_test, y_model, 0)\n",
+ "\n",
+ " return [\n",
+ " scs.percentileofscore(predictions_train, pred, kind='weak') < r\n",
+ " for pred in predictions_test\n",
+ " ]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 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": 40,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def contraction(df, judgeIDJ_col, decisionT_col, resultY_col, modelProbS_col,\n",
+ " accRateR_col, r):\n",
+ " '''\n",
+ " This is an implementation of the algorithm presented by Lakkaraju\n",
+ " et al. in their paper \"The Selective Labels Problem: Evaluating \n",
+ " Algorithmic Predictions in the Presence of Unobservables\" (2017).\n",
+ "\n",
+ " Arguments:\n",
+ " -----------\n",
+ " df -- The (Pandas) data frame containing the data, judge decisions,\n",
+ " judge IDs, results and probability scores.\n",
+ " judgeIDJ_col -- String, the name of the column containing the judges' IDs\n",
+ " in df.\n",
+ " decisionT_col -- String, the name of the column containing the judges' decisions\n",
+ " resultY_col -- String, the name of the column containing the realization\n",
+ " modelProbS_col -- String, the name of the column containing the probability\n",
+ " scores from the black-box model B.\n",
+ " accRateR_col -- String, the name of the column containing the judges' \n",
+ " acceptance rates\n",
+ " r -- Float between 0 and 1, the given acceptance rate.\n",
+ "\n",
+ " Returns:\n",
+ " --------\n",
+ " (1) The estimated failure rate at acceptance rate r.\n",
+ " '''\n",
+ " # Get ID of the most lenient judge.\n",
+ " most_lenient_ID_q = df[judgeIDJ_col].loc[df[accRateR_col].idxmax()]\n",
+ "\n",
+ " # Subset. \"D_q is the set of all observations judged by q.\"\n",
+ " D_q = df[df[judgeIDJ_col] == most_lenient_ID_q].copy()\n",
+ "\n",
+ " # All observations of R_q have observed outcome labels.\n",
+ " # \"R_q is the set of observations in D_q with observed outcome labels.\"\n",
+ " R_q = D_q[D_q[decisionT_col] == 1].copy()\n",
+ "\n",
+ " # Sort observations in R_q in descending order of confidence scores S and\n",
+ " # assign to R_sort_q.\n",
+ " # \"Observations deemed as high risk by B are at the top of this list\"\n",
+ " R_sort_q = R_q.sort_values(by=modelProbS_col, ascending=False)\n",
+ "\n",
+ " number_to_remove = int(\n",
+ " round((1.0 - r) * D_q.shape[0] - (D_q.shape[0] - R_q.shape[0])))\n",
+ "\n",
+ " # \"R_B is the list of observations assigned to t = 1 by B\"\n",
+ " R_B = R_sort_q[number_to_remove:R_sort_q.shape[0]]\n",
+ "\n",
+ " return np.sum(R_B[resultY_col] == 0) / D_q.shape[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Evaluators"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 96,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def contractionEvaluator(df, featureX_col, judgeIDJ_col, decisionT_col,\n",
+ " resultY_col, accRateR_col, r):\n",
+ "\n",
+ " train, test = train_test_split(df, test_size=0.5)\n",
+ "\n",
+ " B_model, predictions = fitPredictiveModel(\n",
+ " train.loc[train[decisionT_col] == 1, featureX_col],\n",
+ " train.loc[train[decisionT_col] == 1, resultY_col], test[featureX_col],\n",
+ " 0)\n",
+ "\n",
+ " test = test.assign(B_prob_0_model=predictions)\n",
+ "\n",
+ " # Invoke the original contraction.\n",
+ " FR = contraction(test,\n",
+ " judgeIDJ_col=judgeIDJ_col,\n",
+ " decisionT_col=decisionT_col,\n",
+ " resultY_col=resultY_col,\n",
+ " modelProbS_col=\"B_prob_0_model\",\n",
+ " accRateR_col=accRateR_col,\n",
+ " r=r)\n",
+ "\n",
+ " return FR\n",
+ "\n",
+ "\n",
+ "def trueEvaluationEvaluator(df, featureX_col, decisionT_col, resultY_col, r):\n",
+ "\n",
+ " train, test = train_test_split(df, test_size=0.5)\n",
+ "\n",
+ " B_model, predictions = fitPredictiveModel(train[featureX_col],\n",
+ " train[resultY_col],\n",
+ " test[featureX_col], 0)\n",
+ "\n",
+ " test = test.assign(B_prob_0_model=predictions)\n",
+ "\n",
+ " test.sort_values(by='B_prob_0_model', inplace=True, ascending=True)\n",
+ "\n",
+ " to_release = int(round(test.shape[0] * r / 10))\n",
+ "\n",
+ " return np.sum(test[resultY_col][0:to_release] == 0) / test.shape[0]\n",
+ "\n",
+ "\n",
+ "def labeledOutcomesEvaluator(df, featureX_col, decisionT_col, resultY_col, r):\n",
+ "\n",
+ " train, test = train_test_split(df, test_size=0.5)\n",
+ "\n",
+ " B_model, predictions = fitPredictiveModel(\n",
+ " train.loc[train[decisionT_col] == 1, featureX_col],\n",
+ " train.loc[train[decisionT_col] == 1, resultY_col], test[featureX_col],\n",
+ " 0)\n",
+ "\n",
+ " test = test.assign(B_prob_0_model=predictions)\n",
+ "\n",
+ " test_observed = test.loc[test[decisionT_col] == 1, :]\n",
+ "\n",
+ " test_observed = test_observed.sort_values(by='B_prob_0_model',\n",
+ " inplace=False,\n",
+ " ascending=True)\n",
+ "\n",
+ " to_release = int(round(test_observed.shape[0] * r / 10))\n",
+ "\n",
+ " return np.sum(\n",
+ " test_observed[resultY_col][0:to_release] == 0) / test.shape[0]\n",
+ "\n",
+ "\n",
+ "def humanEvaluationEvaluator(df, judgeIDJ_col, decisionT_col, resultY_col,\n",
+ " accRateR_col, r):\n",
+ "\n",
+ " # Get judges with correct leniency as list\n",
+ " is_correct_leniency = df[accRateR_col].round(1) == r / 10\n",
+ "\n",
+ " correct_leniency_list = df.loc[is_correct_leniency, judgeIDJ_col]\n",
+ "\n",
+ " # Released are the people they judged and released, T = 1\n",
+ " released = df[df[judgeIDJ_col].isin(correct_leniency_list)\n",
+ " & (df.decision_T == 1)]\n",
+ "\n",
+ " # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
+ " return np.sum(released[resultY_col] == 0) / correct_leniency_list.shape[0]\n",
+ "\n",
+ "\n",
+ "def causalEvaluator(df, featureX_col, decisionT_col, resultY_col, r):\n",
+ "\n",
+ " train, test = train_test_split(df, test_size=0.5)\n",
+ "\n",
+ " B_model, predictions = fitPredictiveModel(\n",
+ " train.loc[train[decisionT_col] == 1, featureX_col],\n",
+ " train.loc[train[decisionT_col] == 1, resultY_col], test[featureX_col],\n",
+ " 0)\n",
+ "\n",
+ " test = test.assign(B_prob_0_model=predictions)\n",
+ "\n",
+ " released = cdf(test[featureX_col], B_model, 0) < r / 10\n",
+ "\n",
+ " return np.mean(test.B_prob_0_model * released)"
+ ]
+ },
+ {
+ "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": "markdown",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "### Without unobservables in the data\n",
+ "\n",
+ "The underlying figure is attached to the preliminary paper. When conducting finalization, last analysis should be conducted with a preset random seed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "hidden": true,
+ "scrolled": false
+ },
+ "outputs": [],
+ "source": [
+ "# f_rates = np.zeros((8, 5))\n",
+ "# f_sems = np.zeros((8, 5))\n",
+ "\n",
+ "# nIter = 15\n",
+ "\n",
+ "# #npr.seed(0)\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(sigma=2)\n",
+ "\n",
+ "# s_logreg, predictions = fitPredictiveModel(\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_model=predictions)\n",
+ "\n",
+ "# s_logreg, predictions_labeled = fitPredictiveModel(\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_model=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='B_prob_0_model',\n",
+ "# inplace=False,\n",
+ "# ascending=True)\n",
+ "\n",
+ "# to_release = int(round(s_sorted.shape[0] * r / 10))\n",
+ "\n",
+ "# # Calculate failure rate as the ratio of failures to successes among those\n",
+ "# # who were given a positive decision, i.e. those whose probability of negative\n",
+ "# # outcome was low enough.\n",
+ "# s_f_rate_true[i] = np.sum(\n",
+ "# s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
+ "\n",
+ "# #### Labeled outcomes\n",
+ "# # Sort by estimated failure probabilities, subjects with the smallest risk are first.\n",
+ "# s_sorted = s_test_labeled.sort_values(by='B_prob_0_model',\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_model', 'acceptanceRate_R',\n",
+ "# r / 10)\n",
+ "# #### Causal model\n",
+ "\n",
+ "# #released = bailIndicator(r * 10, s_logreg, s_train.X, s_test.X)\n",
+ "# released=0\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_model * 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",
+ "# x_ax = np.arange(0.1, 0.9, 0.1)\n",
+ "\n",
+ "# plt.errorbar(x_ax,\n",
+ "# f_rates[:, 0],\n",
+ "# label='True Evaluation',\n",
+ "# c='green',\n",
+ "# yerr=f_sems[:, 0])\n",
+ "# plt.errorbar(x_ax,\n",
+ "# f_rates[:, 1],\n",
+ "# label='Labeled outcomes',\n",
+ "# c='magenta',\n",
+ "# yerr=f_sems[:, 1])\n",
+ "# plt.errorbar(x_ax,\n",
+ "# f_rates[:, 2],\n",
+ "# label='Human evaluation',\n",
+ "# c='red',\n",
+ "# yerr=f_sems[:, 2])\n",
+ "# plt.errorbar(x_ax,\n",
+ "# f_rates[:, 3],\n",
+ "# label='Contraction, log.',\n",
+ "# c='blue',\n",
+ "# yerr=f_sems[:, 3])\n",
+ "# # plt.errorbar(x_ax,\n",
+ "# # f_rates[:, 4],\n",
+ "# # label='Causal model, ep',\n",
+ "# # c='black',\n",
+ "# # yerr=f_sems[:, 4])\n",
+ "\n",
+ "# plt.title('Failure rate vs. Acceptance rate without unobservables')\n",
+ "# plt.xlabel('Acceptance rate')\n",
+ "# plt.ylabel('Failure rate')\n",
+ "# plt.legend()\n",
+ "# plt.grid()\n",
+ "# plt.show()\n",
+ "\n",
+ "# print(f_rates)\n",
+ "# print(\"\\nMean absolute errors:\")\n",
+ "# for i in range(1, f_rates.shape[1]):\n",
+ "# print(np.mean(np.abs(f_rates[:, 0] - f_rates[:, i])))"
+ ]
+ },
+ {
+ "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": 97,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1] 0 en loop\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:78: RuntimeWarning: invalid value encountered in long_scalars\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "jlk loop\n",
+ "1 en loop\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:78: RuntimeWarning: invalid value encountered in long_scalars\n"
+ ]
+ },
+ {
+ "ename": "KeyboardInterrupt",
+ "evalue": "",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m<ipython-input-97-03cd8a3c6103>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 66\u001b[0m f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n\u001b[0;32m---> 67\u001b[0;31m 'result_Y', r / 10)\n\u001b[0m\u001b[1;32m 68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0mfailure_rates\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mr\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_rate_true\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m<ipython-input-96-4ef6c6b281a2>\u001b[0m in \u001b[0;36mcausalEvaluator\u001b[0;34m(df, featureX_col, decisionT_col, resultY_col, r)\u001b[0m\n\u001b[1;32m 90\u001b[0m \u001b[0mtest\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0massign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB_prob_0_model\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpredictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 92\u001b[0;31m \u001b[0mreleased\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcdf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfeatureX_col\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mB_model\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mr\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mB_prob_0_model\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mreleased\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m<ipython-input-94-f0303c92af6c>\u001b[0m in \u001b[0;36mcdf\u001b[0;34m(x_0, model, class_value)\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0my_copy\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx_preds\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mprediction_x_0\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 125\u001b[0;31m \u001b[0mresults\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_copy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mx_values\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 126\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"jlk loop\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/scipy/integrate/quadrature.py\u001b[0m in \u001b[0;36msimps\u001b[0;34m(y, x, dx, axis, even)\u001b[0m\n\u001b[1;32m 477\u001b[0m \u001b[0mfirst_dx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 478\u001b[0m \u001b[0mval\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfirst_dx\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 479\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0m_basic_simps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 480\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0meven\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'avg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 481\u001b[0m \u001b[0mval\u001b[0m \u001b[0;34m/=\u001b[0m \u001b[0;36m2.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/scipy/integrate/quadrature.py\u001b[0m in \u001b[0;36m_basic_simps\u001b[0;34m(y, start, stop, x, dx, axis)\u001b[0m\n\u001b[1;32m 358\u001b[0m \u001b[0mh0divh1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mh0\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mh1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 359\u001b[0m tmp = hsum/6.0 * (y[slice0]*(2-1.0/h0divh1) +\n\u001b[0;32m--> 360\u001b[0;31m \u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mhsum\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mhsum\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mhprod\u001b[0m \u001b[0;34m+\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 361\u001b[0m y[slice2]*(2-h0divh1))\n\u001b[1;32m 362\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtmp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+ ]
+ }
+ ],
+ "source": [
+ "failure_rates = np.zeros((8, 5))\n",
+ "failure_sems = np.zeros((8, 5))\n",
+ "\n",
+ "nIter = 8\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",
+ " df = coinFlipDGWithUnobservables()\n",
+ "\n",
+ " # Decider\n",
+ " df_labeled = coinFlipDecider(df,\n",
+ " featureX_col=\"X\",\n",
+ " featureZ_col=\"Z\",\n",
+ " nJudges_M=100,\n",
+ " beta_X=1,\n",
+ " beta_Z=1,\n",
+ " hide_unobserved=True)\n",
+ "\n",
+ " df_unlabeled = coinFlipDecider(df,\n",
+ " featureX_col=\"X\",\n",
+ " featureZ_col=\"Z\",\n",
+ " nJudges_M=100,\n",
+ " beta_X=1,\n",
+ " beta_Z=1,\n",
+ " hide_unobserved=False)\n",
+ "\n",
+ " # True evaluation\n",
+ "\n",
+ " f_rate_true[i] = trueEvaluationEvaluator(df_unlabeled, 'X',\n",
+ " 'decision_T', 'result_Y',\n",
+ " r / 10)\n",
+ "\n",
+ " # Labeled outcomes only\n",
+ "\n",
+ " f_rate_label[i] = labeledOutcomesEvaluator(df_labeled, 'X',\n",
+ " 'decision_T', 'result_Y',\n",
+ " r / 10)\n",
+ "\n",
+ " # Human evaluation\n",
+ "\n",
+ " f_rate_human[i] = humanEvaluationEvaluator(df_labeled, 'judgeID_J',\n",
+ " 'decision_T', 'result_Y',\n",
+ " 'acceptanceRate_R', r / 10)\n",
+ "\n",
+ " # Contraction\n",
+ "\n",
+ " f_rate_cont[i] = contractionEvaluator(df_labeled, 'X', 'judgeID_J',\n",
+ " 'decision_T', 'result_Y',\n",
+ " 'acceptanceRate_R', r / 10)\n",
+ "\n",
+ " # Causal model - empirical performance\n",
+ "\n",
+ " f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n",
+ " 'result_Y', r / 10)\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.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": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "import pystan\n",
+ "\n",
+ "code = \"\"\"\n",
+ "functions{\n",
+ " // below taken from https://discourse.mc-stan.org/t/quantile-function-in-stan/3642/13\n",
+ " // as Stan doesn't have a quantile function nor supports real-to-int conversion.\n",
+ " int ub(real x) {\n",
+ " int ub = 1;\n",
+ " while (ub < x) ub *= 2;\n",
+ " return ub;\n",
+ " }\n",
+ "\n",
+ " int closest(real x, int a, int b) {\n",
+ " return fabs(x - a) < fabs(x - b) ? a : b;\n",
+ " }\n",
+ "\n",
+ " // L <= x <= U\n",
+ " int to_int_bsearch(real x, int L, int U);\n",
+ "\n",
+ " int to_int_bsearch(real x, int L, int U) {\n",
+ " int mid = (L + U) / 2;\n",
+ " if (L == U) return L;\n",
+ " if (L + 1 == U) return closest(x, L, U);\n",
+ " return x <= mid? to_int_bsearch(x, L, mid) : to_int_bsearch(x, mid, U);\n",
+ " }\n",
+ "\n",
+ " int to_int(real x);\n",
+ "\n",
+ " int to_int(real x) {\n",
+ " if (fabs(x) >= 2^31) reject(\"to_int arugment must be < 2^31, found x = \", x);\n",
+ " if (x < 0) return -to_int(-x);\n",
+ " return to_int_bsearch(x, 0, ub(x));\n",
+ " }\n",
+ "}\n",
+ "\n",
+ "data {\n",
+ " int<lower=0> N;\n",
+ " int<lower=0> N_quantiles;\n",
+ " real<lower=0, upper=1> r;\n",
+ " int<lower=0, upper=1> decision[N];\n",
+ " real X[N];\n",
+ " real<lower=0, upper=1> quantiles[N_quantiles];\n",
+ "}\n",
+ "\n",
+ "parameters {\n",
+ " real Z[N];\n",
+ "}\n",
+ "\n",
+ "model {\n",
+ " Z ~ normal(0, 1);\n",
+ " \n",
+ " for(i in 1:N){\n",
+ " decision ~ bernoulli(inv_logit(X[i] + Z[i]) >= quantiles[to_int(r*N_quantiles)] ? 1 : 0);\n",
+ " }\n",
+ "}\n",
+ "\"\"\"\n",
+ "\n",
+ "dat = dict()\n",
+ "\n",
+ "sm = pystan.StanModel(model_code=code)\n",
+ "fit = sm.sampling(data=dat, iter=4000, chains=4)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": true,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": true,
+ "toc_position": {
+ "height": "1084px",
+ "left": "228px",
+ "top": "111.133px",
+ "width": "300.7px"
+ },
+ "toc_section_display": true,
+ "toc_window_display": true
+ },
+ "varInspector": {
+ "cols": {
+ "lenName": 16,
+ "lenType": 16,
+ "lenVar": 40
+ },
+ "kernels_config": {
+ "python": {
+ "delete_cmd_postfix": "",
+ "delete_cmd_prefix": "del ",
+ "library": "var_list.py",
+ "varRefreshCmd": "print(var_dic_list())"
+ },
+ "r": {
+ "delete_cmd_postfix": ") ",
+ "delete_cmd_prefix": "rm(",
+ "library": "var_list.r",
+ "varRefreshCmd": "cat(var_dic_list()) "
+ }
+ },
+ "position": {
+ "height": "352.85px",
+ "left": "1070px",
+ "right": "20px",
+ "top": "120px",
+ "width": "350px"
+ },
+ "types_to_exclude": [
+ "module",
+ "function",
+ "builtin_function_or_method",
+ "instance",
+ "_Feature"
+ ],
+ "window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/analysis_and_scripts/notes.tex b/analysis_and_scripts/notes.tex
index fadd1b16240776a87d5d676bf588d05fa1c5e913..3721511329f047e294ac8c4a992f45a34e8972b5 100644
--- a/analysis_and_scripts/notes.tex
+++ b/analysis_and_scripts/notes.tex
@@ -87,7 +87,7 @@
\graphicspath{ {../figures/} }
\title{Notes}
-\author{RL, 20 June 2019}
+\author{RL, 25 June 2019}
%\date{} % Activate to display a given date or no date
\begin{document}
@@ -458,7 +458,7 @@ Now the equation \ref{eq:ep} simply calculates the mean of the probabilities for
\STATE Sort $\D_{observed}$ by the probabilities $\s$ to ascending order.
\STATE \hskip3.0em $\rhd$ Now the most dangerous subjects are last.
\STATE Calculate the number to release $N_{free} = |\D_{observed}| \cdot r$.
-\RETURN $\frac{1}{|\D|}\sum_{i=1}^{N_{free}}\delta\{y_i=0\}$
+\RETURN $\frac{1}{|\D_{observed}|}\sum_{i=1}^{N_{free}}\delta\{y_i=0\}$
\end{algorithmic}
\end{algorithm}
@@ -517,35 +517,35 @@ Now the equation \ref{eq:ep} simply calculates the mean of the probabilities for
Results obtained from running algorithm \ref{alg:perf_comp} with $N_{iter}$ set to 3 are presented in table \ref{tab:results} and figure \ref{fig:results}. All parameters are in their default values and a logistic regression model is trained.
\begin{table}[H]
-\caption{Mean absolute error (MAE) w.r.t true evaluation}
-\begin{center}
+\centering
+\caption{Mean absolute error (MAE) w.r.t true evaluation. \\ \emph{RL: Updated 26 June.}}
\begin{tabular}{l | c c}
Method & MAE without Z & MAE with Z \\ \hline
-Labeled outcomes & 0.107563333 & 0.0817483\\
-Human evaluation & 0.004403964 & 0.0042597\\
-Contraction & 0.011049707 & 0.0054146\\
-Causal model, ep & 0.001074039 & 0.0414928\\
+Labeled outcomes & 0.107249375 & 0.0827844\\
+Human evaluation & 0.002383729 & 0.0042517\\
+Contraction & 0.004633164 & 0.0075497\\
+Causal model, ep & 0.000598624 & 0.0411532\\
\end{tabular}
-\end{center}
\label{tab:results}
-\end{table}%
+\end{table}
\begin{figure}[H]
\centering
\begin{subfigure}[b]{0.5\textwidth}
- \includegraphics[width=\textwidth]{sl_without_Z_3iter}
+ \includegraphics[width=\textwidth]{sl_without_Z_8iter}
\caption{Results without unobservables}
\label{fig:results_without_Z}
\end{subfigure}
~ %add desired spacing between images, e. g. ~, \quad, \qquad, \hfill etc.
%(or a blank line to force the subfigure onto a new line)
\begin{subfigure}[b]{0.5\textwidth}
- \includegraphics[width=\textwidth]{sl_with_Z_3iter_betaZ_1_0}
+ \includegraphics[width=\textwidth]{sl_with_Z_8iter_betaZ_1_0}
\caption{Results with unobservables, $\beta_Z=1$.}
\label{fig:results_with_Z}
\end{subfigure}
- \caption{Failure rate vs. acceptance rate with varying levels of leniency. Logistic regression was trained on labeled training data. $N_{iter}$ was set to 3.}\label{fig:results}
+ \caption{Failure rate vs. acceptance rate with varying levels of leniency. Logistic regression was trained on labeled training data. $N_{iter}$ was set to 8. \emph{RL: Updated 26 June.}}
+ \label{fig:results}
\end{figure}
\subsection{$\beta_Z=0$ and data generated with unobservables.}
@@ -646,11 +646,27 @@ Different types of modules are presented in this section. Summary table is prese
Data generation modules usually take only some generative parameters as input.
+\begin{algorithm}[H] % enter the algorithm environment
+\caption{Data generation module: "coin-flip results" without unobservables} % give the algorithm a caption
+%\label{alg:} % and a label for \ref{} commands later in the document
+\begin{algorithmic}[1] % enter the algorithmic environment
+\REQUIRE Parameters: Total number of subjects $N_{total}$
+\ENSURE
+\FORALL{$i$ in $1, \ldots, N_{total}$}
+ \STATE Draw $x_i$ from from a standard Gaussian.
+ \STATE Draw $y_i$ from Bernoulli$(1-\sigma(X))$.
+ \STATE Attach to data.
+\ENDFOR
+\RETURN data
+\end{algorithmic}
+\end{algorithm}
+
+
\begin{algorithm}[H] % enter the algorithm environment
\caption{Data generation module: "results by threshold" with unobservables} % give the algorithm a caption
%\label{alg:} % and a label for \ref{} commands later in the document
\begin{algorithmic}[1] % enter the algorithmic environment
-\REQUIRE Total number of subjects $N_{total},~\beta_X=1,~\beta_Z=1$ and $\beta_W=0.2$.
+\REQUIRE Parameters: Total number of subjects $N_{total},~\beta_X=1,~\beta_Z=1$ and $\beta_W=0.2$.
\ENSURE
\FORALL{$i$ in $1, \ldots, N_{total}$}
\STATE Draw $x_i, z_i$ and $w_i$ from from standard Gaussians independently.
@@ -665,11 +681,11 @@ Data generation modules usually take only some generative parameters as input.
\caption{Data generation module: "coin-flip results" with unobservables} % give the algorithm a caption
%\label{alg:} % and a label for \ref{} commands later in the document
\begin{algorithmic}[1] % enter the algorithmic environment
-\REQUIRE Total number of subjects $N_{total},~\beta_X=1,~\beta_Z=1$ and $\beta_W=0.2$.
+\REQUIRE Parameters: Total number of subjects $N_{total},~\beta_X=1,~\beta_Z=1$ and $\beta_W=0.2$.
\ENSURE
\FORALL{$i$ in $1, \ldots, N_{total}$}
\STATE Draw $x_i, z_i$ and $w_i$ from from standard Gaussians independently.
- \STATE Draw $y_i$ from Bernoulli$(\sigma(\beta_XX+\beta_ZZ+\beta_WW))$.
+ \STATE Draw $y_i$ from Bernoulli$(1-\sigma(\beta_XX+\beta_ZZ+\beta_WW))$.
\STATE Attach to data.
\ENDFOR
\RETURN data
@@ -684,15 +700,16 @@ Data generation modules usually take only some generative parameters as input.
\caption{Decider module: human judge as specified by Lakkaraju et al.} % give the algorithm a caption
%\label{alg:} % and a label for \ref{} commands later in the document
\begin{algorithmic}[1] % enter the algorithmic environment
-\REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent, $\beta_X=1, \beta_Z=1$.
+\REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent / Parameters: $M=100, \beta_X=1, \beta_Z=1$.
\ENSURE
\STATE Sample acceptance rates for each M judges from $U(0.1; 0.9)$ and round to tenth decimal place.
\STATE Assign each observation to a judge at random.
-\STATE Calculate $P(T=0|X, Z) = \sigma(\beta_XX+\beta_ZZ)$ for each observation and attach to data.
+\STATE Calculate $P(T=0|X, Z) = \sigma(\beta_XX+\beta_ZZ) + \epsilon$ for each observation and attach to data.
\STATE Sort the data by (1) the judges' and (2) by probabilities $P(T=0|X, Z)$ in descending order.
\STATE \hskip3.0em $\rhd$ Now the most dangerous subjects for each of the judges are at the top.
\STATE If subject belongs to the top $(1-r) \cdot 100 \%$ of observations assigned to that judge, set $T=0$ else set $T=1$.
-\RETURN data with decisions
+\STATE Set $Y=$ NA if decision is negative ($T=0$). \emph{Might not be performed.}
+\RETURN data with decisions.
\end{algorithmic}
\end{algorithm}
@@ -700,13 +717,14 @@ Data generation modules usually take only some generative parameters as input.
\caption{Decider module: "coin-flip decisions"} % give the algorithm a caption
%\label{alg:} % and a label for \ref{} commands later in the document
\begin{algorithmic}[1] % enter the algorithmic environment
-\REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent, $\beta_X=1, \beta_Z=1$.
+\REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent / Parameters: $\beta_X=1, \beta_Z=1$.
\ENSURE
\FORALL{$i$ in $1, \ldots, N_{total}$}
\STATE Draw $t_i$ from Bernoulli$(\sigma(\beta_XX+\beta_ZZ)))$.
\STATE Attach to data.
\ENDFOR
-\RETURN data with decisions
+\STATE Set $Y=$ NA if decision is negative ($T=0$). \emph{Might not be performed.}
+\RETURN data with decisions.
\end{algorithmic}
\end{algorithm}
@@ -716,9 +734,9 @@ Data generation modules usually take only some generative parameters as input.
\caption{Evaluator module: Contraction algorithm \cite{lakkaraju17}} % give the algorithm a caption
%\label{alg:} % and a label for \ref{} commands later in the document
\begin{algorithmic}[1] % enter the algorithmic environment
-\REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$, acceptance rate r, knowledge that X affects Y
+\REQUIRE Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$, acceptance rate r, knowledge that X affects Y
\ENSURE
-\STATE Split data to a test set and training set.
+\STATE Split data to test set and training set.
\STATE Train a predictive model $\B$ on training data.
\STATE Estimate probability scores $\s$ using $\B$ for all observations in test data and attach to test data.
\STATE Let $q$ be the decision-maker with highest acceptance rate in $\D$.
@@ -745,7 +763,7 @@ Data generation modules usually take only some generative parameters as input.
\begin{algorithmic}[1] % enter the algorithmic environment
\REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$ and \emph{all outcome labels}, acceptance rate r, knowledge that X affects Y
\ENSURE
-\STATE Split data to a test set and training set.
+\STATE Split data to test set and training set.
\STATE Train a predictive model $\B$ on training data.
\STATE Estimate probability scores $\s$ using $\B$ for all observations in test data and attach to test data.
\STATE Sort the data by the probabilities $\s$ to ascending order.
@@ -761,49 +779,61 @@ Data generation modules usually take only some generative parameters as input.
\begin{algorithmic}[1] % enter the algorithmic environment
\REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$, acceptance rate r, knowledge that X affects Y
\ENSURE
-\STATE Split data to a test set and training set.
+\STATE Split data to test set and training set.
\STATE Train a predictive model $\B$ on training data.
\STATE Estimate probability scores $\s$ using $\B$ for all observations in test data and attach to test data.
\STATE Assign observations in test data with observed outcomes (T=1) to $\D_{observed}$.
\STATE Sort $\D_{observed}$ by the probabilities $\s$ to ascending order.
\STATE \hskip3.0em $\rhd$ Now the most dangerous subjects are last.
\STATE Calculate the number to release $N_{free} = |\D_{observed}| \cdot r$.
-\RETURN $\frac{1}{|\D|}\sum_{i=1}^{N_{free}}\delta\{y_i=0\}$
+\RETURN $\frac{1}{|\D_{observed}|}\sum_{i=1}^{N_{free}}\delta\{y_i=0\}$
+\end{algorithmic}
+\end{algorithm}
+
+\begin{algorithm}[] % enter the algorithm environment
+\caption{Evaluator module: Human evaluation} % give the algorithm a caption
+%\label{alg:human_eval} % and a label for \ref{} commands later in the document
+\begin{algorithmic}[1] % enter the algorithmic environment
+\REQUIRE Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$, acceptance rate r
+\ENSURE
+\STATE \emph{Split data to test set and training set and discard the training set.}
+\STATE Assign judges with acceptance rate in $[r-0.05, r+0.05]$ to $\mathcal{J}$
+\STATE $\D_{released} = \{(x, j, t, y) \in \D~|~t=1 \wedge j \in \mathcal{J}\}$
+\STATE \hskip3.0em $\rhd$ Subjects judged \emph{and} released by judges with correct leniency.
+\RETURN $\frac{1}{|\mathcal{J}|}\sum_{i=1}^{\D_{released}}\delta\{y_i=0\}$
\end{algorithmic}
\end{algorithm}
\subsection{Summary}
-%\begin{table}[H]
-%\centering
-%\begin{tabular}{l | l | l}
-%\multicolumn{3}{c}{ \textbf{Module}} \\
-%\textbf{Data generator} & \textbf{Decider} & \textbf{Evaluator} \\ \hline
-% With unobservables, see \ref{fig:dgm} & independent decisions & Contraction algorithm, input: \\
-% Without unobservables & & \tabitem jotain \\
-% & & \tabitem lisaaa
-%\end{tabular}
-%\caption{Types of evaluation algorithms}
-%\label{tab:jotain}
-%\end{table}
-
-\begin{table}
+\begin{table}[H]
\centering
\begin{tabular}{lll}
\toprule
\multicolumn{3}{c}{Module type} \\[.5\normalbaselineskip]
\textbf{Data generator} & \textbf{Decider} & \textbf{Evaluator} \\
\midrule
- With unobservables (figs TBA) & Independent decisions & {\ul Labeled outcomes} \\
- Without unobservables & \tabitem $P(T=0|X, Z)$ & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
- & \tabitem "threshold rule" & \tabitem acceptance rate r \\
- & & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
- & & {\ul True evaluation} \\
- & & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
- & & and \emph{all outcome labels} \\
- & & \tabitem acceptance rate r \\
- & & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+ Without unobservables & Independent decisions & {\ul Labeled outcomes} \\
+ & \tabitem $P(T=0|X, Z)$ & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
+ With unobservables & \tabitem "threshold rule" & \tabitem acceptance rate r \\
+ \tabitem $P(Y=0|X, Z, W)$ & & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+
+ With unobservables & & {\ul True evaluation} \\
+ \tabitem "threshold rule" & & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
+ & & and \emph{all outcome labels} \\
+ & & \tabitem acceptance rate r \\
+ & & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+
+ & & {\ul Human evaluation} \\
+ & & \tabitem Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$ \\
+ & & \tabitem acceptance rate r \\[.5\normalbaselineskip]
+
& & {\ul Contraction algorithm} \\
+ & & \tabitem Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$ \\
+ & & \tabitem acceptance rate r \\
+ & & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+
+ & & {\ul Causal model (?)} \\
& & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
& & \tabitem acceptance rate r \\
& & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
diff --git a/figures/sl_with_Z_8iter_betaZ_1_0.png b/figures/sl_with_Z_8iter_betaZ_1_0.png
new file mode 100644
index 0000000000000000000000000000000000000000..c3a2f46150807e8fa4b5d22a4977c8984cb5d05a
Binary files /dev/null and b/figures/sl_with_Z_8iter_betaZ_1_0.png differ
diff --git a/figures/sl_without_Z_8iter.png b/figures/sl_without_Z_8iter.png
new file mode 100644
index 0000000000000000000000000000000000000000..3ee797927988d15468d3c4dd87d1aca77767c26d
Binary files /dev/null and b/figures/sl_without_Z_8iter.png differ