diff --git a/analysis_and_scripts/Bachelors_thesis_analyses.ipynb b/analysis_and_scripts/Bachelors_thesis_analyses.ipynb index cbb674516add150bad7ce81909145377954da72d..57793dbbc023bf4030d00f5296e478dd6a1e494d 100644 --- a/analysis_and_scripts/Bachelors_thesis_analyses.ipynb +++ b/analysis_and_scripts/Bachelors_thesis_analyses.ipynb @@ -7,7 +7,7 @@ }, "source": [ "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n", - "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Data\" data-toc-modified-id=\"Data-1\"><span class=\"toc-item-num\">1 </span>Data</a></span><ul class=\"toc-item\"><li><span><a href=\"#COMPAS-data\" data-toc-modified-id=\"COMPAS-data-1.1\"><span class=\"toc-item-num\">1.1 </span>COMPAS data</a></span></li><li><span><a href=\"#Synthetic-data\" data-toc-modified-id=\"Synthetic-data-1.2\"><span class=\"toc-item-num\">1.2 </span>Synthetic data</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-model\" data-toc-modified-id=\"Causal-model-2.2\"><span class=\"toc-item-num\">2.2 </span>Causal model</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=\"#Synthetic-data\" data-toc-modified-id=\"Synthetic-data-3.1\"><span class=\"toc-item-num\">3.1 </span>Synthetic data</a></span><ul class=\"toc-item\"><li><span><a href=\"#Predictive-models\" data-toc-modified-id=\"Predictive-models-3.1.1\"><span class=\"toc-item-num\">3.1.1 </span>Predictive models</a></span></li><li><span><a href=\"#Causal-model\" data-toc-modified-id=\"Causal-model-3.1.2\"><span class=\"toc-item-num\">3.1.2 </span>Causal model</a></span></li><li><span><a href=\"#Visual-comparison\" data-toc-modified-id=\"Visual-comparison-3.1.3\"><span class=\"toc-item-num\">3.1.3 </span>Visual comparison</a></span></li></ul></li><li><span><a href=\"#COMPAS-data\" data-toc-modified-id=\"COMPAS-data-3.2\"><span class=\"toc-item-num\">3.2 </span>COMPAS data</a></span></li></ul></li></ul></div>" + "<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=\"#COMPAS-data\" data-toc-modified-id=\"COMPAS-data-1.1\"><span class=\"toc-item-num\">1.1 </span>COMPAS data</a></span></li><li><span><a href=\"#Synthetic-data\" data-toc-modified-id=\"Synthetic-data-1.2\"><span class=\"toc-item-num\">1.2 </span>Synthetic data</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-model\" data-toc-modified-id=\"Causal-model-2.2\"><span class=\"toc-item-num\">2.2 </span>Causal model</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=\"#On-synthetic-data\" data-toc-modified-id=\"On-synthetic-data-3.1\"><span class=\"toc-item-num\">3.1 </span>On synthetic data</a></span><ul class=\"toc-item\"><li><span><a href=\"#Predictive-models\" data-toc-modified-id=\"Predictive-models-3.1.1\"><span class=\"toc-item-num\">3.1.1 </span>Predictive models</a></span></li><li><span><a href=\"#Visual-comparison\" data-toc-modified-id=\"Visual-comparison-3.1.2\"><span class=\"toc-item-num\">3.1.2 </span>Visual comparison</a></span></li></ul></li><li><span><a href=\"#On-COMPAS-data\" data-toc-modified-id=\"On-COMPAS-data-3.2\"><span class=\"toc-item-num\">3.2 </span>On COMPAS data</a></span><ul class=\"toc-item\"><li><span><a href=\"#Predictive-models\" data-toc-modified-id=\"Predictive-models-3.2.1\"><span class=\"toc-item-num\">3.2.1 </span>Predictive models</a></span></li></ul></li></ul></li></ul></div>" ] }, { @@ -18,9 +18,11 @@ "\n", "*This Jupyter notebook is for the analyses and model building for Riku Laine's bachelors thesis*\n", "\n", - "Table of contents is provided above. First I will briefly present the COMPAS data set and then create the synthetic data set as done by Lakkaraju *et al.* ([link](https://helka.finna.fi/PrimoRecord/pci.acm3098066)). Then I will proceed to implement their and our algorithms. Finally I will do the side-by-side comparisons of the results.\n", + "Table of contents is provided above. First I will briefly present the COMPAS data set and then create the synthetic data set as done by Lakkaraju *et al.* ([link](https://helka.finna.fi/PrimoRecord/pci.acm3098066)). Then I will proceed to implement algorithms. Finally I will do the side-by-side comparisons of the results on the synthetic data. Finally I run the causal model on the COMPAS data.\n", "\n", - "## Data\n", + "## Data sets\n", + "\n", + "*Below I load the COMPAS data set and generate the synthetic one.*\n", "\n", "### COMPAS data\n", "\n", @@ -29,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -60,8 +62,9 @@ "import scipy.stats as scs\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 import tree\n", + "from sklearn.ensemble import RandomForestClassifier\n", "\n", "%matplotlib inline\n", "\n", @@ -78,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -87,7 +90,7 @@ "(6172, 13)" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -114,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -329,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "scrolled": false }, @@ -527,7 +530,7 @@ " <th>c_jail_in</th>\n", " <td>6172</td>\n", " <td>6172</td>\n", - " <td>2013-02-13 05:34:20</td>\n", + " <td>2013-10-20 09:56:04</td>\n", " <td>1</td>\n", " <td>NaN</td>\n", " <td>NaN</td>\n", @@ -582,7 +585,7 @@ "decile_score 6172 NaN NaN NaN 4.4185 \n", "is_recid 6172 NaN NaN NaN 0.484446 \n", "two_year_recid 6172 NaN NaN NaN 0.45512 \n", - "c_jail_in 6172 6172 2013-02-13 05:34:20 1 NaN \n", + "c_jail_in 6172 6172 2013-10-20 09:56:04 1 NaN \n", "c_jail_out 6172 6161 2013-09-14 05:58:00 3 NaN \n", "length_of_stay 6172 NaN NaN NaN 14.6228 \n", "\n", @@ -603,7 +606,7 @@ "length_of_stay 46.6935 -1 0 1 5 799 " ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -625,7 +628,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -685,7 +688,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -713,7 +716,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -733,7 +736,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": { "scrolled": false }, @@ -765,7 +768,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -794,7 +797,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -806,7 +809,7 @@ "Name: score_text, dtype: int64" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -817,7 +820,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -828,7 +831,7 @@ "Name: c_charge_degree, dtype: int64" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -839,7 +842,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -853,7 +856,7 @@ "Name: priors_count, dtype: int64" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -865,7 +868,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": { "scrolled": true }, @@ -938,7 +941,7 @@ "Male 2626 29 1621 427 9 285" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -950,7 +953,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": { "scrolled": false }, @@ -1006,7 +1009,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": { "scrolled": false }, @@ -1041,7 +1044,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": { "scrolled": false }, @@ -1337,7 +1340,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "From above it is clear that there are no Native American recidivists of age over 45 or under 25. There are some other value combinations that might be problematic." + "From above it is clear that there are no Native American recidivists of age over 45 or under 25. There are some other value combinations that might be problematic. Therefore the procedure of estimating $P(X=x)$ has to be considered carefully." ] }, { @@ -1346,7 +1349,7 @@ "source": [ "### Synthetic data\n", "\n", - "In the chunk below, we generate the synthetic data as described by Lakkaraju et al. The default values are as per their description. The definitions of $Y$ and $T$ values follow their description.\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", @@ -1358,12 +1361,12 @@ "* 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 would not commit a crime." + "* 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." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": { "scrolled": false }, @@ -1658,7 +1661,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1719,7 +1722,7 @@ "1.0 9371" ] }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1755,7 +1758,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -1864,61 +1867,103 @@ "\n", "**Constructing $\\mathcal{M}_0$, preliminary ideas:**\n", "\n", - "* Approximate $P(X=x)$ with frequencies (make variables factors first)" + "* Approximate $P(X=x)$ with frequencies (makes independence assumption, make variables factors first)\n", + "* Construct Bayesian network.\n", + "\n", + "Functions:\n", + "\n", + "* $f(x)$ gives probability of recidivism given personal properties and predictive model.\n", + "* `ep` counts performance of the predictive model given a data, model and leniency rate like Michael's pdf." ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9941732247162859\n" - ] - } - ], + "outputs": [], "source": [ - "# 1 For now we don't model f(x), just utilize it's N(0, 1)\n", + "def causal(x_list, df_test, df_train, x_cols, y_cols, model_0, model_1,\n", + " leniency_r):\n", + " '''\n", + " Gives probability of negative event given a leniency r.\n", + " \n", + " Parameters:\n", + " x_list = list of x values\n", + " df_test = pandas dataframe of test values\n", + " \n", + " '''\n", "\n", - "# 2 Initialize model\n", - "lr_causal_result = LogisticRegression(solver='lbfgs')\n", + " probability = 0\n", "\n", - "# fit, reshape X to be of shape (n_samples, n_features)\n", - "lr_causal_result.fit(train_labeled['X'].values.reshape(-1, 1),\n", - " train_labeled.result_Y)\n", + " for x in x_list:\n", + "\n", + " p_x = model_0(x)\n", "\n", - "# 3 Predict for all observations in test set.\n", - "causal_probs = lr_causal_result.predict_proba(test.X.values.reshape(-1, 1))\n", + " D_tx = df_test[(model_1(df_test[x_cols]) < leniency_r)\n", + " & (df_test[x_cols] == x)]\n", "\n", - "test = test.assign(B_prob_0_causal=causal_probs[:, 0])\n", + " if D_tx.shape[0] == 0:\n", + " continue\n", "\n", - "# 4\n", - "probability = 0\n", + " p_t = np.sum(D_tx.decision_T == 1) / D_tx.shape[0]\n", "\n", - "r = 0.99\n", - "# 5\n", - "for x in range(-60, 60):\n", - " # A\n", - " p_x = scs.norm.pdf(x/10)\n", + " p_y = lr_causal_result.predict_proba(\n", + " np.array(x).reshape(-1, length(x_cols)))\n", "\n", - " D_tx = test[(test.B_prob_0_causal < r) & (test.X.round(1) == x/10)]\n", - " if D_tx.shape[0] == 0: \n", - " continue\n", - " ## D\n", - " p_t = np.sum(D_tx.decision_T == 1) / D_tx.shape[0]\n", + " probability += p_y[0, 0] * p_t * p_x\n", "\n", - " # E\n", - " p_y = lr_causal_result.predict_proba(np.array(x/10).reshape(-1, 1))\n", - " # F\n", - " probability += p_y[0, 0] * p_t * p_x\n", + " return probability\n", + "\n", + "\n", + "def f(x, model):\n", + " '''\n", + " Probability of recidivism (negative event) given personal properties (x)\n", + " and predictive model (model).\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", + " return f_values[:, 0]\n", + "\n", + "\n", + "def ep(r, df, result_col, feature_cols, model):\n", + " '''\n", + " Returns:\n", + " Empirical performance, i.e. percentage of recidivists. \n", + " \n", + " Parameters:\n", + " r = leniency rate\n", + " df = test data, pandas DataFrame\n", + " result_col = String (list), name of column containing the binarized results.\n", + " feature_cols = String (list), name of columns containge individual features.\n", + " model = trained sklearn classifier \n", + " '''\n", + " rates = np.zeros_like(r)\n", + " for i in range(len(rates)):\n", + " rates[i] = np.mean((df[result_col] == 0) &\n", + " (f(df[feature_cols], model) < r[i]))\n", + " return rates\n", "\n", - "# 6\n", - "print(probability)" + "def gp(r, df, feature_cols, y_model, x_model):\n", + " '''\n", + " Returns:\n", + " Generalized performance\n", + " \n", + " Parameters:\n", + " r = leniency rate\n", + " df = test data, pandas DataFrame\n", + " feature_cols = String (list), name of columns containing individual features.\n", + " y_model = trained sklearn classifier to predict response\n", + " x_model = model of P(X=x)\n", + " '''\n", + " preds = f(df[feature_cols], y_model)\n", + " \n", + " return np.sum(preds * (preds < r) * x_model(df[feature_cols]))" ] }, { @@ -1929,16 +1974,16 @@ "\n", "Below we try to replicate the results obtained by Lakkaraju and compare their model's performance to the one of ours.\n", "\n", - "### Synthetic data\n", + "### On synthetic data\n", "\n", "#### Predictive models\n", "\n", - "Lakkaraju says that they used logistic regression to predict recidivism. We train the model using only *observed observations*, i.e. defendants that were granted bail and are in the train set. We then predict the probability of recidivism for all observations in the test data and attach it to our data set." + "Lakkaraju says that they used logistic regression to predict recidivism. We models using only *observed observations*, i.e. defendants that were granted bail and are in the train set. We then predict the probability of recidivism for all observations in the test data and attach it to our data set. I also applied random forest classifier." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1950,21 +1995,12 @@ "\n", "# predict probabilities and attach to data\n", "label_probs_logreg = logreg.predict_proba(test.X.values.reshape(-1, 1))\n", - "test = test.assign(B_prob_0_machine=label_probs_logreg[:, 0])\n", + "test = test.assign(B_prob_0_logreg=label_probs_logreg[:, 0])\n", "\n", - "# instantiate decision tree classifier\n", - "dectree = tree.DecisionTreeClassifier()\n", + "########\n", "\n", - "# fit, reshape X to be of shape (n_samples, n_features)\n", - "dectree = dectree.fit(train_labeled.X.values.reshape(-1, 1), train_labeled.result_Y)\n", - "\n", - "# predict probabilities and attach to data\n", - "label_probs_dectree = dectree.predict_proba(test.X.values.reshape(-1, 1))\n", - "test = test.assign(B_prob_0_tree=label_probs_dectree[:, 0])\n", - "\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "\n", - "forest = RandomForestClassifier(n_estimators=100, max_depth=4, random_state=0)\n", + "# instantiate the model (using the default parameters)\n", + "forest = RandomForestClassifier(n_estimators=300, max_depth=5, random_state=0)\n", "\n", "# fit, reshape X to be of shape (n_samples, n_features)\n", "forest = forest.fit(train_labeled.X.values.reshape(-1, 1), train_labeled.result_Y)\n", @@ -1978,60 +2014,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Causal model" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Gen perf: 2047.3388927096714\n", - "Rates: [0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8]\n", - "Emp perf: [0.02548 0.09052 0.165 0.24056 0.30824 0.37212 0.42256 0.46524]\n" - ] - } - ], - "source": [ - "def f(x, model):\n", - " f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n", - "\n", - " return f_values[:, 0]\n", - "\n", + "#### Visual comparison\n", "\n", - "def ep(r, df, result_col, feature_cols, model):\n", - " rates = np.zeros_like(r)\n", - " for i in range(len(rates)):\n", - " rates[i] = np.mean((df[result_col] == 0) &\n", - " (f(df[feature_cols], model) < r[i]))\n", - " return rates\n", - "\n", - "print(\"Gen perf:\", np.sum(f(test.X, logreg) * (f(test.X, logreg) < r) * scs.norm.pdf(test.X)))\n", - "print(\"Rates: \", np.arange(1, 9) / 10)\n", - "print(\"Emp perf:\", ep(np.arange(1, 9) / 10, test, 'result_Y', 'X', logreg))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Visual comparison" + "Let's plot the failure rates against the acceptance rates using the difference." ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 22, "metadata": { "scrolled": false }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAHwCAYAAACYFJ/XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xt8j3X/wPHXZwcbNhvmEJONErOT2WyIHUhyKEvdyTFCS3LoJvKrGUqSkCg3hXII5ZBb3d2SMaRsY+R8nGxsbGxhNjt8fn98v9s9M7PNvja8n4/HHvf3uq7P4X1d+/a49/Y5XEprjRBCCCGEEEKI/zEr7wCEEEIIIYQQoqKRREkIIYQQQgghCpBESQghhBBCCCEKkERJCCGEEEIIIQqQREkIIYQQQgghCpBESQghhBBCCCEKkERJCCEqKKXUl0qpCcbPHZVSseUckhBCCPHQkERJCCFMTCkVq5S6rpS6mu+n3p3qaa0Ha62n3osY75ZS6n2l1JLyjqMwxiRTK6XeKuc4HlNK3fcvL1RKWRifp1N5xyKEEKYkiZIQQtwb3bXWNvl+zt2rjpVSFuVZvwIYAFwy/q+4gwfg9y2EEGVCEiUhhCgnSikzpdT3SqkEpVSKUmqrUqpZvuvLlFJhhdS75V/085fNnaanlJqglEoAFhrPP6uU2mfsa4dSyvU2ceW2P0wpdQI4Yjw/VykVp5T6WykVqZRqYzzfDXgb6GMcLYs2nrdXSi1WSp031puslLrl/3eUUg2UUmlKKbt853yUUheMsTRRSkUopVKVUklKqRUleMY2wPPA64CLUsqzwPX2SqnfjW2fVUr1M56vopSapZT6y3gtQillZbzW1lgnRSkVo5Rqn6+9HUqpD5RSUcZ665RS1Y2XI4xlckcVfZRSjyulwpVSycZ7W1rgOcQppd5SSv1pbO/b3DiM1583xvC3UuqEUqpTSZ69sez7SqlVxravAH2VUq3z3eN5pdQcpZRl/vsADhrvo6exnWJ9v4QQ4n4hiZIQQpSvjcDjQF3gALC0jNp1BGyAR4FhSikfDAnTYKAmsAj4QSlVqYg2ngV8ADfj8R+AO1AD+B74TillpbXeCEwHlhtHy1oayy8DrgONAW+gKzCwYCda67NAFIaEJldvYLXWOgv4APgRqG68r3kleA4vApeN8W4G+udeUEo5G9udieGZtAD+NF6eZbxXX+P9TgBylFINgA3AROP58cBapVTNfH32N/7UA5SxLYD2xvvNHVWMNF5/H3gEcAEaAe8VuId/AE8Zr7UEcpO5Nhh+j/8E7IFA4IyxTrGefT7BwArADlgFZAEjAQegLdAZeC3/fQDNjfexppTfLyGEqNAkURJCiHtjvfFf2lOUUusBtNY5WuslWusrWut0IAxoqZSqWgb9ZQFhWusbWuvrwFDgc611pNY6W2u9yFjOp4g2pmqtLxvro7VeqrW+ZExepgPVgMcKq6iUqg90AEZrrdO01gnAbKDXbfpaAbxsrGsGvGQ8B5AJOAGPaK3TtdY7i/MAjAYAK7XWOcb2+qj/TS3rC/ystV6ttc7SWidprWOUUubAK8AIrfV54/PaobXOxJAAbdBa/9f4+/sZ2Ichkcj1tdb6kNb6GhAK9FJKqcKC01of01r/avw9XcCQVPkXKDZba52gtU7GkFjnjoq9Ciw01s/RWp/VWh8txbMH2KG1/rexnevG78kfxudyClhQSFz5leb7JYQQFZokSkIIcW/00FrbG396ACilzJVS05VSp5RSfwMnjGUdyqC/RK31jXzHDYFx+ZK1FAyjGPWLaONs/gOl1NtKqSNKqVQMozRVi4i1IWAFJObrbx5Q5zblvwPaKaXqYBgZSdda/2a89k/AEogyTkEr1lojZZia2B5Ybjy1DsMoW25S0wA4WUjVOkCl21xrCLxc4Dn6YRg9ypX/uZ3B8Bxq3CbGukqp1UqpeON3YAm3PtOEfJ/TjPdQVPwlffYFY0Yp1VQp9aMyTAv9G5hcSFwF+yzp90sIISo0WbAphBDlpz/QBQjC8Ad1TeAihulYt6W1zlJKZQBV8p2uy/8SLYCCu6udBSZprT8qQXx5bSilAoG3MIxUHDKeTs0Xa2H9pQE1jKM5RXekdbJSaguGqXItgG/zXTuPYUoXxvVAvyilIrTWp+/QbH9jfP/JN6BTyXh+ozFG90LqJQI3MExbO1jIfS3WWr9eRL8N8n1+FMjAsJmEfSFlPzJed9NaX1JKvQDMKKLtgrE0vs35Yj97o4K/v38BvwMvaa2vKqXGAN1uUza3z5J+v4QQokKTESUhhCg/thj+SE7GkPR8UIK6+zBMIzNXSnUFnrxD+QXAG8YNBJRSykYp1b0E0/xsMUznS8IwuhOGYUQpVyLglDvFzLjuaBswQylVTRk2rngs/8YHhViBYarc8/xv2h1KqX8Yp5MBpGD4Qz27GDH3xzD1zTPfz0vAs8YNFpYBnZVSPZVh0wgHpZSH1jobw8jObOOIj7kybOBgiWENWbBS6injeWulVKC6ebv3/sYRmarAJAxrrTRwAdBKqUb5ytoC14BU4/qnMcW4r1xfAYON/ZsppRyVUk+U8tkXZIshEb6mDBuM5K5Pwvh8kjGsmcp1t98vIYSocCRREkKI8rMYOGf8OQj8VnTxm4zAsAA/BcMozIaiCmut/8Cw89sXGKbNHcOwRqe4fsKwGcJxIBb4Gzif7/oqDKM1l5RSu43n+mJIpg4Z+/wOw8jX7azHsKHBX1rr/CM5vkCkUuoasBZ4Q2v9F4BS6qhS6qWCDSmlnsQwHW6ecX1PgnGtzjpj/C8ZR6S6A+MwjPjs4X8bV4wGDgPRxmtTAaW1jsXw3N/DMPr3F4apgfn//3QphiTsPGAOjALQWl8BPgT+ME5P88awKUQrDEnJBmBNEc/nJsapiUOAOcb64fxvNKukz76gf2JIWq9gGF1aVeD6RGCF8T6eL4PvlxBCVDjK8I9cQgghhLhbSqkdwJda6yXlHYsQQoi7IyNKQgghhBBCCFGAJEpCCCGEEEIIUYBMvRNCCCGEEEKIAmRESQghhBBCCCEKkERJCCGEEEIIIQp4YF446+DgoJ2cnMo7DCGEEEIIIUQFFh0dnaS1rnWncg9MouTk5ERUVFR5hyGEEEIIIYSowJRSZ4pTTqbeCSGEEEIIIUQBJk2UlFKdjW9NP6GUGl9EuReUUtr4lvLcc+8Y6x1VSj1tyjiFEEIIIYQQIj+TTb1TSpkD84CngDggUim1QWt9qEA5W2AE8Ee+cy5AL6A5UA/YrJRqorXONlW8QgghhBBCCJHLlGuUWgEntNanAJRSK4HngEMFyk0BpgNj8p17Dliptc4ATiulThjb21WSADIzM4mLiyM9Pb2UtyAeVNbW1jg6OmJpaVneoQghhBBCiArIlIlSfeBsvuM4wDd/AaVUC6CB1nqjUmpMgbq/F6hbv6QBxMXFYWtri5OTE0qpklYXDyitNcnJycTFxeHs7Fze4QghhBBCiArIlGuUCstMdN5FpcyAWcA/S1o3XxtDlVJRSqmoixcv3lIhPT2dmjVrSpIkbqKUombNmjLSKIQQQgghbsuUiVIc0CDfsSNwLt+xLeAKbFVKxQJ+wAbjhg53qguA1nqB1tpba+1dq1bhW6FLkiQKI98LIYQQQghRFFMmSpHA40opZ6VUJQybM2zIvai1TtVaO2itnbTWThim2j2rtY4yluullLJSSjkDjwO7TRirySQkJNCrVy8aN26Mi4sLXbp04dixY6Vqa/bs2aSlpZVJXLGxsaxYsSLvOCoqihEjRpRJ2/kFBASU+v1W8+fP55tvvrnt9a1bt/Lbb78Vu7wQQgghhBDFZbI1SlrrLKXUcOC/gDmwSGt9UCk1GYjSWm8oou5BpdRqDBs/ZAFv3I873mmtCQ4OZsCAAaxcuRKAmJgYEhMTadKkSYnbmz17Nn379qVKlSq3XMvOzsbc3LzYbeUmSr179wbA29sbb2/vO9S6t0JCQoq8vnXrVmxsbGjTpk2xygshhBBCCFFcJn2Pktb6J611E611Y631B8ZzoYUlSVrrAONoUu7xB8Z6T2it/2PKOE0lPDwcS0vLm/6A9/T0pF27dmitGTt2LK6urri5ubFq1SrA8Md/QEAAL7zwAk2bNqVPnz5orZkzZw7nzp0jMDCQwMBAAGxsbAgNDcXX15ddu3YxefJkfHx8cHV1ZejQoWhtWNZ14sQJOnbsiIeHB15eXpw8eZLx48ezfft2PD09mTVrFlu3bqVbt24AXLp0iR49euDu7o6fnx/79+8HICwsjEGDBhEQEECjRo2YM2dOiZ7Ht99+i5ubG66urowbNy7v/FdffUWTJk0ICAhgyJAhDB8+PK+/GTNmADBnzhxcXFxwd3enV69exMbGMn/+fGbNmoWnpyfbt2+/qXxh9yyEEEIIIURxmXLXuwpl0r8Pcujc32Xapku9akzs3vy21w8cOEDLli0LvbZ27VpiYmLYt28fSUlJ+Pj40L59ewD27t3LwYMHqVevHm3btmXnzp2MGDGCmTNnEh4ejoODAwDXrl3D1dWVyZMnG+JxcSE0NBSAfv36sXHjRrp3706fPn0YP348wcHBpKenk5OTw7Rp05gxYwYbN24EDAlarokTJ9KiRQvWr1/Pli1b6N+/PzExMQAcOXKE8PBwrly5whNPPMHrr79erC22z507x7hx44iOjqZ69ep06tSJ9evX06pVK6ZMmcKePXuwtbUlKCgIDw+PW+pPmzaN06dPY2VlRUpKCvb29oSEhGBjY8OYMYYNE3/99de88oXdsxBCCCGEEMVl0hElcXs7duzg5ZdfxtzcnDp16uDv709kZCQArVq1wtHRETMzMzw9PYmNjS20DXNzc3r27Jl3HB4ejq+vL25ubmzZsoWDBw9y5coV4uPjCQ4OBgzvDyps6l7B2Pr16wdAUFAQycnJpKamAtC1a1esrKxwcHCgdu3aJCYmFut+IyMjCQgIoFatWlhYWNCnTx8iIiLYvXs3/v7+1KhRA0tLS1588cVC67u7u9OnTx+WLVuGhUXR+X1p7lkIIYQQQoj8HpoRpaJGfkylefPmfP/994Vey50WVxgrK6u8z+bm5mRlZRVaztraOm9dUnp6OsOGDSMqKooGDRoQFhZGenp6kf3cTmF1cneJK25sxWmzqPMF/fjjj0RERLBhwwamTJnCwYMHS9yXEEIIIYQQxSUjSiYUFBRERkYGCxcuzDsXGRnJtm3baN++PatWrSI7O5uLFy8SERFBq1atimzP1taWK1euFHot951ADg4OXL16NS9Bq1atGo6Ojqxfvx6AjIwM0tLSimyrffv2LF++HDBMyXNwcKBatWpFxtahQwfi4+Nve93X15dt27aRlJREdnY23377Lf7+/rRq1Ypt27Zx+fJlsrKyWLNmzS11c3JyOHv2LIGBgUyfPp2UlBSuXr1623u43T0LIYQQQghRXJIomZBSinXr1vHLL7/QuHFjmjdvTlhYGPXq1SM4OBh3d3c8PDwICgpi+vTp1K1bt8j2hg4dyjPPPJO3mUN+9vb2DBkyBDc3N3r06IGPj0/etaVLlzJnzhzc3d1p06YNCQkJuLu7Y2FhgYeHB7NmzbqprbCwMKKionB3d2f8+PF8/fXXRcaVk5PDiRMnqFGjxm3LPPLII3z44YcEBgbmbbDw3HPPUb9+fSZMmICvry8dO3bExcUFOzu7m+pmZ2fTt29f3NzcaNGiBaNHj8be3p7u3buzbt26vM0c8ivsnoUQQgghhCgu9aBMU/L29tYF39dz+PBhmjVrVk4RPTwOHDjAokWLmDlzZqnqX716FRsbG7KysggODmbQoEF564tMSb4fQgghhBAPH6VUtNb6ju/FkRElcddcXV1LnSSBYQTL09MTV1dXnJ2d6dGjRxlGJ4QQQgghyktGdgYJ1+7PmT0PzWYOouLKffeREEIIIYR4cGTmZDJm6xiOXT7GuufWUcXy/tqFWEaUhBBCCCGEEGUqR+fw7o532Rq3lVfdXr3vkiSQREkIIYQQQghRhrTWfPD7B/x0+idGeY3iH0/8o7xDKhVJlIQQQgghhBBlZvae2aw+tppXXV/lVbdXyzucUpNESQghhBBCCFEmvvzzSxYdWMRLT7zESK+R5R3OXZFEycQSEhLo1asXjRs3xsXFhS5dunDs2LFStTV79uwye3FqbGwsK1asyDuOiopixIgRZdJ2ftu3b6d58+Z4enpy/fr1Mm8fYMmSJZw7d84kbQshhBBCiOJZeWQln+75lK6NujLBdwJKqfIO6a5IomRCWmuCg4MJCAjg5MmTHDp0iKlTp5KYmFiq9opKlLKzs0vUVsFEydvbmzlz5pQqrqIsX76cMWPGEBMTQ+XKle9YvqT3AZIoCSGEEEKUt3+f/Dcf/PEBgQ0CmdJ2Cmbq/k8z7v87qMDCw8OxtLQkJCQk75ynpyft2rVDa83YsWNxdXXFzc2NVatWAbB161YCAgJ44YUXaNq0KX369EFrzZw5czh37hyBgYEEBgYCYGNjQ2hoKL6+vuzatYvJkyfj4+ODq6srQ4cOJfdlwidOnKBjx454eHjg5eXFyZMnGT9+PNu3b8fT05NZs2axdetWunXrBsClS5fo0aMH7u7u+Pn5sX//fsDwvqNBgwYREBBAo0aN7phYffnll6xevZrJkyfn3cft7jkwMJDevXvj5uYGwLJly2jVqhWenp689tprZGdnk52dzSuvvJJXf9asWXz//fdERUXRp08fk45aCSGEEEKIwm35awvv7XwP37q+fOz/MZZmluUdUpl4eN6j9J/xkPBn2bZZ1w2emXbbywcOHKBly5aFXlu7di0xMTHs27ePpKQkfHx8aN++PQB79+7l4MGD1KtXj7Zt27Jz505GjBjBzJkzCQ8Px8HBAYBr167h6urK5MmTAXBxcSE0NBSAfv36sXHjRrp3706fPn0YP348wcHBpKenk5OTw7Rp05gxYwYbN24EDMlKrokTJ9KiRQvWr1/Pli1b6N+/PzExMQAcOXKE8PBwrly5whNPPMHrr7+OpWXh/zEMHjyYHTt20K1bN1544QXWrFlz23vevXs3Bw4cwNnZmcOHD7Nq1Sp27tyJpaUlw4YNY/ny5TRv3pz4+HgOHDgAQEpKCvb29sydO5cZM2bg7X3HFywLIYQQQogy9Pv53xmzbQzNazZnTtAcrMytyjukMiMjSuVkx44dvPzyy5ibm1OnTh38/f2JjIwEoFWrVjg6OmJmZoanpyexsbGFtmFubk7Pnj3zjsPDw/H19cXNzY0tW7Zw8OBBrly5Qnx8PMHBwQBYW1tTpUrR+9jv2LGDfv36ARAUFERycjKpqakAdO3aFSsrKxwcHKhdu3aJphHe6Z6dnZ0B+PXXX4mOjsbHxwdPT09+/fVXTp06RaNGjTh16hRvvvkmP//8M9WqVSt230IIIYQQomzFXIhhxJYRONk58XnHz+/LdyUV5eEZUSpi5MdUmjdvzvfff1/otdxpcYWxsvpfJm5ubk5WVlah5aytrTE3NwcgPT2dYcOGERUVRYMGDQgLCyM9Pb3Ifm6nsDq5i/GKG1tx281VtWrVm8oNGDCADz/88JZy+/bt47///S/z5s1j9erVLFq0qNj9CyGEEEKIsnH00lGG/TqMWpVrseCpBdhZ2ZV3SGVORpRMKCgoiIyMDBYuXJh3LjIykm3bttG+fXtWrVpFdnY2Fy9eJCIiglatWhXZnq2tLVeuXCn0Wnp6OgAODg5cvXo1L0GrVq0ajo6OrF+/HoCMjAzS0tKKbKt9+/YsX74cMEzJc3BwuOPoTYcOHYiPjy+yTHHvuUOHDnz//fdcuHABMKyZOnPmDElJSeTk5NCzZ0+mTJnCnj177vhchBBCCCFE2Trz9xle++U1qlhUYWGnhThUdijvkEzi4RlRKgdKKdatW8eoUaOYNm0a1tbWODk5MXv2bNq3b8+uXbvw8PBAKcX06dOpW7cuR44cuW17Q4cO5ZlnnuGRRx4hPDz8pmv29vYMGTIENzc3nJyc8PHxybu2dOlSXnvtNUJDQ7G0tOS7777D3d0dCwsLPDw8eOWVV2jRokVe+bCwMAYOHIi7uztVqlTh66+/LvI+c3JyOHHiBDVq1CiyXHBwcLHu2cXFhffff59OnTqRk5ODpaUl8+bNo3LlygwcOJCcnByAvBGnV155hZCQECpXrsyuXbuKtbueEEIIIYQouYRrCQzZNASNZkGnBdSzqVfeIZmMKs3UrIrI29tbR0VF3XTu8OHDNGvWrJwiengcOHCARYsWMXPmzPIOpUTk+yGEEEIIUXzJ15N55edXSL6ezFdPf0Wzmvfn31FKqWit9R13AZMRJXHXXF1d77skSQghhBBCFN/fN/4mZHMICdcSWNBpwX2bJJWEJEpCCCGEEEKI20rLTOONzW9wIuUEc4Pm0qJ2iztXegBIoiSEEEIIIYQo1I3sG4wKH8X+pP3M8J9B2/ptyzuke0YSJSGEEEIIIcQtsnKyGBcxjl3ndzGl7RSeavhUeYd0T8n24EIIIYQQQoib5OgcJv42kc1/bWaczzh6PNajvEO65yRREkIIIYQQQuTRWvPR7o/YcHIDwzyH0delb3mHVC4kUTIxJycnYmNjCQgIAAwvcO3WrdtNZV555ZW8F8SWp3PnzvHCCy+UqM6SJUsYPnx4mcYREBBAbGwsTk5OZdquEEIIIYS4s3kx81hxZAX9XfoT4h5S3uGUG0mURJ569epViIRNCCGEEEKUj68Pfs2/9v+L5x9/njHeY1BKlXdI5UYSJROrVasW5ubm1KhRo1jlnZycSEpKAiAqKipvJCosLIwBAwbQqVMnnJycWLt2LW+//TZubm507tyZzMxMACZPnoyPjw+urq4MHTqU3BcKBwQEMG7cOFq1akWTJk3Yvn37LX3Hxsbi6uoK3DpS1K1bN7Zu3QrA4sWLadKkCf7+/uzcuTOvzMmTJ/Hz88PHx4fQ0FBsbGzyrn388cf4+Pjg7u7OxIkTAbh27Rpdu3bFw8MDV1dXVq1aBUCNGjUwNzenVq1axXpmQgghhBDi7q05toYZUTN42ulpQv1CH+okCR6iXe8+2v0RRy4dKdM2m9ZoyrhW44osExkZCcDatWvzzm3fvh1PT8+847/++uuW6XiFOXnyJOHh4Rw6dIjWrVuzZs0apk+fTnBwMD/++CM9evRg+PDhhIaGAtCvXz82btxI9+7dAcjKymL37t389NNPTJo0ic2bN5f4ns+fP8/EiROJjo7Gzs6OwMBAWrQw7KU/cuRIRo4cycsvv8z8+fPz6mzatInjx4+ze/dutNY8++yzREREcPHiRerVq8ePP/4IQGpq6k3PKvfZCSGEEEII0/r59M9M2jWJJ+s/yYdPfoi5mXl5h1TuZESpHLRr146YmJi8n2effbZY9Z555hksLS1xc3MjOzubzp07A+Dm5kZsbCwA4eHh+Pr64ubmxpYtWzh48GBe/eeffx6Ali1b5pUvqT/++IOAgABq1apFpUqVeOmll/Ku7dq1ixdffBGA3r17553ftGkTmzZtokWLFnh5eXHkyBGOHz+Om5sbmzdvZty4cWzfvh07O7tSxSSEEEIIIUovIi6Cd7a/Q4vaLZgZMBNLc8vyDqlCeGhGlO408lNRWFhYkJOTA0B6evpN16ysrAAwMzPD0tIybzjUzMyMrKws0tPTGTZsGFFRUTRo0ICwsLCb2sitb25uTlZWVrHjKBhLSYdhtda88847vPbaa7dci46O5qeffuKdd96hU6dOeaNhQgghhBDC9CITInlr61s0qdGEeR3mUdmicnmHVGHIiFIF4+TkRHR0NABr1qwpUd3cZMbBwYGrV6/e1cYMTk5OxMTEkJOTw9mzZ9m9ezcAvr6+bN26leTkZDIzM/nuu+/y6vj5+eXFvHLlyrzzTz/9NIsWLeLq1asAxMfHc+HCBc6dO0eVKlXo27cvY8aMYc+ePaWOVwghhBBClMzBpIO8ueVN6tvUZ37H+dhUsrlzpYfIQzOidL+YOHEir776KlOnTsXX17dEde3t7RkyZAhubm44OTnh4+NT4v5zR4vatm2Ls7Mzbm5uuLq64uXlBcAjjzxCWFgYrVu35pFHHsHLy4vs7GwAZs+eTd++ffnkk0/o2rVr3lS6Tp06cfjwYVq3bg2AjY0Ny5Yt48SJE4wdOzZvhOyLL74ocbxCCCGEEKLkTqacJGRzCPZW9ix4agHVrauXd0gVjsrdFe1+5+3traOiom46d/jwYZo1a1ZOEd1/oqOjeeutt9i2bVup6qelpVG5cmWUUqxcuZJvv/2WH374oYyjLDvy/RBCCCHEw+jslbMM+M8AAL7u/DUNqjUo54juLaVUtNba+07lZERJAIatyHv37s20adNK3UZ0dDTDhw9Ha429vT2LFi0qwwiFEEIIIcTdupB2gaGbhnIj5wZLnl7y0CVJJSGJkgDA29ubY8eO3VUb7dq1Y9++fWUUkRBCCCGEKEuX0y8zdNNQLqVf4qunv+Kx6o+Vd0gVmiRKQgghhBBCPOCu3rjK65tfJ+5qHF90/AJXB9fyDqnCk0RJCCGEEEKIB1h6VjrDtwzn6KWjfBr0KT51S77h18NItgcXQgghhBDiAZWZnclbW99iT+IeprabSnvH9ve2/3PnuLIl/J72WVZkREkIIYQQQogHUHZONhN2TGB7/HZCW4fyjPMz97T/a3/sJn7UKDA3p2rrTZhVvr9eZmvSESWlVGel1FGl1Aml1PhCrocopf5USsUopXYopVyM552UUteN52OUUvNNGaepJCcn4+npiaenJ3Xr1qV+/fp5xzdu3CizfjZv3oydnV1e256enoSHlzxzz8rKwt7evtRxLFq0iISEhLzjgQMHcvTo0VK3J4QQQgghSkdrzZTfp/Bz7M+81fItXmzy4j3t+9I33/DXoEGY16hBw6Xf3HdJEphwREkpZQ7MA54C4oBIpdQGrfWhfMVWaK3nG8s/C8wEOhuvndRae5oqvnuhZs2axMTEABAWFoaNjQ1jxoy5qYzWGq01ZmZ3l7MGBgayfv36u2rjbi1atAgvLy/q1q0LwOLFi8s1HiGEEEKIh5GnWP21AAAgAElEQVTWmpnRM1lzfA1D3IYw0HXgPes7Jz2dhIlhpP7wAzYdO1Bv2jTMbWzuWf9lyZQjSq2AE1rrU1rrG8BK4Ln8BbTWf+c7rAo8GG+/vYMTJ07g6upKSEgIXl5enD179qaRnJUrVzJ48GAAEhMTef755/H29qZVq1b8/vvvxe7nn//8JwsWLMg7fvfdd/n000/5+++/CQoKwsvLC3d3dzZu3HhL3c2bN9OjR4+845CQEJYtWwbAxIkT8fHxybsHrTWrVq0iJiaGl156KW/E7Mknn8xLFJctW4abmxuurq5MmDAB+N8I1vjx4/Hw8KB169ZcuHChBE9SCCGEEEIUtGD/ApYcXMLLTV/mzRZv3rN+M8+d40yfvqT+8AMOI97Ecc6c+zZJAtOuUaoPnM13HAf4FiyklHoDeAuoBATlu+SslNoL/A28q7XefjfBJEydSsbhI3fTxC2smjWlrvGP/pI6dOgQixcvZv78+WRlZd223IgRI3j77bfx8/MjNjaWbt26ceDAgVvKhYeH4+n5vwG49evX06tXL8aPH8/QoUMB+O677wgPD6dy5cr88MMP2NracuHCBdq2bUu3bt2KHfvIkSOZNGkSWmt69+7Nzz//zEsvvcRnn33G3Llzb4oDIC4ujnfffZeoqCjs7Ozo2LEjGzdupHPnzqSmpuLv78+0adN46623WLRoEePH3zJLUwghhBBCFMPyw8uZGzOXZxs/y/hW41FK3ZN+r+3eTfyo0egbN3D84nNsAwPvSb+mZMpEqbDfyi0jRlrrecA8pVRv4F1gAHAeeFRrnayUagmsV0o1LzAChVJqKDAU4NFHHy3r+E2qcePG+PjceWvGzZs337TO5/Lly1y/fp3KBeZ5Fjb1zsnJibNnz5KYmEhcXBx169alXr163Lhxg3HjxrFjxw7MzMw4e/YsSUlJxV6f9Ouvv/Lxxx+Tnp5OUlISLVu25Jlnbr848I8//iAoKAgHBwcAevfuTUREBJ07d6Zy5cp5dVu2bMn27XeVDwshhBBCPLR+OPED03ZPI6hBEJPaTMJMmX6Da601l5cuI/Gjj6jUsCGOc+di1cjZ5P3eC6ZMlOKABvmOHYFzRZRfCXwBoLXOADKMn6OVUieBJkBU/gpa6wXAAgBvb+8ip+2VduTHVKpWrZr32czMDK3/F356enreZ601u3fvplKlSqXqp2fPnqxZs4bY2Fh69eoFwDfffENqaip79uzBwsICR0fHm/oEsLCwICcn55aY0tLSGD58OHv27KF+/fq8++67t9QtKP+9FZT/vszNzYscXRNCCCGEEIXbfGYzob+F4veIHx/7f4yFmek3t87JyDCsR1q/HpugIOpN/+i+nmpXkCnTzEjgcaWUs1KqEtAL2JC/gFLq8XyHXYHjxvO1jJtBoJRqBDwOnDJhrOXKzMyM6tWrc/z4cXJycli3bl3etY4dOzJv3ry849w1P8XVq1cvVq5cydq1a+nZsycAqamp1K5dGwsLC3755Rfi4+NvqdewYUMOHjzIjRs3uHz5Mlu2bAHg+vXrmJmZ4eDgwJUrV1izZk1eHVtbW65cuXJLW35+foSHh5OcnExWVhYrV67E39+/RPchhBBCCCEK99u533g74m3cHNz4NPBTKpmX7h/YSyLz/HnDeqT163F4cziOcz97oJIkMOGIktY6Syk1HPgvYA4s0lofVEpNBqK01huA4UqpjkAmcBnDtDuA9sBkpVQWkA2EaK0vmSrWiuCjjz6ic+fOPProo7i4uJCRkQHAvHnzeP3111m8eDFZWVkEBgbelDjlKrhGaeLEiQQHB+Ph4cHFixdxdnamdu3aAPTr14/u3bvj7e2Nl5cXjz/++C3tOTs706NHD9zc3GjSpAleXl6AYSe/AQMG4OrqSsOGDfH1/d+ys4EDBzJ48GAqV67M7t278847OjoyefJkAgIC0FrTvXt3unbtKqNHQgghhBB3ae+FvYwKH0Uju0bM6zCPKpZVTN5n3nqkjAwcP5+HbVDQnSvdh1RR06LuJ97e3joq6qaZeRw+fJhmzZqVU0SiopPvhxBCCCHuZ0cuHWHQz4OoUbkGSzovwaGyg0n701pzefkKEqdNo1KDBjjOm4tVo0Ym7dMUlFLRWmvvO5Uz/eRFIYQQQgghRJk6nXqa1355jaqVqrLwqYUmT5JyMjJICJtE6rp12AQGGtYj2dqatM/yJomSEEIIIYQQ95HzV88z9BfD618WPrWQR2weMWl/mQkJxL05gvQ//8ThjTdweGMYysz0O+qVN0mUhBBCCCGEuE8kXU9iyC9DuHbjGos7L8bJzsmk/aVFRRE3chQ6PR3HeXOx7dDBpP1VJA9+KiiEEEIIIcQDIDUjldd+eY0LaRf4vOPnPFHjCZP1pbXm0vLlnHllIOa2tjh9t/qhSpJARpSEEEIIIYSo8NIy0xj26zBOp55mboe5eNb2vHOlUsrJyCBh0mRS167FJiCAeh9Pf+DXIxVGEiUhhBBCCCEqsIzsDEaEj+Bg0kE+8f+ENvXamKyvzIQE4kaMJH3/fhyGDcNh+BsPxXqkwjycd30PJSQk0KtXLxo3boyLiwtdunTh2LFjJu9369atdOvWzaR9xMbG4urqetdlAGwesBeUCSGEEEKUhaycLMZuG8sf5/9gctvJdGhouulvaVFRnO75AjdOnMBx7mfUGvHmQ5skgSRKJqW1Jjg4mICAAE6ePMmhQ4eYOnUqiYmJ5R2aEEIIIYSo4HJ0DqE7Qwk/G847rd7h2cbPmqQfrTWXVqy4eT1Sx44m6et+IomSCYWHh2NpaUlISEjeOU9PT9q1a8fVq1fp0KEDXl5euLm58cMPPwC3jsDMmDGDsLAwAObMmYOLiwvu7u706tULgN27d9OmTRtatGhBmzZtOHr0aJExLVmyhB49etC9e3ecnZ2ZO3cuM2fOpEWLFvj5+XHp0iUAYmJi8PPzw93dneDgYC5fvgxAdHQ0Hh4etG7dmnnz5uW1m52dzdixY/Hx8cHd3Z1//etfpXpmWmvGjh2Lq6srbm5urFq1CoCcnByGDRtG8+bN6datG126dOH7778vVR9CCCGEEBWd1poP//iQf5/6N2+2eJPezXqbpJ+cjAzOv/suiZOnYNO2LU7frcaqcWOT9HW/eWjWKG1ffYyks1fLtE2HBja0+0eT214/cOAALVu2LPSatbU169ato1q1aiQlJeHn58ezzxb9rwTTpk3j9OnTWFlZkZKSAkDTpk2JiIjAwsKCzZs3M2HCBNasWVNkOwcOHGDv3r2kp6fz2GOP8dFHH7F3715Gjx7NN998w6hRo+jfvz+fffYZ/v7+hIaGMmnSJGbPns3AgQPzzo8dOzavza+++go7OzsiIyPJyMigbdu2dOrUCaVUkbEUtHbtWmJiYti3bx9JSUn4+PjQvn17du7cSWxsLH/++ScXLlygWbNmDBo0qERtCyGEEELcLz7b+xkrj67kleavMMRtiEn6yExMNLwfaf9+HIa9jsPw4Q/1VLuCHppEqaLRWjNhwgQiIiIwMzMjPj7+jlPy3N3d6dOnDz169KBHjx4ApKamMmDAAI4fP45SiszMzDv2HRgYiK2tLba2ttjZ2dG9e3cA3Nzc2L9/P6mpqaSkpODv7w/AgAEDePHFF285369fP/7zn/8AsGnTJvbv3583ypOamsrx48dp0uT2iWRhduzYwcsvv4y5uTl16tTB39+fyMhIduzYwYsvvoiZmRl169YlMDCwRO0KIYQQQtwvFh1YxMI/F/JCkxd4q+VbJf6H5+JIi442vB8pLY36n82h2lNPlXkf97uHJlEqauTHVJo3b37b6WHLly/n4sWLREdHY2lpiZOTE+np6VhYWJCTk5NXLj09Pe/zjz/+SEREBBs2bGDKlCkcPHiQ9957j8DAQNatW0dsbCwBAQF3jMvKyirvs5mZWd6xmZkZWVlZt62ntb7tf6haaz777DOefvrpm87HxsbeMZ6C7ZTkvBBCCCHEg2T10dXMip7FM07P8K7vu2WeJGmtSVm5koQPplKpfn0clyzG6rHHyrSPB4WMrZlQUFAQGRkZLFy4MO9cZGQk27ZtIzU1ldq1a2NpaUl4eDhnzpwBoE6dOly4cIHk5GQyMjLYuHEjYFijc/bsWQIDA5k+fTopKSlcvXqV1NRU6tevDxjWH5UFOzs7qlevzvbt2wFYunQp/v7+2NvbY2dnx44dOwBDspfr6aef5osvvsgb0Tp27BjXrl27qd34+Hg63OFFZe3bt2fVqlVkZ2dz8eJFIiIiaNWqFU8++SRr1qwhJyeHxMREtm7dWib3KoQQQghRUfx06ife//192ju254N2H2BuZl6m7efcuMH5994jYdJkqrZtY1iPJEnSbT00I0rlQSnFunXrGDVqFNOmTcPa2honJydmz55N8+bN6d69O97e3nh6etK0aVMALC0tCQ0NxdfXF2dn57zz2dnZ9O3bl9TUVLTWjB49Gnt7e95++20GDBjAzJkzCQoKKrPYv/76a0JCQkhLS6NRo0YsXrwYgMWLFzNo0CCqVKly0+jR4MGDiY2NxcvLC601tWrVYv369Te1ef78eSwsiv7KBQcHs2vXLjw8PFBKMX36dOrWrUvPnj359ddfcXV1pUmTJvj6+mJnZwdAaGgo3t7ed1zjJYQQQghRUW09u5UJOybQsk5LPvH/BEszyzJtPzMxkbgRI0jft5+ar4dQ682He+vv4lAPypQmb29vHRUVddO5w4cP06xZs3KKSBQ0d+5cHn300VInNFevXsXGxobk5GRatWrFzp07qVu3bqnjke+HEEIIISqC3ed38/rm12lSvQkLOy3EplLZvl8ybc8e4kaOJOdaGvWmfUi1Tp3KtP37jVIqWmvtfadyMqIk7pnhw4ffVf1u3bqRkpLCjRs3eO+99+4qSRJCCCGEqAj+vPgnb255kwa2Dfii4xdlniRdXrmKhA8+wLLeIzRctAirxx8v0/YfZJIoifuGrEsSQgghxIPk+OXjhGwOoYZ1DRZ0WoC9tX2ZtZ1z4waJU94n5bvvqNq+HfVnzMC8WrUya/9hIImSEEIIIYQQ99jZv88y9JehWJtbs7DTQmpXqV1mbWcmXiB+xAiu79tHzddeo9aIN1HmZbsxxMNAEiUhhBBCCCHuoYRrCQz5ZQhZOVks6bwER1vHMms7bc9e4kaOIOdaGvU//ZRqTz/c65Huhmx1IYQQQgghxD1yKf0SQ38ZSkpGCvOfmk9j+8Zl1vblVas5M2AAZpWr4LTyW0mS7pKMKAkhhBBCCHEPXLlxhZBfQjh39RzzO86nec3mZdJuzo0bJL7/ASmrV1O1XTvqz/gYc+NrVETpyYiSiSUkJNCrVy8aN26Mi4sLXbp04dixYybvd+vWrXTr1s2kfcTGxuLq6nrXZe7kyJEjeHp60qJFC06ePHlXbQkhhBBClIfrWdcZ/utwjl8+zsyAmXjXvePu1MWSeeECf/UfQMrq1dQcOpQG87+QJKmMSKJkQlprgoODCQgI4OTJkxw6dIipU6eSmJhY3qFVWFprcnJybjq3fv16nnvuOfbu3UvjxmU3PC2EEEIIcS9kZmcyeuto9l7Yy4ftP6S9Y/syaTdt715ie75A+rFj1J89m9pvjZZNG8qQJEomFB4ejqWlJSEhIXnnPD09adeuHVevXqVDhw54eXnh5ubGDz/8ANw6AjNjxgzCwsIAmDNnDi4uLri7u9OrVy8Adu/eTZs2bWjRogVt2rTh6NGjRca0ZMkSevToQffu3XF2dmbu3LnMnDmTFi1a4Ofnx6VLlwCIiYnBz88Pd3d3goODuXz5MgDR0dF4eHjQunVr5s2bl9dudnY2Y8eOxcfHB3d3d/71r38V+znFxsbSrFkzhg0bhpeXF2fPns279tNPPzF79my+/PJLAgMDi92mEEIIIURFkJ2Tzfjt49kZv5OJrSfS2alzmbR7efVqzvQfgLK2NqxH6vx0mbRbprSG47/AjlnlHUmpPDRrlMKXLODCmVNl2mbtho0IfGXoba8fOHCAli1bFnrN2tqadevWUa1aNZKSkvDz8+PZZ58tsr9p06Zx+vRprKysSElJAaBp06ZERERgYWHB5s2bmTBhAmvWrCmynQMHDrB3717S09N57LHH+Oijj9i7dy+jR4/mm2++YdSoUfTv35/PPvsMf39/QkNDmTRpErNnz2bgwIF558eOHZvX5ldffYWdnR2RkZFkZGTQtm1bOnXqhFKqyFhyHT16lMWLF/P555/fdL5Lly6EhIRgY2PDmDFjitWWEEIIIURFoLVm0q5JbDqziTHeY+jZpOfdt3njBgkfTCVl1SqqPvmkYT2Sfdm9f6nMxEXD5okQux1qPga+r4OldXlHVSIPTaJU0WitmTBhAhEREZiZmREfH3/HKXnu7u706dOHHj160KNHDwBSU1MZMGAAx48fRylFZmbmHfsODAzE1tYWW1tb7Ozs6N69OwBubm7s37+f1NRUUlJS8Pf3B2DAgAG8+OKLt5zv168f//nPfwDYtGkT+/fv5/vvv8+L6/jx4zRp0qRYz6Nhw4b4+fkVq6wQQgghREWntebjqI9Zd2Idr7m/xoDmA+66zcwLF4gfOYrre/dSc8gQao0aWfGm2iWdgC2T4dAPUMUBnvkYWr4CFpXKO7ISe2gSpaJGfkylefPmeYlDQcuXL+fixYtER0djaWmJk5MT6enpWFhY3LRGJz09Pe/zjz/+SEREBBs2bGDKlCkcPHiQ9957j8DAQNatW0dsbCwBAQF3jMvKyirvs5mZWd6xmZkZWVlZt62ntb7tCJHWms8++4ynn7552Dc2NvaO8QBUrVq1WOWEEEIIIe4H8/fNZ+mhpfRp1oc3PN+46/aux8QQN2Ik2VeuUH/2LKp1LpspfGXmSgJs+wiivwYLawh4B1q/AVa25R1ZqckaJRMKCgoiIyODhQsX5p2LjIxk27ZtpKamUrt2bSwtLQkPD+fMmTMA1KlThwsXLpCcnExGRgYbN24EICcnh7NnzxIYGMj06dNJSUnh6tWrpKamUr9+fcCw/qgs2NnZUb16dbZv3w7A0qVL8ff3x97eHjs7O3bs2AEYkr1cTz/9NF988UXeiNaxY8e4du3aTe3Gx8fToUOHMolRCCGEEKKiWnpoKZ/v+5znGj/H2z5vF3spwu1c/u47zvTrj7KyMq5HqkBJUvrfsOV9mNMC9nwDPq/CyBgIGH9fJ0nwEI0olQelFOvWrWPUqFFMmzYNa2trnJycmD17Ns2bN6d79+54e3vj6elJ06ZNAbC0tCQ0NBRfX1+cnZ3zzmdnZ9O3b19SU1PRWjN69Gjs7e15++23GTBgADNnziQoKKjMYv/6668JCQkhLS2NRo0asXjxYgAWL17MoEGDqFKlyk2jR4MHDyY2NhYvLy+01tSqVYv169ff1Ob58+exsCjeV27w4MGEhITg7X3r1pldunThyy+/pF69endxh0IIIYQQZW/d8XVMj5zOUw2fIqxNGGaq9OMS+sYNEj78kJRvV1K1bVvqfzKj4qxHysqAyK8g4mO4fglce0Lg/0HNB2eHYqW1Lu8YyoS3t7eOioq66dzhw4dp1qxZOUUkCpo7dy6PPvroHTetuFfk+yGEEEKIsrQpdhNjI8bi94gfnwV9RiXz0q/Lybp4kbiRo7i+Zw81hwym1qhRFWM9Uk4O/PkdhL8PKX9BowDoGAb1WpRvXCWglIrWWt/xRVYyoiTumeHDh5d3CEIIIYQQJrEjfgfjto/Do5YHswJm3VWSdH3fPuLeHGFYjzTzE6p16VKGkZaS1nDiV9gcBol/wiMe0P1TaFx2M5oqGkmUhBBCCCGEuAt7EvcwOnw0j9k/xtwOc6liWaXUbaWsWUNC2CQs6tTBaeW3WD/xRBlGWkr5t/qu7gQ9v4Lmz4PZg73dgSRKQgghhBBClNKh5EO88esb1K1al/kd51OtUrVStXPTeqQ2baj3yQwsqlcv42hLqAy2+t53NoWjCVf4h08D08VpIg98olTUltbi4fWgrM0TQgghRPk5lXKKkF9CsK1ky8JOC6lZuWap2sm6eJG4UaO5Hh1NjVcHUXv0aFQxN8AyiYJbffuPhzbDi72LXXaO5tfDiXy5/TS7Yy9Ry9aK51rUw8qiAqyxKoEHOlGytrYmOTmZmjVrSrIk8mitSU5Oxtr6/no7tBBCCCEqjvir8Qz5ZQhmyoyFnRZSt2rdUrVzff9+w3qk1FTqfTIDu65dyzjSEkj/G36bA7vmQfYNw1bf7ceCTe1iVb9+I5vvo8/y1Y7TxCanUd++Mu92bcZLPg3uuyQJHvBEydHRkbi4OC5evFjeoYgKxtraGkdHx/IOQwghhBD3oYtpFxmyaQjXs66z+OnFNKzWsFTtpKxZS0JYGBa1axvWIxlfC3PP3eVW3xeupPPNb2dY9scZUtIy8XC047OXW/CMa10szO/fdUwPdKJkaWmJs7NzeYchhBBCCCEeEKkZqQz9ZShJ15NY2GkhT9Qo+WYLOjOTxA+ncXnFCqq2aU29Tz4pn/VId7nV99GEK3y5/RQ/xJwjMyeHjs3qMKRdI3ycqj8Qs7ke6ERJCCGEEEKIsnIt8xqvb36dM3+f4fOOn+NRy6PEbWQlJRE3ahTXo6KpMWgQtd8qh/VIBbf6rusO/Yq31bfWmh0nkli4/TQRxy5ibWnGP3wcefXJRjg7VDV97PeQJEpCCCGEEELcQUZ2BiO2jOBQ8iFmBszE7xG/Erdx/c8/iRv+pmE90owZ2HUrh/VI8dHwS8m3+s7Iyubf+87z5fZTHEm4goONFWM6NaGPb0OqVy39O6MqMkmUhBBCCCGEKEJmTiZjto5hd8Jupj45laBHS/6S1ZS16wzrkWrVwunbFVg3a2aCSItQyq2+U9JusPyPv/j6t1guXMngiTq2TH/Bnec8779d7EpKEiUhhBBCCCFuI0fn8O6Od9kat5X/8/0/ujfuXqL6OjOTxGkfcXn5cqq09qP+zJn3dj1SKbf6jk26xqKdp/kuKo7rmdm0e9yBj1/0oP3jDg/E+qPikERJCCGEEEKIQmit+eD3D/jp9E+M9BpJr6a9SlQ/KzmZ+JGjSIuKosbAgdT+51v3bj1Swa2+vQeB/9tFbvWttSb6zGUWbj/FpkOJWJgpnvOsz+B2zjStW7oX6d7PTPqbUkp1Bj4FzIEvtdbTClwPAd4AsoGrwFCt9SHjtXeAV43XRmit/2vKWIUQQgghhMhv9p7ZrD62mkGugxjsNrhEda//eYC4N98kOyWFeh9/jF33biaKsoCsDIhaZNjqOy25WFt9Z2Xn8PPBBL7cfpqYsynYVbZkWEBjBrR2ona1h/e9kyZLlJRS5sA84CkgDohUSm3ITYSMVmit5xvLPwvMBDorpVyAXkBzoB6wWSnVRGudbap4hRBCCCGEyPXln1+y6MAi/tHkH4zyGlWiuinr1pMwcSIWDg44rViOtYuLiaLMp+BW387+8NSkIrf6vpqRxarIsyzeeZq4y9dpWLMKk59rzgstHalSSSaemfIJtAJOaK1PASilVgLPAXmJktb673zlqwLa+Pk5YKXWOgM4rZQ6YWxvlwnjFUIIIYQQgpVHVvLpnk/p4tyF//P7v2KvydGZmSR+NJ3Ly5ZRxc+P+rPuwXqkUmz1fT71Okt2xrJi919cSc/Cx6k673Z14SmXOpibPRzrj4rDlIlSfeBsvuM4wLdgIaXUG8BbQCUg9zdaH/i9QN36pglTCCGEEEIIg3+f/Dcf/PEBAY4BvP/k+5iporfNzpWVnEz8qNGkRUZSY8AAao8dY/r1SCXc6vtAfCpfbj/Fxv3nydGaZ9weYUi7Rng2sDdtnPcpU/72CktH9S0ntJ4HzFNK9QbeBQYUt65SaigwFODRRx+9q2CFEEIIIcTDbctfW3hv53u0qtuKGQEzsDSzLFa96wcOGtYjXbpEvY+nY9e9ZDvjlVjySfh1Mhxaf8etvnNyNOFHL7Bw+yl+P3WJqpXM6d/aiYFtnWhQo4pp47zPmTJRigMa5Dt2BM4VUX4l8EVJ6mqtFwALALy9vW9JpIQQQgghhCiO38//zphtY3Cp6cKcoDlYmVsVq17K+vUkhE7E3KEmDVcsp3Lz5qYLsgRbfadnZrN2Tzxf7TjFyYvXeMTOmneeaUqvVo9iV7l4CeDDzpSJUiTwuFLKGYjHsDlD7/wFlFKPa62PGw+7ArmfNwArlFIzMWzm8Diw24SxCiGEEEKIh9S+i/sYsWUEDas15IuOX1DVsuod6+jMTBI//pjL3yyliq+vYT1SjRqmCbAEW30nXc1g6a4zLPv9DMnXbvD/7N13eJNV/8fx9520TdORdKYto0DL3qOAIAgOEPfe6+fAvRVwMVVQQAVxsAQHuNej4gBBGbKHIFM6GIXukY6MZpzfH6nQMkqBhvl9XZdXm+Tc5z7J49MrX885n9O2vomJN3fk0nYJBOprt4xQ+PitUFJKuTVNexT4DV88+Ayl1CZN00YBq5VSPwCPapp2EeACivAtu6Oy3Zf4gh/cwCOSeCeEEEIIIeratsJtPPT7Q8QYY5jabypmg/mI17gLC337kVauJOquO7EMGuSf/UhHEfWdmlvK9MUZfLtuDxVuLxe2tHBf7yTOSYo6aw6IrWuaUmfGirWUlBS1evXqkz0MIYQQQghxmthZspO7frkLvU7Px5d8TP2wI2eHVd2PlDBqJOarrqr7gdUy6lspxbK0AqYtTuePbXkYAnRc27kB9/ZqQlNLWN2P6wyhadoapVTKkdpJQLoQQgghhDjrZJdnM3DuQLzKy4z+M2pVJFn/9z+yhg1HHx3ln/1ItYz6dnm8/LRhL9MWZbA5q4To0CCevKgZd5zTiOiw2u2tEkcmhZIQQgghhDirFNgLGDh3IKUVpXxw8QckmZNqbK/cbnLHjaPwo48J6daN+iYM/GYAACAASURBVBPeqvv9SFWjviMaHTLq22p38dnKXXz41w6ySxw0tYTx2rXtuLpTfYID9XU7HiGFkhBCCCGEOHuUVJTw4O8Pkl2ezZR+U2gd3brG9lX3I0XeeQdxgwahBdZhalwtor53F9qY8VcGX67aTXmFh57J0Yy5th19mseikwNi/UYKJSGEEEIIcVawuWw88vsjpBanMumCSXSO61xje/umyv1I+QXUe/21ut2PVJpTGfX94WGjvtfuKmL64nR+3ZiNTtO4okM97u3VhLb1jxw4IY6fFEpCCCGEEOKMV+Gp4Kk/n2JD/gbGnTeOXvV71dje+uOPZL00FH1UFI0+/RRj2zraj3SEqG+PVzFvczbTFmewZmcR4cEBDDwvif/r2ZgEs7FuxiBqRQolIYQQQghxRnN73QxZNISle5cyquco+jfuf9i2vv1I4yn86CNCunb17UeKjq6DQRwQ9d3mWrjgpX1R37YKN1+tzmTGXxnsLLDRMMrI8Ctac2NKQ0IN8pX9ZJBPXQghhBBCnLG8ysuIpSP4fdfvDOk6hGuaXXPYtu6iIvY89TS25cuJvOMO4gbXwX4krxc2fg0LXj5k1HdOiYOPlu5g9opdWO0uOiVGMGRASy5uE49e9h+dVFIoCSGEEEKIM5JSirGrxvK/tP/xcIeHub317Ydt69i8mcxHH8Odn0/CmDFEXHP18d68xqjvLVklTFuczo/r9+LxKi5uE899vZvQpVEdp+mJYyaFkhBCCCGEOCO9+/e7zN4ymzta38GDHR48bDvrjz+RNXQo+ogIGs2ejbFd2+O78WGivpWmsXBbLtMXZ7AkNZ+QID23dW/E3ec2plF06PHdU9Q5KZSEEEIIIcQZ56NNHzFlwxSuaXoNg1IGoWkHL2NTbje549+g8MMPCUlJof7ECce3H+mgqO+x0OVunOj535o9TF+Szr85ZcSZDAwe0ILbujXCHFKHUeOiTkmhJIQQQgghzijf/PsN41ePp3+j/gzvMfyQRZK7qIg9Tz+NbdlyIm+/nbghg499P9Jhor4L3QZmLdzJx8t2kl/mpGV8OG/c0IErOtQjKEB3xG7FySWFkhBCCCGEOGP8mvErI5eN5Nz65/Ja79fQ6/QHtXFs2eLbj5SXR8Lo0URce/iAhxo5SmDpJFj2TrWo73R7CB/8nME3azNxuLz0bRHLfb2SOLdp9CGLNnFqkkJJCCGEEEKcERZlLuL5xc/TydKJt/q+RaD+4Bki609zyHrpJfRmM41mz8LYrt3R3+gQUd/qgpdYaY1g2jcZzN+aQ6BOxzWd6nNv7yY0jws/cp/ilCOFkhBCCCGEOK0ppfh6+9e8tuI1mkU2450L38EYUP1wVuV2k/vGmxTOnIkxpQsNJkwgICbm6G50UNT3ebgvGMGcgng++CyDDZlbiQwJ5LHzm3JHj8bEhhvq8F2KE00KJSGEEEIIcdoqd5UzctlIfsn4hZ71evJ679cJD6o+g+MuKmLvM89QvnQZkbfdRtxzQ45uP9Ihor7Lb3qDT3OT+XD2TvYUZ5MUE8orV7flus4NMAYdvNxPnH6kUBJCCCGEEKelbYXbeHbhs+wq3cVjnR7jvnb3odOqhyQ4tm4l85FHcefmkvDqq0Rcd+3R3eSAqO/CAe/zXl57Pv98D2XOrXRvEsXIK9twQUsLOjkg9owihZIQQgghhDitKKX4dvu3jFk5BlOQien9p9M1vutB7axz5pD1YpX9SO3b1/4m1aK+o9nTYwTjCs7lxx/ygV1c1i6B+3o3oX2DiLp7Y+KUIoWSEEIIIYQ4bdhcNkYtH8Wc9Dn0SOjBmN5jiDZWP/tIud3kvvUWhR/MwNilCw0mvEVAbGztbvBf1Pfaj1B6A+mtH2FU/gUs/MNJuKGIe85tzP+d24T6EcYj9yVOa1IoCSGEEEKI08K/Rf/yzJ/PsKt0F492fJT72t13UPy3p7iYPU8/Q/nSpUTeegtxzz2HFhR05M6rRH0rTwXbGlzPC/mXsHZtIPUjdLx0WStu6tqQ8GA5IPZsIYWSEEIIIYQ4pSml+D71e0avGE1YUBjT+k2jW0K3g9o5tm3z7UfKySHh1VeIuO66I3fudsLqmbBoLNgK2Brdj8GFV7Dh3xg6NDAz6eIkLmkbT4BeDog920ihJIQQQgghTlk2l41Xlr/Cj+k/0j2hO6/1fo0YY/VY74rMPRR8MB3rN9+ij4ig0axPMHboUHPHB0R9bw/tzBD306zb24SLWsXxZe8kujaOlANiz2JSKAkhhBBCiFPS9qLtPLvwWTKsGTzc8WHub3d/taV2zvR0CqZOw/rjj6DTEXH11cQ+/ljN+5GUgrT5qHnD0XI2sjMwmZcqnmOVpwPXpzRk/LlNSIoNOwHvTpzqpFASQgghhBCnnO9Tv+fV5a8SGhjKtP7T6J7Qfd9rji1byJ88hdK5c9EMBiJvu5Xoe+4hMD6+5k73rME7bwS6HYvI1sUxpuJRlun7cNdFTXi7eyMiQ2uxl0mcNaRQEkIIIYQQpwyby8arK17lh7Qf6BbfjdfPe33fUjvb2nXkT5lM+cJF6MLCiB44kKi77iQgOrrmTgvSqJg7gqBtP2DFxATXXayOvoq7Lm3OuI71MATIAbHiYFIoCSGEEEKIU0JacRrP/PkM6dZ0HuzwIA+2fxCdpqN82TLyJ0/BtmIF+ogIYp94nMjbbkNvMtXcYWkOpXNfJeSfWbhUAO97rmVjozu4vU87RjSLkf1HokZSKAkhhBBCiJPuh7QfeGX5KxgDjEzpN4VzEs6h7I8/yZ8yGcf6DQTExmIZMoTIG29AFxpaY1/KYSXrl3FEb5hGsNfFZ94LSGv1MDeen8ITCUcoroSoJIWSEEIIIYQ4aexuO2NWjOG71O/oGt+V13qOJnjxWjIeugbntm0E1q9P/IjhmK+5Bp3BUGNfbqedbXPepsE/71BPlfArPdnd6WmuuqA3FlPwCXpH4kwhhZIQQgghhDgp0ovTeWbhM6QVp/FA63u5ZWd9im+4m4IdOwhKSiLhtTGYL7sMLbDmQ16V18u6ebOJX/4ybVQOa3TtyO7+POdfcDEhQfJ1Vxwb+TdHCCGEEEKccD+m/cjLy1/GpIKZWXYjpiE/kLs3C0OrVtSfMIHwfheh6Y8csrBjy2rKvn+Gzs6/ydA1YvW50+l0/nXo5YBYcZykUBJCCCGEECeMw+1gzMox/LzxG+5OrccFf5WjCmYT2KkTCcOHE3reebUKWbAW5rHls+dJyf2Gcs3IipbP0eW6Z2gSKBHfom5IoSSEEEIIIU6IdGs6Q395iua/p/LBukACy3cT0rMH0Q88SEi3rrUqkDxuN6u/m0DzTRPoqspYHXMVLW5+je6xCSfgHYiziRRKQgghhBDC735d8zkb3xnDs2tcBFcowi44l5gH7sfYoUOt+9iy4leC5j5Pd086m4PaUXjFeLq3O8ePoxZnMymUhBBCCCGE35TtzmDBa4/TaGEqDT1g6H8BDR5+nOAWLWrdR05mKplfDKJL6QKyiWFNtzfoPOAeNJ3sQxL+I4WSEEIIIYSocxU7drDj3beomDOXJkB27xacO+QNQpKSa92Hw17Ous9H0WHHTNrgZVnifXS8eQTxoeH+G7gQlaRQEkIIIYQQdcax7V8KpkzB+usvuHSKJSnBdHxiOP26XF3rPvbHfY+ih8plbfh5xF8/nh6Naz8LJcTxkkJJCCGEEEIcN/uGDeRPnkLZggW4ggP4uRvsGNCBEVdMID40vtb9HBj3vfHCT+jc60o/jlyIQ5NCSQghhBBCHBOlFLaVqyiYMpnypcvAFMaCfrF80qaQG7vex6ROjxGoq/mw2P8cLu47QOK+xUkihZIQQgghhDgqSinKFy0if/IU7OvWoY+JoejeK3ghZiFuo5exvd7jvAbn1aovj9vNmu8m0KxK3HdzifsWpwAplIQQQgghRK0or5fSufPInzoF5+YtBCQkEP3Cc0xvnMFnGd/QIbYD484bR0JY7Yqc/+K+u/0X9335OLq37+HndyFE7UihJIQQQgghaqRcLqxz5lAwdRoV6ekENWpEwquvUtK3I48ufY4tGVu4u83dPNa5dkvtJO5bnA6kUBJCCCGEEIfkdTqxfvcdBdOm49qzB0OLFtR/8w3CL76Yubt/Z8Rvt6HTdEy6YBJ9G/Y9Yn8S9y1OJ1IoCSGEEEKIarw2G0VffEnhjBm48/IIbt+euBdfJOz8vri8Lkaveo3Pt31O+5j2jOszjnph9Wrs76C477DziL9B4r7Fqc2vhZKmaQOAiYAemK6Ueu2A158G7gPcQB5wj1JqZ+VrHuCfyqa7lFKSCymEEEII4UeekhKKPv2Uwo8+xlNUREi3btR7/TVCevRA0zR2l+zm2UXPsrlgM3e2vpMnOz9JoL7mpXZV47536BIl7lucNvxWKGmapgfeBfoBmcAqTdN+UEptrtJsHZCilLJpmvYQMBa4qfI1u1Kqo7/GJ4QQQgghfNyFhRR++BFFn36Kt6yM0D7nEfPAg4R07rSvzbyd8xj21zA0TWPi+RO5IPGCGvusGvdtk7hvcRry54xSNyBVKZUOoGna58BVwL5CSSn1R5X2y4Hb/TgeIYQQQghRhSsnh8IZMyj64kuU00n4xRcTc/9Aglu33temwlPBm2veZPaW2bSLace4PuOoH1b/sH163G5WfzeR5pvekrhvcVrzZ6FUH9hd5XEm0L2G9vcCv1R5HKxp2mp8y/JeU0p9X/dDFEIIIYQ4+1Ts3k3BtOlYv/sO5fVivvxyoh+4H0NSUrV2maWZPLvwWTYVbOL2VrfzdJena1xqt2XFbwTOfZ7unjSJ+xanPX8WStohnlOHbKhptwMpQJ8qTycqpfZqmpYELNA07R+lVNoB190P3A+QmJhYN6MWQgghhDhDOVNTyZ86lZI5P6PpdJivu5bo++4jqEGDg9rO3zmfoX8NBWDC+RO4MPHCw/abk5nG7i8GkVI6X+K+xRnDn4VSJtCwyuMGwN4DG2madhHwItBHKeX873ml1N7Kn+mapv0JdAKqFUpKqanAVICUlJRDFmFCCCGEEGc7+8ZNFEyZQum8eWhGI1F33EHU3XcTGGc5qK3L4+LNNW8ya8ss2kS3YXyf8TQIP7iQgupx3+0k7lucYfxZKK0Cmmma1gTYA9wM3Fq1gaZpnYApwAClVG6V5yMBm1LKqWlaDHAuvqAHIYQQQghRS7Y1a8ifPIXyxYvRhYcT/dCDRN15JwGRkYdsv6dsD4MWDuKf/H+4rdVtPN3laYL0B4cvSNy3OBv4rVBSSrk1TXsU+A1fPPgMpdQmTdNGAauVUj8A44Aw4CtN02B/DHgrYIqmaV5Ah2+P0uZD3kgIIYQQQuyjlKL8r6UUTJ6MbfVq9FFRxD71FJG33oI+/PAzPQt2LeClv14CBW/1fYuLGl10yHYS9y3OFppSZ8aKtZSUFLV69eqTPQwhhBBCiJNCeb2ULVhA/uQpODZuJCAujuh77yHihhvQGY2Hvc7lcfHW2rf4ZPMntI5uzfg+42kY3vCgdgfGfW9p+ZjEfYvTkqZpa5RSKUdq59cDZ4UQQgghhH8pt5uSX36lYOoUnNtTCWzYkPhRIzFffTW6oJqLmL1lexm0cBAb8jdwS8tbeDbl2YOW2u2P+55AV1Uqcd/irCGFkhBCCCHEaUhVVFD8v/9RMG06rl27CGqaTL1xYzFdcglawJG/4v25+09eXPIiXuXljT5v0L9x/4PaHBz3PZbu7Xv64+0IccqRQkkIIYQQ4jTitdsp/uprCmbMwJ2dTXCbNlgmvU34hRfWKo7b5XXx9tq3+XDTh7SKasX4PuNJNFU/ZqVq3HcO0azp+gadL5G4b3F2kUJJCCGEEOI04Ckro+jTzyj88EM8hYUYU7qQ8PLLhPY6l8pQrCPKKsti0KJBrM9bz00tbmJQ10EY9IZ9rx8Y97284b10uHkEXcJM/npbQpyypFASQgghhDiFuYuKKPrkEwpnzcZbUkJor17EPPgAISlH3ItezaLMRbyw5AXcXjfjzhvHgCYD9r12uLjvcyTuW5zFpFASQgghhDgFuXJzKZz5IUVffIGy2QjvdxHR9z+AsV3bo+vH62LSuknM3DiTllEtGd9nPI1Mjfa9LnHfQhyaFEpCCCGEEKeQisw9FHwwHes336LcbkyXXUbM/QMxNGt21H1ll2czaOEg/s77mxub38jgboP3LbU7MO57RcvnJO5biCqkUBJCCCGEOAU40zMomDoV608/gaYRcfXVRA+8j6DExCNffAiLMhfx4pIXqfBUMPa8sVzS5BKgetx3N1XKKon7FuKQpFASQgghhDiJHFu2kD9lKqW//YZmMBB56y1E33MPgfHxx9Sf2+tm0rpJzNg4g+aRzXmjzxs0NjcGDoz7bkvh5eMk7luIw5BCSQghhBDiJLCtW0fB5CmULVyILjSU6IEDibrrTgKio4+5z5zyHAYvGsza3LVc3/x6hnQdQnBAsMR9C3EMpFASQgghhDhBlFLYli8nf/IUbCtWoI+IIPaJx4m87Tb0puOL4F6yZwkvLH4Bh8fBa71f47Kky3DYy1n2yXN02DFD4r6FOEpSKAkhhBBC+JlSirI//yR/8mQc6zcQEBuLZcgQIm+8AV1o6HH17fa6ee/v95j2zzSaRTbzLbULb8Ta3z4hfvnL9FA5EvctxDGQQkkIIYQQwk+Ux0Pp3LnkT5mKc+tWAuvVI37EcMzXXIPOYDhyB0eQa8tl8KLBrMlZw3XNrmNItyHkbt/Mxu/vprNzncR9C3EcpFASQgghhKhjyuXC+sOPFEybRsWOHQQ1aULCmDGYL78MLTCwTu6xdM9Snl/yPHa3ndG9RnNe5Dmsn/IYKbnfEKkZWdFyCF2ue1bivoU4RlIoCSGEEELUEa/TSfE331A4/QNce/diaNWK+hPeIrxfPzS9vk7u4fa6eX/9+0zbMI3kiGTG9nqdwgU/4t30sMR9C1GHpFASQgghhDhO3vJyij7/goIPZ+LJy8fYsSPxw4cRet55aJpWZ/fJs+UxeNFgVues5pqm13Ctrivaezf74r4D21J4hcR9C1FXpFASQgghhDhGHquVwlmzKPr4EzxWKyE9ziFm3HhCuner0wIJYNneZTy3+DnsbjuDWz9Bq0U/07F0osR9C+EnUigJIYQQQhwld1ERhTNmUPTpZ3jLywk7/3xiHnwAY4cOdX4vj9fD5A2TmbJ+Co1NjXnc1pZLfnoBfWXcd/ubh9MlzFzn9xXibCeFkhBCCCFELSmlKJnzMzmjR+MpKsJ0yQCiH3iA4Bb+id3Ot+czZNEQVmavpFdwWwb9s4Yk70LWhfUm7vrxnNOkpV/uK4SQQkkIIYQQolZce/eSNXIk5QsXEdyhPYkzZxLcornf7rc8aznPLXqOsopSHigK5dHin9mhS2TThR/TqfdVfruvEMJHCiUhhBBCiBooj4eiTz8j9623AIh74QUib7u1zlLsDuTxepi6YSrvr3+feK+B2Xt2keAOlLhvIU4wKZSEEEIIIQ7DuX07WS8Nxb5+PaG9e5MwYjiB9ev77X759nyeWzSEFdkrubi0ghH5u9kUfSUWifsW4oSTQkkIIYQQ4gDeigoKJk8hf9o09GFh1Bs3DtPll9V5kl1VK7NW8sz8J7G5ShlVUEBzZ2Nyrp0pcd9CnCRSKAkhhBBCVGFbu5asocOoSEvDdOUVxD3/PAGRkX67n8frYcJfr/NR2mc0drkYm+siqOMoWkvctxAnVa0LJU3TQpVS5f4cjBBCCCHEyeIpKyPvzTcp+vQzAuvVo+G0aYT17uXXe+4t2s2T/7uTLVo+l5TZuTT4Ujo88TIhEvctxEl3xEJJ07SewHQgDEjUNK0D8IBS6mF/D04IIYQQ4kQoXfAH2SNH4s7NJequO4l9/HF0oaF+u5/yevlszhim5H5GuU5xd2kMN102mfpJrfx2TyHE0anNjNJbwMXADwBKqfWapp3n11EJIYQQQpwA7vx8sl99ldJffsXQvDkN3p7ol0Njq8rYvIpZ8x/h63AbCUpjcMPHuOyiB/x6TyHE0avV0jul1O4DNi96/DMcIYQQQgj/U0ph/fY7csaORdlsxD75BNH33IMW5L/obWthPis/e5avdH+xzBRMN11j3rzxE8wh/tv/JIQ4drUplHZXLr9TmqYFAY8DW/w7LCGEEEII/6jYtYus4cOxLVuOMaULCaNGYUhK8tv9PG43q7+biC1tEmNijRTpjTzb9nHu7HyvX1P0hBDHpzaF0oPARKA+kAnMBWR/khBCCCFOK8rtpvCjj8mbNAktIID4ESOIuPEGvybLbVnxG/q5z/FPWD5vx0eQEGzh8/7v0SKqhd/uKYSoG7UplFoopW6r+oSmaecCf/lnSEIIIYQQdcuxeTNZLw3FsXkzYRdeSPywoQTGxfntfjmZaez+YhDJ5X/wTGw8q0IiGNDoYob3HEFYUJjf7iuEqDu1KZQmAZ1r8ZwQQgghxCnF63CQ/+67FMyYiT4qkvoTJxLev5/flrw57OWs++JlOmTMwGPQc2ViMja9Ymi3IdzQ/AZZaifOOh63C3tJCWFR0Sd7KEftsIWSpmk9gJ5ArKZpT1d5yQTo/T0wIYQQQojjUb58BVnDhuHatQvz9dcRN2gQerN/zidSXi/r5s0mfvnLdFc5vGppz9dhJdQPtzC1zxu0ipbYb3FmcjkclOTnUpKXW+Vnnu9nXg5lxUWER8dw/7szT/ZQj1pNM0pB+M5OCgDCqzxfAlzvz0EJIYQQQhwrj9VKzrhxWL/+hsBGiSR++CGh53T32/12bllDyffP0Nm5jvUBiQxpfhF/2/+lf6P+jOw5UpbaidOWUgpHedm+Iqh0XzGUhzUvh5L8PBylJdWu0ekDCI+JwRRjoVH7zphiYzFb4k/SOzg+hy2UlFILgYWapn2olNp5AsckhBBCCHHUlFKU/jaX7FdewVNURPTA+4h55BF0wcF+uZ+1MJ8tnz1PSu7XRGpGZjW7hw+D/qHQkcGL3V/kphY3yVI7cUpTXi/l1uLqs0EHzAy5HPZq1wQYDJhiLJhiLcQnN9v3uynGgsliITQiEp1u/+Izl9ODo9x1ot9anajNHiWbpmnjgDbAvr80SqkL/DYqIYQQQoij4MrJIXvUy5TNn09w69YkTp1CcOvWfrmXo8LNqu8n0Xbzm3RTpayMuYK13VKYum0mCboEZl06i9bR/rm3EEfD43ZTVlhwmCIol9L8PDxud7VrgkPDCI+1EBFfj8R2HTDFWDDHxmGKtRAeE4sx3LTvPwBU2N2UFTkpK3ZgLXCyN62UssI8yoqdlBU5KS924rS5CYsycNfoc0/GR3BcalMozQa+AC7HFxV+F5Dnz0EJIYQQQtSG8nop/vJLcse/gXK7sQwaRNRdd6IF1OYrztGxV3j4acFCkpa/RG82sTWoNTsGjOCToh9YtHU6/Rr1Y2TPkYQHhR+5MyHqgKvCSWl+HiW5vmVw1fcK5VFWWIBS3mrXhEZEYoqxYGnSlGbdelaZEYrFFGshyBiCUgqnzU15ZcFTVuRgx0YnZcV7KS9KryyOnLgcnuoD0iAkPIiwSAPmWCP1m0cSFmkgPMo/s7r+Vpu/ItFKqQ80TXuiynK8hf4emBBCCCFETZzp6WQNHYZ9zRpCepxDwsiRBCUm1vl9yp1uPl26He/iN/k/z7e4dcGkdx+Ns9O5DF48iAJ7Ac93e55bWt4iS+1Endq/Pyjv4H1C+XnYrMXV2ms6HeHRvv1BDdu0278kLsaCKTaW8OhY9IGBOMpdvhmfyiIod5eT9A02yoq2VRZHDtwV1QssTYMQs4GwSANRCaE0bB1FWEQwYZG+50IjDYSaDegD/Hcu2YlWm0Lpv0WFWZqmXQbsBRr4b0hCCCGEEIenKioo+OAD8t97Hy0khITRozFfc3WdFyllTjcfL9vB2kU/8bx7Msm6LAqSriD62jdYk7WI0b/dTVxoHJ9c8gltYtrU6b3FmU8phc1avG/2p9qSuMriyGkrr3ZNQGAQ4ZUzP8mNkw6aDQo1R+G0eykrclTOBPmWxWXvcFJWlENZ8S7Ki5x43AcUQTqN0IggwiKCiWkQRqN20YRFGAiL3F8IhZiC0OnPnCKoNmpTKL2iaZoZeAbf+Ukm4Cm/jkoIIYQQ4hDs69eT9dJQnNu3Y7r0EuJeeIGAmJg6vUeJw8XHS3fw5eINPOL6mOkBf+I0NYSrviG62UXM3DiTN9e8Sa/6vXj9vNcxBZnq9P7izOD1eCgrKjhoRui/x6V5ubhdFdWuCTKGYI61EB5roX6rtvtnhGJjCYuKRdNCKCv+bybIt/wtc5uDshVOyopSKS924vWoan3q9JpvxifCQFxjE2EdfbM/4ZHBhFYWQcbwIHQ6mQ09UI2FkqZpeqCZUuonwAqcf0JGJYQQQghRhbe8nNyJEyn6ZBYBcXE0eO89wi+o268lVruLmX9lMGNJOudXLOSn4E8JDyyFnk9g6PMcKtDIu+veYcqGKVzc+GLG9BpDoD6wTscgTh9ul4vSqrNBBwQmlBbko7zVZ25CzBGYYmKJbdiIpM5d980IhUXFEBAUgcsZQFmRY9/eoIIsJ7u2OCgryqfcuhflrV4E6QN1lTM/BhKamqsthQuLDCY0woAxLBBNiqBjUmOhpJTyaJp2JfDWCRqPEEIIIUQ1ZYsXkz18BK6sLCJvuYXYp59CH1Z3ZxMV2yqYsSSDmX/tILJiD59FzKINayChC1wxEeLboZRi7KqxzNoyi2uaXsPwHsPRV4lAFmeeCrut2mzQf+cG/bdHqLy4qFp7TdMRFhWNKTaW+i1a75sNCo2MIdAQAVo4Dpvavzeo2EneeiflRQ5sJTs58DSegCDdvqVvDVpEVs7+VCmEIoIxhAbIvjg/qs3Su6Wapr2DL/lu30JJpdTaI12oadoAYCKgB6YrpV474PWngfsAvbUauwAAIABJREFUN74kvXv+O7NJ07S7gJcqm76ilPqoFmMVQgghxBnCXVREzugxlPz4I0HJyTSaPYuQzp3rrP/C8go+WJLOR0t34nA6GFdvEVdZP0HnCYJLxkHXe0Gnx+P18PLyl/lm+zfc1uo2BncdjE47u/ZqnGmUUthLS3yJcfuKoP2zQ6V5uTjKy6pdow8I8O0PirHQpFPK/iIoOBKd3oTXG4KtxL2vCNqb7uTfNQ7spSVA9UNZg4L1hFYWPdH1oqsvhaucIQoyShF0smlKqZobaNofh3haHekcpcple/8C/YBMYBVwi1Jqc5U25wMrlFI2TdMeAvoqpW7SNC0KWA2kAApYA3RRShUdeJ//pKSkqNWrV9f4XoQQQghx6lNKUfLTT+SMHoOnrIyY++8n+oH70QUF1Un/BWVOpi5O55NlO7G7PDzStJBHyycRXLgNWl0Bl4wFUz0AXF4XLy55kV8yfmFgu4E81ukx+fJ6GlBeL2XFhZTkVj83qOpeIbfTWe2awGDjvlCE/4qgIGMk+kAzaOG4nAbKrS7Kixy+c4IKnYc8SNUQElC5J6jqMjjfDNB/hVCQse7j60XtaZq2RimVcqR2R/xfSSl1rAuAuwGpSqn0ygF9DlwF7CuUlFJVi7DlwO2Vv18MzFNKFVZeOw8YAHx2jGMRQgghxGnAtWcPWSNGUr54McYOHUh45WUMzZrVSd95pU6mLkpj1vJdONwebmwTzvOGr4jY9ImvMLr5M2h56b72To+TZxc+y5+7/+TJzk9yb7t762Qc4vj9NyNkzcmmODebktwcinOyKcnLxpqXS2l+Pl7PAQephpswxcQSVa8BiW06EhQSRYDBDJoJpcJwlOv37Q3asdl3UKpPWeU/EBwWWFn0GIhvYt4XhvBfQlxohIFAgyzJPFP4s5ytD+yu8jgT6F5D+3uBX2q4tn6djk4IIYQQpwzl8VA0eza5EyaiAXEvvUTkLTej6Y//S2duiYPJC9OZvWInLo+XqzrUY3DiVhKWPgXledD9QbjgRTDsPyjW5rLx+B+PsyJrBS92f5GbW9583OMQR8dV4aQkNxdrbva+Iqg4JwdrbjbWnGxcTke19iHmCMyWOCyNmpLYpjsBwRHo9L4iyOUKxVHq2x+Uk+kkM7XqQak2wIbRFERYRPWDUkMj9s8IhUYYCAiUIuhs4s9C6VDz0odc56dp2u34ltn1OZprNU27H7gfINEPB8wJIYQQwv8c2/4la+hQHBs2ENrnPBKGDyewXr3j7jfLamfKwnQ+XbkLj1dxdcf6PJkSTMNlQ2HubxDfHm75HOpX3/dUUlHCI78/wob8Dbza61WuTL7yuMciDqa8XsqKCrHmZGPN880IWXOzseb6iqHyosJq7QMMBiIs8Zhi44hPbkOgMRJNM+HxhOO0h1Ba6KEkz05Rvqf6jTQnoSZFaGTwQQel/rcULjTizDooVdQNfxZKmUDDKo8b4DusthpN0y4CXgT6KKWcVa7te8C1fx54rVJqKjAVfHuU6mLQQgghhDgxvE4n+ZMnUzBtOnqTiXrjx2O67NLj3gO0p9jO+3+m8uWqTLxKcV3nBjzcpxGNtn8Cn73qa9T/Vd9Mkr76V6FCRyEPznuQ7cXbGd9nPP0a9TuusZztnLZyX+FTuUTuvyLImpNNSV4OHvf+5XGapiMsOpoISzyNO3QmOCyagKBIlDLhdoVRXqKnJM9Ozm4Hnoz9sdu6ADfmGFflTFAE4VHB+9LhQiMMhJiD0J9lB6WKunHEQknTtBB8h80mKqUGaprWDGhRebZSTVYBzTRNawLsAW4Gbj2g707AFGCAUiq3yku/AaM1TYusfNwfeL42b0gIIYQQpz7b6tVkDR1GRUYG5quuwvLcEAIiI498YQ12F9p47880vl7jW71/fZeGPNw3mYaObfDtFZC1HppdDJeNh4iDV6LklOdw/7z72VO2h7fPf5veDXof13jOBh63m9L8vP37hCqLoP8KIkdZabX2waFhmOPiiU1sTFKX7hhCotDpI/B6w3E6jJQWVGDNtZPxjwPvvjOD3AQElmC2GImMD6VxuxjMFiOmWCPmWCNhkcFyWKrwi9rMKM3ElzrXo/JxJvAVUGOhpJRya5r2KL6iRw/MUEpt0jRtFLBaKfUDMA4IA76q/K9Hu5RSVyqlCjVNexlfsQUw6r9gByGEEEKcvjylpeS+8QbFn39BYP36NJw+nbBe5x5Xn7sKbLz7RyrfrM1Ep2nc1LUhD/VtSn2jGxaMgpVTIDQWbvgQWl8Nh5ixyizN5L6591HkKOL9i96na3zX4xrTmeJwoQm+JXLZlObno1SV2R19AGaLBbMlnvjkpoRFWQgMjkLTTLjcYdhKNN/yuFw7u7Y7KjdWeAErQcFlmC0hxCaG07SLBbPFiDk2BLPFSIgpSNIGxQlXm3jw1UqpFE3T1imlOlU+t14p1eGEjLCWJB5cCCGEOLWVzp9P9shRuPPzibrzTmIffwxdSMgx95eRX867f6Ty3bo96HUat3RtyIN9k0kwG2Hrz/DzICjZAyn3wEXDIdh8yH7SrekMnDsQh9vB5Ism0y623TGP6XTkC03IwZp78D6hQ4UmhEZEYrLEEWGJxxwXT0hELAGBEShlwmk3UFLgxJproyTPTrm1otq1wWGBmCtngsyxRsyWkMqfRoJDA6UYEidEncWDAxWaphmprPk1TUsGnDVfIoQQQgjh487LI/uVVyn97TcMLVrQ4N13MLY79mIkLa+Mdxek8v3fewjU67irR2Me6JNEnCkYSvbCFwNhy49gaQ03zISG3Q7b19bCrTww7wE0NGYOmEnzyObHPK5TVdXQhAP3CVnzcg4bmmCOiyexTXtMljhCzLFoOjMeTxjlxV6seTasuXayVtpxlLmA8sp/IMQchDnWSMM20ZhjjJUzQ75/DCGBJ/4DEOIY1aZQGg78CjTUNG02cC7wf/4clBBCCCFOf0oprN98Q87YcSiHg9inniL6nrvRAo/ty/L2nFImLUjlxw17MQTouLdXEwael4QlPBi8Hlg5DX4fCV4XXDgMej4O+sPf6+/cv3l4/sOEBoYyrd80GpsbH+M7PfmctnJfhHbVfUJ5OYcNTQiPicEcG0eTjl0wW+IxxVoIDosBTDhsAZTkO7Dm2cnbayd1vZ0KuwNwADmgQVikAXNsCEmdYjHHGomIDdm3Z0jOERJnihoLJc03/7kVuBY4B19s9xNKqfwTMDYhhBBCnKYqdu4ka9hwbCtWENK1K/GjRmJo0uSY+tqaXcKkBan8/E8WxkA995+XxMDeScSEGXwNsjfCj0/AntWQdD5c/iZEJdXY54qsFTy24DFijbFM6z+NemHHH0fuT4cPTfDNEB02NKFRE5p2PQezJR5zbBwBwZF43KGUFbmw5tqx5tvZscmONc+GuyIPyANA02mERwcTEWskvomp2hK58OhgOU9InBVqLJSUUkrTtO+VUl2AOSdoTEIIIYQ4TSm3m4KZM8l/5120oCDiR40k4vrr0XRHH8+8eW8JkxZs55eN2YQG6XmoTzL39U4iKjTI16DCBgtfg6XvgDESrp0G7W44ZFhDVQt3L+TpP58m0ZTI1H5TiQ2JPZa3WqeUUthLrL59Qgckxx0qNEEfEIApNg6zJY745OaY4+IxW+IIj7GgD4jAUabDmmf3FUN5NjK32ynJL8HjLt7Xhy5A8y2NizXSoEXk/iVyFiNhUcESqS3OerVZerdc07SuSqlVR24qhBBCiLOVfdMmsoYOxbl5C+H9+hH30ksExlmOup+Ne6y8PX87czfnEG4I4PELmnJPryZEhATtb5T6O/z0NBTvhE63Q7+XISTqiH3/mvErzy9+nhZRLZh80WQigiOOenzHyuV0UJKXWxmYsL8I+u+coUOFJpgt8dRv2QazJQ6zJZ4ISzyhUTF4PKGUFjgpybNjzbWRnWFn60o7pQWZKO/ufX0EBOkwx4YQmRBK4/Yx1UIUQiMMEqstRA1qUyidDzygadpOfLv0NHyTTe39OjIhhBBCnBa8djt5k96h8MMPCYiOpv7bEzH173/U/azfXczb87czf2supuAAnryoGXf3bIK5agBAWS78+jxs/Bqim8H/zYHGvWrV/7fbv2XE0hF0snTi3QvfJSwo7KjHWJODQxP2F0HW3GzKi4uqtQ80BPsKoLh4Ett22F8MxcVjNMVgK9kfmmDNt5O6zo41z0pZUW5lxJZPkDEAc6wRS6NwmqVYfJHalTNDEqstxLGrTaF0id9HIYQQQojTUvmyZWQNG45r924ibrwRy7PPoDeZjqqPtbuKeHv+dv7clofZGMgz/Zpz17mNMQVXKZC8Xlj3McwbBi479H0eej0FAYZa3WPW5lm8vup1etbryYTzJ2AMMB7VGKvyej1kbf+Xvf9uqV1ogiWeJp1SfPuE4nx7hSLi4tEFhOwLTbDm2inKtVXuF9qFzZpa7Z7G8EBMMUbqNYuoVgiZYyVWWwh/qU2hVPNBS0IIIYQ463iKi8kZOw7rt98S1KgRiR9/RGi3w8dwH8rqHYVMnL+dxdvziQwJZPCAFtxxTiPCgw9IqsvdCj89CbuWQaNecPlbEFu7GG+lFFM3TOWdv9/hwsQLGXveWIL0QUe+8AAuh4Md/6wjbfUK0teuwl5iBSA4LByzJc4XmtCtB+ZY3wxRhCWesOgYXA7lK4Qql8hlbrOzaUkZ1tx/cJS7qt0j1ByE2RJCYpvofUvkIiy+NDmDsTZf2YQQdak2/6+bg69Y0oBgoAmwDWjjx3EJIYQQ4hSklKL011/JfuVVPFYr0Q88QMxDD6ILDq51HyvSC5g4fztL0wqIDg3i+Utacvs5jQg1HPC1xOWAxeNhyQQICoUr3/HtR6rl7IlSirfWvsXMjTO5IukKRp07igBd7QuOsqJC0teuJG31Cnb9sx63qwJDSChNOqWQ3KUbjdp3IjgsHJu1AmuejeJcOyV5drJX2LHmZWLN/ZcKh2d/hxqERwZjthhJ7hyLqTJW22wxYoqRWG0hTjVH/GuhlKp2IpymaZ2BB/w2IiGEEEKcklzZ2WSPHEXZH38Q3LYtiR9MJ7hly1pdq5RiWXoBE3/fzoqMQmLCDLx0WStu7Z5ISNAhvo5kLIIfn4TCNGh3I1w8GsJqn07nVV5GrxjNF9u+4MbmN/LiOS+i02pOcVNKkb97J2mrV5C2ZgXZqf8CYIqNo/1FA0jq3I2QiMbk7iwnc7uVvxdswZpnx12xP41OVxmrbbYYiU9KqBKeYMQUbUQfKElyQpwujnoeVym1VtO0rv4YjBBCCCFOPcrrpejzz8l7402U14tlyBCi7rgdLeDIXyOUUvyVWsDE+f+yakcRlnADwy5vza3dEwk+1Fk85QUw9yVY/ylENoE7voPkC45qvG6vm+FLh/ND2g/c3eZunury1GH38HjcbjK3bCRtzQrSVq+kJC8HgPimzelx/W2Y49pgKw0nO72EeR9acdrWAr49Q5bGJhq0jKqyXyiE8CgDOonVFuKMcMS/cJqmPV3loQ7ozH+nkQkhhBDijOZMSyPrpaHY160jtGdP4keNJKhBgyNep5Ri4b95vD1/O2t3FRNvCmbUVW24MaXhoQskpWD95/DbC+AsgV5PQ5/BEHh0oQsVngqGLBrC77t+59GOj3J/+/sPKpIc5WXs+HsNqatXsOPvNTht5QQEBlGvZTuadB6Apm9C4V7F+j/K8HrzgXwiE0JJ7mwhIdlMfLIZc6xRAhSEOMPVZkYpvMrvbnx7lr7xz3CEEEIIcSpQFRXkT5tGweQp6EJCSHhtDOarrjpicaCU4o9tuUycn8r63cXUjzDyytVtuSGlAYaAw+zBKUiDn56CjIXQoBtcMQHijn4rtN1t56k/n+KvPX8xuOtg7mh9x77XrLnZpK3x7TfK3LIRr8dDcJiJmMQOBAQ3pdxqITfTS24mBASWYWlsolP/ROKTzcQnmQkODazhzkKIM1Ft9iiNPBEDEUIIIcSpwbZuHdnDhuHcnorpssuIe+F5AqKja7xGKcXvW3J5e/52/tljpUGkkTHXtuO6zg0ICjjMUjR3Bfw1ERaN88V8X/YmdLkbdEe/dK2sooxHFzzK2py1jOw5kmuSryYrdRtpq1eStmYF+bt2ABBijscc3xOnoyEej4WCHB0h5iASks10TI4gPtlMTMMw9LJ8Toiz3mELJU3TfqSGaHCl1JV+GZEQQgghTgpPWTl5EyZQNHs2AfHxNJj8PuF9+9Z4jdermLs5m7fnp7I5q4TEqBDGXteeazrXJ7CmYmPnMl/kd95WaH01XPI6hMcf07iLHcU89PtDbM/bytC4hwhbsIf3x96JvaQY0AgKTSTA2AddYBJefSQhkWEkVy6hS0g2Ex4dLMvohBAHqWlGafwJG4UQQgghTqqyhQvJGjESd3Y2kbfdRuyTT6IPCz1se69X8cvGbCYt2M7W7FKaxITyxg0duKpjPQJqKpDsRfD7CFjzIZgbwq1fQvOLj3ncu3PSeXXWUzRM99C1qBG7PHNAC0IX0JjAkHMICmtKQnLcvqIorolZziQSQtTKYf9SKKUWnsiBCCGEEOLEcxcUkDN6DCVz5hDUNJlGn84mpFOnw7b3eBVz/sli0vztbM8tIyk2lAk3deTy9gk1F0hKwaZv4ZfnwJYPPR6Fvs+DIeyoxquUIjstgw0LlpD+93LKC3bRDEALRxeURGhsSxq2aUe9ZjEkJJuJrh8qKXRCiGNS09K7L5VSN2qa9g+HWIKnlGrv15EJIYQQwm+UUlj/9z9yx7yGx2Yj5rFHiR44EF1Q0CHbuz1eftqQxaQF20nLK6eZJYy3b+nEZe0S0OuOsGytaAfMeQZSf4eEjnD715DQodbjLM4pZ8uS1aStWUlB5kY8FYUAaHoLLlNbGrftRpeePUlIjiA8qvYH3wohRE1qmnt+ovLn5SdiIEIIIYQ4MSoyM8keNpzypUsxdupEwsujMDRtesi2bo+X//29l3f+SCUjv5wWceG8e2tnLmkbj+5IBZLHBcvfgz/GgE4PA16Dbvf7fj/cJW4vebtLydySTdqaNeRmrKfClgrKCegJiUjC3LYHcwxLyYrZxbuXDKJVdKvj+DSEEOLQalp6l1X5c+eJG44QQggh/EW53RR+Mou8t99G0zTihg0l8uab0Q6RMufyePlu7R7e+SOVXYU2WiWYmHx7Z/q3rkWBBJC5Bn58AnL+gRaXwqXjwHzw+UuOchfZaVay0qzs3ryTnPT1uB2peN27AS/6wBDqNe9E83N60KbPOaTaM3jw9wcx6AxM7z+NpIikOvhkhBDiYLU5cPYcYBLQCggC9EC5Usrk57EJIYQQoo44tm4l66WhODZuJKxvX+KHDyMwIeGgdhVuL9+szeTdP1LJLLLTrr6ZaXemcFErS+2S4RwlsOAVWDnVl2J30yxoeTlomm+5X66drLRistKsZKUWU7hnBx5XGl5XOsqTC0BoZBxNu15Oy549qde8FTq9bwZqdfZqHl3wKBGGCKb1n0bD8IZ1+hkJIURVtYl9eQe4GfgKSAHuBA49Py+EEEKIU4rX4SD/vfcpmDEDvdlM/TffIPySSw4qepxuD1+tzuT9P9PYU2ynQwMzo65qw/ktalkgAWz5EX4eDKVZ0G0g7t4vkpcDWXN3kZVmJTvdir3Ujte9G01l4HVl4K6wgqaR0KwlTVMuJTmlO9H1Dy6AluxZwlN/PEVCWALT+k0jLjSuLj4eIYQ4rFrlYyqlUjVN0yulPMBMTdOW+nlcQgghhDhO5StXkj10GBU7d2K+5hrihgxGHxFRrY3D5eGLVbt5/880skscdEqM4NVr2tKneWztCyRrJvw8GNvmJWSH9ier8f+RvTGY3J/X4XUrlNeOwZiJxg7c5f/icTkJMBho3KEzySndSerclRCT+bDdz9s5j8GLBtM0oilT+k0hKjjqeD4WIYSoldoUSjZN04KAvzVNGwtkAYc/WEEIIYQQJ5WnpITcceMp/uorAhs0IHHGB4T27FmtjcPl4dMVu5i8MI3cUiddG0cy/oYOnNs0ulYFkvIqirJKyZo/h+z1/5LlvByr+z7IA12mi0iLjdh6Oykr3Eph5nacVi+hkVG06XM+ySndSWzTgYDDJOxV9UPaDwz9ayjtYtrx3kXvYQqSlf9CiBOjNoXSHYAOeBR4CmgIXOfPQQkhhBDi2JTMm0fOqJdxFxQQdc89xD72KDqjcd/r9goPs1fsZPLCdPLLnHRvEsWEmzvSI6nmAslV4SF3R4lvCV2alezUQpwOBcRhDAwnrlkU9aIcOEr+JTv1b/ZsygQgNrEx3a+9keQu3YlrknzI4IjD+Xzr57y64lW6J3Tn7fPfJiQw5Jg/FyGEOFo1naOUqJTaVSX1zgGMPDHDEkIIIcTRcOXkkvPKK5TOm4ehVSsavP8+xrZt9r1e7nQza/lOpi1OJ7+sgnObRvPOBZ04Jyn6kP2VW51kpVorE+mKyd9dhtfrO1YxMryMZG05MdG78DTrTLZNI33tKuylJej0ehq0bkfH/peR3KUbZsux7SWasXEGb615i74N+jK+73gMesMx9SOEEMeqphml74HOAJqmfaOUklkkIYQQ4hSjvF6Kv/6a3HHjURUVxD7zNNH/939ogYEAlDndfLxsB9MXZ1BYXkHvZjE8cWEzUhrv3+fj9SoK95aTXZlGl51upSTfAYA+UEdcYxMd+yeSEJxO+Nph7MkpJFXXnvU73HhSF2AIDaVJxxSSU7rTpGMXDCHHvkJfKcU7f7/D1A1TGdB4AKN7jyZQF3hcn5EQQhyLmgqlqvPvckiBEEIIcYpxZmSQPWw4tlWrCOnWjYRRIwlq3BiAEoeLj5fuYPqSDIptLvq2iOXxC5vROTGSCoeb3VsL951flJNupcLhASDEFERCspl2fRuQkBxBdINQiravJe2r5/grPZdsRzQQjdliokP/c0ju0p36LVujD6hVPlSNlFKMXTWWWVtmcW2zaxl2zjD0NRxOK4QQ/lTTXzV1mN+FEEIIcRIpl4uCGTPJf/ddNIOBhFdexnzddWiahtXuYuZfGcxYkkGJw81FrSzcn9KISJsia2keX85KJT+zDOVVoEF0vVCadYsnIdlMQrKZ8OhgvB43mZs3semPn0lbtoCSEhsACXH16HXlFSR3O5foBom1T8WrBY/Xw6jlo/h2+7fc3up2BncdXKf9CyHE0aqpUOqgaVoJvpklY+XvVD5WcuCsEEIIceLZ//mHrJeG4ty2jfCLLybuxRcItFgotlUwY0kGHy7ZQbDNw+WxEXSMMmLfamPVso0ABBj0xDU20WVAIxKSzcQlmTEYfV8FHGVlZPy9grTVK8j4ew0VdhsBOkViSCHd20aTfOsoQpM7++U9ubwuXlj8Ar/u+H/27jM8yjL9+/j3nknvvTdSICQhlITee3ERsa8uYgNdu4uubnFX/bs+rm2xroiKwYYNFTtIR4oJJaRQ0kjvvU6mXM+LcV3bSjFhknB+3njkyNz3nFcOj0x+nPd1Xl9wQ/IN3DziZglJQgib+59BSSklvW4hhBCij7B0dFD79DM0rF2LnZ8fYc8+g/usWVTVdfDG2kNkZ9bib4DrLfboLfbQ1kWntyLo205RcIwXvqGu6PT/nTrXVF1FztZ9FOzfR9mRHCxmMy4engyOcCWm4wCRvhbs5z8Ew38LvRRcDGYDK7atYHvZdv6Q8geuSbqmV95HCCFO169/oFgIIYQQvapt5y6q7r+f7vJyHC5einHWZewu7uTYH3egazHihEYKejyCXYga4kNwjCdBMZ64+zj94D7KYqEy7xgF+62do7pS62Bb37AIUhdeSEyQHcGZj6E1FcHEK2DOQ+D681PxekKHsYPbttzGN1XfcN+4+7h0yKW99l5CCHG6JCgJIYQQfVTnoUMUPfUKZSVGWkIuomV4PJ11CtYVYdAUFXoL7lGuzJ0ayaiRgTg4/fRj3WjooiQ7k4KMfRTs/4aO5iY0nY6w+ESmXXU90Slj8HZ3gC//DNvfBp8YuGoDRE/t1bU1G5q5afNN5NTl8I9J/2BhzMJefT8hhDhdEpSEEEKIPsRssnBiSxbH1++lssODTpcLIA5cvR1octaxW2ulRGdmUkowN8+MI8bf7Sf3aG9qpPBAOgX791F8+BCmbgMOzs5EjUglNmUMUSNTcXZzB6Xg0BuQ9lcwtMGUu2HyXWDv9DOV9Zz6znpu/OpG8pvyeWLqE8yMnNmr7yeEEGdCgpIQQghhY+1NBopz6incW0J5Xgsm7NBZoggM7CZ+ShhftXfxVHY55i7F4nGhPD49lii//55VpJSiobyU/Ix9FGTspTL/OCiFu58/SdNnE5M6lvCEJPR23zuPqC4PPrkTTuyE8HGw8CkIiO/1tVa1V7F803Iq2yp5dsazTAyd2OvvKYQQZ0KCkhBCCHGWWSyKmhMtFGfXcyKrjrrSNgAcuxoIbD5GVEoQEdcsYu2RBu7bUUiXycLFo8K4eXosEb4u1nuYzZQfzfl2v9E3NFVXAhAYHcuEi68gJnUs/pGDfjo9zmSAXSth5+Ng72wNSCOvAp2O3lbaWsqyjctoMjTxwuwXSAlM6fX3FEKIMyVBSQghhDgLutqNlB5poDirnuKcerrajGg68LVrJubEDvyajhB2/jQ8rlvOuwXtXL/mIHVt3SwYFsRdc4YQ7e+GoaODY3t2Wkd4H8ygq70NvZ0dEUnDSV24mOhRY3D39fvfRZz4Gj65A+qOQ9JFMPf/gXvgWVl/YVMhyzYuw2Ax8NKcl0jySzor7yuEEGdKgpIQQgjRC5RSNFS0f9c1qipsQVkUTq72hA92x6dyP44fv4xdVwteF12Ez41r+LJW8XhaNiUNHYyL9uHF3w0mjGbKMrbw3oF0SnOysJhNOLl7EJM6lpiUsUQmj8DB2eWXi+logE1/g4OvgVcEXPk+xM06Oz8I4Ej9EW5jDwD4AAAgAElEQVTYdAM6TceauWuI8447a+8thBBnSoKSEEII0UOM3WbKjzVSnFXPiew62hoMAPiFuzFqbgThMa7YbXufptWvYmlvx+M3v8H/lpv5ptuVZe8fIbeskVS3Tm6KM+BYv5/dD67E0N4OgHdwKKMWnE9M6lhCBsej053CcYdKQdZ78OWfrGFp4u0w9R5wcD35tT3kUM0hbvrqJtwc3Fg9ZzWRHpFn7b2FEOLXkKAkhBBC/AotdZ3fdo3qKT/eiNlowc5RT3i8N6MXDCIi0RcXZ0Xjm29R/8hqzI2NuM+ehd+tt3LMwZv/e3cbdflHSDBVM6OrCmU0UJ4N3sEhxI2ZSHhCEqHxiXgGnOYjcg2F8OkKKNgCoSmw5AMIGtY7P4T/YU/FHm7fejsBLgGsnr2aYLfgs/r+Qgjxa0hQEkIIIU6D2WyhKr/ZGo6y62mstHZ8PP2dSZwcQlSSHyFxXujtdajubprWr6fg+X9jqqnBccJ4WLSQw41NHFz5NHYNpcQpM3GAT1gkERNmETbUGozcvH3OsEAj7H4Gtv8TdPYw/zEYfR2cSgeqB20t2cqK7SuI8ozixdkv4uf8C3unhBCiD5KgJIQQQpxER0s3JTnWrlHpkQa6O03o9BohcV4kTgohMskXr8D/7hNSZjNNH35I5XPPUdPUQEtMJE2j4qmtqUK9+TIWNFod/fFLmMTsWeOJG5aMs7vHry+0NB0+vh1qciD+N7DgMfAI+fX3PU2fFX7Gn3f9mQTfBP496994Onqe9RqEEOLX6tWgpGnaPOApQA+8pJR65EffnwKsBJKBy5VS733ve2Yg69svS5RS5/dmrUIIIcR/KIuitrT1u0fqaopbQIGLpwMxo/yJSvIjbKg3Dk4//Bhtb24if92bFH7xGXVmAy3ejuATjE5nwWJxINNzBCWOwUyckMIf5g0jwKOHDnbtaobND0L6y9ZgdPmbEH9ez9z7NL1//H0e2PMAKYEpPDvzWVztz95+KCGE6Em9FpQ0TdMDzwGzgTIgXdO0DUqp3O+9rAS4GrjrZ27RqZQa0Vv1CSGEEN/X3Wmi9EgDJ7LrKcmup6OlGzQIjPJg7MJBRCb54Rfu9oNziVob6ijLzabsSDYl+9NpaqwHQG8PgZExxI+fzFH8eemYieoOxYJhQbzy7ajvHqEU5H4En98D7TUw9kaY8RdwdO+Z+5+mtTlreSzjMSaFTuLJaU/ibOdskzqEEKIn9GZHaQyQr5QqBNA0bR2wCPguKCmlTnz7PUsv1iGEEEL8hFKKpuqO77pGlflNWMwKRxc7whN8iEryJSLRF2d3h+9e31xdRdmRbMqO5FB2NJvm6irA+mHq3dLOUL0jMRcsZtCVV/HF8Ub+8uUxSho6GDvIhxfmxzMywrvnFtBUCp/dBce/gKBk+O1bEDqq5+5/GpRSrDq8iucOPcfsyNn8c/I/sdfb26QWIYToKb0ZlEKB0u99XQaMPY3rnTRNywBMwCNKqQ97sjghhBDnHpPRTMXxJk5k11OcVUdLXRcAPiGujJgVTmSSH0HRHuj0Ous5SOWlHN/7bTA6kk1bg7Vj5OTuQXBIGFGN7bhl5+Lj7oX/Tb/H68IL+bq4hRUvZZBd3kJ8kDtrrhnNtMH+P+hE/SpmE3yzCrb8A1Aw5x/WTpLeNtuOlVL8a/+/WJOzhvNjzueBCQ9gp5Mt0EKI/q83f5P93CeCOo3rI5RSFZqmRQNbNE3LUkoV/OANNG05sBwgIiLizCsVQggxYLU1dnEiq57i7HrKjjZg6rZgZ68jNN6bkbMjiEjyxcPXGYvFTG3xCQ59uf27YNTZ2gKAq7cPYUOTCBuaRICLG+Z179D2zsfovbzwvfUOvK/4Lbn1Bm577SA78+oI9XLmX5cNZ9HwUHS6HgpIABUHrcMaKjMhbi6c97j1AFkbsSgL/9j7D945/g6XDbmMP4/9MzpNZ7N6hBCiJ/VmUCoDwr/3dRhQcaoXK6Uqvv1voaZp24CRQMGPXvMi8CJAamrq6YQwIYQQA5TFoqgubP62a1RPfXkbAO6+TgwdH0zkMD9CB3uh6RTVhfkc3bWXsiPZlB/NpbuzAwAP/0CiR40mdGgiYUOT8AoMxlhSQu2zz9H8ySfoXF3xu+1WfK5aSpkB7v/gCB9nVuDtYs99v0ngd+MicLTrwXHchjbY+g/Y9wK4+sMlr0LCBdBTXaozYLKYuO/r+/ik8BOuTbqWO0bd0XNdMyGE6AN6MyilA3Gapg0CyoHLgStO5UJN07yBDqWUQdM0P2Ai8GivVSqEEKJf62ozUpxj7RqV5NZjaDeh6TSCYzwZf2EMUUl+uPnqqS7Io+zIRr75IJuKvKOYDAYAfELCiJ8whbChiYQOTcTDL+C7exurqqj6+/00vf8+mr09vtdfh8+119Jk78KDm/N4Y18JdnqNW6bHsnxqNB5OPbg3p6kUDqyFA2nQVgOp18LMv4GzV8+9xxnoNnfzxx1/ZHPJZm4beRvLkpfZtB4hhOgNvRaUlFImTdNuAb7EOh78FaVUjqZpDwIZSqkNmqaNBj4AvIGFmqY9oJRKBIYCq74d8qDDukcp93+8lRBCiHOMUor68jbrI3VZ9VQXNaMUOLvbM2iYH5HD/AiMcqK+LJ+yI9vZuCqbqvzjmE0m0DT8I6IYNn2ONRjFJ+Lq9dMhC6b6eupffJHGt9ahlML78svxvWE5Bk8fnt1ZyOodhXSZLFw+OpzbZ8b13KhvixnyNkHGK5C/yTrZLnYWTLkbIk5nq2/v6DR1csfWO9hdsZt7x9zLlUOvtHVJQgjRKzSlBsYTa6mpqSojI8PWZQghhOgl3V0myo42UpxjHd/d1mjtBvlHuBM5zJfgaCe620soO5ZD+ZFsqosKUBYLmk5HYHTst3uMEgkdkoiT2/8ez21uaaH+lVdoWPsaqqsLz8UX4H/TTajAYNall/D05jzq2rpZMCyIFXOGENNTo75bKuDAa9YOUksZuAXCyCUw6irwjuyZ9/iVWrtbuWXzLRyqPcT94+9ncdxiW5ckhBCnTdO0/Uqp1JO9TsbSCCGE6LOaazu+G8RQfrwRi0lh76QnYqgPw2fYo9NVUlu8n2M7stn1RjEohd7OjqDYIYxZdAlhCUmEDI7Hwenk5/lY2ttpeO116l95BUtLCx4L5uN3y63YR0XxSVYlT7y5neJ666jv1Vf10KhviwUKt0DGGjj2OSgzRE+HeQ/DkAXWA5n6iKauJm746gaONxznn1P+ybyoebYuSQghepUEJSGEEH2G2WShIr+J4m8HMTRVW4creAW6MHiMK46O1bQ3FlF+NJecLWUA2Dk6EjJ4KBPHTSJsaBJBsYOxc3A45fe0GAw0vf02datexFxfj9v06fjffhtO8fHsyqvjked29fyo77YaOPg67H8VmorBxQ8m3AKjloJvzK+7dy+o7ahl+abllLSU8NSMp5gSNsXWJQkhRK+ToCSEEMKm2psN1mCUXU/pkQaMXWY0PQRGWIhOrsPYWUJ10VEOHa0BwNHFldD4BIZNn20d1z0oBr3d6X+cKaORpg8/pO655zFVVeEybhwBzz2L84gRZJc388+X9/XsqG+loGiHde/R0U/BYoSoydbhDEMXgp3jmd+7F1W0VbBs4zJqO2v596x/MyZ4jK1LEkKIs0KCkhBCiLNKWRTVxS3fdY1qS1pRSuHk2oqXXz3KVE5jZR4nDjQC4OzhSdjQRFLOu4CwoUn4RUSi05356G1lsdDy6WfUPvsMxuISnIcPJ+SR/4fruHEU17fz+FsHe3bUd3s9ZL5pfbyuoQCcvGDMcki5GvwHn/l9z4ITzSdYtmkZ7cZ2Vs9ZzXD/4bYuSQghzhoJSkIIIXqdocNISW6DdXx3Tj0dLQaw1OLqUYereyVtdYU0N7XRXA5uPr6EJyZ/d8CrT2hYj5zPo5SibcsWalc+hSEvD8chQwh7/nncpk+jvr2bRz/K7rlR30pByR5r9yj3IzB3Q/g4mPpHSFgE9iffM2VrxxqOccOmG1AoXpn7CvE+8bYuSQghzioJSkIIIXqcUoqGynaKvx3EUJHfgMVYhaZVYG9fhbmjBFN3F4YW8AoMJnbMuO+CkWdAYI8eXKqUon33bmqfepquw4dxiIoi9MkncJ83j3ajhac25/XcqO/ORsh82xqQ6o6Bo4e1c5RyDQQm9NiaeltWbRY3fnUjTnZOrJ6zmmjPaFuXJIQQZ50EJSGEED3C1G2m7Fgjxdn1nMisorm2CIupDL2+ClNXORazEQC3sAhiRk0nbGgSoUMTcffx67WaOg4coPZfK+lIT8cuJJjgfzyE56JFGNHx2r4eGvWtFJRlWMNRznowdUFoCpz/LCRdCA6uPb+wXpRelc4tm2/Bx8mH1XNWE+YeZuuShBDCJiQoCSGEOGMt9Z0UZ9VTeKic0twcTIZSlLkci6naOupa0/CNjCZs6HzCEpIIjU/ExcOz1+vqys2l5qmnaN++A72fH4F/+Qtel10KdvZ8nFXJExuP/fpR310tkPWOde9RdTY4uMHw30LqNRDcP/fy7CzbyZ3b7iTMLYwX57xIgEuArUsSQgibkaAkhBDilFnMFqoKm8nLKKFg/yFaagqwmMpR5hpAoen0BEbHEp44gbChiYQMHoqTaw8dyHoKDAUF1D79DK1ffonO0xP/FX/A58or0bm4WEd9f3Hk14/6rjho7R5lvQ/GdghKht/8C4ZdAo7uvbOws2DjiY3cs/Me4rziWDV7Fd5OPXBOlBBC9GMSlIQQQvyiztZuju0r4PieA1QVHsXUVYKy1AOg09sTOCiOqOHWR+lC4uKxdzrD/T2/QndZGXXPPkfzhg3onJzwu+kmfK65Gr27u3XU91v/HfX95KXDWTQiFP3pjPo2tEH2e9buUeUhsHOGYRdByrUQOgp6cE+VLXyU/xF/2/03hvsP57mZz+Hu0H8DnxBC9BQJSkIIIX7AYrFQfPgEOTu+ofxoDu2NRShLEwA6vSP+kXFEj5pHZHIyQTGDsbM/w8lwPcBYXUP9qhdofPc9NJ0On6VL8V12PXY+PhTXt/PEWwfZ8GtGfVdlW7tHh9+B7lYISID5j0HypeDs1XsLO4veOvoWD+97mHHB43hq+lO42LvYuiQhhOgTJCgJIYRAWRTH04+RseETaooOYDG3AKDTO+ETEkfU8PMYMn4UgdGx6PS/4kyhHmJqbKR+9Us0vvEGymzG6+KL8Pv977EPDKSuzcAzv2bUt7ETcj6wBqSydNA7QuJi696j8LH9vnv0fS9nvczKAyuZHj6dx6Y+hqO+bx56K4QQtiBBSQghzlFKKaqLmkj/eCtFB7di7CwCNNz94olIOo/EqaMJi49F0+lsXep3zG1tNKx5lYZXX8XS2YnnwoX43XIzDuHhtBlMPPfV8e9GfV/27ajvwFMd9V1zFPavgcy3oKsZfONg7sPWAQ0uPr27sLNMKcUzB59hddZqFgxawEOTHsJeZ7vOoBBC9EUSlIQQ4hzTUNFO9o5j5O7YRHvDQVBt2Dl4MHj8IiZetgif4L436czS2UnjG29Qv/olzM3NuM+Zg/9tt+IYG0u3ycLaPSfObNS3yQC5G6zdo5LdoLOHhPOt5x5FTRpQ3aP/sCgLj6Y/yhtH3uCiuIu4b9x96HW27xIKIURfI0FJCCHOAc21neRlVJK9bR+N5fuwGAsAhV9EIqMXLSR+/Pg+8Ujdj6nubhrffZe6F17AXFuH6+TJ+N9+O85JiVgsio8zK3j8TEZ91+Vbu0eH3oTOBvAeBLMegBFXgpt/7y/MRswWM/fvuZ8P8z/kqoSruCv1rh493FcIIQYSCUpCCDFAtTcZyN9fw9G9RVTl7cVsOIyyNGHv5EbyjEWkLDgPr6BgW5f5s5TJRPNHG6h77jmMFRW4pKbiv3IlLikpAGc26tvUDcc+tXaPinaApof48yD1Whg0FfrQI4a9wWg2cu/Oe9lYvJHfD/89vx/+ewlJQgjxCyQoCSHEANLZ1k3BgVry0qsoO3IEkyETi/E4KDOBMfGkzL+OuHGTbDqp7pcoi4XWL7+k9uln6C4qwikpiaAHH8R14gQ0TbOO+v7i6OmN+m48AfvT4OBr0F4LnhEw468wcgm4B521tdlSl6mLFdtXsKNsB3el3sXSxKW2LkkIIfo8CUpCCNHPdXeaKMysJS+9htLcKoxduWDOwmSowd7RmeQ580ieNR//iChbl/o/KaVo276d2pVPYTh6FMe4WEKfeRr3WbPQNM066nvj8e9Gff/1vKH8blwkTvb/43FBswmOf2HtHhVsse41GjzPuvcodiacQ3ty2o3t3LblNtKr0vnb+L9xyeBLbF2SEEL0CxKUhBCiHzJ1mzmRVU9eRjXFWfUYu6rRadl0d+RiMRnwj4pmxOxLiZ80FQcnZ1uX+4va9+6jduVKOg8dwj48nJDHHsVjwQI0vd466ntz3qmP+m4qhQNrrd2j1kpwD4Gp98CoJeAZdnYX1gc0G5q56aubyKnP4eHJD/Ob6N/YuiQhhOg3JCgJIUQ/YTZZKD3SQF56NUWZdXR3GdDrC9FUNt2tJ9DbOzB04mSGz15AUOzgPr//pDMzk5qVK+nYsxe7wECCHngArwsXo9nb02Yw8dLWUxz1bTFD3ibrcIa8jaAUxM6C856AuLmgPzc/6uo767lh0w0UNhfyxLQnmBkx09YlCSFEv3JufnoIIUQ/YbEoKo43kpdeTcHBWgwdJuwcWnBxPY6heT8dne14B4cy+qrrSZg6E2c3d1uXfFJdx45R+9TTtG3Zgt7Hh8A/3YvX5Zejc3Sk22Rh3Z7/jvqenxTEXXP/x6jvlko4+DocSIPmUnANgEl3wqil4B151tfVl1S1V7Fs4zKqO6p5duazTAiZYOuShBCi35GgJIQQfYz1INgW8tKryd9fQ0dLN3oHDb/gGjqbD1BTlEOHXk9s6jiSZ88nIml4n+8eARiKiqh75llaPv8cnZsb/nfcjs+SJehcXU991LfFAoVbrXuPjn0OygzR02DOQ9YJdvq+OaTibCptKWXZpmU0G5p5YdYLjAocZeuShBCiX5KgJIQQfYBSirqyNvIzqslLr6G1oQu9nY6QODv8Q/MpO7KL4kMNuPn6MeHSKxk2Yy5u3j62LvuUGCsqqH3+eZo/+BDNwQHfZcvwve5a9J6ewCmO+m6r+W/3qPEEuPjC+Jsh5WrwjbHJuvqigqYClm1chtFi5KW5L5Hom2jrkoQQot+SoCSEEDbUWNVOXkYN+RnVNFZ1oOk0wuK9GDS8g7oTX5O/Nx2lFFHDRzHr+puJHpnaJw+G/Tmm2lrqVr1I09tvA+B95RX4LV+OnZ8fwMlHfSsFJ3Zau0dHPgGLESInwYz7YOhCsHO01dL6pNz6XG7YdAP2OnvWzF1DrHesrUsSQoh+TYKSEEKcZS31neRn1JCXUU1daRtoEBrnRfx4b7paMzmy403yvq7E2d2D1IUXkjxzHl6B/ee8H3NTE/Uvv0LD66+jurvxunAxfr//PfYhIQA/GPXt9XOjvjsa4NAbsP9VqM8HJy8Ys8zaPfIfYrN19WUHaw5y01c34eHgweo5q4nwiLB1SUII0e9JUBJCiLOgvdlAwYEa8tJrqCpsBiBwkAcTL47FzbOR43s3sWPtLswmE6HxiUy47HfEjZnQZw+G/TnmtnYaX1tL/cuvYGlvx+O88/C/5WYcoqIAfjLq++bpMdwwNcY66lspKN5j7R7lfgRmA4SPhSl3Q8IisO/bI85taXfFbu7YegeBLoGsnrOaINf+E6qFEKIvk6AkhBC9pKvdSOHBWvIyqik/1ohS4BvqxrgLoolIcKf8yF4yv3yVupITODi7MGzmPIbPmodfHz4Y9udYurpofGsd9S++iLmxEbeZM/G/7TachgwGsI763ln486O+O5tg39vWgFR7FBw9YNRVkHoNBMr+mpPZUrKFu7bfxSDPQayavQo/Zz9blySEEAOGBCUhhOhB3V0mijLryM+opiS3AYtZ4envTMr8KOJSAzF1V5O56RO+fms7xq5OAqJimL38FuIn9v2DYX9MGY00vb+eun//G1N1Na4TJuB/x+04JycDWEd9p5f8dNS3nyuU74ctr0D2ejB1QsgoOP8ZSLoIHFxtvLL+4dPCT/nLrr+Q6JvI87Oex9PR09YlCSHEgCJBSQghfiWT0Uxxdj156TUUZ9VhMlpw83YkeUY4cakBeAU5kLf3a754/jkq845hZ+/AkAlTGD5nPkExff9g2B9TZjMtn3xC7bPPYSwtxXnkSEIefRTXsWMA69lPn2ZV/mDU94tXxTMqQA9Z6+C9V6E6C+xdYfhlkHINhIyw7aL6mXePv8v/7fk/UoNSeWbGM7jaS7gUQoieJkFJCCHOgNlsoeyo9SDYwkO1GLvMOLvbEz8hmLjRgQRHe9JUXUHmpnfI2b6ZrrZWvEPCmHbVMhKmzugXB8P+mFKK1k2bqH36abrzC3AcOpTwVS/gOmXKd2HvZ0d9u5Wj7f87ZL0HxnYIGgbnPQnDLgEnDxuvqv9Jy0nj8YzHmRw6mSenPYmTnZOtSxJCiAFJgpIQQpwiZVFU5DeRl15NwYFautqNODjbETMqgMGpgYQO8UIpCwX79/HeW59Rkp2JTq8ndvR4hs9eQHjisH7XPQJrQGrftYvalU/RlZODQ3Q0oSv/hfucOWg6HfDTUd9PXRjHQv0edNv/BhUHwc7Z+lhd6rUQOgr64c/B1pRSvJD5As9nPs+cyDk8MvkR7OWAXSGE6DUSlIQQ4hcopag50UpeRjX5GdW0N3dj56BjULIfcaMDiUjwRW+vo6Wulj3vv0nWlo20Nzbg7ufPxMuWkDR9dr85GPbndGRkULNyJZ0Z+7EPDSX44YfxPH8hmp3146OkvoPHNx77btT3k1P0nG/+BLvN74KhBfyHwvzHIPlScPay8Wr6L6UUT2Q8QVpuGhfEXsD94+9Hr+sf52kJIUR/JUFJCCF+Rn15G3np1eRlVNNS14XOTiMy0Ze41ECikv2wd9SjLBZOHD5I5qbPKdz/DQrFoBEpDF92M4NGpqLrx3/IdmbnULtyJe27dmHn70/g3+7D++KL0RwcAOuo72e35PPGvmJcdEaeTypgTudn2H2TDnpHSLzA2j0KHyvdo1/JaDbyj33/4P2897ki/gruGXMPOk1n67KEEGLAk6AkhBDfaqrpID+jmryMGhoq2tF0GmHx3qQuiCJ6hD+OLtbHnDpamjn4xSYOb/6C5uoqnD08GX3+hSTPmodnQP8+w6YzJ4f6F1bRumkTek9PAu6+G+8rfovO2TqR7/ujvkNNpbwaso/xrZvQ5TeBbyzM+QeMuAJc+m8XrS+paq9ixfYVHK49zLJhy7h15K398vFNIYTojyQoCSHOaa0NXeTvryEvvZraklYAgmM9mXL5YGJGBeDiYe2gKKUoO5pD5sbPyNv3NWaTibChSUy6bAmx/exg2B9TZjOtW7bQmLaWjowMdK6u+N1yCz5XL0Xv5gb8d9T3v7/KZXTnLj7w2MngrsPQYA9DF1q7R1GTpHvUg74u/5p7d96L0WLk8amPMzdqrq1LEkKIc4oEJSHEOaejpZuCAzXkZVRTmd8MgH+EOxMuiiU2JQB3n/9OETN0dJC7cwuHN31OXWkxDs4uJM+aT/KsefiFR9pqCT3C3NZO8/r3aXjtdYylpdiHhBBwzz14XXwRenfrVL7/jPp+64utTG39lC8dduHh0AzOUTDpfhjxO3Dzt+k6BhqzxcwLh19gVeYqYr1jeXLqk0R5Rtm6LCGEOOdIUBJCnBMMHUYKD9WSl1FD2dFGlEXhHezK2PMHEZsSiFegyw9eX11UwOFNn3Nk1zaMhi4CBsUwe/mtDJ04FXun/j2OubusnMbXX6fpvfewtLXhPGoUAStW4D5r5ndDGgB2H69k+4Y0Jjdv4E19DhZ7PdqQBdbu0aBpoJN9Mj2tvrOee3fey97KvSyKWcRfxv0FZ7v+dRCxEEIMFBKUhBADltFg5sThOvIyqinOqcdiUnj4OTFqTgRxowPxCXH9wX4PY7eB43t2kbnxMyrzj2Hn4MiQCZMZMXsBQbGDbbiSX08pRefBgzS8mkbrV1+BTofH3Ln4LL0K5+TkH7z22JEsjn32LONbPmeC1kyHWzCWcX9FN2oJuPfvPVh92cGag9y17S6au5t5cMKDLI5bbOuShBDinCZBSQgxoJiNFopz6snPqKbocB2mbguung4MmxpGXGogAVHuP9kM31BRzuGvPiNn22a62tvwCQlj+tJlJEyZidO3e3T6K2U00vLlRhrS0ujKykLn6YnvddfifeWV2Af9N/Qos5HjO9+je9/LJHZkEKtBmf9kumfejMuQ2dCPJ/j1dUop1uau5V/7/0WIWwivz3qdeJ94W5clhBDnPAlKQoh+z2K2UH6sieMZ1RQerKW704STqz1DxgYRNzqQ4FgvdLofhiOzyURBxl4yN31GSfZh68GwYyYwYvZ8whL658Gw32duaqLxnXdpfOMNTNXVOERFEfT3v+G5aBE6l/8+ZmhsKKHgy+fxy3uHIZZ6avBmX8R1JC28lciAKNst4BzR0t3C377+G5tLNjMrYhYPTnwQdwd3W5clhBACCUpCiH5KWRSVhc3kpVdTcKCGzlYj9k56okf4Ezc6kLB4b/T6n+6haamrJWvzF9aDYZsavzsYdtiMObh6edtgJT3LUFhEw9o0mj/8CNXVhcv4cQQ9cD9uU6ag/WdPkcVMR+4X1G57gbC6XQxWinS7keSM+htj5vyW8U6Otl3EOeJow1H+sO0PVLZVcnfq3SxJWNLvA7oQQgwkEpSEEP2GUoraklby0qvJ319DW6MBvb2OqGF+xI0OIDLJFzv7nz4ipiwWTmQe4NCmzyg6kIFCET0yleRZ8xk0MqVfHwwL1p9Lx5491Kel0b59B5qDAx4Lf4PPVUtxGvK9vfRZSHoAACAASURBVFWtVTTvfhm1fy1e3VW4KE8+cruUgKnLmJCa8pOum+gdSinW563n4X0P4+XkxZp5axgRMMLWZQkhhPiRXg1KmqbNA54C9MBLSqlHfvT9KcBKIBm4XCn13ve+txT467dfPqSUSuvNWoUQfVdDRTt5GdXkZVTTXNOJTq8RkeDDuAtiGDTcDwenn/9V1tHcRPa2rzj81ec011Tj4unF6EUXkTxzHp4BgWd5FT3PYjDQ8vHHNKStxZCXh97XF79bbsH7t5dj5+v77YssULSNpp2rcD+xCU/MfG1J4ljYjYyeeyUXRgbYdhHnmE5TJw/tfYgNBRsYHzyeR6Y8go+THM4rhBB9Ua8FJU3T9MBzwGygDEjXNG2DUir3ey8rAa4G7vrRtT7A34FUQAH7v722sbfqFUL0Lc21neTvryYvvZr68nY0DUKHeDNqTiTRI/1xcv35A16VUpQfzSFz0+cc3/s1FrOJsIQkJv12KXFjxqO3678Hw/6Hqa6OxjffonHdOswNDTgOGULwww/jcd4CdI7fPjbXVovl4Ot07X0Zl/ZSzMqdNM6jK/l3LJo5hYleMnL6bCtqLuIP2/5AQVMBNw2/ieXJy9H3826mEEIMZL3ZURoD5CulCgE0TVsHLAK+C0pKqRPffs/yo2vnApuUUg3ffn8TMA94qxfrFULYWHuTgfz91oNgq4taAAiK9mTyZXHEjArA1fN/750xdLSTu2MLmZs+p76sBEcXV4bPmc/wWQvwDQs/W0voVV1Hj9Lwahotn36KMplwmzYNn6VX4TJ2rHVvi1JQtAPTN6+gHf0YvTJx2DKUzx3/QOSky7hkbAzuTv0/KPZHX5z4gr9//Xcc9Y68MOsFJoROsHVJQgghTqI3g1IoUPq9r8uAsb/i2tAeqksI0Yd0tnVTcKCW/IxqyvOaQIFfuBvjF8cQmxKAh98vdz6qC/PJ3PQZR77ejslgIDA6jjk33kb8+Cn9/mBYsO6vatu2nYa0NDr27UNzdsbrkkvwuWoJDlFR1hd1NMChNzGlr8GuMZ8OXHnXNJsDfuczb/o07ksKwu5nBluI3mc0G3k843HePPomw/2H8/jUxwlylbOohBCiP+jNoPRzu4JVT16radpyYDlARETEqVcmhLApZVGUHmkga3s5Jdn1WCwKr0AXRp83iLjUALyDXH/xeqOhi2O7d5L51edU5R/HzsGR+IlTGT57PkExcWdpFb3L0t5O0wcf0vDaWozFJdgFBRFw1wq8LrkEvaentXtUvAf2r8GS8yE6s4FMy2DeNN9IZ9z5XD11KNdGecsUNRuqbKvkru13cbjuMEsSlnBnyp3Y66SjJ4QQ/UVvBqUy4PvPu4QBFadx7bQfXbvtxy9SSr0IvAiQmpp6qiFMCGEj3Z0mjuypJHt7OU3VHTh7ODB8VjhxowPxC3M76R/1DRVlZG76nJztX2Fob8cnNJzpVy8nYcoMnFz798Gw/2GsqKDhjTdoevc9LC0tOA1PJuD223GfPRvN3h46m2DfKlTGGrTaI3RoLrxrnML72mySUyZwy6RoBvn9ctAUvW9n2U7+tOtPmCwmnpz2JLMjZ9u6JCGEEKepN4NSOhCnadogoBy4HLjiFK/9EnhY07T/HGoyB/hTz5cohDgbGqvaydpaxtG9VRgNZgIHeTDrmgRiRwWgt//lR8LMJhP56daDYUtzDqPT2xE3ZjzD5ywgbGjSgOmYdB46RH1aGq0bN4FSuM+ZY91/NHKktXtUvh8y1qCy30czdZKnj+Ul4zJ2O03j8hlDSBsbiberg62Xcc4zW8w8n/k8Lx5+kcHeg3ly2pNEekTauiwhhBBnoNeCklLKpGnaLVhDjx54RSmVo2nag0CGUmqDpmmjgQ8Ab2ChpmkPKKUSlVINmqb9H9awBfDgfwY7CCH6B4tFUZxdT9bWUkqPNKKz04hLCWTY9DACozxOen1LXQ2Hv/qS7K3Wg2E9/AOYdPlVJE2fPSAOhgVQJhOtmzbR8GoanZmZ6Nzd8Vm6FJ8rr8A+NBQMrZD+MuxfA1VZGHXOfMwkXjZMwxSQzHXzB/F/I0JwtJPJaX1BfWc99+y4h31V+1gcu5g/j/0zTnb9f5+cEEKcqzSlBsYTa6mpqSojI8PWZQhxzutqN3JkdyXZ28toqevC1dOBpKmhJEwKxcXjlzseFouZE5kHyNz4GUUH9393MOzw2QuIGjGq3x8M+x/mlhaa3n2XhtffwFRZiX1EBD5LluC5eDF6N1eoOGQNR1nvQXcblc6xrGqfxnvd4xgZF8H1k6OZEuc3YLppA8GB6gPcvf1umrub+cvYv7A4brGtSxJCCPE/aJq2XymVerLX9eqBs0KIc0d9eRuHt5VxfF8Vpm4LwbGejLsghuiR/uhPMnGto7mJrC0bObz5S1pqrQfDjrngYpJnzsPDf+AciNpdXEzD2tdo+uADVEcHLmPGEHTfX3GbOhXN3AXZ70PGGqg4gFnvxF6XaTzeNoFsYyyLRoTx3uRBxAedvBsnzh6lFGk5aaw8sJJQt1Cen/U8Q3yG2LosIYQQPUCCkhDijFnMFooO15G1tYzy403o7XUMHm19vM4/3P2k15cfzeXgl5+Qt283FrOJ8IRhTLnyamJHjxsQB8OC9Q/pjn3f0JCWRtu2bWBnh+eCBfgsvQqnhASozoEv7oHDb4OhhVaPONa53cgzdSloFi9+NzWCVeOjCPCQR7j6mpbuFu7bdR9bSrcwO3I2D0x4AHeHk/9/L4QQon+QoCSEOG2dbd3k7qoge0c5bQ0G3HwcGb84hoSJITi5/XLAUUpRkpXJ3vXrKDuSjaOLKyPmLCB51vwBczAsgKW7m5ZPP6Nh7VoMR46g9/bG7/c34v3b32Ln5QY5H8LLd0DpPpTekQL/WTzZMIHPaqKI9HXlrkWDuDglDBcH+TXdF+XW57Ji2wqq2qu4Z/Q9XDn0SnkUUgghBhj5BBZCnLLaklYObysj75tqzCYLoUO8mHzpYKKS/dDpfvmPRKUURQcz2Lt+HZV5x3Dz9mH60mUMmzF3QBwM+x+m+noa162j8a11mOvqcIyLJfih/8PjN79B11oC+5+EQ29CVxMm7xi2hd/G/aXDKTvhzOgob144P5rZCYHoT/LzFLahlOK9vPd4ZN8jeDt5s2beGkYEjLB1WUIIIXqBBCUhxC8ymy0UHqwla2sZlQXN2DnoiJ8QzLBpofiGnPzsImWxkJ++l73r36bmRAEe/gHMuv4mEqfNxs5+YDxeB9B1/DgNa9fSsuFjVHc3rlMm47N0Ka5jUtCOfgJvXQTFu0BnT1PUPF43zmBlQSCWKpg/LJhnJ0czItzL1ssQv6DD2MFDex/i48KPmRAygUcmW8OSEEKIgUmCkhDiZ3W0dJOzs5ycHeW0N3fj4efExItjGTohGEeXkwcci8XM8T272PfBO9SVFuMVFMzcG29n6OTp6O0Gxq8eZbHQvnMnDWlptO/eg+bkhOeFi/FZsgRHL2D/q/CvJdBRj/KOoiD5Lh6tTmVjrgVXBz1XjY/gmolRhPu42Hop4iQKmwtZsW0FBU0F3DTiJpYPW45+gExhFEII8fMGxl8rQogeU13UwuFtpeTvr8FiUkQk+DDtd2FEJvqincLjYGaTiaNfb2ffB+/QWFmOb1gEC269iyHjJ6PTD4w/LC0dHTRv2EBD2lq6i4qwCwjA/8478bp4MXZVX8PXf4DCbaDpMQ+ez3aPhTx8JID8bzoJ9nTgT/OjuHxMBJ7OA6ejNpB9XvQ59+++H0e9Iy/MfoEJIRNsXZIQQoizQIKSEAKz0UL+gRoOby2j5kQL9k56EieHMmxqKN5Brqd0D5PRSO72zXzz0bs011TjHzmIhXfeS9yYCWi6Xx4P3l8Yq6tpfP0NGt95B0tzM06JiYQ89igeY4eiZb0Jr0yA9hrwDKd94r28YZjCqoMd1Ld3kxhiz8rLhnBecjD2JxmXLvqGbnM3j2c8zltH32KE/wgem/oYQa5Bti5LCCHEWSJBSYhzWHuTgewd5eTsLKez1YhXoAuTLxtM/LggHJxP7deDsdtA9paNfLPhfdrq6wiKiWP61cuJHjVmwEwB68zKpiEtjZYvvgCLBfeZM/FZ8juc3WvQ9q+B5zeDpkHcXCpiL+fZ0kje215Ft6mJmfEBXD85mnHRPgPm53EuqGirYMW2FWTXZ7M0YSm3p9yOvU46gEIIcS6RoCTEOUYpRVVBM4e3lVF4oBaLUkQl+TJsehjh8T6n9HgdQHdXJ4c3fU7GJx/Q3tRIaHwCc2+4jcjkkQMiECizmdavNtOQlkbngQPoXF3xufIKvC+YjUPVJti5FForwD0YNeVu9vst5PkDBrasr8HRroqLRoVx3aRBxAacfOCF6Ft2lO3gTzv/hEVZ+Ne0fzErcpatSxJCCGEDEpSEOEeYus3kZVRzeGsZdaVtOLrYMWxGGMOmhuLpf+rDBAwdHRz68hMyPv2QrtYWIpKGc95tdxOWMGxABCRzWxtN771H42uvYywvxz4sjMB778FzhA/63DfhnUdBKYidiWn+Y3zSmcTqr0vJqSjF19WBO2bFsWRcJL5ujrZeijhNJouJ5w89z+qs1cT7xPPE1CeI8IiwdVlCCCFsRIKSEANca0MX2dvLyN1VSVe7EZ8QV6ZeMYQhY4Owdzz14Qqdba0c+GwDB7/YgKG9nUEjUxl34WWEDB7ai9WfPd2lpTS89hrN76/H0t6Oc0oKAbctx92zCO3g4/BhKbgGwKQ7aUm4gjePa7z64QmqWnKI8Xfl/104jMUjQ3GyHxgDK841dZ113LPjHr6p+oaL4i7i3jH34mQ3cM73EkIIcfokKAkxACmlKD/eRNbWMooyawEYNNyfYdPDCB3sdVqdn47mJjI+/ZBDX36KsauT2NHjGHfh5QRGx/ZW+WeNUorOjAzq09Jo27wF9Ho85s3DZ1YCzs1bIPP3YDHBoKkw5yFKA6bxyt5y3vl3Pu3dZibE+PL/LhzG1MH+Jz1wV/RdGVUZ3L3jbtq623ho4kMsil1k65KEEEL0ARKUhBhAjAYzx/ZVkbWtjIaKdhxd7Rg5J4LEKaF4+Dqf1r3aGurJ+GQ9mZu+wGTsZsi4SYy98DL8I6J6p/izSHV30/LFFzS8mkZXbi56T098r/4d3gkK+8J3Ye+L4OIL426ClKs50O7DyzuL+Dz7a3SaxsLhIVw3aRBJoZ62Xor4FSzKwqs5r/L0gacJdw9n1exVDPYebOuyhBBC9BESlIQYAJprO8naXsbR3ZUYOkz4hbsxfUk8g0cHYudweo+CtdTW8M2G98neuhGL2czQSdMYu/hSfELCeqn6s8fU2EjT22/T+MabmGprcYiOJujWK/H0Oo6u4EnYb4TISTDjr5iH/IZNxxtZ/U4R+4uP4u5kx7Ip0Vw9IYpgz9MLnaLvaTY089ddf2Vb2TbmRs3l/vH34+YggzeEEEL8lwQlIfoppRSlRxrI2lrGiex6dJpG9Ch/kqeFERTjedqDFZqqKtn34bvk7tgMaCROm8mYRZfgFdj/z40xFBTQkLaW5o8+QhkMuI4bQ/DvxuFq2IxW+xi0esKYZZByNR2eMbybUcYrT+2huL6DcB9n/r4wgUtTw3F1lF+ZA0FOfQ4rtq2guqOae8fcyxXxVwyIQSRCCCF6lnzqC9HPdHeZOLrH+nhdU3UHzu72pM6PInFyKG7epz9prb68lH0fvMPRXdvR2elJnjWP0edfhIdfQC9Uf/YopWjf9TUNa9fSvnMnmoMDnjPH4TO4Dce6z6HSAOFjYcpdkHgB1Z0aabtP8Ma+LTR3GhkZ4cU98+KZkxCInRwQOyAopXj3+Ls88s0j+Dr7kjYvjWT/ZFuXJYQQoo+SoCREP9FU3cHhbWUc3VOJsctMQJQHs65JIHZUAHr70/9Dvra4iL0fvMPxvbuwc3Bg1ILzSV14IW7ePr1Q/dlj6eqiecMGGtaupTu/AL2vD34XjsfbJxu7tnXQ5AGjroLUayAwkSOVLbz0wXE2ZJZjsijmJgSxbMogUiL7989B/FCHsYMH9z7Ip4WfMjF0Io9MegQvJy9blyWEEKIPk6AkRB+mLIrinHqytpZRktuATq8RmxpA8rRwAgd5nNE9qwry2Lv+bQoy9uLg7MyYRReTct4FuHj078EExpoaGt96i6Z1b2NubMQxJpLgS4biYbcbncoGj5Ew4xlIughl78L247W89PE+duXX4eKg58qxkVwzMYpIX1dbL0X0sMKmQu7cdicnWk5w68hbuX7Y9eg06RIKIYT4ZRKUhOiDDB1GjuyuJGt7OS21nbh6OjBm4SASJ4fi4uFwRvcsP3aEvevXceLQfhxdXRl/8RWMnL8QZzf3Hq7+7OrKzaUhLY3mzz4Hkwm3kTH4zDDjYrcHzcEVki+DlGsgZAQGk5mPDlbw0q4Mjle3EeDuyB/nDeHKMZF4utjbeimiF3xa+CkP7HkAZztnVs1exbjgcbYuSQghRD8hQUmIPqS+oo2sbeUc21eFyWAmOMaTcYuiiR7pj/4M9skopSjNyWLv+nWU5hzG2d2DSb9dyog55+Ho4tILKzg7lNlM29atNLyaRkdGBpqTI95jgvHxz8HBaQcEDoPUJ2HYJeDkQWN7N69vziNtTzF1bQbig9x54pLhLBwegoOddBYGom5zN4+mP8rbx95mVMAoHpv6GAEu/XvfnRBCiLNLgpIQNmaxKE4cruPw1jLKjzWit9MRNyaQ5Glh+EecWbdHKcWJzAPsXf82FcdycfXyZuqS6xg+az72Tk49vIKzx9zWTvP69TS8/jrGkhLs/DwImOKOl99x9C5VkHSRde9RaApoGoW1bbz8eRbvHyijy2hh6mB/lk2OZmKsr0w5G8DK28pZsW0FOfU5XJN4DbeOuhV7nXQMhRBCnB4JSkLYSFebkdyvK8jeXk5rQxdu3o6MuyCahEkhOLud2eN1SikKMvaxd/3bVBfm4e7rz4xrb2TY9DnYOZzZPfuC7rJyGl9/nab33sPS1oZzpBcBUztxD6xACxwKqf+0PmLn7IVSim+KGli9s4jNR6ux1+lYPDKU6yYPYnBg/37MUJzc9tLt/HnXn1FK8dT0p5gRMcPWJQkhhOinJCgJcZbVlbVyeGsZx7+pxmy0EDrEi4mXxDIo2Q/dGY6htljM5O3bw77166gtOYFnQCCzl99C4tSZ6O3657+kK6XoPHiIhrQ0WjdtAhQeg53xCa/FOaAeEi+w7j2KGAeahsls4bPMCl7aWcjhsma8Xey5dXosS8ZH4e9++mPTRf9isph49uCzvJz9MkN9hvLEtCcIdw+3dVlCCCH6MQlKQpwFZrOFokN1HN5aSmV+M3YOOuLHBTFsWhi+oW5nfF+L2czR3TvYt/5tGirK8A4JY95NdzJ00jR0en0PruDsUUYjLV9upGHtWroOH0bnbI9vggHvQfXYR0RDyv0w4gpwsY7vbu0y8nZ6KWu+PkF5UyfRfq48dEESF40Kw9mhf/4MxOmp7ajljzv+SEZ1BhcPvph7x9yLo17CsRBCiF9HgpIQvaijpZvcXRVk7yinvcmAh58TEy+OJX58ME6uZ97pMZuM5O7YyjcfvktTdSV+4ZGcd/sfGTxuIjpd/wwH5uZmGt95h8bX38BUXY2Dtz2BKU14RRvRJS+E1GshahJ8u7eovKmTNbuKWJdeSpvBxJhBPtx/fiIz4wPQ6WT/0bkivSqdu7ff/f/bu+/wOMs73//ve0Z11HsfFXfJNuBesDEGDKYmhATISU5IQrLZhJQDIbvZ1E1y0ve3Zzebs2cTlmxINiGBUGwCsYFQ3bCxwUWSm2xLsnqxeply//6YsSzLGMtYo5Gtz+u6dGn06H5mvuPbI81H9/N8H3q9vXz/yu9zy5Rbwl2SiIhcIhSUREKg8Wgne16q5eCbjfi9loLSVFZ9eAbu2WkX9CbeOzjI3pdf4I2nH6OrpZnM4inc+uWvMXX+Yozj4uzeNnDkCO2/+Q0nnngC2z+AK8dP9op24suyMQu+Apd/BOIzhsbvrj3BL187wrN76gG4aU4O964oZm6+Lh46mfitn4f3PszPdv0Md4Kbh9Y8xNSUqeEuS0RELiEKSiJjxOf1c3hnE7tfqqXxSCeR0U7Krsxjzqo8UrIv7CKmnoF+dr+wgR3r/0R3exs502dy3b2fo+jy+Rdl9zZ/Xx9dL/6VjqeepOf1TRinIdHdQ+qMPmKWrgmce1RyNQTDn99vebGyiV++VsUbR9qIj47gE8uLuGd5MXnJsWF+NjLeOgY6+IfX/4FXa19lbdFavrXsW8RF6kLBIiIythSURC5QT8cAe189zr7X6ujrHCQ5y8WKO6cxc0kOUbEX9hIb7OvlrY3PsuOZJ+nr7KCgdA5r73uAgrK5F11Asj4fvdu20fHUk3RtfB5//wARcZb0sm5S5iURceV9cMVHIDFnaJ++QR9/2lnLw68foaqlh7zkWL5+0yzuXFhAQszF2aRCLszelr088PIDNPU18Q+L/4G7Ztx10b0WRETk4qCgJPIeWGtpqOpkz0s1HN7ZjN9aCmenMXdVPgWzUjEXeI5Mf083u55bz85nn6a/p5uiy+ax+PY7yZ9ZNkbPYHxYaxmorKTjicfofGY93vZuHJGWhIJekqY7cF15HWbuHTD1Whh2blVz1wCPbDnKb7ceo73Xw9z8JP717iu4cXY2Ee+xM6Bc3Ky1/GH/H/jx9h+THpvOIzc8wpyMOeEuS0RELmEKSiLnwevxcXB7E3terqW5uouo2AjmXJ3P7KvySM50XfD993Z2sPPZp9n1l2cY7OulZP4iltx+JzlTZ4xB9ePHU19Px+O/o/PpJxmobQVjic/tJ2leDPHX3YBjzm2BxgzO01eFDjR28dBrVTy1qw6P38+1s7K498piFhWnatVgEuv19PLtzd/muaPPsSJvBd+/8vskx+icNBERCS0FJZFR6GrrZ++rxyl/vY7+bg8pOXFc9eEZTF+URVTMhb+Mek60s339E7z9/LN4BweZvmgZi2+/k8yikjGofnz4Ojvp+tMjdDz5BL0HAo0WYtMGyb4qgYS1NxKx4AOQe8XQeUcnWWvZdKiVX75WxSsHmomJdPChhfl8YnkxJRnvvXW6XBoOtR/i/lfu51jnMb4474t8YvYncBitKoqISOgpKImchbWWuoMn2PNSLVVvt4C1FM1NZ+7V+eTNSBmTFY6u1ha2r/sTe17cgM/rZebylSx+/4dIy3ePwTMIPdvfT/e6X9Px5ON0767F+iAqwUv6shSSbr6JqBV3Q8b0d9y3tXuA58sb+a/NR6ls6CI9PpoHrpvO/1hSSGpc1Dg/E5mI1h9ez3e3fhdXhItfXvdLFuUsCndJIiIyiSgoiYzgGfRxYFsDe14+TuvxbqLjIrj82gJmX5VHYtrYdFjraGrgjaceZ+/LLwCW0pWrWXTbHaTk5I3J/YeS9QzQ95dH6HziMTp3VuMbMDij/SRfkUrSzTcSs/aTmKTcd9y3pq2XDfsa2FjeyI6jbfgtTM+K58cfmMutl+cSE3lxXgNKxtaAb4AfvfEjHjvwGPOz5vOTlT8hw5Vx7h1FRETGkIKSSFBnSx97XjlOxaY6Bnq9pOXHc/VHZzJ9YRYRUWPzBr6t7jhvPPUY5a/9FYfDwZzV17Hw1jtIyswak/sPmYEuBl/9PR1PPEbHjmo8XQ6M05IwK43Em9cSf/tnMInpZ+xmraWivouN5Q1s2NdIRX0nADOzE7jv6qmsKcumLDdR5x/JkJquGh54+QEq2ir4xOxP8PkrPk+EQ7+qRERk/Om3j0xq1lpqK9vZ/VItR/e0YIyh5PIM5q7OJ2dK0pi9gW+pPsq2px5j/+bXcEZEcMX1N7Pg1ttJSD0zXEwY3U14tz9O59OP07G9mv7WSMDimpJG+iduIOGuz+JMObN+n9/y5rH24MpRAzVtfRgDCwpT+NqNs7iuNIuidF3zRs70UvVLfO31r4GBn63+GasKVoW7JBERmcQUlGRSGuz3sn9rA3terqW9oZfYhEgWrC2ibEUe8SnRY/Y4jUcOs+2JP3Dwjc1ERsew4Jb3M/+m9xGXnDJmjzGm2qrwv/0U3c8+Qcebx+mujwZriM5NJ/PeNSR++G+IzD3z8MB+j49Nh1rYsK+BFyuaaO0ZJMrpYPnUND63airXzMoiI2Hs/l3l0uL1e/nXXf/Kr/b+itK0Uv7pqn8iPyE/3GWJiMgkp6Akk8qJxl72vFJL5eZ6Bvt9ZBYmcO09s5g6Pwtn5Nh10qo/uJ+tTzxK1c7tRLviWPKBu5i39lZiExLH7DHGhLVQ/za2/Bl6X3yKjrea6aqJwe91EJGUSuqd15J018eJmTnzjF07+jy8VNnExvIGXt7fTO+gj4ToCK6emcn1ZdlcNSOD+Gj9iJF319TbxIOvPMjOpp3cOeNOHlz4INFOhWoREQk/vYuRS57P5+fYnlb2vVZH9b5WHE7D1PmZzLk6n+zipDF9rNryvWx54lGq97xFTHwCyz/0ES6/4WZi4iZQm2ufF6o3Q+Wf6d/0DJ17O+ioduHtdeKISSLh+lUkffDDuBYuxDhPPzeroaOf58sDzRi2HG7F67dkJkTz/ivyWFOWzdKSNKIi1LpZRmdb/Ta+8upX6PP28cMVP+SmkpvCXZKIiMgQBSW5ZLU39FCxqZ7KbQ30dQ7iSopi0S3FlF6ZS1zS2P3F2lrLsT1vsfVPj3K8ch+upGRW/o+Pc9maG4mKGZsueRdssBcO/xUq/4xn13N0Hhik42gcAyciwJFI/LKlJN3+AeKvvhpH7Ok1H2rqHmrG8HbNCQBK0uO4d0UJa8qyuDw/GYdDzRhk9PzWz0N7HuLnb/2cosQiHr7+YaYkTwl3WSIiIqdRUJJLymC/l8M7m6jYVE/94Q4cDkPhnDRKl+fiLkvF4Ry71Q5rLVU7t7PtiT9Qf2g/8alpXH3PP8uPhwAAIABJREFUp5mzeg2R0TFj9jjvWW8bHNgAlc/gq3iRrqPQUZ1Ib0Ms2Fhi5swm6773kXjjWiJSU4d28/stb9eeYGN5Ixv2NVDV3APAZflJPHj9DK4vy2JKRrw61cl7cqL/BF99/au8fvx1biy+kW8t/RauSFe4yxIRETmDgpJc9Ky1NB7ppGJTHQd3NOEZ8JGc5WLp7VOYuSQHV+LYXrzU+v0c2r6VrU/8gaajh0nMyOTaez9H2apriYiMHNPHOm8namD/s1D5DLZqE931EXQeT6OrOg3r8RNZkE/6395K4i03E11cPLTboNfPtiOtbNjXwPPljTR2DhDhMCwpSeOeZUVcV5pFTtIEWR2Ti9bu5t18+ZUv09LXwjeWfIMPTv+gAreIiExYIQ1KxpgbgH8BnMBD1tofjvh+NPAIMB9oBe601h41xhQBFcD+4NCt1trPhLJWufj0dg6yf1sDFZvraa/vISLaybT5mcxankt2ydhfm8fv97F/y+tse+IPtNZWk5ydw/Wf+SKzVlyNMyJMf3OwFporoeKZQDiqe4v+tkg6GvPorHLj6x7AmZRE0h1rSbr1VmIvv3zo36VnwMsrB5rZsK+Bv1Y20dXvJTbSyaoZGawpy2L1jCySXGEOfnJJsNby+8rf85MdPyHLlcVv1v6GsvSycJclIiLyrkL27s4Y4wR+DlwH1ALbjTHrrLXlw4Z9Emi31k41xtwF/Ai4M/i9w9bay0NVn1yc/H5L9b5WKjbXc/TtFvx+S3ZJIld/dCZT52cSFTP2/6V9Xi8Vr7/MG0/9kfb6OtLy3dz4+S8zY+kKHM6xuRDtefH7oXY7VK6Hyj9DWxWD3U462qfReWgWg40dmCiIv3oVSbfdSvyVV2KiAqtqLd0DvFjRyMZ9jbx2qIVBr58UVyQ3lGVzfVk2V05LJyYyDM9JLlk9nh6+tflbbDi6gavyr+J/X/m/SYoe2yYqIiIioRDKP4MvAg5Za6sAjDGPArcBw4PSbcC3g7cfB/7N6DgMeQcdzX1UbK6jcksDPScGiE2IZO7qfGYtyyU1NzQXL/V6POx7+QXeePpxOpsbySgq4Zb7v8q0hUsxjnHu7OYdgCOvQuUzUPks9DTh9UTR1TubjkML6DtYB3TiWrSItM/fQsKaNTgTA63Ia9p62bCvlo37GtlxrA2/hbzkWD6yuJA1ZVksKEwhYgzP3RI56WD7Qe5/+X6qu6r50rwv8fHZH8dh9H9NREQuDqEMSnlAzbCva4HFZxtjrfUaYzqAtOD3io0xu4BO4OvW2tdCWKtMQN5BH4d3NVOxqY7jB05gDLhnp7HyzukUzknDGaI21J7BAfa8uJHt6/9Ed2sL2VOns/rjf0PJvIXjez5Ffycc3BhYNTr4PAx24XfG0+2dR0fVbLp3HQJvA1FTp5Bx//0k3XwTkbm5WGspr+9k47YDbNjXQGVDFwAzsxP4/OpprCnLojRn7A9NFBlu3eF1fHfLd4mPiuehNQ+xMHthuEsSERE5L6EMSu/0LsyOckw94LbWthpj5gNPGWPKrLWdp+1szKeBTwO43e4xKFnCzVpLc3UXFZvqObC9kcE+L4kZsSy+rYSZS3KITwndhSgH+/t4+/nn2LH+CXo7TpA3s5Tr/+YLFM69YvxCRVfjUDMGql4BvwfryqA3dhWdDVF0btmDv+sQzox0Uj/yEZJuu5XomTPxW9h+tI2N68vZWN5AbXsfxsDCwlS+ftMs1pRm405TZzEJvQHfAD/Y9gP+dPBPLMxeyI9X/pj02PRwlyUiInLeQhmUaoGCYV/nA3VnGVNrjIkAkoA2a60FBgCstW8aYw4D04Edw3e21v4C+AXAggULRoYwuYj093g48EYD5Zvqaa3txhnpYMq8DEqX5ZI7LRkTwuv0DPT2sOsvz/Dms0/T39WJe/ZlLPnS31FQOidkj3ma1sOBYFTxTODcIyykFDNQ+GE6jkTR8dxOvPVvYlwuEq+7lsRbbyVuyRIG/PD6wRY2PL6bFyubaOsZJCrCwYqp6Xx+9VSumZVFenzogqXISDWdNdz/yv1UtlXyqTmf4rOXf5YIh5qriojIxSmUv8G2A9OMMcXAceAu4MMjxqwDPgZsAe4A/mqttcaYDAKByWeMKQGmAVUhrFXCwPottZXtlG+uo+qtZvxeS2ZhAlfdPZ1pC7OIDnHHtb7uLnY++zS7nlvPQG8PxVcsYMntd5I7fVZIHxdroW5X4JC6yj9Dc0Vge85leOb9LzqPRtPx0hsMVDwPTidxy5eRef/9JFyzmi4ieX5/Ixt+9xavHGimz+MjISaC1TMzub4sm5XTM4iP1htTGX8vVr/IN17/BsYYfn7Nz1mZvzLcJYmIiFyQkL2jCp5zdB+wgUB78IettfuMMd8Bdlhr1wH/CfzGGHMIaCMQpgBWAt8xxngBH/AZa21bqGqV8dXV1k/F5noqN9fT1dZPdFwEs1fkMWt5Dun5CSF//N6OE+z481O8teHPePr7mLpwKUtuv5Oskqmhe1CfB45tDjZj+DN0HgfjhMJl+Mu+S1d9Ah0vbKJnyx/B7ydm9myy/uGrJN54I82RcTxd3sjG3+1ha1UrXr8lMyGaD8zP4/qybBYXpxEVovO1RM7F4/fwL2/+C78u/zWz02bz01U/JS8+L9xliYiIXDATOMrt4rdgwQK7Y8eOcw+UsPB5/FS93UzF5npqKgKZt2BmCrOW51J8WToR49CSurutle3rn2D3C3/B6xlkxtIVLH7/h8hwF4XmAQd74PBfA4fUHfgL9J+AiFiYeg122lp62lLp2PgyXS+8gO3rIzI3l8RbbyHxlluoTchkw75GNu5r4O3aDgBKMuK4viybNaVZXJafjCOEhyOKjEZjTyMPvvogu5p2cdeMu3hw4YNEOcf2As8iIiJjzRjzprV2wbnG6RgdCamW2m4qNtWx/40GBnq8xKdGs/DGImYuyyExLTYkj2mtpaulmZbaY7RUH6O1tpqWmsBta/2UrriaRe/7IKm5+WP/4L1tsP+5wKrR4b+Ctw9ikmHGWuyMm+gfzKXzuY10/Nt/4GtpwZGYSNItt5Bwyy0cyCjm8YpmNj5ZQ1VLJQCXFSTzlRtmsKY0m6mZ8WNfr8h7tKVuC3//2t/T5+3jxyt/zNriteEuSUREZEwpKMmYG+jzcnB7IxWb6mg61oUjwlByeaAxQ97MlDFbCbHW0tPeRkttNa01x2ipCXxuPV7NYF/f0Lj4lFTSCgqZf9NtzL12LclZ2WPy+ENOVJ863+jYJrB+SMyHef8TZt3MoLOQzmefo+OX/4/BqipMZCTxq1bhuulm9hSU8ciBNp7f2EhT11YiHIalU9L4+PIirivNJjspZmxrFblAfuvnF7t/wf996/9SklTCr67/FSXJJeEuS0REZMzp0DsZE9Za6g6eoGJTPYd3NuH1+EnLi2fW8hxmLMomJv7CGjP0dnYEwtCIUNTf0z00JjYxifSCQtLy3YHPBW7S8wuJiR/jlRhroak8EIwq1kPD7sD2zFKYeRPMvAmfq5jODRvpWL+Ovh1vBupbMJ+YtTexq3gezx3r5aXKJroGvLiinKyakcGa0myunplJUmxom1iIvFft/e189bWvsqluEzeX3Mw3lnwDV6TazouIyMVFh97JuOg5MUDl1noqNtXT0dxHVIyTGUtzKF2eQ4Y74byvP9Tf001rTfXQ4XKttYFQ1NtxYmhMdFwc6QWFTF96ZTAYFZJe4MaVlDzWT+8Uvw9q3jjVjKH9CGCgYBFc912YeRP+hAK6X3mFzh/8iu6XX8Z6PEQVF+P628/x5tRFPNNseL2ihcE9h0iLi+LGOTmsKcti+dR0YsbhHC2RC/F289s88PIDtPW38c2l3+SOaXfoosUiInJJU1CS8+bz+Tm2u5XyzXVU723FWsibnszCm4oomZdJZNS53/R7+vtPnTt0cpWotpru1pahMZExsaTlF1Ayb+HQKlF6QSFxKanj8wbN0w9HXgmEo/3PQU8zOKOg+CpY/kWYcSM2LoO+Xbvo+Nff0PmXv+Dv6MCZlobzfXewffpinuyOZ0f1CWx9M/kpsXx0SSHXl2UzvzAFp5oxyEXAWst/V/w3/7Tjn8iKy+K3N/6W0rTScJclIiIScgpKMmrtDT2Ub6pn/9Z6+ro8xCVFMe/6QmYuyyE5850Pv/EODtJWVxs8XO5UKOpoahwaExEZRWpeAe7SOaQFw1BavpvE9AyMY5zbXvd3wMHnA4fUHXoBBrshKgGmrwkcVjf1OohJZKCqio7//D2d65/Bc/w4JjYW37KVvDl9CY/6sihv6oV9Xkpz/HzxmmmsKc1mVs75r7CJhFP3YDff3PxNnj/2PKsKVvG95d8jKTop3GWJiIiMCwUleVeD/V4OvdlExaZ6Gqo6cDgMRXPTmbU8B3dpKg5nIMj4vF7a64+fOmSuJvD5REM91voBcDgjSM3NI3vKdGavui5wDlFBIUlZ2TgcYTz0rLMe9j8bOKTuyKvg90BcJsy5A2beAsUrICIab0sLnX98io516+nfuxccDjyXL2Dnitt5xFlEVY/F0QALimL4xs1FrCnNoiBV52/IxWl/234eeOUBartquX/+/dxTdo+CvoiITCoKSnIGay0NVZ1UbKrj4JtNeAd8pGS7WHb7VKYtysDT10ZLzQHeeOrkeUTVtNUdx+/zAmCMg+ScXNILCpmxbCXpwUCUnJ2LM2KC/JdrOQSV6wPhqHZ7YFtqCSz5W5h5M+QvBIcDf18fXc89T8f6dfRs2gw+H4PF09h1w0f5dcw0juAiyutgZXE6nynL5pqZmaTFR4f3uYlcoKcOPcX3tn6PxKhEHlrzEAuyz3m+q4iIyCVngrxrlYmgt3OQ/VsbqNhcR1t9D86IHrKLPSSm9THQ3cDeF2t49ZEavJ7BoX2SMrNIKyikZN7CYKe5QlJz84mImmAXnfR5oH73qWYMLfsD23Muh9VfD4SjjJlgDNbno2fLFjrXrafr+efx9/biScvgrcVr+W18KQdcmSTGRHDNrCy+UprFyukZxEXrpSQXp+beZspby0/7aOprYlH2In608kekx6aHu0QREZGw0Lu7Sc7n9XFgWxV7X9lN/cEq/N4WnBEn8HlaGPAMUBXsrRCflk56QSEFs+cGmirku0nNLyAqJjQXjX3PrIXuJmjcC437Tn00VwYOqTNOKFoOC++FmTdCUn5wN8tAZSUdT6+j889/xtvcjDc2jt1TF/DH5NnsTi0iMymWNaXZfLMsm8UlqUQ6x/n8KZELdDIU7WvdNxSKmvuaATAYipOKWZSziPlZ83n/1PfjDOchsSIiImGmoDSJ9HZ20FIdaKpQf/Awx/cfprutDusfGBoTm5BERmEhaQXzSM8PrBCl5RcQEzfG1yIaC57+QAAaCkTBcNR7qnMeCbmQVQpTV0P2XJiyGlypp+6ivp6O9c/QsW4dg4cO4XdGUOGezVNFN7Atu5TCnBTWlGbxnbJs5uQljdnFckVCram36YyVopGhaHHOYkrTSilNK2Vm6kziIuPCXLWIiMjEoaB0Cerv7qal9lRDhZMNFvo6O04NMtE4nOkkZV1G4ezpTFtSSoa7EFfiBOxoZS101AwLQ+WB260HIdgogohYyJwFM9ZC1mzIKgt8DAtFJ/m6uujasIET69bTu307xloOZ5bw3GW382reZUydmsea0mz+sSyLKRkTMCCKjDAyFO1r3UdLX+APBidD0ZKcJaeFIl0oVkRE5N0pKF3EBvv7zugy11pbTXdb69CYyJhYkjLzcCXPwE8cfn8qiZl5zF45jVlLc4lLnmCNBwa6oKlixKFz5TAwLOQlFwbCUOltwUA0G1KL4SyHCVmvF29jI/0VFbSvf4buv76E8QzSkJDBxhlreM09j+LLZnB9WTbfLM0iKzFmnJ6syPlr6m1iX8s+yttOBaOTochhHBQnFrM0Z6lCkYiIyAVSULoIeAYHaDteO3RR1sA1iarpbB52LaKoaFLz8nHPvoz0gkIS0vPoaI6l6u1+2up6iIh0MHNZJrOW55A7LTn8bX79Pmg/OiIQ7Q1sOykqIRCE5txxKhBlzoKYxNPvqrcXz5GjeOrq8Byvw1Nfj6eujr6aWgaP10FLMya48tQZHcdLBYvYUryA/KULWDM7m7+fkUlSbOT4PXeRUbDWnlopepdQtCx32VAompEyQ6FIRERkjBhrbbhrGBMLFiywO3bsCHcZF8Tn9dBed/y0MNRae4wTDQ2nX4soL3/ooqyBTnNukjKzMDioqWyjYlM9VW834/daMgsTmLU8l2kLs4iODVMu7m2DpvLTzyNqqgBPb+D7xgFpU08dLnfy0LmkAizgO3EiEIDqjuOpq8MbDEKDx+sYOH4cOjpOezifcdAam0RjbAqNrhSaYlNodiXTn5lLzpWLuW5uHsumpBMTqRPVZWIYHoqGN1po7Q+sDjuMg5KkkqFApFAkIiLy3hlj3rTWnvPaFwpKYeD3+zjR0BAMQ6dWidrrj+P3+QAwDgcp2blDF2UNBKNCkrNzzrgWUWdrH5Wb66nYUk932wDRcRHMWJzNrGW5pOeP4zk2Pg+0HDwViE6Go87jp8bEpkL27KEwZNNn4rWpeJraAitCdXV46upPu237+057mMHIKFrjUqmLTqYhNpkmVwrNsSm0xqcQkZNLYn4uBenxFKa5KEh1BT6nuNTCWyYEay2NvY1nNFo4WygqSytjesp0hSIREZExMtqgpHeOIWT9fjpbmgJhqKZ66NC5tuM1+DyewCBjSM7MJq3AzdSFS4ZWiVJy84mIPPvhYF6PjyNvtVC+qY7a/e0AFMxKZdntUym5LANnZAhbV5+tBXfLfvAFr7HkiISMGfhzl+JxF+DxpeHpj8HT1oNnXx2e52vw1G3D29gEwXB4Up8rkdb4FOqik6nNyw8GoWQaXSkMpGWSmp2OOy0OdzAELUt1UZgWR3ZiDE51pZMJZGQoOrla1NbfBpwKRcvzlisUiYiITDAKSiHwym8fprZ8D621NXgG+oe2J6RlkF7gpnDO5UOrRKl5+URGj755QEttF+Wb6jnwRgMDPV4SUmNYeFMxM5dmk5gWgmsavUsLbmvBN2jwkI3HWYDXfw2eAReeLj+eli489fX42jefdnfW4aA3MZW2+DTqXW6OTiujISaZxtgUmlwptLqSSc9Iwp3qwp0aCEOXn1wVSnXpXCKZsE6GouGHzr1TKLoy78qhUDQjdQaxERPsWmQiIiICKCiFRHdbK1GuOOasXkNaQSHpBW7S8t1Eu97bNUoGej0c3N5I+aZ6mqu7cEQYSi7PoHRZLvkzUzBjsYpiLXTUnhaGbP1evLVH8PQYPD3OwIqQPxVPfw6e7mw8bT3Y/pPXYKoFavFHRdObkkF7QhoNeXM5VpRAlSOBppNBKCaR2Jgo3GlxFKa6cKe5WJ7qGlodyk2O1YVcZcI7VyhyGiclySWsyFtx6pwihSIREZGLis5RmqCs33L84AkqNtdxeGczPo+ftPx4SpfnMH1RNjFxF7CyEmzB7a95C8/+nXiqKvHUVuPpGMTb6wyEor5oPD3AiP8e/sQk+lIyOJGQRmNsMsciEzlEPNVRSTTFptAZ5QJjyEmKCZwfFAxB7rSTYSiOFFdk+LvuiYzSUChq2RcIRm3lVLRWnBGKSlOD5xSlBw6fUygSERGZmHSO0kWqu32Ayi31VGyuo7Oln6jYCGYtzWHW8hwy3AmjDhjWWvzt7Xj278BTuQNPVUUgDDU24zkxgKfHiW9geNe3aDAxkJpMf3oOJ5IyaYpNoToykYPEsd/G0RCbzEBE4LpL0RGOoVWgwlQXK4fCUBz5KbHqKCcXJWstDT0Np84neodQNCV5CivzV57WfS4mQtfeEhERudQoKE0APq+fo3taqNhUT/W+VqyFvOnJLLqlhJIrMoiMOjN0WJ8Pb3PzqWsHHTuE50glnppjeBqb8bb14vecvhxkIsCZFIM/LYueaVnUJ7k5FJvHYUcCe72xHDVx+IddtDU9Php3aiyFaXHcdnJ1KBiMMhKitSokF7UzQlHw8Ln2gUBzFIUiERGRyU1BKYza6nuo2FTH/m0N9HV5iEuOZt4NhcxalkNCohNPXR0D27fSffLaQSevJVRTjae5BXz+0+7PGeUjMs5HZLwTZ2ky3amZ1CcWsDe2mFdNCXv6Y/EOy06RTkNBSqBJwvJUFx9WO225RFlrqe+pP6Ml9/BQNDV5KqsKVg2Foukp0xWKREREJjG9Ex5ng/1eDm5vpOK1WhqrezDGkpfST2FWLWntFXh/W0fjj+uoa209fUcDEXEOImMHiHV5SJzuIyLe0puSQUNSPuWxxbzhdbOtN4dmkgM7AMmuyGAHORdLh3WPUzttuVSNDEX7WvdR0VoxFIoiTARTkqcoFImIiMi7UlAKAev3Bw6LOx64aOrg8Toaq7upakmgzubjc0Th6qlnav0Wshu3EeXpxkRFMpieSGSCk6h8D5FuL9FRXUTG+Yhw+ehOSOaQo5C3PXns9RZQad1U2Vx8JoK8hNihdtqfGNZBTu205VJnraWup+6MlaITAyeAQCiamjKVq91XDzVbmJ46nWhndJgrFxERkYlOQSkEjnzgDgYqKhiMTKA+ezH1OUvpdU3BaQfJM9WUxB4hJfk45LcQ5R8k0TQRGe3FGOgnikp/PpX+Uiqtm/22gOqIIhKTc4bOEVqY6uIDaqctk8xoQ9Fq92qFIhEREblgCkpjzFpL7/Uf59AsQ117LNYaklxNXBb/NHMc60iibWhstT+DvdZNhb2Cxsgp9KTMJDpjCgVpCbjTXNwWXB1KjYtS4wSZVE6Gon0tp5osVLRVnBGKrnFfM3T43LSUaQpFIiIiMmYUlMaYMYad5e14vfFc7trArNgXiXC2cQA3r0QupiNxOoPppcTklpGTlUlJahwr1U5bJjFrLce7j5++UtRWTsdABxAIRdNSpikUiYiIyLhSUAqBork1OOiCnIVUuz9Fjnsa8xJjmK9VIZnEPD4PNd01VHdWc6zz2NDH/vb9p0KRI4JpydO41n1t4OKtaWVMS5lGlDMqzNWLiIjIZKOgFAIr7/1auEsQCQuf30d9Tz3VndUc7TxKdVfg87GOY9T11OG3p1raJ0cn4050KxSJiIjIhKSgJCLnxVpLc1/zaatCJz9qumrw+D1DY10RLgoTC5mTPoebSm6iMLFw6CMpOimMz0JERETk3Skoicg7OtF/IrAaNCwIVXcFDpvr8/YNjYtyROFOdFOcVMxVBVdRlFiEO8FNUVIRaTFpakQiIiIiFyUFJZFJrMfTc8aq0MnD5joHO4fGOY2T/IR83AluFmQtOG1lKDsuG4dRi3oRERG5tCgoiVzi+r391HTVnH7eUEfgc0tfy2ljc+JycCe6WVu89rQwlBufS6RDFy8WERGRyUNBSeQS4PF7qOuue8fzhhp6GrDYobFpMWkUJhayIm/FaWGoIKGAmIiYMD4LERERkYlDQUnkIuG3fhp7GgOrQsNWh451HuN413G81js0NiEqgaLEIuZnzced6A6cN5TopjChkPio+DA+CxEREZGLg4KSyARiraW1v/WsHeUGfANDY2MjYnEnuJmRMoM1hWtOWx1Kjk5WEwURERGRC6CgJBIGHQMdp68KdRwbut3j6RkaF+GIwJ3gxp3o5sq8K0+tDiW4yXRlKgyJiIiIhIiCkkiI9Hp6hw6NG9lVrn2gfWicwzjIjculMKmQKzKvOG1lKCcuB6fDGcZnISIiIjI5KSiJXIBB3yC1XbVnnjfUcYymvqbTxma6MilKLOKawmuGVoUKkwrJj88nyhkVpmcgIiIiIu9EQUnkHHx+H3U9de94raH6nnr81j80NjUmFXeCm6W5S8/oKOeKdIXxWYiIiIjI+VBQEiHQRKGxt/HUqlBn8JC5rkATBa//VEe5+Mh43Ilu5mbM5dYpt57WVS4xKjGMz0JERERExkpIg5Ix5gbgXwAn8JC19ocjvh8NPALMB1qBO621R4Pf+yrwScAHfMFauyGUtcqlz1pL+0D7UBga2VGuz9s3NDbaGY070c2UpCmsLlg9tDLkTnSTFpOmJgoiIiIil7iQBSVjjBP4OXAdUAtsN8ass9aWDxv2SaDdWjvVGHMX8CPgTmNMKXAXUAbkAi8YY6Zba32hqlfeO7/14/V78fg9Q589vmG3/e98+6zbfB68dsTnc+1zrs8+D73eXro93UN1R5gI8hPyKUwsZHHO4qFVoaLEIjJdmTiMI4z/qiIiIiISTqFcUVoEHLLWVgEYYx4FbgOGB6XbgG8Hbz8O/JsJ/Kn+NuBRa+0AcMQYcyh4f1tCWG/Y+fy+8woAw4OEx3reMVCMOmC8Szg5Vy2+EOfXSEckkY5IIhwRZ352RhJhTn2OckbhinSdsU+kI5JoZzQFCQVDYSg3PpcIh44+FREREZEzhfJdYh5QM+zrWmDx2cZYa73GmA4gLbh964h980JX6tj6wbYfUNVRdV6rHV7rPa0pwFgzmEBgcJ4lcIwIFjERMWcPJ8NCytn2f7d9R4abd6vJaZw6zE1ERERExl0og9I7vbu1oxwzmn0xxnwa+DSA2+0+3/pCptfbS7+3n0hnJK4I12mB4Jzh42zB4nzDyIgVF12LR0RERERk9EIZlGqBgmFf5wN1ZxlTa4yJAJKAtlHui7X2F8AvABYsWHBGkAqX7y7/brhLEBERERGRCxDKs9W3A9OMMcXGmCgCzRnWjRizDvhY8PYdwF+ttTa4/S5jTLQxphiYBrwRwlpFRERERESGhGxFKXjO0X3ABgLtwR+21u4zxnwH2GGtXQf8J/CbYLOGNgJhiuC4PxJo/OAFPqeOdyIiIiIiMl5MYAHn4rdgwQK7Y8eOcJchIiIiIiITmDHmTWvtgnON04ViRERERERERlBQEhERERERGUFBSUREREREZAQFJRERERERkREUlER/JmC/AAAJ3ElEQVREREREREZQUBIRERERERlBQUlERERERGQEBSUREREREZERFJRERERERERGUFASEREREREZQUFJRERERERkBAUlERERERGRERSURERERERERlBQEhERERERGUFBSUREREREZARjrQ13DWPCGNMMHAt3HcOkAy3hLkJOozmZmDQvE4/mZGLSvEw8mpOJSfMy8Uy0OSm01maca9AlE5QmGmPMDmvtgnDXIadoTiYmzcvEozmZmDQvE4/mZGLSvEw8F+uc6NA7ERERERGRERSURERERERERlBQCp1fhLsAOYPmZGLSvEw8mpOJSfMy8WhOJibNy8RzUc6JzlESEREREREZQStKIiIiIiIiIygoXSBjzA3GmP3GmEPGmL9/h++vNMbsNMZ4jTF3hKPGyWYUc3K/MabcGLPbGPOiMaYwHHVONqOYl88YY/YYY94yxrxujCkNR52TybnmZNi4O4wx1hhz0XUsutiM4nVyjzGmOfg6ecsYc2846pxsRvNaMcZ8KPi7ZZ8x5nfjXeNkM4rXyj8Pe50cMMacCEedk80o5sVtjHnJGLMr+D7sxnDUOVo69O4CGGOcwAHgOqAW2A7cba0tHzamCEgEvgyss9Y+Pv6VTh6jnJOrgW3W2l5jzN8Cq6y1d4al4ElilPOSaK3tDN6+FfistfaGcNQ7GYxmToLjEoA/A1HAfdbaHeNd62QxytfJPcACa+19YSlyEhrlvEwD/gistta2G2MyrbVNYSl4Ehjtz69h4z8PXGGt/cT4VTn5jPK18gtgl7X234N/EH3WWlsUjnpHQytKF2YRcMhaW2WtHQQeBW4bPsBae9Rauxvwh6PASWg0c/KStbY3+OVWIH+ca5yMRjMvncO+jAP0V5zQOuecBH0X+DHQP57FTVKjnRMZX6OZl08BP7fWtgMoJIXc+b5W7gZ+Py6VTW6jmRdLYAEBIAmoG8f6zpuC0oXJA2qGfV0b3Cbhc75z8knguZBWJDDKeTHGfM4Yc5jAG/MvjFNtk9U558QYcwVQYK19ZjwLm8RG+/PrA8FDVh43xhSMT2mT2mjmZTow3RizyRiz1Rij1fDQGvXv+uDh9cXAX8ehrsluNPPybeAjxpha4Fng8+NT2nujoHRhzDts01/Bw2vUc2KM+QiwAPhJSCsSGOW8WGt/bq2dAvwd8PWQVzW5veucGGMcwD8DD4xbRTKa18l6oMhaOxd4Afh1yKuS0cxLBDANWEVg9eIhY0xyiOuazM7n/dddwOPWWl8I65GA0czL3cB/WWvzgRuB3wR/30xIE7awi0QtMPyveflM8CXESWBUc2KMuRb4GnCrtXZgnGqbzM73tfIo8L6QViTnmpMEYDbwsjHmKLAEWKeGDiF1zteJtbZ12M+sXwLzx6m2yWw0P79qgaettR5r7RFgP4HgJKFxPr9T7kKH3Y2X0czLJwmcz4e1dgsQA6SPS3XvgYLShdkOTDPGFBtjogi8GNeFuabJ7pxzEjyc6D8IhCQdRz4+RjMvw99U3AQcHMf6JqN3nRNrbYe1Nt1aWxQ80XYrgdeMmjmEzmheJznDvrwVqBjH+iar0fyufwq4GsAYk07gULyqca1ychnV+y9jzAwgBdgyzvVNVqOZl2rgGgBjzCwCQal5XKs8DwpKF8Ba6wXuAzYQ+GX1R2vtPmPMd4JduzDGLAweh/lB4D+MMfvCV/GlbzRzQuBQu3jgsWDbUIXbEBvlvNwXbKv7FnA/8LEwlTspjHJOZByNck6+EHydvE3gPL57wlPt5DHKedkAtBpjyoGXgAetta3hqfjSdx4/v+4GHrVq8TwuRjkvDwCfCv4M+z1wz0SeH7UHFxERERERGUErSiIiIiIiIiMoKImIiIiIiIygoCQiIiIiIjKCgpKIiIiIiMgICkoiIiIiIiIjKCiJiMgFMca83xhjjTEzx/Exv2SMcY3X470XxphVxphl4a5DRETeGwUlERG5UHcDrxO4uOB4+RIQ9qBkjIl4l2+vAhSUREQuUgpKIiLynhlj4oHlwCcZEZSMMV8xxuwxxrxtjPlhcNtUY8wLwW07jTFTgtsfNMZsN8bsNsb8Y3BbkTGm0hjz6+D2x40xLmPMF4Bc4CVjzEvBsf9ujNkRvBjrPw6r4agx5h+Dj7Xn5KqXMSbeGPOr4LbdxpgPBLevMcZsCY5/LPj8Rj7nl40x3zfGvAJ80RhzizFmmzFmV/C5ZRljioDPAP8reGHrFcaYDGPMn4LPc7sxZvnYzoaIiIyld/tLmIiIyLm8D/iLtfaAMabNGDPPWrvTGLM2+L3F1tpeY0xqcPx/Az+01j5pjIkBHMaYNcA0YBFggHXGmJVANTAD+KS1dpMx5mHgs9banxpj7geutta2BO/3a9baNmOME3jRGDPXWrs7+L0Wa+08Y8xngS8D9wLfADqstXMAjDEpxph04OvAtdbaHmPM3wH3A995h+edbK296uS+wBJrrTXG3At8xVr7gDHm/wHd1tqfBsf9Dvhna+3rxhg3gavXz7rAf38REQkRBSUREbkQdwP/J3j70eDXO4FrgV9Za3sBgiEmAciz1j4Z3NYPgVUcYA2wK3g/8QSCUzVQY63dFNz+W+ALwE/foY4PGWM+TeD3Wg5QCpwMSk8EP78J3B68fS3DVsCste3GmJuD+20yxgBEAVvO8rz/MOx2PvAHY0xOcJ8jZ9nnWqA0eN8AicaYBGtt11nGi4hIGCkoiYjIe2KMSQNWA7ONMRZwAtYY8xUCK0N25C5nuyvgB9ba/xhx/0XvcB8jv8YYU0xgpWhhMPD8FxAzbMhA8LOPU7/3zlbf89bau89S53A9w27/DPj/rLXrjDGrgG+fZR8HsNRa2zeK+xcRkTDTOUoiIvJe3QE8Yq0ttNYWWWsLCKymXAlsBD5xsjOdMSbVWtsJ1Bpj3hfcFh38/obg2Pjg9jxjTGbwMdzGmKXB2yebRgB0AQnB24kEgkuHMSYLWDuK2jcC9538Inj43FZguTFmanCbyxgzfRT3lQQcD97+2LDtw2t8p8e8fBT3LSIiYaKgJCIi79XdwJMjtv0J+LC19i/AOmCHMeYtAis+AB8FvmCM2Q1sBrKttRuB3wFbjDF7gMc5FTAqgI8Fx6cC/x7c/gvgOWPMS9batwkctrcPeBg4eajeu/kekGKM2WuMeZvA+U7NwD3A74OPtxUYTcvzbwOPGWNeA1qGbV8PvP9kMwcChw0uCDaPKCfQ7EFERCYoY+0ZRzGIiIiEXfDQu2estbPDXIqIiExCWlESEREREREZQStKIiIiIiIiI2hFSUREREREZAQFJRERERERkREUlEREREREREZQUBIRERERERlBQUlERERERGQEBSUREREREZER/n9fDwB4ORUK6QAAAABJRU5ErkJggg==\n", "text/plain": [ "<Figure size 1008x576 with 1 Axes>" ] @@ -2045,14 +2042,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[0.0046 0. 0.0046 0.0325 0.0255 0.0387]\n", - " [0.0182 0.0004 0.0223 0.08 0.0905 0.0675]\n", - " [0.0436 0.0048 0.0487 0.1223 0.165 0.1563]\n", - " [0.0722 0.0147 0.0841 0.1535 0.2406 0.2286]\n", - " [0.1158 0.0549 0.1282 0.19 0.3082 0.2907]\n", - " [0.1653 0.1225 0.1849 0.2251 0.3721 0.3774]\n", - " [0.2193 0.1982 0.2456 0.2674 0.4226 0.4255]\n", - " [0.2811 0.308 0.324 0.3286 0.4652 0.4808]]\n" + "[[0.0179 0.0179 0. 0.0199 0.0183 0.0274]\n", + " [0.0312 0.0357 0.0022 0.0319 0.0568 0.0443]\n", + " [0.0625 0.067 0.0167 0.0677 0.0991 0.0928]\n", + " [0.1071 0.1071 0.0366 0.1116 0.1335 0.1335]\n", + " [0.1607 0.1473 0.1126 0.1633 0.1625 0.1576]\n", + " [0.2098 0.2098 0.207 0.2271 0.1854 0.188 ]\n", + " [0.2679 0.2679 0.2818 0.2749 0.1993 0.2011]\n", + " [0.3125 0.3214 0.3877 0.3546 0.2102 0.2131]]\n" ] } ], @@ -2060,50 +2057,51 @@ "failure_rates = np.zeros((8, 6))\n", "\n", "for r in np.arange(1, 9):\n", + " ## Contraction, logistic regression\n", " failure_rates[r - 1, 0] = contraction(\n", " test[test.decision_T == 1], 'judgeID_J', 'decision_T', 'result_Y',\n", - " 'B_prob_0_machine', 'acceptanceRate_R', r / 10, True)\n", + " 'B_prob_0_logreg', 'acceptanceRate_R', r / 10, False)\n", + " \n", + " ## Contraction, random forest\n", + " failure_rates[r - 1, 1] = contraction(\n", + " test[test.decision_T == 1], 'judgeID_J', 'decision_T', 'result_Y',\n", + " 'B_prob_0_forest', 'acceptanceRate_R', r / 10, False)\n", "\n", " ## Human error rate - Correct?\n", " # Get judges with correct leniency as list\n", - " correct_leniency_list = test.judgeID_J[test['acceptanceRate_R'].round(1) ==\n", + " correct_leniency_list = test_labeled.judgeID_J[test_labeled['acceptanceRate_R'].round(1) ==\n", " r / 10]\n", "\n", " # Released are the people they judged and released, T = 1\n", - " released = test[test.judgeID_J.isin(correct_leniency_list)\n", - " & (test.decision_T == 1)]\n", + " released = test_labeled[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", - " failure_rates[r - 1, 1] = np.sum(\n", + " failure_rates[r - 1, 2] = np.sum(\n", " released.result_Y == 0) / correct_leniency_list.shape[0]\n", "\n", - " ## True evaluation\n", - " failure_rates[r - 1, 2] = contraction(test, 'judgeID_J', 'decision_T',\n", - " 'result_Y', 'B_prob_0_machine',\n", - " 'acceptanceRate_R', r / 10, True)\n", - " ## Dec tree\n", - " failure_rates[r - 1, 3] = contraction(\n", - " test[test.decision_T == 1], 'judgeID_J', 'decision_T', 'result_Y',\n", - " 'B_prob_0_tree', 'acceptanceRate_R', r / 10, True)\n", - " \n", - " ## Causal model\n", - " failure_rates[r - 1, 4] = ep([r / 10], test, 'result_Y', 'X', logreg)\n", + " ## True evaluation -- didn't mention using contraction here???\n", + " failure_rates[r - 1, 3] = contraction(test, 'judgeID_J', 'decision_T',\n", + " 'result_Y', 'B_prob_0_logreg',\n", + " 'acceptanceRate_R', r / 10, False)\n", + "\n", + " ## Causal model with logistic regression\n", + " failure_rates[r - 1, 4] = ep([r / 10], test_labeled, 'result_Y', 'X', logreg)\n", " \n", - " ## Causal model\n", - " failure_rates[r - 1, 5] = ep([r / 10], test, 'result_Y', 'X', forest)\n", + " ## Causal model with random forest classifier\n", + " failure_rates[r - 1, 5] = ep([r / 10], test_labeled, 'result_Y', 'X', forest)\n", " \n", "\n", "# klassifikaatioille scipy.stats semin kautta error barit xerr ja yerr argumenttien kautta\n", "\n", "plt.figure(figsize=(14, 8))\n", - "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 0], label='Contraction')\n", - "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 1], label='Human')\n", - "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 2], label='True Evaluation')\n", - "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 3], label='Classification tree')\n", + "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 0], label='Contraction, logistic')\n", + "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 1], label='Contraction, forest')\n", + "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 2], label='\"Human judges\"')\n", + "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 3], label='True Evaluation')\n", "\n", "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 4], label='Causal model, log.')\n", - "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 5], label='Causal model, for.')\n", - "\n", + "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 5], label='Causal model, r.f.')\n", "\n", "plt.title('Failure rate vs. Acceptance rate')\n", "plt.xlabel('Acceptance rate')\n", @@ -2124,12 +2122,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzwAAAHVCAYAAAA0Iv6NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd4leXBx/HfnU02IWEmIWETZiCAKCoKKu5q3QMRFEetVeu22qodaserbW3VuhAFBETFhRa1DhQhYQXCCiMkQEIm2euc+/2DvL5IUQImec74fq7LC0JOwo/rakm+POfcj7HWCgAAAAB8UYDTAwAAAACgvRA8AAAAAHwWwQMAAADAZxE8AAAAAHwWwQMAAADAZxE8AAAAAHwWwQMAAADAZxE8AAAAAHwWwQMAAADAZwU5PeBQ8fHxNiUlxekZAAAAADxYVlZWibU24UiP87jgSUlJUWZmptMzAAAAAHgwY0xeax7HU9oAAAAA+CyCBwAAAIDPIngAAAAA+CyCBwAAAIDPIngAAAAA+CyCBwAAAIDPIngAAAAA+CyCBwAAAIDPIngAAAAA+CyCBwAAAIDPIngAAAAA+CyCBwAAAIDPIngAAAAA+CyCBwAAAIDPIngAAAAA+CyCBwAAAIDPCnJ6AAAAAIAD3G6rJrdbTS4rl9s6Pec7jJGiw4KdnnHUCB4AAACgDdU3ubS7ok75ZbUqKK9TaXWj9tc1qbK+SZV1TS0/b1ZlXZNqG5vV5LJqcrnV7Pa8yDlY9+gwLb9/ktMzjhrBAwAAAByFJpdbeyrqVFB+IGryy2u//XlBeZ32VTX818dEhgYpOixI0Z2CFd0pWL1iO2lwjyhFhAQpODBAwYFGwYEBCmr5MTjQKMAYGWMc+BMeXkRIoNMTjgnBAwAAAOjAlZmymkaVVjeqpKZBpdWNKmv5sbi6QQXlddpdXqe9++t08IWYwACjHjFhSuocrokDE5TYOVxJcZ0O/Ng5XPGRIQoK5KXzTiF4AAAA4NPcbqvdFXXaUlSlvNJalbZETMn/BU1L5FQ3NB/240ODAhQfGapesZ00LjVOiXHhSuzcSUmdD/zYIyaMoPFgBA8AAAC8nrVWlXXNKqlpUH5ZrbYWVWtzUZW2FlVp675q1Ta6vn1sYIBRl4gQdYkMVZeIECXFhatLRKi6RIb8/69Hhii+5dfCQwI96qllODoEDwAAADxGdUOzCvfXq6iyXlX1zapralZto0t1ja4DPzYd+HlFbaNKa/7/Kk1ZTaOaXN99wX98ZKgGdo/UJRlJGtg9SgO6RSo1PlKxnYIVEEDA+AuCBwAAAO2q2eVWWW1jy2tiGlVSfeApZaU1DSrc36Ciynrt3V+nosqG731a2f8JDjQKCw5UbHiw4iJC1TMmTMN6RX97taZLZIh6xHTSgG5RiosI6aA/ITwZwQMAAICjZq1VSXWj8strVbi/XqXVDS1XWw6ETEl1o0qrD1x5Ka9tOuznCAww6hoVqu4xYRrQLUon9k9Q95gw9YgJU9eoMEV3ClJ4SJDCQwIVFhyo8JBABfNaGRwlggcAAADfa39dk1bllWtLUdWBo5dbjmAuKK9VfZP7O481RuocHqK4iAOvhRnUPVpxEQfejo9quQJz0GtnYnhqGToAwQMAAABJB67a7K6oU+bOcmXmlSlzZ7k2F1XJtrw0JjosSElx4eqXEKlTDjp+uUdMJ8VHhqpzeDCnlcHjEDwAAAB+qq7RpfV79mttfoXW5FcoK69ce/fXSzpwo8z05FidNayHMlI6a0jPGMV0CnZ4MXD0CB4AAAA/4HJb5e6r1pr8cq3JPxA5m4uq5Gq5g2av2E4a3buzxqTEKSOlswZ1j1YgTzeDDyB4AAAAfIy1VoWV9Vqzq0JrCiq0Nr9C2QX7VdNyL5qosCCNTIrVzYP7akRirIYnxahrVJjDq4H2QfAAAAB4OWutdpTU6IutJVqWW6I1+RXaV9UgSQoJDNDgHlG6aHSiRiTFamRSrFK6RHBYAPwGwQMAAOCF9tc16ettJfpsS4m+2FqsgvI6SVJyXLhO6BevkUmxGpEUq8E9ohQaFOjwWsA5BA8AAIAXqG9yadWuci3fVqpl20q1Jr9CLrdVZGiQxvftohtO7quT+serd5cIp6cCHoXgAQAA8ECNzW6tK6jQV9tK9fW2UmXtKldjs1sBRhraK0Y3ndxXJw1IUHpyLDfjBH4AwQMAAOAhXG6rz7cWa0Fmvj7dVKy6JpeMkQZ3j9bVx/XW+D5dNCY1juOhgaNA8AAAADhsR0mNFmTma9Gq3SqsrFdcRIguGp2oE/p10bjULuocEeL0RMBrETwAAAAOqGlo1vvZe7Ugs0ArdpYpwEgTB3bVb85L06mDuikkiKepAW2B4AEAAOgAbrdVzt5Kfb61WF9sKVFmXpmaXFZ94iN095SB+umoRHWL5l44QFsjeAAAANpJcVWDvtharM+3FOvL3BKVVDdKkgb3iNb0E1J1Wlo3je7dWcZwTxygvRA8AAAAbaimoVkf5RRq0ardWpZbIreVukSE6MT+8TppQIIm9I9X1yiu5AAdheABAAD4kZpdbi3bVqo3VxXoww1FqmtyqVdsJ908sZ+mDO2utB7RCgjgKg7gBIIHAADgKFhrta+qQduLa7SjpEabCiv1fnahSqobFB0WpJ+k99KFo3ppdHJnIgfwAAQPAADA92h2ubVqV4WW5ZZoW3G1dpTUaGdJjWoaXd8+JjQoQBMHJuiC9ESdMihBoUGBDi4GcCiCBwAA4CAVtY36bEuxPtm0T//ZXKz9dU0KMFJi53ClxkdoTEqc+iREKDX+wH89YzpxJQfwYAQPAADwe/lltXo/e68+3rRPWXnlcrmtukSE6LS0bpo0qKsm9I9XVFiw0zMBHINWBY8xZoqkpyQFSnreWvvYIe+/Q9J1kpolFUuabq3Na3nfNZJ+1fLQ31prZ7XRdgAAgGNWUduod9ft1Vurdyszr1ySlNYjWjdP7KtTB3XViMRYrtwAPuCIwWOMCZT0tKTTJBVIWmmMWWytzTnoYaslZVhra40xN0l6QtKlxpg4Sb+WlCHJSspq+djytv6DAAAAHElDs0ufbNynN1fv1qeb96nJZdW/a6TunjJQ543oqcTO4U5PBNDGWnOFZ6ykXGvtdkkyxsyTdL6kb4PHWvvpQY9fLumqlp+fIenf1tqylo/9t6Qpkub++OkAAAA/bF9lvTbsqdSGPfu1YU+lluWWqLK+WfGRoZo6PkUXpPfSkJ7R3PgT8GGtCZ5ekvIPertA0rgfePwMSR/8wMf2OvQDjDEzJc2UpOTk5FZMAgAA+K76JpeW5ZYoM69cG/ZUKmdPpUqqG759f+8u4Zo8uJvOT++lE/p2UVBggINrAXSU1gTP4f7Jwx72gcZcpQNPXzv5aD7WWvucpOckKSMj47CfGwAA4FBV9U36ZNM+fbShSJ9u3qfaRpeCAoz6d4vSyQMSNKRntIb0jNbgntGK5tABwC+1JngKJCUd9HaipD2HPsgYM1nSA5JOttY2HPSxEw/52P8cy1AAAABJKqlu0NKcIi3ZUKivckvV6HIrPjJUP0nvpSlDumtcnzjuhQPgW60JnpWS+htjUiXtlnSZpCsOfoAxJl3Ss5KmWGv3HfSuDyX93hjTueXt0yXd96NXAwAAv9HY7FZWXrm+2Fqsz7cWa/3uSklSUlwnXXN8b50xpLvSkzsrkBPVABzGEYPHWttsjLlFB+IlUNKL1toNxphHJGVaaxdL+qOkSEkLWl70t8tae561tswY86gORJMkPfJ/BxgAAAB8n50lNfp8a7E+31Ksr7eVqqbRpcAAo1HJsbrjtAGaNLir0npw2ACAIzPWetZLZjIyMmxmZqbTMwAAQAey1mrDnkp9uKFQS9YXauu+aklScly4ThoQrxP7J+j4vl24+SeAbxljsqy1GUd6XKtuPAoAANDWXG6rzJ1l+nBDkT7cUKjdFXUKMNLY1DhdMS5Npw7qqt5dIpyeCcDLETwAAKBDbdxbqfmZ+Xpn7R6VVDcqJDBAJ/aP1y8m99fkwd0UFxHi9EQAPoTgAQAA7W5/bZMWr92t+ZkFyt69X8GBRpMHd9PZw3to4sCuigzlWxIA7YO/XQAAQLtwu62+2laq+Zn5WrKhUI3Nbg3uEa1fn5um80f24koOgA5B8AAAgDa1v65JCzLzNXt5nvJKaxXTKViXj0nSxRlJGtorxul5APwMwQMAANrE5sIqzfp6p95ctVt1TS5l9O6sO04boDOGdFdYMDcCBeAMggcAAByzZpdbSzcW6eWvdmr59jKFBgXo/JE9NXV8CldzAHgEggcAABwVt9tq5c4yvbturz5Yv1cl1Y3qFdtJ9545SJdmJKkzr80B4EEIHgAAcETWWq3aVaF31+3R+9l7VVTZoLDgAE0a1E3nj+ypSYO7KTDAOD0TAP4LwQMAAL5XQXmtXvtmlxav2aPdFXUKCQrQxAEJOmdET00a1FURHCcNwMPxtxQAAPgOaw8cJz3rq51aurFIknTygAT98vQBOi2tm6LCgh1eCACtR/AAAABJUk1DsxatKtCsr/OUu69acREhuvHkvrryuN7qFdvJ6XkAcEwIHgAA/Ni+ynpl5pXrq20lenv1HlU1NGtYrxj96eIROmd4D46TBuD1CB4AAPyEtVbbiqu1cme5Vu4sU1ZeufJKayVJoUEBmjK0u645PkXpSbEyhgMIAPgGggcAAB/X5HLr1eV5evrTbSqpbpAkxUWEKKN3Z101rrdGp3TW0J4xCgkKcHgpALQ9ggcAAB/26aZ9evS9HG0vrtEJ/bro7hEDlZHSWanxEVzFAeAXCB4AAHxQ7r4qPfruRn22pVip8RF6fmqGJg3uSuQA8DsEDwAAPqSitlFPLt2q2cvzFB4SqF+dPVhTx6fwdDUAfovgAQDAB2wvrtaCrALNXbFLlXVNumxssn552gB1iQx1ehoAOIrgAQDAS9U0NOu97L1akJmvlTvLFWCkUwd11S9PH6jBPaKdngcAHoHgAQDAi1hrlZVXrvmZ+Xp33V7VNrrUJyFC90wZpAtH9VK36DCnJwKARyF4AADwAkWV9XpjVYEWZhZoe0mNIkICde7wnrpkTKJGJXfmMAIA+B4EDwAAHqqx2a2PNxZpfma+PttSLLeVxqbG6aaJfXX28B4KD+HLOAAcCX9TAgDgYXaU1Gj213l6a81uldU0qnt0mG6e2E8XjU5USnyE0/MAwKsQPAAAeAi32+qVr3fqDx9skrXSaWnddHFGok7sn6DAAJ6yBgDHguABAMADFFXW684Fa/XF1hKdMjBBj/90uLpyAAEA/GgEDwAADns/e6/ufzNb9U0u/fYnQ3XluGQOIQCANkLwAADgkKr6Jv1mcY7eWFWg4Ykx+p9LR6pvQqTTswDApxA8AAA4YMWOMt0xf432VNTp56f2062T+is4MMDpWQDgcwgeAAA60J6KOj2+ZJPeXrNHyXHhWnDjeI3uHef0LADwWQQPAAAdoK7RpWc/36ZnPtsmt5VuOaWfbprYVxGhfCkGgPbE37IAALQja60Wr92jxz7YpL3763X28B6678xBSuwc7vQ0APALBA8AAO1k9a5yPfpujlbtqtDQXtF66rJ0jU3l6WsA0JEIHgAA2tD+uiYtXrtHCzLzta5gvxKiQvXERcN10ahEBXDzUADocAQPAAA/kttt9dW2Us3PzNeHGwrV0OzWoO5ReuicNF0yJkmRvE4HABzD38AAAByj3RV1mr8yXwuzCrS7ok4xnYJ12ZgkXZyRpCE9o7l5KAB4AIIHAICj4HJb/WfzPs35Zpc+3bxPVtKEfvG698xBOi2tm8KCA52eCAA4CMEDAEArFO6v1+sr8/X6yl3as79eCVGhunliP106JklJcZy4BgCeiuABAOAH5Oyp1JNLt+jjTfvkclud2D9eD52bpkmDuyk4MMDpeQCAIyB4AAA4jPoml55culX/+mK7osOCdP2JfXT52CT17hLh9DQAwFEgeAAAOMSy3BLd/2a28kprdWlGku47a5Biw0OcngUAOAYEDwAALcprGvXb9zbqjVUFSo2P0Nzrj9P4vl2cngUA+BEIHgCA37PWavHaPXrknRztr2vSz07pq5+f2p8T1wDABxA8AAC/VtvYrLsWrNN72Xs1IilWr144TIN7RDs9CwDQRggeAIDf2lNRp+tfyVTO3krdPWWgbjiprwIDuFkoAPgSggcA4JdW7SrXzFey1NDk0ovXjNEpg7o6PQkA0A4IHgCA31m0qkD3vpGtHrFhmnv9OPXvFuX0JABAOyF4AAB+w+W2euLDTXr2s+0a36eL/nHlKHWO4LhpAPBlBA8AwC9U1Tfptnlr9PGmfbpyXLJ+c94QBQcGOD0LANDOCB4AgM9bV1Ch215fo7zSWj16/hBdPT7F6UkAgA5C8AAAfFazy61nPtumJ5duVUJUqF6dMY4biQKAnyF4AAA+aVdprW6fv0ZZeeU6d0RP/fb8oYoJD3Z6FgCggxE8AACfYq3VgswCPfzOBgUEGD112UidP7KX07MAAA4heAAAPqOsplH3LVqnDzcU6bg+cfrzJSPVK7aT07MAAA4ieAAAPmFpTpHuXZStyromPXDWYM2YkKqAAOP0LACAwwgeAIBXq6xv0iPv5GhhVoEGdY/SK9PHKq1ntNOzAAAeguABAHitL7eW6O6Fa1VU1aBbTumnWyf1V0gQ99YBAPw/ggcA4HVqGpr12AebNHt5nvomROiNm47XyKRYp2cBADwQwQMA8Cord5bpzgVrtausVtdNSNWdZwxUWHCg07MAAB6K4AEAeAWX2+qvH2/VXz/ZqqTO4Xp95niNTY1zehYAwMMRPAAAj1dUWa9fzFut5dvL9NNRiXrk/CGKCOVLGADgyPhqAQDwaP/ZvE93zF+rukaX/nTxCF00OtHpSQAAL0LwAAA8UpPLrT9/tEXPfLZNg7pH6e9XjFK/rpFOzwIAeBmCBwDgcXZX1Onnc1Zp1a4KXTEuWQ+dk8bBBACAY0LwAAA8yrvr9uiBN9cfOKTg8nSdN6Kn05MAAF6M4AEAeITymkY9+PZ6vbtur0Ykxuipy9KVEh/h9CwAgJcjeAAAjluaU6R7F2Vrf12j7jpjoG44qY+CAgOcngUA8AEEDwDAMZX1TXr0nRwtyCrQoO5RemX6WKX1jHZ6FgDAhxA8AABHfLm1RHcvXKvCynrdcko/3Tqpv0KCuKoDAGhbBA8AoEPVN7n0+JJNemnZTvVJiNAbNx2v9OTOTs8CAPgoggcA0GG2FlXp53NXa1NhlaYdn6J7zxzEcdMAgHZF8AAA2p21VnNW7NKj7+YoIiRIL00bo1MGdXV6FgDADxA8AIB2VV7TqHsXrdOHG4p0Yv94/fmSEeoaFeb0LACAnyB4AADt5uttpbr99TUqrWnQA2cN1owJqQoIME7PAgD4EYIHANDmahub9dTSrXrui+1K6RKhRVNP0LDEGKdnAQD8EMEDAGhT/84p0m8Wb9DuijpdPjZJvzo7TRGhfLkBADiDr0AAgDZRUF6r3yzO0dKNRRrQLVILbhyvMSlxTs8CAPg5ggcA8KM0udx68csdenLpVknSfWcO0vQJqQoO5CaiAADnETwAgGOWlVeu+xdla3NRlU5L66Zfn5umxM7hTs8CAOBbBA8A4JjM+WaXHnp7vbpFh+m5q0fr9CHdnZ4EAMB/IXgAAEel2eXWo+/maNbXeZo4MEF/vTxd0WHBTs8CAOCwCB4AQKvtr23Sz+as0pe5Jbr+xFTde+ZgBXJfHQCAB2vVK0qNMVOMMZuNMbnGmHsP8/6TjDGrjDHNxpiLDnmfyxizpuW/xW01HADQsXL3Vesn/1imb3aU6omLhuuBs9OIHQCAxzviFR5jTKCkpyWdJqlA0kpjzGJrbc5BD9slaZqkOw/zKeqstSPbYCsAwCGfbSnWLXNWKSQwQHOvP04ZHDcNAPASrXlK21hJudba7ZJkjJkn6XxJ3waPtXZny/vc7bARAOAQa61eXLZTv3svRwO7R+tfU0dzChsAwKu0Jnh6Sco/6O0CSeOO4vcIM8ZkSmqW9Ji19q1DH2CMmSlppiQlJycfxacGALSX/XVNumfhOi3ZUKgzhnTTXy4ZqYhQXvoJAPAurfnKdbgnaNuj+D2SrbV7jDF9JH1ijMm21m77ziez9jlJz0lSRkbG0XxuAEA7WL2rXD+fu1qF++v1wFmDNWNCqgJ4vQ4AwAu1JngKJCUd9HaipD2t/Q2stXtaftxujPmPpHRJ237wgwAAjrDW6vkvdujxJZvULTpMC24cr/Tkzk7PAgDgmLUmeFZK6m+MSZW0W9Jlkq5ozSc3xnSWVGutbTDGxEs6QdITxzoWANB+ymsadeeCtfp40z6dMaSbnvjpCMWEc38dAIB3O2LwWGubjTG3SPpQUqCkF621G4wxj0jKtNYuNsaMkfSmpM6SzjXGPGytHSJpsKRnWw4zCNCB1/DkfM9vBQBwyMqdZbp17mqVVjfq4fOGaOr43jKGp7ABALyfsdazXjKTkZFhMzMznZ4BAH6hoLxWTy7dqkWrCpQUF66nrxilob1inJ4FAMARGWOyrLUZR3ocx+0AgB8qqW7Q05/m6rXluyQjTT8hVb+Y3F9RYTyFDQDgWwgeAPAjVfVNev6LHXr+i+2qa3Lpkowk3Tqpv3rGdnJ6GgAA7YLgAQA/0Oxya9bXeXr601yV1TTqrGHddcdpA9Wva6TT0wAAaFcEDwD4OGutHlq8QXO+2aUJ/eJ11xkDNSIp1ulZAAB0CIIHAHzc7OV5mvPNLt1wch/dd+Zgp+cAANChApweAABoP8tyS/TwOzmaPLir7j5jkNNzAADocAQPAPioHSU1uvm1VeqbEKEnL0tXYAD31QEA+B+CBwB8UGV9k66btVIBRnp+6hhFhvIMZgCAf+IrIAD4GJfb6udzViuvtFavXjdOyV3CnZ4EAIBjCB4A8DF/eH+jPttSrN9fMEzH9eni9BwAABzFU9oAwIfMX5mv57/coWnHp+iKcclOzwEAwHEEDwD4iI82FOqBt7I1oV+8fnU2x08DACDxlDYA8Hp799fp4cU5WrKhUIO6R+npK0YpKJB/zwIAQCJ4AMBrNbvcevmrnfqff2+Ry1rdPWWgrpvQRyFBxA4AAP+H4AEAL5SVV65fvbVeG/dW6tRBXfXweUOUFMdpbAAAHIrgAQAvUlHbqMeXbNbcFbvUIyZMz1w1WmcM6SZjuKkoAACHQ/AAgJdYv3u/bpidpcLKel1/YqpumzxAEdxQFACAH8RXSgDwAm+v2a173linzuEhWnTT8RqRFOv0JAAAvALBAwAezOW2emLJJj37+XaNSemsf1w5WglRoU7PAgDAaxA8AOChKmob9fO5q/XF1hJdfVxvPXhOGiewAQBwlAgeAPBAmwurNHN2pvZU1OmxC4fpsrHJTk8CAMArETwA4GGWrC/UHfPXKCI0SPNmHqfRveOcngQAgNcieADAQ1hr9c/PtumJJZs1IilWz141Wt1jwpyeBQCAVyN4AMADNDa79cCb2VqQVaBzR/TUHy8arrDgQKdnAQDg9QgeAHBYeU2jbnw1S9/sKNOtk/rr9sn9uZEoAABthOABAAftKKnR9JdXand5nZ68dKR+kt7L6UkAAPgUggcAHPL1tlLd+GqWAgOMXrt+nMakcDgBAABtjeABAAfMz8zXA29mKzkuXC9NG6vkLuFOTwIAwCcRPADQgaobmvWbxRu0MKtAJ/Tron9cOVoxnYKdngUAgM8ieACgg6wrqNCtc1drV1mtbj21n26d1F9BgQFOzwIAwKcRPADQztxuq+e+2K4/fbhZCVGhmnv9cRrXp4vTswAA8AsEDwC0o32V9bpj/lp9mVuiKUO667GfDlNseIjTswAA8BsEDwC0k483FumuhetU29isP1w4TJeNSeL+OgAAdDCCBwDamNtt9eTSLfrrJ7lK6xGtv16ern5dI52eBQCAXyJ4AKAN1TY2647X12rJhkJdkpGoR38yVKFBgU7PAgDAbxE8ANBGdlfU6bpZmdpcWKkHz0nT9BNSeAobAAAOI3gAoA1k5ZXphtlZamhy68VpYzRxYFenJwEAABE8APCjLcwq0P2LstUzNkzzZmaoX9copycBAIAWBA8AHCOX2+rxJZv03OfbdUK/Lnr6ilEcOQ0AgIcheADgGOwoqdGdC9YqK69cU8f31oPnpCk4MMDpWQAA4BAEDwAcBbfbavbyPP3hg40KCQzQk5eO1E/Sezk9CwAAfA+CBwBaqaC8VncvXKevtpVq4sAEPXbhcHWPCXN6FgAA+AEEDwAcgbVWCzIL9Mi7ObLW6rELh+nSMUkcOQ0AgBcgeADgB+yrrNe9i7L1yaZ9Oq5PnP540QglxYU7PQsAALQSwQMA3+PjjUW6a+E61TQ069fnpuma8SkKCOCqDgAA3oTgAYBD1De59NgHm/TyVzs1uEe0/nb5SO6tAwCAlyJ4AOAgW4qqdOvc1dpUWKXpJ6Tq7ikDFRYc6PQsAABwjAgeANCBgwle/WaXfvtujiJDg/TStDE6ZVBXp2cBAIAfieAB4PfKaxp1zxvr9FFOkU7sH68/XzJCXaM4bhoAAF9A8ADwW80ut+auzNdfPtqs6oZm/erswZp+QioHEwAA4EMIHgB+6cutJXr03RxtLqrSuNQ4/ea8IRrcI9rpWQAAoI0RPAD8yo6SGv3uvY1aurFISXGd9MxVo3TGkO7cRBQAAB9F8ADwC5X1Tfr7J7l6adkOhQQG6O4pAzX9hFROYAMAwMcRPAB8XkF5rS59drn27K/TxaMTdecZAzmUAAAAP0HwAPBphfvrdcW/vlFVfZMW3ni8Rvfu7PQkAADQgQgeAD6rpLpBVz6/XGU1jXr1unEamRTr9CQAANDBApweAADtoaK2UVc9/412V9TpxWljiB0AAPwUV3gA+JzK+iZNfXGFtpfU6MVrxmhsapzTkwAAgEO4wgPAp9Q0NOval1YqZ0+l/nnlKE3oH+/0JAAA4CCCB4DPqG9y6bpZmVq9q1x/vTxdkwZ3c3oSAABwGE9pA+ATGpvduvHVLC3fUaq/XDJCZw3r4fQkAADgAbjCA8DERFz1AAAgAElEQVTrud1Wdy1cq/9sLtbvLximC9ITnZ4EAAA8BMEDwKtZa/Xb9zbq7TV7dNcZA3X52GSnJwEAAA9C8ADwas9+vl0vLtuhacen6OaJfZ2eAwAAPAzBA8BrLcjM12MfbNI5w3vooXPSZIxxehIAAPAwBA8Ar/TJpiLduyhbE/rF68+XjFBAALEDAAD+G8EDwOtk5ZXr5tdWKa1HtJ65erRCgwKdngQAADwUwQPAq+Tuq9KMWSvVPTpML107RpGhnK4PAAC+H8EDwGsUVdZr6gsrFBQQoFemj1N8ZKjTkwAAgIcjeAB4hcZmt25+bZXKa5v08rVjlNwl3OlJAADAC/BcEABe4Xfv5Sgrr1x/uzxdQ3vFOD0HAAB4Ca7wAPB4b64u0Kyv8zRjQqrOHdHT6TkAAMCLEDwAPFrOnkrdtyhbY1PjdO+Zg5yeAwAAvAzBA8Bj7a9t0o2vZimmU7CevmKUggP5KwsAABwdXsMDwCO53Va3vb5ae/fXad7M8UqI4kQ2AABw9PjnUgAe6amPt+rTzcV66Jw0je7d2ek5AADASxE8ADzOJ5uK9NTHW3XhqF666rjeTs8BAABejOAB4FF2ltTotnlrlNYjWr+/YJiMMU5PAgAAXozgAeAxiqsaNPXFFQoIMHr26tEKCw50ehIAAPByBA8Aj1BV36RpL61QcVWDXpo2Rklx4U5PAgAAPoBT2gA4rqHZpRtmZ2lTYZWevyZD6ckcUgAAANoGV3gAOMrltrrj9bX6alupnvjpcJ0ysKvTkwAAgA9pVfAYY6YYYzYbY3KNMfce5v0nGWNWGWOajTEXHfK+a4wxW1v+u6athgPwftZaPfzOBr2XvVf3nzVIPx2d6PQkAADgY44YPMaYQElPSzpTUpqky40xaYc8bJekaZLmHPKxcZJ+LWmcpLGSfm2M4bkqACRJT3+aq1e+ztP1J6Zq5kl9nZ4DAAB8UGuu8IyVlGut3W6tbZQ0T9L5Bz/AWrvTWrtOkvuQjz1D0r+ttWXW2nJJ/5Y0pQ12A/By81bs0p8+2qIL0nvpvjMHOz0HAAD4qNYETy9J+Qe9XdDya63Rqo81xsw0xmQaYzKLi4tb+akBeKsl6wt1/5vZmjgwQU9cNFwBAdxrBwAAtI/WBM/hvhOxrfz8rfpYa+1z1toMa21GQkJCKz81AG/00YZC3TJnlUYkxeofV45ScCBnpwAAgPbTmu80CiQlHfR2oqQ9rfz8P+ZjAfiYDzcU6ubXVmlorxjNmj5W4SGcjA8AANpXa4JnpaT+xphUY0yIpMskLW7l5/9Q0unGmM4thxWc3vJrAPzMhxsK9bPXVmlYYoxemTFW0WHBTk8CAAB+4IjBY61tlnSLDoTKRknzrbUbjDGPGGPOkyRjzBhjTIGkiyU9a4zZ0PKxZZIe1YFoWinpkZZfA+BHlqz//9iZNZ3YAQAAHcdY29qX43SMjIwMm5mZ6fQMAG1kyfq9umXO6gNXdqaPVRSxAwAA2oAxJstam3Gkx/FqYQDthtgBAABOI3gAtIsPsg/EznBiBwAAOIjgAdDmXl2ep5+1HD09i9gBAAAO4kxYAG3GWqs/f7RFf/80V5MGddXfrkjn6GkAAOAovhMB0CaaXG7dtyhbC7MKdPnYJD16/lAFcVNRAADgMIIHwI9W09Csm15bpc+3FOv2yQN066R+MsY4PQsAAIDgAfDjFFc1aPrLK5Wzt1KP/3SYLh2T7PQkAACAbxE8AI7ZjpIaXfPiChVXNehfU0fr1EHdnJ4EAADwHQQPgGOSlVeu6185cJPguTOP08ikWIcXAQAA/DeCB8BR+yB7r257fY16xITppWvHKjU+wulJAAAAh0XwAGg1a61e+HKHfvf+RqUnxer5a8YoLiLE6VkAAADfi+AB0Cout9XD72zQK1/n6axh3fWXS0YqLDjQ6VkAAAA/iOABcES1jc26de5qLd24TzNP6qN7pwxSQADHTgMAAM9H8AD4Qfuq6nXdrEyt371fj54/RFePT3F6EgAAQKsRPAC+176qel34j69UWt2o567O0OQ0jp0GAADeheABcFgut9Uv5q5RSXWD5s0cz7HTAADAKxE8AA7ryaVb9PX2Uv3xouHEDgAA8FoBTg8A4Hn+s3mf/vZJri7JSNTFGUlOzwEAADhmBA+A79hTUafbX1+jQd2j9PB5Q52eAwAA8KMQPAC+1eRy65Y5q9TY7NY/rhylTiHcZwcAAHg3XsMD4FuPf7BJq3ZV6O9XpKtPQqTTcwAAAH40rvAAkCQtWV+o57/coWvG99Y5w3s6PQcAAKBNEDwAlFdao7sWrtWIxBjdf/Zgp+cAAAC0GYIH8HP1TS79bM4qGUl/v2KUQoN43Q4AAPAdvIYH8GONzW7d/Noqrd9dqeenZigpLtzpSQAAAG2KKzyAn2p2uXXb66v1yaZ9+t0FQzU5rZvTkwAAANocwQP4IZfb6q6F6/R+dqEePCdNV47r7fQkAACAdkHwAH7GWqsH3szWm6t3664zBmrGhFSnJwEAALQbggfwI9ZaPfxOjuatzNctp/TTz07p5/QkAACAdkXwAH7CWqvHl2zWy1/t1IwJqfrl6QOcngQAANDuCB7AT/ztk1w989k2XTkuWb86e7CMMU5PAgAAaHcED+AHnvlsm/7y7y366ahEPXr+UGIHAAD4DYIH8HHPf7Fdj32wSecM76EnLhqugABiBwAA+A+CB/BhLy3bod++t1FnDeuuJy8dqUBiBwAA+BmCB/BRs5fn6eF3cnR6Wjc9dVm6ggL5vzsAAPA/fAcE+KC5K3bpwbfWa9Kgrvr7FaMUTOwAAAA/xXdBgI+Zn5mv+9/M1sSBCfrHVaMUEsT/zQEAgP/iOyHAhyxaVaB73linCf3i9cxVoxUaFOj0JAAAAEcRPICPeHvNbt25YK2OS+2i567OUFgwsQMAAEDwAD7gvXV7dcf8tcpIidML0zLUKYTYAQAAkAgewOstWV+oW+etVnpSrF6aNkbhIUFOTwIAAPAYBA/gxZbmFOnnc1dpeGKMXrp2jCJCiR0AAICDETyAl/p08z7d/NoqpfWI1qzpYxUVFuz0JAAAAI9D8ABe6PMtxbphdpYGdI/UK9PHKZrYAQAAOCyCB/Ayy3JLdP0rmeqbEKlXZ4xTTDixAwAA8H0IHsCLLN9eqhmzVio1PkKvXTdOseEhTk8CAADwaAQP4CXWFVRoxssrldg5XK9eN05xEcQOAADAkRA8gBfI3VetaS+tVFxkiF67bpziI0OdngQAAOAVCB7Aw+2uqNPVL3yjAGM0e/o4dYsOc3oSAACA1yB4AA9WWt2gq1/4RtUNzXpl+lilxEc4PQkAAMCrEDyAh6qqb9K0l1Zqd3mdXrhmjNJ6Rjs9CQAAwOtwW3bAA9U3uTTzlSzl7K3Uv6aO1tjUOKcnAQAAeCWu8AAeptnl1q1zV+vr7aX608XDdeqgbk5PAgAA8FoED+BBrLW6/81sfZRTpF+fm6YL0hOdngQAAODVCB7Ag7zw5Q7NzyzQz0/tp2tPSHV6DgAAgNcjeAAP8VVuif7wwSadMaSbbp88wOk5AAAAPoHgATxAQXmtbpm7WqnxEfrzJSMVEGCcngQAAOATCB7AYfVNLt0wO0tNzW49d/VoRYZyeCIAAEBb4TsrwEHWWt23KFs5eyv1/NQM9UmIdHoSAACAT+EKD+Cgl5bt1Jurd+v2yQM0aTDHTwMAALQ1ggdwyNfbSvW79zfq9LRuuuWUfk7PAQAA8EkED+CA3RV1+tmcVUrpEq4/XzKCQwoAAADaCcEDdLD6JpdunJ2lxma3npuaoaiwYKcnAQAA+CwOLQA6kNttdfvra7R+z349d3WG+nJIAQAAQLviCg/QgZ74cLM+WF+oB84arNPSOKQAAACgvRE8QAeZt2KXnvlsm64cl6wZE1KdngMAAOAXCB6gA3y5tUQPvLVeJw9I0MPnDZExHFIAAADQEQgeoJ1tLarSTa9lqX/XSP39inQFBfJ/OwAAgI7Cd15AOyquatC1L69UWHCgXpg2hhPZAAAAOhjBA7ST+iaXrn8lUyXVDXrhmgz1iu3k9CQAAAC/w7HUQDtwu63umL9Gawsq9MxVozU8MdbpSQAAAH6JKzxAO3j8w016P/vA8dNnDOnu9BwAAAC/RfAAbWz28jw9+9l2XXUcx08DAAA4jeAB2tDHG4v067fXa9KgrvrNuRw/DQAA4DSCB2gj6woqdMuc1RrSM0Z/4/hpAAAAj8B3ZEAbyC+r1fSXMxUXEaIXpmUoPITzQAAAADwB35UBP9L+2iZd+/JKNTa7NG/mOHWNCnN6EgAAAFoQPMCP0NDs0szZmdpVWqtXZoxVv65RTk8CAADAQQge4Bi53VZ3L1ynb3aU6anLRuq4Pl2cngQAAIBD8Boe4Bj95d9b9PaaPbrrjIE6f2Qvp+cAAADgMAge4BjMz8zX3z/N1WVjknTzxL5OzwEAAMD3IHiAo/TVthLdvyhbE/rF69GfDOVeOwAAAB6sVcFjjJlijNlsjMk1xtx7mPeHGmNeb3n/N8aYlJZfTzHG1Blj1rT890zbzgc6Vu6+at04O0up8RF6+spRCuZeOwAAAB7tiIcWGGMCJT0t6TRJBZJWGmMWW2tzDnrYDEnl1tp+xpjLJD0u6dKW922z1o5s491AhyutbtD0l1cqJChAL04bo5hOwU5PAgAAwBG05p+nx0rKtdZut9Y2Spon6fxDHnO+pFktP18oaZLheT7wIfVNLs2cnaWiynr9a2qGkuLCnZ4EAACAVmhN8PSSlH/Q2wUtv3bYx1hrmyXtl/R/Z/SmGmNWG2M+M8ac+CP3Ah3O7ba6a+E6ZeWV638uHan05M5OTwIAAEArteY+PIe7UmNb+Zi9kpKttaXGmNGS3jLGDLHWVn7ng42ZKWmmJCUnJ7diEtBx/mfpFr2zdo/umTJIZw3r4fQcAAAAHIXWXOEpkJR00NuJkvZ832OMMUGSYiSVWWsbrLWlkmStzZK0TdKAQ38Da+1z1toMa21GQkLC0f8pgHYyPzNff/skV5dmJOnGk/s4PQcAAABHqTXBs1JSf2NMqjEmRNJlkhYf8pjFkq5p+flFkj6x1lpjTELLoQcyxvSR1F/S9raZDrSvt9fs1r1vrNOJ/eP12ws4fhoAAMAbHfEpbdbaZmPMLZI+lBQo6UVr7QZjzCOSMq21iyW9IGm2MSZXUpkORJEknSTpEWNMsySXpButtWXt8QcB2tJ76/bq9tfXaExKnJ67OoPjpwEAALyUsfbQl+M4KyMjw2ZmZjo9A35syfq9+tmc1RqVHKuXrx2riNDWvNQNAAAAHckYk2WtzTjS4/hna+Ag/84p0i1zVmtEYoxeInYAAAC8HsEDtPh00z7d/FqWhvSK0cvTxyqS2AEAAPB6BA8g6bMtxbrh1SwN6h6tV6aPVXRYsNOTAAAA0AYIHvi9ZbklmvlKpvolRGr2jLGK6UTsAAAA+AqCB37t441Fmv7ySqV0idCr141TbHiI05MAAADQhgge+K23Vu/WzNlZGtg9SnNnHqe4CGIHAADA1/CqbPil2V/v1EOLN2hcapz+NTVDUbxmBwAAwCcRPPAr1lr94z/b9McPN2vy4K76+xWjFBYc6PQsAAAAtBOCB37DWqs/fLBJz32+XRek99ITFw1XcCDP6gQAAPBlBA/8gsttdf+ibL2ema+p43vrN+cOUUCAcXoWAAAA2hnBA5/X5HLrtnlr9F72Xv381H6647QBMobYAQAA8AcED3xa80Gx88BZg3X9SX2cngQAAIAORPDAZ7ncVnfMX6v3svfqV2cP1nUnEjsAAAD+hldswye53FZ3LVirxWv36J4pg4gdAAAAP0XwwOe43Vb3vLFOi1bv1p2nD9BNE/s6PQkAAAAOIXjgU9xuqwfeytbCrAL9YlJ/3XJqf6cnAQAAwEEED3yGtVYPLV6vuSvy9bNT+uq2ycQOAACAvyN44BOstXr4nRy9unyXbjipj+48fSBHTwMAAIBT2uD96ptcuveNdXprzR5NPyFV9545iNgBAACAJIIHXq60ukEzZ2cpK69cd54+QD87pR+xAwAAgG8RPPBaW4uqNH3WSu2rbNDfr0jXOcN7Oj0JAAAAHobggVf6cmuJbnotS6FBgZo38zilJ3d2ehIAAAA8EMEDr/PaN3l66O0N6t81Us9fk6HEzuFOTwIAAICHInjgNVxuqz+8v1HPf7lDEwcm6G+XpysqLNjpWQAAAPBgBA+8grVWD769XnO+2aVpx6foV2cPVlAgp6oDAADghxE88ApPf5qrOd/s0g0n99F9Zw52eg4AAAC8BP9EDo+3IDNff/poiy5I76V7zhjk9BwAAAB4EYIHHu2zLcW6b1G2JvSL1+M/Ha6AAO6xAwAAgNYjeOCxsgv266ZXs9S/W5T+edUohQTxP1cAAAAcHb6DhEfKL6vVtS+vVOfwEL187RhOYwMAAMAx4dACeJyymkZd8+IKNbncmjdznLpFhzk9CQAAAF6KKzzwKHWNLs2YtVK7K+r0wjUZ6tc1yulJAAAA8GJc4YHH2F/bpJmzM7Umv0L/vHK0MlLinJ4EAAAAL0fwwCPkl9Vq2ksrlF9WpycvHakpQ7s7PQkAAAA+gOCB49bmV2jGrJVqclnNnjFW4/p0cXoSAAAAfATBA0d9tKFQt85brYSoUM2bNlb9ukY6PQkAAAA+hOCBY15etkMPv5uj4Ymxen5qhhKiQp2eBAAAAB9D8KDDudxWv3tvo15ctkOnpXXTXy9LV6eQQKdnAQAAwAcRPOhQdY0u3f76Gi3ZUKhpx6fowXPSFBhgnJ4FAAAAH0XwoMOUVDfoulmZWltQoQfPSdOMCalOTwIAAICPI3jQIbYVV+val1aqqLJe/7xyNMdOAwAAoEMQPGh3K3aUaebsTAUao3kzj1N6cmenJwEAAMBPEDxoV++s3aNfzl+rxLhOennaWCV3CXd6EgAAAPwIwYN2Ya3VM59t1+NLNmlsSpyemzpaseEhTs8CAACAnyF40ObcbquHFq/Xq8t36dwRPfXHi4YrLJhjpwEAANDxCB60Kbfb6r5F2Xo9M183nNRH90wZpACOnQYAAIBDCB60Gbfb6t5F6zQ/s0C3ntpPt582QMYQOwAAAHAOwYM28Z3YmdRft0/uT+wAAADAcQQPfjS32+qeN9ZpQVaBfjGpv24/bYDTkwAAAABJUoDTA+DdiB0AAAB4MoIHx8zltrqb2AEAAIAH4yltOCbNLrfueSNbb6wq0G2T++u2ycQOAAAAPA/Bg6NW09CsW+as0qebi3X75AH6xeT+Tk8CAAAADovgwVEpqqzX9JdXalNhlX5/wTBdMS7Z6UkAAADA9yJ40GqbC6t07UsrVFHXpOevydApA7s6PQkAAAD4QQQPWmVZbolunJ2lTiGBmn/DeA3tFeP0JAAAAOCICB4c0cKsAt37xjr1TYjUi9eOUa/YTk5PAgAAAFqF4MH3stbqyaVb9dTHWzWhX7z+cdUoRYcFOz0LAAAAaDWCB4dVVd+kuxas05INhbpodKJ+f8EwhQRx2yYAAAB4F4IH/yV3X5VumJ2lnaW1euCswbruxFQZY5yeBQAAABw1ggff8UH2Xt25YK3CggP16oxxGt+3i9OTAAAAgGNG8ECS1Oxy648fbtazn2/XyKRY/fOqUeoRw+EEAAAA8G4ED1RS3aBb567WV9tKdeW4ZD10bppCgwKdngUAAAD8aASPn8vKK9ctc1aprKZRf7xouC7OSHJ6EgAAANBmCB4/5XJbPf1prp76eKt6xobpjZuO52aiAAAA8DkEjx/aU1Gn215foxU7ynT+yJ569CdDub8OAAAAfBLB42eWrN+re97IVrPLrT9fPEIXjurFkdMAAADwWQSPn6hrdOmRd3M0d8UujUiM0VOXpSslPsLpWQAAAEC7Inj8wPrd+3Xb62u0rbhaN03sq9snD1BIUIDTswAAAIB2R/D4sKr6Jv35oy165eudio8M1aszxumEfvFOzwIAAAA6DMHjg6y1ei97rx55J0fF1Q26+rje+uXpAxXTiYMJAAAA4F8IHh+zs6RGD769Xl9sLdHQXtH619QMjUiKdXoWAAAA4AiCx0c0NLv0zH+26+n/5CokMEC/OTdNV49PUWAAJ7ABAADAfxE8Xq7Z5dai1bv114+3qqC8TucM76EHz0lTt+gwp6cBAAAAjiN4vJTLbfX2mgOhs7O0VsMTY/SHC4fpxP4JTk8DAAAAPAbB42Xcbqt3s/fqqaVbtK24RoN7HHidzuTBXbmBKAAAAHAIgsdLWGv14YYi/eXfm7WlqFoDukXqn1eO0hlDuiuA1+kAAAAAh0XweIH1u/frkXdztGJHmfokROivl6frnGE9CB0A+N/27i3GrrKMw/jzdgpF2nKQKa30QNswI9AGRMeKIVFIUQrG1guUkhBBG7kRiIeYSDCRoBciIUYDHlAQIVFALnRilCoHgyEUGUNCaKUythUapAwtljKlh2lfL/YKGYa2sxhm9l579fklk6y917dn/pO8WXu/833rG0mSRmHDU2EDO3Zz85/Xc2/fCxx/9JF89zOLWfnhuUzumNTqaJIkSVJbsOGpoN1D+/jlY5u45eF+du3dx6pzFnD10i7/cagkSZL0DtnwVMieof38Zd0WbnzgWZ7ftpOlp57IdZ86jYUzprU6miRJktSWbHhabOeeIR791wAPPPMSDz37Mjt2DdF14jTu+uISPtbtFtOSJEnSu2HD0wLbd+7lwX9uYfXal3j0uQF27d3PcUcfwbJFs7hg0SzOff8M79ORJEmSxkGphicilgE/BDqAX2Tm90acnwLcBXwI2ApckpmbinPXAquAfcA1mbl63NJX3J6h/WzaOsj6l3bw3JYdrN+yg+e2vM6mrYPsT5h1zFFc0jOXCxbPYsn899rkSJIkSeNs1IYnIjqAW4FPAJuBJyOiNzPXDRu2Cng1M0+JiJXAjcAlEXE6sBJYBJwEPBgR3Zm5b7x/kVbJTLYN7mHjK4Nv+fr3wOtsGBhkaH8CMClgfudUumdO59NnnsR5p57IGbOPdWtpSZIkaQKVmeFZAvRn5gaAiLgHWAEMb3hWANcXx/cDt0REFM/fk5m7gY0R0V98v8fHJ/7Eur53LRteGTzo+e1v7GXjwOu8tmvozecmTwrmnXA0Czuncv5pM+meOZ3umdNZOGMqRx3R0YzYkiRJkgplGp7ZwAvDHm8GPnKwMZk5FBHbgROK59eMeO3skT8gIq4ErgSYN29e2ewTbnD3EK+9sfeg56dN6WD5B05iQec0FnZOZUHnVOYc/x6XpkmSJEkVUabhOdCaqyw5psxryczbgNsAenp63na+VW767JmtjiBJkiTpXSgzFbEZmDvs8RzgxYONiYjJwLHAtpKvlSRJkqQJUabheRLoiogFEXEkjU0IekeM6QUuL44vBh7OzCyeXxkRUyJiAdAF/H18okuSJEnSoY26pK24J+cqYDWNbanvyMy1EXED0JeZvcDtwN3FpgTbaDRFFOPuo7HBwRDw5Trt0CZJkiSp2qIxEVMdPT092dfX1+oYkiRJkiosIv6RmT2jjXM7MUmSJEm1ZcMjSZIkqbZseCRJkiTVlg2PJEmSpNqy4ZEkSZJUWzY8kiRJkmrLhkeSJElSbdnwSJIkSaotGx5JkiRJtWXDI0mSJKm2bHgkSZIk1ZYNjyRJkqTasuGRJEmSVFs2PJIkSZJqKzKz1RneIiIGgP+0OscwncArrQ6htmPdaCysG42FdaOxsG40FlWrm5Mzc8ZogyrX8FRNRPRlZk+rc6i9WDcaC+tGY2HdaCysG41Fu9aNS9okSZIk1ZYNjyRJkqTasuEZ3W2tDqC2ZN1oLKwbjYV1o7GwbjQWbVk33sMjSZIkqbac4ZEkSZJUWzY8kiRJkmrLhqcQEcsiYn1E9EfENw9wfkpE3FucfyIi5jc/paqmRN18LSLWRcTTEfFQRJzcipyqltHqZti4iyMiI6LttgDV+CtTNxHxueKaszYift3sjKqeEu9T8yLikYh4qnivuqgVOVUdEXFHRLwcEc8c5HxExI+Kmno6Ij7Y7IzvlA0PEBEdwK3AhcDpwKURcfqIYauAVzPzFOAHwI3NTamqKVk3TwE9mXkGcD/w/eamVNWUrBsiYjpwDfBEcxOqisrUTUR0AdcC52TmIuArTQ+qSil5vfkWcF9mngWsBH7c3JSqoDuBZYc4fyHQVXxdCfykCZneFRuehiVAf2ZuyMw9wD3AihFjVgC/Ko7vB5ZGRDQxo6pn1LrJzEcyc2fxcA0wp8kZVT1lrjcA36HRIO9qZjhVVpm6+RJwa2a+CpCZLzc5o6qnTN0kcExxfCzwYhPzqYIy81Fg2yGGrADuyoY1wHER8b7mpBsbG56G2cALwx5vLp474JjMHAK2Ayc0JZ2qqkzdDLcK+NOEJlI7GLVuIuIsYG5m/qGZwVRpZa433UB3RDwWEWsi4lB/odXhoUzdXA9cFhGbgT8CVzcnmtrYO/3803KTWx2gIg40UzNyv+4yY3R4KV0TEXEZ0AN8fEITqR0csm4iYhKNZbNXNCuQ2kKZ681kGktMzqUxm/y3iFicmf+b4GyqrjJ1cylwZ2beHBEfBe4u6mb/xMdTm2q7z8TO8DRsBuYOezyHt0/pvjkmIibTmPY91HSf6q9M3RAR5wPXAcszc3eTsqm6Rqub6cBi4K8RsQk4G+h144LDXtn3qd9n5t7M3Aisp9EA6fBVpm5WAfcBZObjwFFAZ1PSqV2V+vxTJTY8DU8CXRGxICKOpHHTXu+IMb3A5cXxxcDD6X9tPdyNWjfF0qSf0Wh2XE8vGKVuMnN7ZnZm5vzMnE/j3q/lmdnXmriqiDLvU78DzgOIiE4aS9w2NDWlqqZM3TwPLAWIiNNoNDwDTU2pdtMLfL7Yre1sYHtm/rfVoWv6xJoAAADJSURBVA7FJW007smJiKuA1UAHcEdmro2IG4C+zOwFbqcxzdtPY2ZnZesSqwpK1s1NwDTgt8UeF89n5vKWhVbLlawb6S1K1s1q4JMRsQ7YB3wjM7e2LrVarWTdfB34eUR8lcaypCv8g+7hLSJ+Q2NpbGdxb9e3gSMAMvOnNO71ugjoB3YCX2hN0vLCmpYkSZJUVy5pkyRJklRbNjySJEmSasuGR5IkSVJt2fBIkiRJqi0bHkmSJEm1ZcMjSZIkqbZseCRJkiTV1v8BKMl5yk/81+oAAAAASUVORK5CYII=\n", "text/plain": [ "<Figure size 1008x576 with 1 Axes>" ] @@ -2138,23 +2136,138 @@ "needs_background": "light" }, "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "array([0. , 0. , 0.00058348, 0.00125031, 0.00250063,\n", + " 0.00475119, 0.00675169, 0.00916896, 0.012003 , 0.01508711,\n", + " 0.01850463, 0.02242227, 0.02583979, 0.02925731, 0.03367509,\n", + " 0.03700925, 0.04101025, 0.04467784, 0.04867884, 0.05326332,\n", + " 0.05776444, 0.06234892, 0.06726682, 0.07151788, 0.07551888,\n", + " 0.07951988, 0.08360423, 0.08877219, 0.09218971, 0.09569059,\n", + " 0.09960824, 0.10394265, 0.1089439 , 0.11327832, 0.11736267,\n", + " 0.11961324, 0.12244728, 0.12511461, 0.12836542, 0.13119947,\n", + " 0.13453363, 0.13770109, 0.14011836, 0.14486955, 0.14695341,\n", + " 0.1498708 , 0.15312161, 0.15553888, 0.15837293, 0.16104026,\n", + " 0.16395766, 0.16662499, 0.16937568, 0.17262649, 0.17512712,\n", + " 0.17671084, 0.17821122, 0.18046178, 0.18321247, 0.18471284,\n", + " 0.18621322, 0.18846378, 0.18938068, 0.19104776, 0.19238143,\n", + " 0.19404851, 0.19554889, 0.1967992 , 0.1978828 , 0.19913312,\n", + " 0.1998833 , 0.20130033, 0.20246728, 0.20305076, 0.20446778,\n", + " 0.20555139, 0.20705176, 0.20805201, 0.20913562, 0.20996916,\n", + " 0.2108027 , 0.2117196 , 0.21221972, 0.21255314, 0.21288655,\n", + " 0.21330333, 0.21347003, 0.21380345, 0.21447028, 0.2148037 ,\n", + " 0.21513712, 0.21563724, 0.21613737, 0.21638743, 0.21647078,\n", + " 0.21647078, 0.21647078, 0.21647078, 0.21647078, 0.21647078])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "x_vals = np.linspace(0, 1, 1000)\n", - "y_vals = ep(x_vals, test, 'result_Y', 'X', logreg)\n", + "x_vals = np.linspace(0, 1, 100)\n", + "y_vals = ep(x_vals, test_labeled, 'result_Y', 'X', logreg)\n", "plt.figure(figsize=(14, 8))\n", "plt.plot(x_vals, y_vals)\n", - "plt.show()" + "plt.show()\n", + "y_vals" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### COMPAS data\n", + "### On COMPAS data\n", + "\n", "\n", - "etc etc" + "#### Predictive models\n", + "\n", + "Let's build the predictive models (first here random forest and logistic regression). Some of our variables are string so they will first have to be transformed to be dummy / indicator variables." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# convert string values to dummies, drop first so full rank\n", + "compas_dummy = pd.get_dummies(compas, columns=['c_charge_degree', 'race', 'age_cat', 'score_text', 'sex'], drop_first=True)\n", + "\n", + "########\n", + "\n", + "predict_columns = ['priors_count', 'days_b_screening_arrest', 'length_of_stay',\n", + " 'c_charge_degree_M', 'race_Asian', 'race_Caucasian', 'race_Hispanic',\n", + " 'race_Native American', 'race_Other', 'age_cat_Greater than 45',\n", + " 'age_cat_Less than 25', 'score_text_Low', 'score_text_Medium', 'sex_Male']\n", + "\n", + "response_column = 'two_year_recid'\n", + "\n", + "# instantiate the model (using the default parameters)\n", + "logreg_c = LogisticRegression(solver='lbfgs', max_iter=1000)\n", + "\n", + "# fit, reshape X to be of shape (n_samples, n_features)\n", + "logreg_c.fit(compas_dummy[predict_columns], compas_dummy[response_column])\n", + "\n", + "# predict probabilities and attach to data\n", + "#label_probs_logreg = logreg_c.predict_proba(test.X.values.reshape(-1, 1))\n", + "#test = test.assign(B_prob_0_machine=label_probs_logreg[:, 0])\n", + "\n", + "########\n", + "\n", + "# instantiate the model\n", + "forest_c = RandomForestClassifier(n_estimators=300, max_depth=5, random_state=0)\n", + "\n", + "# fit, reshape X to be of shape (n_samples, n_features)\n", + "forest_c = forest.fit(compas_dummy[predict_columns], compas_dummy[response_column])\n", + "\n", + "# predict probabilities and attach to data\n", + "#label_probs_forest = forest.predict_proba(test.X.values.reshape(-1, 1))\n", + "#test = test.assign(B_prob_0_forest=label_probs_forest[:, 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1008x576 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "failures_compas = np.zeros((11, 2))\n", + "\n", + "for r in np.arange(0, 11):\n", + " ## Causal model with logistic regression\n", + " failures_compas[r, 0] = ep([r / 10], compas_dummy, response_column, predict_columns, logreg_c)\n", + " \n", + " ## Causal model with random forest classifier\n", + " failures_compas[r, 1] = ep([r / 10], compas_dummy, response_column, predict_columns, forest_c)\n", + "\n", + "# klassifikaatioille scipy.stats semin kautta error barit xerr ja yerr argumenttien kautta\n", + "\n", + "plt.figure(figsize=(14, 8))\n", + "plt.plot(np.arange(0, 11) / 10, failures_compas[:, 0], label='Causal model, log.')\n", + "plt.plot(np.arange(0, 11) / 10, failures_compas[:, 1], label='Causal model, for.')\n", + "\n", + "plt.title('Failure rate vs. Acceptance rate - COMPAS')\n", + "plt.xlabel('Leniency')\n", + "plt.ylabel('Empirical performance')\n", + "plt.legend()\n", + "plt.show()\n" ] } ],