Analysis_07MAY2019_new.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Causal-model\" data-toc-modified-id=\"Causal-model-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Causal model</a></span><ul class=\"toc-item\"><li><span><a href=\"#Notes\" data-toc-modified-id=\"Notes-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Notes</a></span></li></ul></li><li><span><a href=\"#Synthetic-data\" data-toc-modified-id=\"Synthetic-data-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Synthetic data</a></span></li><li><span><a href=\"#Algorithms\" data-toc-modified-id=\"Algorithms-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Algorithms</a></span><ul class=\"toc-item\"><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Contraction algorithm</a></span></li><li><span><a href=\"#Causal-algorithm\" data-toc-modified-id=\"Causal-algorithm-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Causal algorithm</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Predictive-models\" data-toc-modified-id=\"Predictive-models-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Predictive models</a></span></li><li><span><a href=\"#Visual-comparison\" data-toc-modified-id=\"Visual-comparison-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Visual comparison</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Causal model\n",
    "\n",
    "Our model is defined by the probabilistic expression \n",
    "\n",
    "\\begin{equation}\\label{model_disc}\n",
    "P(Y=0 | \\text{do}(R=r)) = \\sum_x \\underbrace{P(Y=0|X=x, T=1)}_\\text{1} \n",
    "\\overbrace{P(T=1|R=r, X=x)}^\\text{2} \n",
    "\\underbrace{P(X=x)}_\\text{3}\n",
    "\\end{equation}\n",
    "\n",
    "which is equal to \n",
    "\n",
    "\\begin{equation}\\label{model_cont}\n",
    "P(Y=0 | \\text{do}(R=r)) = \\int_x P(Y=0|X=x, T=1)P(T=1|R=r, X=x)P(X=x)\n",
    "\\end{equation}\n",
    "\n",
    "for continuous $x$. Model as a graph (Z is a latent variable, and can be excluded from the expression with do-calculus by showing that $X$ is admissible for adjustment):\n",
    "\n",
    "<!--- ![Model as picture](../figures/intervention_model.png \"Intervention model\") --->\n",
    "\n",
    "For predicting the probability of negative outcome the following should hold because by Pearl $P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0 | R=r, X=x)$ when $X$ is an admissible set:\n",
    "\n",
    "\\begin{equation} \\label{model_pred}\n",
    "P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0|X=x, T=1)P(T=1|R=r, X=x).\n",
    "\\end{equation}\n",
    "\n",
    "Still it should be noted that this prediction takes into account the probability of the individual to be given a positive decision ($T=1$), see second term in \\ref{model_pred}.\n",
    "\n",
    "----\n",
    "\n",
    "### Notes\n",
    "\n",
    "* Equations \\ref{model_disc} and \\ref{model_cont} describe the whole causal effect in the population (the causal effect of changing $r$ over all strata $X$).\n",
    "* Prediction should be possible with \\ref{model_pred}. Both terms can be learned from the data. NB: the probability $P(Y=0 | \\text{do}(R=r), X=x)$ is lowest when the individual $x$ is the most dangerous or the least dangerous. How could we infer/predict the counterfactual \"what is the probability of $Y=0$ if we were to let this individual go?\" has yet to be calculated.\n",
    "* Is the effect of R learned/estimated correctly if it is just plugged in to a predictive model (e.g. logistic regression)?\n",
    "* $P(Y=0 | do(R=0)) = 0$ only in this application. My predictive models say that when $r=0$ the probability $P(Y=0) \\approx 0.027$ which would be a natural estimate in another application/scenario (e.g. in medicine the probability of an adverse event when a stronger medicine is distributed to everyone. Then the probability will be close to zero but not exactly zero.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as scs\n",
    "import scipy.integrate as si\n",
    "import seaborn as sns\n",
    "import numpy.random as npr\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# Settings\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "plt.rcParams.update({'font.size': 16})\n",
    "plt.rcParams.update({'figure.figsize': (14, 7)})\n",
    "\n",
    "# Suppress deprecation warnings.\n",
    "\n",
    "import warnings\n",
    "\n",
    "def fxn():\n",
    "    warnings.warn(\"deprecated\", DeprecationWarning)\n",
    "\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\")\n",
    "    fxn()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Synthetic data\n",
    "\n",
    "In the chunk below, we generate the synthetic data as described by Lakkaraju et al. The default values and definitions of $Y$ and $T$ values follow their description.\n",
    "\n",
    "**Parameters**\n",
    "\n",
    "* M = `nJudges_M`, number of judges\n",
    "* N = `nSubjects_N`, number of subjects assigned to each judge\n",
    "* betas $\\beta_i$ = `beta_i`, where $i \\in \\{X, Z, W\\}$ are coefficients for the respected variables\n",
    "\n",
    "**Columns of the data:**\n",
    "\n",
    "* `judgeID_J` = judge IDs as running numbering from 0 to `nJudges_M - 1`\n",
    "* R = `acceptanceRate_R`, acceptance rates\n",
    "* X = `X`, invidual's features observable to all (models and judges)\n",
    "* Z = `Z`, information observable for judges only\n",
    "* W = `W`, unobservable / inaccessible information\n",
    "* T = `decision_T`, bail-or-jail decisions where $T=0$ represents jail decision and $T=1$ bail decision.\n",
    "* Y = `result_Y`, result variable, if $Y=0$ person will or would recidivate and if $Y=1$ person will or would not commit a crime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set seed for reproducibility\n",
    "#npr.seed(0)\n",
    "\n",
    "def generateData(nJudges_M=100,\n",
    "                 nSubjects_N=500,\n",
    "                 beta_X=1.0,\n",
    "                 beta_Z=1.0,\n",
    "                 beta_W=0.2):\n",
    "\n",
    "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
    "    judgeID_J = np.repeat(np.arange(0, nJudges_M, dtype=np.int32), nSubjects_N)\n",
    "\n",
    "    # Sample acceptance rates uniformly from a closed interval\n",
    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
    "    acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
    "\n",
    "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
    "    acceptanceRate_R = np.repeat(acceptance_rates, nSubjects_N)\n",
    "\n",
    "    # Sample the variables from standard Gaussian distributions.\n",
    "    X = npr.normal(size=nJudges_M * nSubjects_N)\n",
    "    Z = npr.normal(size=nJudges_M * nSubjects_N)\n",
    "    W = npr.normal(size=nJudges_M * nSubjects_N)\n",
    "\n",
    "    probabilities_Y = 1 / (1 + np.exp(-(beta_X * X + beta_Z * Z + beta_W * W)))\n",
    "\n",
    "    # 0 if P(Y = 0| X = x; Z = z; W = w) >= 0.5 , 1 otherwise\n",
    "    result_Y = 1 - probabilities_Y.round()\n",
    "    \n",
    "    # For the conditional probabilities of T we add noise ~ N(0, 0.1)\n",
    "    probabilities_T = 1 / (1 + np.exp(-(beta_X * X + beta_Z * Z)))\n",
    "    probabilities_T += npr.normal(0, np.sqrt(0.1), nJudges_M * nSubjects_N)\n",
    "\n",
    "    # Initialize decision values as 1\n",
    "    decision_T = np.ones(nJudges_M * nSubjects_N)\n",
    "\n",
    "    # Initialize the dataframe\n",
    "    df_init = pd.DataFrame(np.column_stack(\n",
    "        (judgeID_J, acceptanceRate_R, X, Z, W, result_Y, probabilities_T,\n",
    "         decision_T)),\n",
    "                           columns=[\n",
    "                               \"judgeID_J\", \"acceptanceRate_R\", \"X\", \"Z\", \"W\",\n",
    "                               \"result_Y\", \"probabilities_T\", \"decision_T\"\n",
    "                           ])\n",
    "\n",
    "    # Sort by judges then probabilities\n",
    "    data = df_init.sort_values(by=[\"judgeID_J\", \"probabilities_T\"],\n",
    "                               ascending=False)\n",
    "\n",
    "    # Iterate over the data. Subject is in the top (1-r)*100% if\n",
    "    # his within-judge-index is over acceptance threshold times\n",
    "    # the number of subjects assigned to each judge. If subject\n",
    "    # is over the limit they are assigned a zero, else one.\n",
    "    data.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    data['decision_T'] = np.where(\n",
    "        (data.index.values % nSubjects_N) <\n",
    "        ((1 - data['acceptanceRate_R']) * nSubjects_N), 0, 1)\n",
    "\n",
    "    return data\n",
    "\n",
    "\n",
    "df = generateData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25000, 8)\n",
      "(25000, 8)\n",
      "(25000, 8)\n",
      "(25000, 8)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>decision_T</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>result_Y</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0.0</th>\n",
       "      <td>3911</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>8759</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "decision_T     1\n",
       "result_Y        \n",
       "0.0         3911\n",
       "1.0         8759"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split the data set to test and train\n",
    "from sklearn.model_selection import train_test_split\n",
    "train, test = train_test_split(df, test_size=0.5, random_state=0)\n",
    "\n",
    "print(train.shape)\n",
    "print(test.shape)\n",
    "\n",
    "train_labeled = train.copy()\n",
    "test_labeled = test.copy()\n",
    "\n",
    "# Set results as NA if decision is negative.\n",
    "train_labeled.result_Y = np.where(train.decision_T == 0, np.nan, train.result_Y)\n",
    "test_labeled.result_Y = np.where(test.decision_T == 0, np.nan, test.result_Y)\n",
    "\n",
    "print(train_labeled.shape)\n",
    "print(test_labeled.shape)\n",
    "\n",
    "tab = train_labeled.groupby(['result_Y', 'decision_T']).size()\n",
    "tab.unstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algorithms\n",
    "\n",
    "### Contraction algorithm\n",
    "\n",
    "Below is an implementation of Lakkaraju's team's algorithm presented in [their paper](https://helka.finna.fi/PrimoRecord/pci.acm3098066). Relevant parameters to be passed to the function are presented in the description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contraction(df,\n",
    "                judgeIDJ_col,\n",
    "                decisionT_col,\n",
    "                resultY_col,\n",
    "                modelProbS_col,\n",
    "                accRateR_col,\n",
    "                r,\n",
    "                binning=False):\n",
    "    '''\n",
    "    This is an implementation of the algorithm presented by Lakkaraju\n",
    "    et al. in their paper \"The Selective Labels Problem: Evaluating \n",
    "    Algorithmic Predictions in the Presence of Unobservables\" (2017).\n",
    "    \n",
    "    Parameters:\n",
    "    df = The (Pandas) data frame containing the data, judge decisions,\n",
    "    judge IDs, results and probability scores.\n",
    "    judgeIDJ_col = String, the name of the column containing the judges' IDs\n",
    "    in df.\n",
    "    decisionT_col = String, the name of the column containing the judges' decisions\n",
    "    resultY_col = String, the name of the column containing the realization\n",
    "    modelProbS_col = String, the name of the column containing the probability\n",
    "    scores from the black-box model B.\n",
    "    accRateR_col = String, the name of the column containing the judges' \n",
    "    acceptance rates\n",
    "    r = Float between 0 and 1, the given acceptance rate.\n",
    "    binning = Boolean, should judges with same acceptance rate be binned\n",
    "    \n",
    "    Returns:\n",
    "    u = The estimated failure rate at acceptance rate r.\n",
    "    '''\n",
    "    # Sort first by acceptance rate and judge ID.\n",
    "    sorted_df = df.sort_values(by=[accRateR_col, judgeIDJ_col],\n",
    "                               ascending=False)\n",
    "\n",
    "    if binning:\n",
    "        # Get maximum leniency\n",
    "        max_leniency = sorted_df[accRateR_col].values[0].round(1)\n",
    "\n",
    "        # Get list of judges that are the most lenient\n",
    "        most_lenient_list = sorted_df.loc[sorted_df[accRateR_col].round(1) ==\n",
    "                                          max_leniency, judgeIDJ_col]\n",
    "\n",
    "        # Subset to obtain D_q\n",
    "        D_q = sorted_df[sorted_df[judgeIDJ_col].isin(\n",
    "            most_lenient_list.unique())].copy()\n",
    "    else:\n",
    "        # Get most lenient judge\n",
    "        most_lenient_ID = sorted_df[judgeIDJ_col].values[0]\n",
    "\n",
    "        # Subset\n",
    "        D_q = sorted_df[sorted_df[judgeIDJ_col] == most_lenient_ID].copy()\n",
    "\n",
    "    # All observations of R_q have observed outcome labels\n",
    "    R_q = D_q[D_q[decisionT_col] == 1]\n",
    "\n",
    "    # \"Observations deemed as high risk by B are at the top of this list\"\n",
    "    R_sort_q = R_q.sort_values(by=modelProbS_col, ascending=False)\n",
    "\n",
    "    number_to_remove = int(\n",
    "        round((1.0 - r) * D_q.shape[0] - (D_q.shape[0] - R_q.shape[0])))\n",
    "\n",
    "    # \"R_B is the list of observations assigned to t = 1 by B\"\n",
    "    R_B = R_sort_q[number_to_remove:R_sort_q.shape[0]]\n",
    "\n",
    "    return np.sum(R_B[resultY_col] == 0) / D_q.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Causal algorithm\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x, model, class_value):\n",
    "    '''\n",
    "    Parameters:\n",
    "    x = individual features\n",
    "    model = a trained sklearn predictive model. Predicts probabilities for given x.\n",
    "    class_value = the result (class) to predict (usually 0 or 1).\n",
    "    \n",
    "    Returns:\n",
    "    The probabilities (as vector) of class value (class_value) given \n",
    "    individual features (x) and the trained, 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[:, model.classes_ == class_value].flatten()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance comparison\n",
    "\n",
    "Below we try to replicate the results obtained by Lakkaraju and compare their model's performance to the one of ours.\n",
    "\n",
    "### Predictive models\n",
    "\n",
    "Lakkaraju says that they used logistic regression. We construct the models using only *observed observations*, i.e. observations for which labels are available. We then predict the probability of negative outcome for all observations in the test data and attach it to our data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instantiate the model (using the default parameters)\n",
    "logreg = LogisticRegression(solver='lbfgs')\n",
    "\n",
    "# fit, reshape X to be of shape (n_samples, n_features)\n",
    "logreg = logreg.fit(\n",
    "    train_labeled.X[train_labeled.decision_T == 1].values.reshape(-1, 1),\n",
    "    train_labeled.result_Y[train_labeled.decision_T == 1])\n",
    "\n",
    "# predict probabilities and attach to data\n",
    "label_probs_logreg = logreg.predict_proba(test.X.values.reshape(-1, 1))\n",
    "\n",
    "test = test.assign(B_prob_0_logreg=label_probs_logreg[:, 0])\n",
    "test_labeled = test_labeled.assign(B_prob_0_logreg=label_probs_logreg[:, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train model for predicting the probability of positive decision with a given\n",
    "# leniency r  and indivual features x.\n",
    "\n",
    "# Instantiate the model (using the default parameters)\n",
    "decision_model = LogisticRegression(solver='lbfgs')\n",
    "\n",
    "# fit, reshape X to be of shape (n_samples, n_features)\n",
    "decision_model = decision_model.fit(train[['X', 'acceptanceRate_R']],\n",
    "                                    train.decision_T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visual comparison\n",
    "\n",
    "Let's plot the failure rates against the acceptance rates using the difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1wAAAH/CAYAAABD8tytAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XmczdX/wPHXe8bsBsNgLNkZa6RRYx/rIJSEMKTfV0mbpVKImUERiSgUhShTaSFKq7GOkKWsJfue7IxhZs7vj8+d2yx3zB1mw/v5eNwH93zO53zen8+51+O+nfM5HzHGoJRSSimllFIq67nkdgBKKaWUUkopdbvShEsppZRSSimlsokmXEoppZRSSimVTTThUkoppZRSSqlsogmXUkoppZRSSmUTTbiUUkoppZRSKptowqWUUhkQkTEiYkSkUbKylrayV3MzNqWUUkrlbZpwKaVuCyJSzpYApfc6m9sx3i7u5GRTRL63nfuW3I4lK93JfZoVRGS1iMTndhxKqbwpX24HoJRSWWw3EOWg/MpNtDkZmA8cuIk21C1OREoDLQED1BaRe4wxm3M5LKWUUnmcJlxKqdvNLmNMRFY2aIw5BZzKyjbVLakP1syQicALwP8Bz+VmQEoppfI+nVKolLrjiIiHiAwQkZ9E5IiIXBWRoyIyX0QqOqif5h6udNqtZKs3y9ltInJYRPaISBEReV9EjolIYqr7xSqLyNxksR4SkXdExN/J881nO/ZPIlJWRKJE5B9bWWlbnc4i8pmI7BWRKyJyRkR+FJHmqa8F8KPt7ehkUzbjU9UrYYtxn4jEichxEflIRMo6Ea+IyAFbjG7p1PnbFqO77b2XiLwiIttE5KKInBORXSLyoYiUcOY6OaEPcAYYDuwFeoiIx3XOo6WILLWdxxUR2S8i80SkRqp6hUTkNRHZISKxInJaRH4VkcHptPmdrc4V2z5DRCRfqnp9bf0SJiKPisgWW9tHRGSCiHgnq5thn4pIPRGZZjveBRG5JCK/ichTDmJM/nkrYfte/Ssil0XkFxGpk871qiIis0XkoO0zc0xElonIA6nquYjIUyKy3tbXF0VkjYg8mF5fODiW/TstIv1E5Hfb9Zxl215aREaLyAYROWWL5y8RGS8i+VOfK9AQcJWU05hfTXXMriKywvbZjBWRTSLS19mYlVK3Lh3hUkrdiYpijVKsABYD54GqwKNAWxGpa4zJyemDnkA01n+CfQ64ARcAxEq8vgU8gEXAfqAa8DTQWkTuM8Y4e39aUSAGOAzMA/yAa7Zt44CLWNfkBFACeAj4UUQeNsYsstX7BSgD9AKWAytt5YlJBxGRQNv5FAOWAgtt+3QHQkUk2BizL70gjTFGRD4BXgFa29qwE5FgoAIw0xhz1Vb8iS3eVcD3trJyQGfgfeBYRhfnekSkKVAReM8YEyci84GRwIPAZw7qDwHeAM4BX9uOfxfWlMRfge22eiVsMVe0lU8FvIBatvN/K1mbA23vT9raPAM0sR2nHtDFQejdgRZY02yXAaHAi0AdEQk1xiTiRJ8C/Wz7rgS+AQrY3k8XkUrGmBcdHLswsMYW71ys/ugE/CIiVY0xJ5OdWzNbu57AEmAn4A/UBx7H9hkQERes690Z2AbMwfrePAB8LSLPGWPecRBLeoYDDWzH/g44aisPAQYAP9vOwQDBwEtAYxFpbIyJt12jSKzRztLAqGRtJ11HRGQSMBDYh9UXV4BWwEwRCTTGvJSJmJVStxpjjL70pS993fIvrB9zBtgFRDh4VU1W1xMo4aCN5kACMCNV+Rhb242SlSXdy/NqsrJKtrJZDtp2uA0r+TFYP6DdU23zAA4B/wKBqbZ1t+032Ylrk89W1wDvAOKgTnkHZSWwfoDuSlWe5txTbV+P9YOyYaryRkA88LUTMde0HeMTB9um2rY1sb0vYnv/mYO6XoBPFny+5tiO0dD2vrLt/XcO6gZh/RDfAwSk2uYGFEv2frGtnZcctFM62d/vtl27NUCBZOUCTLe18VCy8r62ssRUn1sXrOTCAL0z0adlARcHn6sfbXGVTlWe9Hl7K/nnDRid+nxtfXQcuJr6M2PbXirZ35+x7f928niA/MBG2+cuwNE5pGoz6Tt9BqjiYHsxwNtBeYRtv0dTla8G4tM51gO2fRYCHsnK3ZP1xT03+xnVl770lXdfOqVQKXW7CQTCHbyqJlUwxlwxxqQZ8TDG/IK16EbLnAk1hZfNf6M1SR7E+l/z0caY3ck3GGMWAFuxRuWcFYv1g9qk3mAcjDjZrtHXQKDYph5mRETuwxptmWGMWZOqvdVYoxftk0/LcsQYsw34HegoIj7J2s8HdAMOYo0MgfWDNen8UrcTa4y55Ezs6RERX+ARYF/SORlj/sIakWotIqVS7dIPKxF6xRhzPFU814xtZMd2TTsAf2CNuKaO/XCyt08BrsAzxpjzyeoYYJjtraPPwre2655UPxFrVAcg7HrnnSqWA7Z9k5fFAzNtcYU42O0CaT9vc2x/BiUrexgoDryf+jNjO86RZG+fwbqf8sXk8RhjLmIlUR5YI53OmmGM+dPBMU8aYy47qD/N9mdm/o14Bivx7WeMiUt2jKvACNvbbploTyl1i9EphUqp280iY0yGP7hEpB7W9KCGWP+bnfzfQ0c/tLLTxdQJlc39tj/vFpEIB9s9gOIiUsg4N63w7/Tq2aa2DcOaJnYX1ihgciWwRuMykhRzmXRiLo71A70SkNHS6vOB8Vg/oD+2lbXCmho5LumHvDHmtIj8BPQW6x6xRVjJ2GZjTIITMWekK+Bjiye5eVjn+xjwerLyerY/f8ig3aSk46fUyYwD92ONvnYSEUef7ysk+0+FZFanLjDG/C4i54HaGRzTTkQ8sabYdQWqYI0oJefoPrndDpKWpOSpULIyp66XiBTAmk67DxguIqmrFLf96eg6pGfjdY7XDXgSqGOLN/l/UmfmvsD7saaWPucg5qR7ADMTs1LqFqMJl1LqjmO7HydpKtT3WFO/LmONlPwfUDKHQzqZTnlh25+PZ7C/D+BMwuXwOCJSFNiAdd4rse5lOYf1v/LNgcb898MwI0kxd7K90uNznW1JFmDdW9aD/xKunrY/Uyc/nbDuqerOf/c9/SMibwFvOBrVy4Sk65/6mJ8Ck7AW00iecBUELiUfiUpHQdufR69by1IYK1EdeZ06jq7pP+nUPYk1euqsr7GS8R1Y98v9g/X9qYB175ejz8c5B2VJC3G4Jitz9jr42f4sjzVqnR5nPltJ0vtODMXq0xNY91AeBuKwkq4ROP99ACtuIetiVkrdYjThUkrdiYZh3UvTyBizPvkGEenpeBenJI1SuDrYVuA6+6WXDCT9YG9mjIm+0aCcOE5foBQwxBgzIfkG23S5xpk4RlLMjxtj5mQ6wmSMMYdFZCXWtD1/rKT4IWCrMWZ7qroXgSHAENuiHS2A54GxwCWs+74yTUSqYI2CAux2MEIBUNm2iELSFMezQDkRKZBB0pWUJDuT4J/HWuDExxhzLaPKyRRNp7wY//XVdYlIfaxkawnwYPLRONv3pVcm4nHE2euQFO8KY0zITR4zSZrvhFgrXw7Dun+yjjHmdLJtpfhvGqCzLgBnjDHlbiJOpdQtTO/hUkrdiSoCJxwkWyWxFt+4UUk/HFPf0wNwzw20lxRf8I2F47SkpfC/SV4oVnZR30H9pGl6jhLLrI75Y6z/HOyKlWw5mtqXgjFmtzFmGtDGVtTxJo6fNLr1C/CBg9c3qeqBNVoI1gqL17MR6wd/C9vqe9ezHus/Ce51Lmy7NI8yEJG7sf4DYGuy4uv1adLnY6mDqY8NU1e+AU5dL2PMGazR6FqSbFn7bFAMa8rk2uTJlk1655uA7YkGDratx5pim9Mj50qpPEITLqXUneggUNQ2egFYz+bCWsHvhkf+bT/O9gNNJdnzpkSkOP8tbJAZX2JNsxomIkGpN4qIt4jcn3a3TDto+zP1j8kXgRqklfQj1FFiuRbYBPQVkXapN4qIm2TwPLNUPseaytXT9krEmmqYvM3iIuIoEUm6pyc2WV1vEakqIndldGARcQV6Y02D626M6Zv6hbUU+xmgS7KFQN6zxTlORAJStZlPRIqBfTGIb7BWIHT0zK3k13earc1pqdu01Q0QEUf3AbWTlM90cwFes71Nnrher08dfj5EpCHwPwf1M+srrKl7T4pIg9QbUyUqU7GmV74jDp6BJiI1xcnn011H0oqJ99ruXUsex2vp7HMa6zeVo3u7pmJNKfzAdh9a6pgriBPPp1NK3bp0SqFS6k70DtAMiBGRT7F+yLbE+sH0B1D9JtqebHutE5GFWEted8RaxKFCZhoyxsSKSBese0h+FZEfsO6hccO6j6Up1j1X7W8iXrCekfQS1jOVWmAleUmrDX4LpE6cdmDd+9JTRK7Y6icaY8YbY4yIPIr1PKeltimBW7CucVms6YknsJZ9z5Ax5pyILMW6RysRiE61ah1Yi3xsEJEttmMdw5qe1gkrWZqSrG4DrPv3fibjleZCbe0sMsmeGZUqvjgRWYD1XLQuwGxjzG8iMgzr/rNdIvIl1o/4UrZjjsX6DIK1+mBNYIKIdMb6nHhgJbq1sCWNxpjNIjIAazn0P0XkW6zkvjDWEvWNsZ7btStViN9hPUvtU1sMrbFGW38iZcKVbp9iJdGbgTBb0vEb1qhXR6xl7R/O4Dpel+1z3h1ryuJKEVlii6cI1kjpX1irRIJ13RpgjSg2F5HlWJ+nkliJa22sz+2pm4gnXkTeA54DNtuudWGsFSWjsRZ8SW051gjs5yLyPVbCttIYs9YYs1hEJmB9x/bYvseHsUbSqmEtqtEVyMln/ymlclJurUevL33pS19Z+eK/53Bl+IwnW/3uWD/OL2P9EP0Q6wdQmufp4ORzuJJtewHYi/Wj60+se4mSntvk6DlcezKItSzWCMderNGe01hLpr8NBDlxrknPRfrpOnXuxUpCztpe39nK0py7rX4j27W6ZNue+poVxXog706sEabztr/PwronLTN9+zD/PdfpcQfb/bCej7TK1pdxWKMyC4F6qeom9Vu61yJZ3c9J9XyrdOoF2eqtSlXeBmtRljNYqwjuAz4CqqWqV9h2rf6yxf4vsA4Y4OBYDYEv+G8U5jjWw6xfJeWzsJKewxWGtVz8FlsMR4E3cfyMqXT7FAiwxX4M6zuz0dauo+fRpft5y2BbNayVH4/Zzu0oVsLfNlU9wbpvLNr2Wb2Clawsw1qSP825OTiWw891su0ets/UHlv7e7AWLPFyFD/WM7UmYX2f41NfE1udB7C+V6ds53fEdg6DgSKZ+U7oS1/6urVeYszNLNyklFJKqbxGRPpiPSOrlzHmuve8KaWUyl56D5dSSimllFJKZRNNuJRSSimllFIqm2jCpZRSSimllFLZRO/hUkoppZRSSqlsoiNcSimllFJKKZVN9DlcDvj7+5ty5crldhgAXLp0CR8fn9wOQ6Wi/ZL3aJ/kTdoveY/2Sd6k/ZL3aJ/kTXmpX3777bdTxpiiGdXThMuBcuXKsXHjxtwOA4Do6GhCQkJyOwyVivZL3qN9kjdpv+Q92id5k/ZL3qN9kjflpX4REaceWK5TCpVSSimllFIqm+R4wiUid4nIQhE5JyLnReRLESlzA+0MFREjIqsdbHOxbd8vIldEZKuIdM6aM1BKKaWUUkop5+RowiUi3sAvQFXgMaAXUBlYLiJOT8YUkQrAcOBkOlVGAxHAO0BbYB3wuYi0u+HglVJKKaWUUiqTcvoerieACkCgMWYPgIj8DvwF9APecrKd6cDHQCCpzkFEigEvAuOMMW/aipeLSCVgHPDtzZ6EUkoppZRSSjkjp6cUdgTWJSVbAMaYfcAa4EFnGhCRHkBdYGg6VUIBd2B+qvL5QC0RKZ/ZoJVSSimllFLqRuR0wlUD2OagfDtQPaOdRcQPmAQMMcacvs4x4oA9qcq32/7M8DhKKaWUUkoplRVyekphYeCMg/LTgJ8T+08A/gTmZHCMs8YY4+AYSdvTEJEngScBihcvTnR09HUDcXV1xcfHBxHJOOqbUKBAATZv3pytx1CZp/3iHGMMly5dIiEhIduPdfHixQy/tyrnab/kPdoneZP2S96jfZI33Yr9khvP4UqdCAFkmLWISGOgN1DXQTKVuq1MH8MY8z7wPkBQUJC53vr+58+f58SJE5QqVQovL69sTbouXLiAr69vtrWvboz2S8aMMcTGxnLkyBGKFy9OgQIFsvV4eem5HOo/2i95j/ZJ3qT9kvdon+RNt2K/5PSUwjM4HmHyw/HIV3LvAR8Ah0WkkIgUwkoYXW3vPWz1TgN+kjYL8ku2/aacPHmSUqVK4e3tne0jXErdqkQEb29vSpUqxcmT6S0oqpRSSil1e8vphGs71j1WqVUHdmSwbzXgKazELOnVEAi2/b1/smN4ABUdHAMnjpOha9eu4eXldbPNKHVH8PLy4tq1a7kdhlJKKaVUrsjphGsxEGx7jhYAIlIOK3FanMG+zRy8tmItwtEMWGirtwy4CvRMtX8YsM22KuJN05EtpZyj3xWllFJK3cly+h6umcCzwCIReRXrXqvRwCGsKYMAiEhZ4G9glDFmFIAxJjp1YyJyFsiXfJsx5qSITAKGisgFYBPQDWiOk0vPK6WUUkoppVRWyNGEyxhzSUSaYy3tPg9rIYufgYHGmIvJqgrgyo2PwA0HLgIDgABgN9DVGPPNjcaulFJKKaWUUpmV01MKMcYcNMZ0NsYUMMb4GmMeMsbsT1VnvzFGjDERGbQVYoxp5KA8wRgzxhhT1hjjYYy52xiz0FEbdzoRyfBVrly53A4TgFdeeSXdGIODg7PlmLt27UJEiIqKypb2ARYuXMiUKVPSlC9btgwRYd26ddl2bKWUUkoplb1yY1l4lYfExMSkeN+pUydq165NRESEvczDw4O8wtXVldWrV6cpv5WXaF+4cCEbN27k+eefT1Fev359YmJiqFmzZi5FppRSSimlbpYmXHe41CNDHh4e+Pv7Oz1iFBcXl+MJWXaNZuU1BQsWvGPOVSmllFLqdpXjUwrVrevRRx+lUqVKrFy5kuDgYLy8vBg5ciRXrlxBRBg3blyK+ulNx/vpp58ICQkhf/785M+fnwceeICdO3dmSYwfffQRIsKff/6ZZluzZs1SJDCTJk0iODgYPz8//Pz8aNiwIT/88EOGxwgODqZTp05pygMCAnjqqafs748dO8YTTzxB5cqV8fb2pkyZMvTu3Zvjx4/b6zz66KN8+umn/P333/bpkVWrVgUcTylMTExk/PjxVK5cGXd3d0qVKsWAAQO4dOmSvU5Sf4wZM4aJEydStmxZfH19adGiBbt3787w/JRSSiml8qJ9Z/ZhjMntMDJNEy6VKadOnaJXr1707t2b7777jkceeSRT+3/55ZeEhobi7+/PJ598wrx58/jnn39o0qQJx44dc6qN+Pj4NK/ExEQAOnfujI+PD/Pnz0+xz6FDh1i5ciW9evWylx04cIB+/frxxRdfsGDBAmrWrEmbNm1Yvnx5ps4pPadOncLX15c33niDZcuWMW7cOP744w+aNGlify7VmDFjaNmyJaVLlyYmJoaYmBg+/fTTdNt88cUXefnll2nfvj1Llixh0KBBzJw5k44dO6b5B2jWrFn88ssvvPPOO8yaNYs///yTTp062a+VUkoppdStYPep3fT8sicVp1Rk09lNuR1OpumUwiwycNlAthzfkuXtJiQk4Orq6lTdOgF1mNxmcpbHkNy5c+f49NNPCQ0NtZdduXLFqX0TExMZMGAAoaGhLFz43xomTZs2pUKFCrz99ttpRslSS0hIwM3NLU35Cy+8wJtvvomPjw+dOnVi/vz5REZG2p8B9fHHH+Pq6kq3bt3s+0ye/N+1SkxMpGXLluzcuZMZM2bQrFkzp87pemrVqsVbb71lfx8fH0+9evWoUqUKP/30E23btqVSpUoUKVIEDw+PDKcPHj9+nKlTp9KvXz8mTZoEQOvWrSlUqBBPPPEEP/74I61bt7bX9/HxYfHixfbPz7Vr1+jVqxdbtmyhbt26N31+SimllFLZ6a9//2L0ytF8/MfHeObz5KUGL1HRVMztsDJNR7hUpnh7e6dItjJj+/btHD58mLCwsBSjUwUKFKBevXqsXLkywzZcXV3ZsGFDmtfAgQPtdXr16sW+fftYs2aNvWz+/Pm0a9cOf39/e9mvv/5K27ZtKVasGK6urri5ubFq1aosm3ZnjGHKlCnUqlWL/Pnz4+bmRpUqVQBu6Bhr164lPj6esLCwFOU9e/ZERFixYkWK8tDQ0BTJeq1atQA4ePBgpo+tlFJKKZVT/j79N32+7kO1d6uxcMdCBgcPZt+AfbzR6g0KuRfK7fAyTUe4skh2jSxduHAhT63AFxAQcMP7njx5ErAShJ49e6bZnpSMZCQoKOi621u2bEnJkiWZN28ejRo1YtOmTWzfvp3IyEh7nb1799KyZUvq1q3LtGnTKF26NPny5ePll1/myJEjmTir9L355pu8/PLLDBkyhBYtWlCoUCFiY2Np2rSp06OCyZ0+fRqAEiVKpCj38vKiQIEC9u1JChcunOJ90uImN3JspZRSSqnstu/MPsasHMPcrXNxc3Xj+fufZ0jDIQTkv/Hfn3mBJlwqU5Km6CXn5uaGq6srV69eTVH+77//pnhfpEgRACZOnEiTJk3StOPp6ZklMbq4uNCjRw8++OADpkyZwvz58/Hz86N9+/b2OkuXLuXixYt88cUXKUa9Ll686KjJNHEm3YOVJDExkbNnz6Yoi4qKol27dimmSd7M4iBJCdTx48epWPG/4fTY2FjOnz9vv75KKaWUUreS/Wf389rK15izdQ6u4soz9Z7hlUavUMK3RMY73wI04VI3zdXVlVKlSrFt27YU5UuXLk3xvlatWpQsWZKdO3cyePDgbI2pd+/evPnmmyxatIgFCxbQtWvXFMvXX758GYB8+f77Cmzbto2NGzdSuXLl67ZdtmxZfvjhhxT31/3000/ExcWlqHf58uU095vNnj07TXseHh7ExsZmeE4NGjQgX758REVF0bBhQ3v5J598gjGGpk2bZtiGUkoppVRecfDcQV5f9Tofbv4QEeGpe5/ilUavUKpAqdwOLUtpwqWyxKOPPspbb73FG2+8QVBQEMuXL+fzzz9PUcfV1ZV33nmHLl26cPnyZTp37kyRIkU4fvw4a9asoUqVKjz77LMZHiv5MulJ3NzcuPfee+3va9WqRe3atRk8eDDHjx9PsTohWItNDBs2jLCwMAYMGMDhw4cJDw+nTJkyTp3rRx99RN++fenZsyd79uxhypQp+Pj4pKjXpk0bpk6dyvjx46lbty7ff/89X3/9dZr2qlevzkcffcQHH3zA3Xffjbe3NzVq1EhTLyAggOeee47Jkyfj6elJ69at+f333xk5ciTNmzenZcuWGcaulFJKKZXbDp8/zNhVY5m5aSYAfev2ZWijodxV8K5cjix7aMKlskR4eDgXLlxg0qRJXL58mQ4dOjBnzhwaNWqUol6nTp1Yvnw5r7/+Ov/73/+IjY2lRIkS1K9fP81iEI4kJCRQv379NOVFihTh1KlTKcp69erFiy++SIUKFVKMCAHcc889zJ07l1GjRtGhQwcqV67MpEmT+Pzzz9my5fqrTbZt25bx48czY8YMoqKiCAoKYsGCBWkWExk9ejQXL15kwoQJxMXF0bx5c5YuXUpgYGCKev3792fjxo288MILnDt3jsDAQHbt2uXw2G+++SYBAQHMnDmTt99+G39/f/r27cvrr7/ucLqnUkoppVRecfTCUcauGsv7m94n0STyv3v+x7DGwyhTMOP/8L6Vya348LDsFhQUZDZu3Jju9p07d1KtWrUciSWvLZqhLNovmZMT35no6GhCQkKy9Rgq87Rf8h7tk7xJ+yXv0T7JOscuHOONNW8wY+MMEkwCfWr3YXiT4ZQrVC7TbeWlfhGR34wx11/NDR3hUkoppZRSSmWDExdP8MaaN5i+cTrXEq7xWO3HGN5kOBX8KuR2aDlKEy6llFJKKaVUljl56SQT1kzg3Q3vEpcQR6+7e/Fqk1epVLhSboeWKzThUkoppZRSSt20U5dPMWHNBN7Z8A5X4q/Qs1ZPRjQZQeUi118B+nanCZdSSimllFLqhv17+V8mxkxk6vqpXLp6ie61ujOyyUgC/QMz3vkOoAmXUkoppZRSKtNOx57mrZi3mPLrFC5evUjXGl0Z2XQk1YtWz+3Q8hRNuJRSSimllFJOO3vlLJNiJjH518mcjztPl+pdCG8aTo1iaZ8jqjThUkoppZRSSjnh3JVzTF43mUnrJnEu7hwPV3uY8Kbh3F387twOLU/ThEsppZRSSimVrvNx55ny6xQmxkzk7JWzPFT1IcKbhlMnoE5uh3ZL0IRLKaWUUkoplcaFuAtMXT+ViTETOR17mg5VOhAREkHdEnVzO7RbiiZcSimllFJKKbuLVy/y7vp3mbB2Av/G/ssDlR8gIiSCoJJBuR3aLckltwNQuW/OnDmICHv27LnptkJCQmjUqFEWRGXp06cP5cqVy7L2IiIiEJEsay8zx/3ll19y/LhKKaWUUs66dPUSb659k/Jvl+eVn1+hXql6/Nr3V5b0WKLJ1k3QhEupHBAZGakJl1JKKaXypMvXLvNWzFtUmFKBl358ibol6rL2/9byXc/vuK/Ufbkd3i1PpxQqpZRSSil1B4q9Fsv7v73PuDXjOH7xOC3KtyAyJJKGZRrmdmi3FR3hUk7ZsGEDjzzyCKVLl8bLy4vAwECGDRtGbGysw/qLFi2iZs2aeHh4ULVqVT777LM0dbZu3UrHjh3x8/PDy8uLhg0bsmrVqgxjuXz5Mi+//DLly5fH3d2d8uXL89prr5GYmJii3ubNm2ncuDGenp6UKlWK0aNHY4xx6nyvXbvGq6++Srly5XB3d6dcuXK8+uqrXLt2zV4nOjoaESE6OjrFvklTNPfv3w9gn8L42muvISKICBEREfb6K1asoFWrVhQsWBAfHx9q167NBx98kKlY9u/fj4gwY8YMhg4dSkBAAL6+voSFhXH58mX27NlDaGgo+fMjyPq7AAAgAElEQVTnp1KlSsydOzfNOTvTHxs2bKBVq1YUKVIEb29vKlSowNNPP+3UNVVKKaVU3nAl/gpTf51KxSkVGfj9QKr5V2Nln5X81PsnTbaygY5wKaccPHiQOnXq0KdPH3x9fdm+fTujRo1i7969REVFpai7Z88enn/+eSIiIihWrBjTp0/n0UcfpWjRojRr1gyATZs20bhxY+655x5mzpyJt7c3M2bMoGXLlqxdu5Z7773XYRzx8fGEhoayY8cORowYQa1atVi3bh2jR4/m9OnTTJw4EYBTp07RvHlzAgICmDt3Lh4eHkyYMIGDBw86db6PPfYYn332GcOGDaNRo0bExMQwZswY9u7dyyeffJKpaxcTE0P9+vXp06cP/fr1A6B06dKAlZh27tyZhg0b8t577+Hv78/27ds5cODADcUyduxYQkJCmDt3Ljt27GDIkCG4uLiwefNmnnjiCV588UWmT5/O448/TlBQEDVq1HC6Py5evEhoaCj33Xcfc+bMwdfXl/3797N27dpMXQ+llFJK5Y64+Dg+2PwBr696nSMXjtCkbBM+6fwJIeVCcju025omXFlkIAPZwpYsbzfBKwFXXJ2qW4c6TGZylscA0LlzZ/vfjTE0bNiQAgUK0Lt3b959912KFCli337ixAliYmIIDg4GoE2bNtSoUYORI0faR0xeeuklypQpwy+//IK7uzsAoaGh1KxZk9GjR/P11187jGPBggWsXr2aFStW0KRJEwBatGgBWPdJvfzyyxQrVoxJkyZx6dIlvv/+e8qUKQNAq1atKFu2bIbnum3bNhYsWEB4eLh9JKp169a4uroyYsQIXnnlFcqXL+/0tUu6DqVKlbL/Pek6DhgwgDp16rB8+XJcXKwB55YtW2Yqlrvv/u9hgxUrVrSPXoWGhrJq1SrmzZvHvHnzCAsLAyAoKIjFixezcOFCe8LlTH/s2rWLM2fOMH78+BTH7NOnj9PXQimllFI572rCVWZvns1rq17j0PlDNCrTiI86fUSzcs1yZTGxO41OKVROOX/+PC+//DIVK1bEw8MDNzc3evXqhTGGv/76K0Xdu+66K0Vi4erqSpcuXVi/fj2JiYnExsayYsUKunTpgouLC/Hx8cTHx2OMoWXLlqxcuTLdOJYtW0bZsmVp0KCBfb/4+Hhat27NtWvXWLduHYA94UtKtgB8fHzo0KFDhueadPykBCVJ0vsVK1Zk2IYzdu/ezYEDB+jbt6892brZWNq2bZvifdWqVQEreUri5+dHsWLFOHToEIDT/VG5cmUKFSpEv379mD9/vn1/pZRSSuVN1xKuMfO3mVSZWoWnlj5F6QKl+SHsB1b2WUnz8s012cohOsKVRbJrZOlC7AV8fX2zpe3MePzxx/npp58YNWoUderUwcfHh/Xr1/PMM89w5cqVFHWLFy+eZv/ixYtz9epV/vnnH+Lj40lISGD06NGMHj3a4fESExMdJiEnT57kwIEDuLm5Odzv33//BeDYsWPUrFnTYRwZOX36NAAlSpRIUR4QEJBi+81KijVpemFWxOLn55fifdJolaPypH47ffq0U/1RsGBBli9fzujRo3n66ae5cOECNWrUIDIyMsUIqFJKKaVy17WEa8z7fR6jV45m/9n93F/qft5r/x6tK7bWJCsXaMKlMnTlyhUWLVpEREQEAwYMsJf/8ccfDuufOHHCYZm7uztFixYlNjYWFxcXnnnmGXr37u2wjfRGfIoUKUL58uUdLsIB2J/ZVaJEiXTjyEjhwoUBOH78OBUrVrSXHz9+3B4DgKenJwBXr15NsX9SIpURf39/AI4cOXLTsdyMQoUKOd0fderU4YsvviA+Pp6NGzcyduxYunbtytatWx0muEoppZTKOfGJ8cz/fT6jV45m75m9BJUM4t1279K2UltNtHKRJlwqQ3FxcSQkJKQZVZozZ47D+ocOHWLdunX2aYUJCQl8/vnn3Hfffbi4uODj40Pjxo3ZunUrdevWTTe5cqRNmzZ88cUX5M+f3z5dzpH69eszYcIEDh06xF133QXApUuX+OabbzI8RtOmTQGIiopi+PDh9vKPP/4YwH7vWNL9YNu2baN169b2et9++22aNt3d3dOs6FilShXKlSvHrFmzePLJJx3+Q+hsLDfjRvojX758BAcHM3r0aBYvXszOnTs14VJKKaVySXxiPAv+WMColaPYc3oP9wTcw+JHF9O+SntNtPIATbiU3bJly+xT1ZIULFiQVq1aERwczMSJEylRogT+/v58+OGH6Y7MFC9enG7duhEZGUnRokWZPn06f/75J9OnT7fXeeutt2jSpAmhoaH873//o0SJEpw6dYpNmzaRkJDAuHHjHLbds2dPZs+eTYsWLXjhhReoXbs2V69e5e+//2bx4sV8/fXXeHt7M2jQIKZNm0br1q2JiIiwr1Lo5eWV4XWoUaMG3bt3JyIigvj4eBo0aEBMTAyjR4+me/fu3H333Vy4cIESJUrQtGlTxo4di7+/P8WKFWP+/Pn8/fffadqsXr06S5cupU2bNvj5+VGyZElKlizJ5MmTefjhh2nevDlPPfUURYsWZefOnZw8eZLIyEinYskKzvTHkiVLeP/993nooYcoX748ly5dYsqUKfj6+lK/fv0siUMppZRSzktITCBqWxSjVo7iz3//pHbx2nzd7Ws6BnbURCsvMcboK9Xr3nvvNdezY8eO627PSufPn8/2Y8yePdsADl81atQwxhizb98+06ZNG5M/f35TtGhR88wzz5glS5YYwCxfvtzeVtOmTU3Dhg3NokWLTI0aNYy7u7upUqWKiYqKSnPcHTt2mG7dupmiRYsad3d3U6pUKdOhQwezdOlSe53HHnvMlC1bNsV+sbGxJjw83AQGBhp3d3fj5+dngoKCTHh4uLl27Zq93m+//WYaNWpkPDw8TMmSJc2oUaPMyJEjjfWxv76rV6+a4cOHmzJlyph8+fKZMmXKmOHDh5urV68aY/7rl0OHDpn27dubggULmuLFi5uhQ4eamTNnGsDs27fP3t7q1atN3bp1jYeHhwFMeHi4fdvPP/9sQkJCjI+Pj/Hx8TF33323+fDDD52OJal/ADNz5swU5xEeHm6AFNfFGGPKli1revbsman+2LVrl+nataspV66c8fDwMP7+/qZt27Zm3bp1GV7PnPjOJP8cqrxD+yXv0T7Jm7Rf8p683CfxCfFmwR8LTNV3qhoiMLWm1TJf7PjCJCQm5HZo2S4v9Quw0TiRW4hx8kGwd5KgoCCzcePGdLfv3LmTatWq5UgsFy7kjUUzVEraL5mTE9+Z6OhoQkJCsvUYKvO0X/Ie7ZO8Sfsl78mLfZJoElm4YyGRKyLZ8c8OahStQURIBA9XexgXuTMWH89L/SIivxljgjKqp1MKlVJKKaWUysMSTSJf7fyKiBURbDu5jWr+1YjqHEWXGl3umETrVqYJl1JKKaWUUnmQMYavd31NxIoIfj/xO4FFAvnk4U/oWqMrri6uuR2ecpImXEoppZRSSuUhxhi++fMbIqIj2Hx8M5ULV2Zep3l0r9ldE61bUI6PQYrIXSKyUETOich5EflSRMo4sV9ZEVkkIgdEJFZETolItIi0dVDXpPOqkz1npZRSSiml1M0xxrDkzyXUm1mPB6Me5HzceeY+NJcdz+wg7O4wTbZuUTk6wiUi3sAvQBzwGNZKeGOA5SJytzHm0nV2zw+cAl4FDgMFgCeAb0WkszHmy1T15wDvpSr786ZPQimllFJKqSxkjGHZnmWER4ez4egGyhcqz4cdP6RX7V7kc9EJabe6nO7BJ4AKQKAxZg+AiPwO/AX0A95Kb0djzHbgf8nLRGQpsA94HEidcB0xxqzLutCVUkoppZTKOsYYfvj7B8Kjw/n1yK+ULViWWR1m0bt2b9xc3XI7PJVFcjrh6gisS0q2AIwx+0RkDfAg10m4HDHGxIvIOeBa1oaplFJKKaVU9jDG8PO+nwmPDmftobWUKViG99q/R586fXB3dc/t8FQWy+l7uGoA2xyUbweqO9OAiLiISD4RCRCREUAV4F0HVfuLSJyIXBaRX0Sk8Y2HrZRSSiml1M1bvm85Tec0pdW8Vhw8d5DpD0znz2f/5Ml7n9Rk6zaV0yNchYEzDspPA35OtjEeeMH294vAo8aYn1PVmQ8sAY4CZYGXgF9EpJUxJjqzQSullFJKKXUzVuxfQXh0OCsOrKCkb0neafsOfev2xSOfR26HprKZGGNy7mAiV4GJxpihqcpfA142xmSYAIpIaSDA9uqNNU3xEWPMkuvs44s1snbIGNMonTpPAk8CFC9e/N6oqKh0YyhYsCCVKlXKKNQskZCQgKurrkiT12i/ZM6ePXs4d+5cth7j4sWL5M+fP1uPoTJP+yXv0T7Jm7Rf8p6s6pM/zv3B7P2z2Xx2M4XdC9OzTE/al2iPu4uOZt2IvPRdadas2W/GmKAMKxpjcuwFnADec1A+DfjnBtuMBnY5UW8aEOdMm/fee6+5nh07dlx3e1Y6f/58th9j9uzZBjB//fVXmm3Xrl0zgAkPD8/2OG4lN9sv2X1Nly9fbsLDw01CQkKK8n379hnAzJ49O9uO7UhOfGeWL1+e7cdQmaf9kvdon+RN2i95z832yZqDa0zLj1oaIjDFJxQ3k2ImmctXL2dNcHewvPRdATYaJ3KLnL6HazvWfVypVQd23GCbGwFnhpsEaxl6pW570dHRREZGkpiYmKK8RIkSxMTE8MADD+RSZEoppdTt7dfDv9JmfhsaftiQrce3MrH1RPYO2MvA4IF4uXnldngqF+T0PVyLgTdFpIIxZi+AiJQDGgKvZLYxEXEBGgF/Z1CvAPAA8Gtmj6HU7cTDw4Pg4ODcDkMppZS67Ww4soHw6HC+2/Md/t7+jG85nqfrPY2Pu09uh6ZyWU6PcM0E9gOLRORBEekILAIOkewhxSJSVkTiRWRksrIIEZkiIt1EpKmIdAOWAfcB4cnqvSgiM0Wkh4iEiMhjwBqse75ezYmTvN1FREQgImnK+/TpQ7ly5ezv9+/fj4gwY8YMhg4dSkBAAL6+voSFhXH58mX27NlDaGgo+fPnp1KlSsydOzdFe3v27KFXr16UL18eLy8vKlSoQP/+/Tlz5kya45YuXZrNmzfTuHFjvL29qVy5MjNmzHDqfE6dOkX//v0pVaoUHh4eVK1alffff9++ff369YgI33zzTZp9+/fvT9GiRbl2zXoyQVRUFM2bN6do0aLkz5+fe+65J815OZL62iUJCQkhJCTE/v7KlSsMGjSImjVrkj9/fgICAujQoQO7du2y14mIiCAyMhIANzc3RMTeX0l9MmfOnBTHmT9/PrVr18bT0xN/f3969erFsWPHUtQpV64cYWFhREVFUa1aNXx8fAgKCmL16tUZnp9SSil1u/rt6G90WNCB+2bdx69HfmVsi7HsG7CPlxq+pMmWAnJ4hMsYc0lEmgOTgHlY0/x+BgYaYy4mqyqAKykTwk3AQOBRoCBwHNgKNDbGrElWbzfQyfYqCJzHSrj+Z4xZnx3ndbtISEggPj4+TdnNGjt2LCEhIcydO5cdO3YwZMgQXFxc2Lx5M0888QQvvvgi06dP5/HHHycoKIgaNaxZp0ePHqV06dJMnjwZPz8/9u7dy+uvv067du2IiYlJcYzz58/To0cPBg4cyMiRI5k9ezb9+/cnMDCQZs2apRvb+fPnadiwIbGxsURERFC+fHm+//57+vfvT1xcHM899xz33XcfgYGBzJs3jw4dOtj3vXr1Kp999hk9evTAzc16OOHevXt55JFHeOWVV3BxcWHlypX07duX2NhYnnrqqZu+lnFxcVy4cIFXX32VEiVKcPr0aaZNm0ZwcDC7du0iICCAvn37cvjwYT744ANWr16d4eIe77//Pv369aNbt26MHTuWo0ePMmzYMH799Vc2bdqU4sbUVatWsXv3bkaPHo2npycjRoygffv27N+/n0KFCt30+SmllFK3is3HNhOxIoLFuxfj5+nHa81f47n7nsPXwze3Q1N5TE5PKcQYcxDonEGd/VhJV/KyxVhTEjNq/xsg7VBEdhs4ELZsyfJmvRISwNnV8OrUgcmTb/hYVatWveF9r6dixYr2UZ7Q0FBWrVrFvHnzmDdvHmFhYQAEBQWxePFiFi5caE+4mjRpQpMmTeztNGjQgEqVKtG4cWM2b97MPffcY9924cIFpk2bZk+umjRpwg8//MCCBQuum3C9/fbbHDhwgD/++IPKlSsD0LJlS86ePUtkZCT9+/cnX7589OrVizFjxnDu3DkKFiwIwLfffsvp06fp1auXvb1hw4bZ/56YmEhISAjHjh1j+vTpWZJwFSxYkFmzZtnfJyQkEBoaSvHixVmwYAGDBg2idOnSlC5dGoD777+ffPnS/5onJCQwYsQIQkJCSL4yZ9WqVWncuDEffvghzz//vL38/PnzbNmyBT8/6ykOAQEB1KtXj2+//ZYePXrc9PkppZRSed3vJ34nIjqCr3Z9RSHPQowKGcWA4AEU8CiQ26GpPCqnpxSqPOyrr75iw4YNKV7r1q276Xbbtm2b4n1SYhcaGmov8/Pzo1ixYhw6dMhedvXqVV5//XWqVq2Kl5cXbm5uNG5sPb969+7dKdr09vZOkVh5eHhQuXJlDh48eN3Yli1bxv3330/58uWJj4+3v0JDQ/n333/ZscNayyUsLIy4uDg+//xz+77z5s0jMDCQ++67z172119/0b17d0qVKoWbmxtubm7MmjUrTbw347PPPuP++++nUKFC5MuXDx8fHy5evHhDx9i9ezcnT56kZ8+eKcobNWpE2bJlWbFiRYry+vXr25MtgFq1agFkeJ2VUkqpW922k9t45LNHqD2jNr/s+4WIphHsG7CPEU1HaLKlrivHR7huWzcxsnQ9sRcu4OubM0PTNWvWTPN8sdRTDG9E8h/oAO7u7umWX7lyxf5+6NChTJ06lZEjR9KgQQN8fX05fPgwDz/8cIp6jtoCK+lKXS+1kydPsmfPHvuUwNT+/fdfAMqWLUuTJk2YP38+ffv25ezZsyxdupQRI0bY6168eJFWrVrh7e3NuHHjqFixIu7u7kyfPp0PP/zwunE465tvvqFbt2489thjhIeH4+/vj4uLC+3atcvwXB05ffo0YK1emFpAQIB9e5LChQuneO/hYT2s8UaOrZRSSt0Kdvyzg8gVkXy+/XPyu+dnRJMRDAoehJ9X2t8eSjmiCZfKNE9PT8AagUpKnuC/5CSrREVF0bt3b1599b+1Ti5evHidPTKvSJEiFCtWjLffftvh9sDAQPvfe/XqxRNPPMGBAwdYtGgRV69eTTEyFBMTw4EDB1i1ahWNGv33fG1nklZPT0+uXr2apvzff/+lSJEi9vdRUVFUqlQpxaIX165dS5MYOSspgTp+/HiabcePHycoKONn+SmllFK3o4OXD9Ljix5EbYvCx92HYY2HMbj+YAp7Fc54Z6WS0SmFKtPKli0LwLZt2+xlZ8+eZe3atVl6nMuXL6cZeZo9e3aWHqNNmzbs2rWLMmXKEBQUlOaVfHSxS5cueHp68vHHHxMVFUWTJk1SrCx4+fJlgBQxnzlzhkWLFmUYR9myZTlx4gSnTp2yl/39999ppglevnw5zT1Z8+bNS7O4SdLIU2xs7HWPGxgYSPHixVPcvwWwdu1aDhw4QNOmTTOMXSmllLqd7Dq1i7Avw3h8w+Ms3r2Ylxu+zL4B+xjTfIwmW+qG6AiXyrS2bdtSsGBBnnjiCSIjI4mLi2P8+PEpVrPLCm3atGHu3LnUqlWLSpUq8eWXX2Z5Ujdo0CA+/fRTGjduzKBBgwgMDOTSpUvs2rWLVatWpUiWChQoQMeOHXn33Xc5duwYM2fOTNFWgwYNKFCgAM888wyRkZFcunSJMWPG4O/vz7lz564bR5cuXRgxYgQ9e/Zk8ODBnDp1irFjx+Lv75+iXps2bfj6668ZNGgQ7du357fffmPKlClpVgisXr06ABMnTqRt27a4uro6HK1ydXVl1KhR9OvXj7CwMMLCwjhy5AjDhw+ncuXKPP7445m6nkoppdStauc/OxmzagwL/liAl5sXXUp3YeqjUynqUzS3Q1O3OB3hUplWqFAhlixZgouLC127dmXo0KE899xz110N8EZMnTqVjh07Mnz4cLp168aFCxdYsGBBlh6jYMGCrF27lnbt2vHGG28QGhrK//3f/7Fo0SKH59OrVy+OHj2Kh4cHjzzySIptRYsW5auvviIhIYFHHnmEoUOH0rdvX/tKjNdTqVIlFi5cyJEjR3jooYcYP348b731FlWqVElR74knnmD48OF8+umndOjQgaVLl/LNN9/YV05M0r59e55++mmmTZtG/fr1qVevXrrHfvLJJ5k3bx5//PEHDz74IEOGDKFVq1asWLEiy5NopZRSKq/Z8c8Oun/RnRrTarBo1yJeavAS+wfs56mKT2mypbKEGGNyO4Y8JygoyGzcuDHd7Tt37qRatWo5EsuFHFw0QzlP+yVzcuI7Ex0dneIh0Spv0H7Je7RP8ibtl5y3/eR2Rq8czWfbP8PbzZvn7nuOFxq8gL+3NbtE+yRvykv9IiK/GWMyvOFdpxQqpZRSSqk7xraT2xi9cjSfb/8cH3cfXmn0CoPrD7YnWkplNU24lFJKKaXUbW/byW2MWjGKz3dYy7sPbTSUwfUHU8S7SMY7K3UTNOFSSimllFK3rT9O/MGolaNYuGMhvu6+DG88nEHBgzTRUjlGEy6llFJKKXXb+f3E74xaMYovdn6Br7svrzZ+lUH1B+nS7irHacKllFJKKaVuG1uPb2XUylF8ufNLCngUYESTEQwMHqiJlso1mnAppZRSSqlb3pbjW4hcEcnXu76moEdBwpuGM+D+Afh5+eV2aOoOpwmXUkoppZS6ZW0+tpnIFZEs2r2Igh4FiWgawYDgARTyLJTboSkFaMKllFJKKaVuQZuObSJyRSSLdy+mkGchIkMief7+5zXRUnmOJlxKKaWUUuqW8dvR34hcEck3f35DIc9CjAoZxfP3P09Bz4K5HZpSDmnCpZRSSiml8ryNRzcSuSKSJX8uwc/Tj9HNRvPcfc9poqXyPJfcDkDlHTExMXTt2pWSJUvi7u5OkSJFaNWqFXPnziUhISFbjhkdHU1ERASJiYnZ0n5GJk+ezJdffpmmPCIiAhHJhYjSCgkJISQkJLfDUEoppXLFhiMbaP9Je+rNrMfaQ2sZ02wM+wfu59Umr2qypW4JmnApwEo8GjZsyOnTp3njjTf46aef+PDDD6lSpQr9+/dnyZIl2XLc6OhoIiMj81zC1bdvX2JiYnIhIqWUUkoB/Hr4V9p93I77Zt1HzOEYXmv+GvsG7GN4k+EU8CiQ2+Ep5TSdUqhYuXIlgwcP5tlnn2XKlCkptj344IMMHjyYS5cu5VJ0/7l27Rr58uXLkZGn0qVLU7p06Ww/jlJKKaVSWnd4HZErIlm2ZxlFvIowtsVYnqn3DL4evrkdmlI3REe4FOPGjaNw4cKMHz/e4faKFSty991329+vX7+eli1bkj9/fnx8fGjRogXr169PsU+fPn0oXbo0mzdvpnHjxnh7e1O5cmVmzJhhrxMREUFkZCQAbm5uiIg9mdq/fz8iwrRp0xgyZAglS5bEw8ODs2fP8s8//9CvXz+qVKmCt7c3d911Fz169ODIkSNpYt+6dSudOnWiSJEieHl5ERgYyNixYwEoV64cBw4c4OOPP7Yfu0+fPvbYUid258+f59lnn6VkyZL4+/sTGBjIpEmTMMbY60RHRyMiLF68mGeffRZ/f3+KFi1KWFgYZ8+edbZLMrR79246depEoUKF8PLyIjg4mGXLlqWpt2DBAqpWrYqnpye1atVi8eLFOkVRKaVUnhRzKIY289tQ/4P6bDiygXEtxrFvwD5eafSKJlvqlqYjXHe4hIQEoqOjeeihh/D09Myw/u+//07Tpk2pXr06c+bMQUQYN24cTZs2Zd26ddSuXdte9/z58/To0YOBAwcycuRIZs+eTf/+/QkMDKRZs2b07duXw4cP88EHH7B69WpcXV3THO+1116jXr16vP/++yQkJODp6cnBgwfx9PRk7NixFC1alKNHjzJx4kQaNmzIrl277Oexfv16QkJCqFSpEpMmTaJ06dL89ddf/P777wB89dVXtGvXjtq1axMREQFA0aJFHZ53YmIiDzzwAJs2bWLUqFFUrFiR5cuXM3jwYP755x9ef/31FPUHDBhA+/bt+eSTT9i9ezdDhgzB1dWVuXPnOtUv13P06FEaNWqEr68v77zzDgULFuTdd9/lgQceYMmSJbRt2xaAH3/8kZ49e9KxY0cmTpzIqVOnGDhwIFeuXKFKlSo3HYdSSimVFdYeWkvkikh++PsH/L39eaPlGzxd72nyu+fP7dCUyhKacGWRgQNhy5asbzchwQsHeYhDderA5MmZa//UqVPExsZStmxZp+qPGjUKDw8Pfv75ZwoVsp5z0apVK8qVK0dkZGSK+6EuXLjAtGnTaNasGQBNmjThhx9+YMGCBTRr1izFtL3777+ffPnSfhyLFy/OV199lWK0KTAwkLffftv+PiEhgYYNG1KmTBm+++47OnXqBMCLL75IkSJFWLduHd7e3gA0b97cvt8999yDh4cH/v7+BAcHX/e8v/32W1avXs3s2bPp06cPFy5c4KGHHuLSpUtMnDiRwYMH4+/vb6/fpEkTpk6dCkDr1q3ZvXs3s2bNsiepN+Ott97izJkzxMTEUKlSJQDatWtH9erVGT58uD3hCg8Pp3r16imuX61atbj33ns14VJKKZXr1hxcQ+SKSH7c+yNFvYsyvuV4+tfrr4mWuu3olEKVKStXrqR9+/b2ZAugQIECdOzYkRUrVqSo6+3tbU+2ADw8PKhcuTIHDx50+ngPPfSQwwRl+vTp1K5dm/z585MvX+NL3J8AACAASURBVD7KlCkDWFPtAC5fvsyaNWvo2bOnPdm6GStXrsTFxYXu3bunKA8LC+Pq1atpFth44IEHUryvVasWcXFxnDhxIktiCQ4OtidbAK6urnTv3p0tW7Zw/vx5EhIS2LhxI507d05x/erWrUv58uVvOgallFLqRq0+uJpW81rRaHYjtp7YyoRWE9g3YB8vNXxJky11W9IRriyS2ZElZ124EIuvb/bNW066t+nAgQNO1T99+jQlSpRIUx4QEMCZM2dSlPn5+aWp5+HhwZUrV5yOz9Gxpk6dyvPPP8/gwYOZMGECfn5+JCYmEhwcbG/7zJkzJCYmZtnCF6dPn6Zw4cJ4eHikKA8ICLBvT65w4cIp3iftl5lzv14s99xzT5rygIAAjDGcOXOG2NhYrl27RrFixdLUK168+E3HoJRSSmXWqgOriFgRwS/7fqGYTzHebPUmTwU9hY+7T26HplS20oTrDpcvXz5CQkL48ccfiYuLS5NQpFa4cGGOHz+epvz48eNpkoys4Gh0KyoqihYtWjBx4kR72b59+1LU8fPzw8XFxeFCGjeicOHCnD59mqtXr+Lu7m4vT7oWRYoUyZLjOBtLen0gIhQuXBhvb2/c/p+9+46ruvofOP46CCKouMXcq5w5cuReubc5sjRHWmllrtxpbnHvvfeeqd/MTERxheZIcSTuvVJkyLjn98dBfw5UULgXuO9nDx7C5577+bwvH24P3pxz3m8nJ27duvXSuJs3bz6dERRCCCFim9dFLwZ6DmTnhZ24J3VnbPWxdCjeAVend1+BIkR8IEsKBb179+bu3bv06NEj0sfPnz//tNBExYoV2bJlC/7+/k8f9/f359dff6VixYrRvvaTBC8oKCjKzwkMDMTJyem5Y/Pnz3/ua1dXV8qVK8eSJUtee25nZ+coXbtixYpYLBZWr1793PGlS5eSOHHiN+4Bi0lPCpRcuHDh6bHw8HBWrlxJ0aJFSZ48OYkSJaJ48eKsXbv2uSqKhw4deik5FUIIIWKD5wVPKi+sTMUFFfG948v4GuPx6+xHt9LdJNkSdkUSLkGFChUYN24cU6ZMoVq1aixdupTdu3ezadMmOnfuTMGCBZ/+kt6/f3+CgoL45JNPWLt2LevWraNq1aoEBgYyYMCAaF87f/78AIwdO5YDBw7g4+PzxufUrFmTbdu2MXz4cP744w/69u3LihUrXho3ZswY7t69S+nSpVm8eDE7d+5k7ty5dOrU6bnr7969m82bN+Pj4/NcEvOsWrVqUa5cOTp06MCECRP4888/6dq1K3PmzKF79+7PFcyIqjZt2rxVAY2uXbuSMmVKqlWrxrJly9i8eTP16tXjzJkzDBs27Om4QYMGceLECRo1asTWrVtZtGgRTZs2JUOGDDg4PP/Wd3R0pF27dtGORQghhHiR5wVPKi2oROWFlTl15xQTakzA70c/upTqIomWsEuScAkAunTpwp49e0iZMiU//fQTVapUoU2bNvj6+jJz5kzq1asHQKFChfD09MTNzY3WrVvz5ZdfkixZMnbt2vVcSfioqlu3Lt999x3Tpk2jdOnSlChR4o3PGTBgAN9++y3jx4+nUaNGHDt2jG3btr00rkSJEnh7e5MlSxY6depE7dq1GT169HP7ukaMGEGePHlo1qwZJUqUeFoe/kUODg5s2bKF1q1bM3LkSJo2bcqWLVsYN27cc0lOdAQEBLzVfqqMGTOyZ88eChQoQMeOHWnSpAn37t1jy5Yt1KxZ8+m4J8mzr68vjRo1YuTIkYwdO5YMGTKQIkWK584ZHh5OeHj4W70OIYQQQmvNzvM7qbigIpUXVubM3TNMrDkRvx/96FyqMy5OLrYOUQibUc8uNxJG8eLF9etmWnx9fcmXL59VYvH394/Vohni7cTEfcmUKROdO3emZ8+eMRTVm125coXcuXPTr18/+vfvb7XrWuM94+npKQ2d4yC5L3GP3JO4Kb7eF601Oy/sZKDnQHZf2k3G5BnpXbY3Xxf7miSOb+7vGZfF13uS0MWl+6KUOqS1Lv6mcVI0QwgbOHv2LMHBwXz33Xexdo2goCC6detG1apVSZs2LX5+fowaNQpXV1fat28fa9cVQgiR8Gmt2XF+B4N2DWLPpT1kSp6JybUm0/6j9vE+0RIipknCJYQNvP/++9y9ezdWr5EoUSJu3LjBDz/8wN27d0maNCnly5dn9erVkZbbF0IIId5Ea80ffn8waNcgvC97kyl5JqbUmkK7j9pJoiViV1AQzJmDypPH1pFEmyRcQiRQiRMnZv369bYOQwghRAKgtWa733YG7RrE3st7yeyWmam1p9KuaDucHV/fUkaIdxIWBgsXwi+/wNWrpBkyBKpXt3VU0SIJlxBCCCGEiJTWmt/P/c7AXQPZf2U/WdyyML3OdNoWaSuJlohdWsPmzdC7N5w8CR9/DMuWccdisXVk0SZVCoUQQgghxHO01vz272+UnluamktrcvXhVWbUmcHZTmfpULyDJFsidu3fDxUrQv36EBoKa9bAvn1QoYKtI3srMsMlhBBCCCGA/0+0Bu4ayMGrB8maIisz686kTZE2JE6U2NbhiYTu9Gno2xfWrQN3d5g2Ddq3BycnW0f2TiThEkIIIYSwc1prtp7dyqBdg/jr2l9kS5GNWXVn0bpIa0m0ROy7fh0GD4bZs8HFBQYNgm7dIFkyW0cWIyThEkIIIYSwU1prtpzdwqBdg/C55kP2lNmZXW82rQq3kkRLxD5/fxg9GsaOhZAQ6NAB+vc3s1sJiNX3cCmlsiil1iilHiilHiql1imlskbhedmUUhuVUheVUkFKqTtKKU+lVK1IxiZRSo1WSl2PGLtPKRU/F30KIYQQQsQwrTW/nv6VErNLUG95Pe4G3mVOvTmc+eEM7T9qL8mWiF0hITBlCuTKBUOGQN264OtrjiWwZAusPMOllHIF/gQeA60BDQwFdiqlCmmtA17z9GTAHeBn4ArgBnwNbFVKNdZar3tm7FygDtAD8AO+B7YppUprrY/E8MsSQgghhIgXtNb8euZXBu0axOHrh8mZKifz6s+jZaGWOCWK3/tkRDxgscDq1dCvH5w7B5UqwahRUKKErSOLVdae4foayAk01Fpv0FpvBOoD2YBvX/dErfUJrXU7rfVirfXOiOc2xCRfbZ+MU0oVBr4AumqtZ2utdwDNgEvA4Fh5VQnEvn37aNasGRkzZiRx4sSkSZOGatWqsXDhQsLDw20d3mtduHABpRQLFiyIsXMOHz6crFmz4ujoSJEiRQC4ceMG9evXJ2vWrCilmDBhQoxdD2DChAmsW7fuzQOFEEKIaNBas/HURorNKkaDFQ14EPyA+Q3mc+r7U7Qt2laSLRH7du40pd2bNwdXV9i6Ff78M8EnW2D9hKs+sF9r/e+TA1rr84A30CC6J9NahwEPgNAXrhEKrHxh3AqghlJK6phGYsKECZQtW5Z79+4xcuRI/vjjD+bNm8cHH3xAx44d2bx5s61DtKqDBw/Sr18/mjdvjpeXF4sXLwZg8ODB7Nq1i6lTp7Jv3z6aN28eo9eVhEsIIURM0lqz4dQGPpr1EQ1XNuTh44csaLCAUz+cok2RNpJoidh37BjUqgVVqsDNm7BgAfz9tzmmlK2jswprF80oAGyM5PgJoGlUTqCUcsAkimkxM2YfAJ1fuMZ5rXVgJNdIDOSO+FxE8PLyolu3bvzwww9MmjTpuccaNGhAt27dCAh43WrPhMfX1xeADh06kDNnzueOFy5cmHr16pE8eXJbhSeEEEK8lkVb2HBqA4N3DebozaPkTp2bhQ0X8sWHX+DoIDXThBVcumQKYCxeDClSmKWDnTpBkiS2jszqrD3DlRq4H8nxe0CqKJ5jFGYG6zrQE2gesWwwKtd48rh4hoeHB6lTp2bUqFGRPp4rVy4KFSoEwO3bt/n222/54IMPcHV1JUuWLHzxxRdcvXr1uee0adOG7Nmzv3SuSpUqUalSpadfP3r0iE6dOpE1a1acnZ1xd3enatWqnDp16umYKVOmULp0aVKnTk3KlCkpVaoUW7ZseevXe/ToUerXr0+qVKlwcXGhbNmy7N69+7kY27Rp8/S1K6Vo06YNSik8PT3ZvXs3bm5uKKW4cOECAOfPn6dFixakS5cOZ2dnihQpwvr16yO9dqNGjUiTJg0uLi7kyZOHESNGAJA9e3YuXrzI0qVLUUo9va4QQggRVRZtYe3JtRSdWZTGqxoTGBrIooaL8P3el1aFW0myJWLfvXvw00/wwQewcqX53M8PevSwy2QLbFMWXkdyLDrziRMwywMzAK2AZUqpJlrrJ2ve1NtcQyn1DfANgLu7O56enq8cmyJFCvz9/aMR8tsLDw+P1WuFh4fj6elJnTp1CA0NJTQ09LXjL1++jIODAwMGDCBt2rRcv36dyZMnU6ZMGXx8fEgS8UYKDQ1Fa/1S7E/2gj053qlTJ7Zu3covv/xCrly5uHfvHvv37+fq1atkypQJgDNnztCyZUuyZs1KWFgY//vf/6hbty5r1qyhevXqgEncAIKDg1/7/Tpy5Ag1a9akUKFCTJo0CRcXF+bNm0fVqlXZvn07RYsWZfTo0axcuZKxY8eydOlS3N3dyZAhA19++SVdunQhUaJEjB49GgcHB5IlS4avry8VKlQgXbp0DB8+nLRp07Ju3ToaN27M8uXLqV27NgA+Pj7UqVOHnDlzMnz4cDJlysS5c+f4559/8Pf3Z8mSJTRp0oSCBQvSp08fANKmTWu1n7XYFBwc/Nr3VEx49OhRrF9DRJ/cl7hH7knc9K73xaIt7L6zm0UXF+EX4EcWlyz0zduXKumrkOh+IvZ47Ym5YO2EvFeix+HxYzKtW0fWZctwDAjgRo0aXGjThsfu7nD0aIxdJ17eF6211T6Am8DMSI5PA26/5Tk9gVPPfL0SOB3JuGaYRKzAm85ZrFgx/TonT558+WBnrXXFmP8ILRca9fGdXxt2pG7cuKEB3bt37+g/WWsdFhamL126pAG9bt26p8dbt26ts2XL9tL4ihUr6ooVKz79ukCBArpr165Rvl54eLgODQ3V1apV0/Xr1396/Pz58xrQ8+fPf+3zq1SpovPmzasfP3783GvImzevbtCgwdNjs2fP1oA+f/78c88vW7asrlixon748OHTY1999ZVOmzatvnPnznNjq1atqgsXLvz06/Lly+vMmTPrgICAV8aXLVs23aJFi9e+hvgo0vdMDNu5c2esX0NEn9yXuEfuSdz0tvcl3BKuV/2zShecVlAzEJ1nch695OgSHRYeFrMB2iF5r0RRWJjW8+ZpnTmz1qB17dpaHzsWa5eLS/cF8NFRyFesvaTwBGaP1YvyAyff8pw+mH1Zz14jR0QJ+hevEQL8i3gn06dPp3DhwiRLlgxHR0eyZjVt1E6fPh3tc5UoUYIFCxYwfPhwfHx8Iq2GeOjQIerWrYu7uzuOjo44OTmxffv2aF8vKCiIXbt20bRpUxwcHAgLCyMsLAytNVWrVsXLyyva8QP89ttv1K5dmxQpUjw9Z1hYGDVq1ODo0aM8fPiQwMBAvL29adGiBa6uL/5oCiGEENFj0RZWnVhFoemFaLamGWGWMJZ9uowT352gRaEWJHJIZOsQRUKnNWzZAkWKwFdfwXvvmUqEW7bAhx/aOro4xdpLCjcBY5RSObXWfgBKqexAWaB3dE8WUUCjHHDuhWsMwhThWBgxzhH4DPhda/34HeJ/tZitDv5UkH9QrBZneLKX6OLFi1EaP3nyZH788Ue6devG6NGjSZUqFRaLhVKlShEcHBzt60+ePJkMGTIwb948+vXrR+rUqWnVqhXDhg3D1dWVy5cv88knn5A/f34mT578tEx7//79nxa2iKp79+4RHh7OkCFDGDJkSKRjLBYLDg7R+zvErVu3WLRoEYsWLYr08bt375I4cWIsFguZM2eO1rmFEEKIZ4Vbwllzcg2DvQZz8vZJ8qXNx/LGy2mav6kkWcJ6DhyAXr1g1y7InRtWrYImTeym6mB0WTvhmg38AGxUSv2MWeI3BLgMzHwySCmVDZNEDdZaD444NhBT8MIbuIHZw9UOKInpuwWA1vqIUmolMEEp5QScBzoCOYAWsfz64h1HR0cqVarE9u3befz4Mc7Or6+av2LFCj755BPGjh379Nj58+dfGpckSRJCQkJeOn737l3SpEnz9OtkyZIxYsQIRowYwcWLF1mzZg29e/cmceLEjBw5kt9++40HDx6watWq55KVwMAXi1C+WcqUKXFwcOD777+nVatWkY6JbrIFJmktX748vXr1ivTxjBkzEh4ejoODw0vFRYQQQoioCLeEs+rEKoZ4DcH3ji/50+VnReMVNMnfRBItYT1nz0LfvrBmDaRLB1OmwDffgJO0F3gdqyZcWusApVQVYDywGFPIYgfQRWv96JmhCkjE81UUDwNdgOZACkzSdRQor7X2fuFSbYFhwFAgZcS4mlrrwzH+ohKA3r17U6lSJXr06PFSWXgwCZW/vz+FChUiMDAQNze35x6fP3/+S8/Jli0bN2/e5M6dO6RNmxaAc+fOcfr0acqUKRNpHNmyZaN79+4sXbqUf/75B/j/xMrpmTfymTNn8Pb2jvZsUdKkSSlfvjxHjx7lo48+eqvkKjI1a9Zk3759FChQABcXl1eOK1euHEuWLGHAgAGvHOfs7ExQUFCMxCWEECL+C7eEs/LESoZ4DeHUnVMUSFeAlU1W0iR/ExyUtXeGCLt18yYMHgyzZoGzM/zyC3TvDtIiJ0qsXqVQa30JaPyGMRd4oaqg1noTZrlgVK4RBHSL+BBvUKFCBcaNG0e3bt3w9fWlTZs2ZM2alfv377Njxw7mzJnDsmXLKFSoEDVr1mTkyJEMHz6ckiVL8ueff7JmzZqXztm0aVP69+9PixYt6NatG3fu3GHEiBFPk68nSpcuTf369fnwww9JliwZu3bt4ujRo7Ru3RqAqlWr4ujoSKtWrejevTvXr1/nl19+IWvWrFgslmi/1nHjxlGhQgVq1KhBu3bteO+997hz5w6HDx8mPDwcDw+PaJ9z8ODBlCxZkgoVKvDDDz+QPXt27t+/zz///IOfnx/z5s0DYMyYMVSsWJHSpUvTvXt3MmfOjJ+fH0eOHGHy5MkA5M+fn927d7N582YyZMhA2rRpIy2vL4QQImELt4Sz4p8VDPEawum7pymYviCrmqyicf7GkmgJ6/H3h7FjYcwYCA42s1kDBkCGDLaOLH6JSmUNe/t4qyqFseTZanixzdvbWzdp0kRnyJBBOzo66lSpUulq1arpxYsX6/DwcK211oGBgbpDhw46bdq0OlmyZLpOnTraz89PA/qXX3557nzr16/XBQoU0EmSJNGFChXS27Zte6lKYc+ePXWRIkW0m5ubdnV11QULFtQTJ0587jwrV67UefLk0c7Ozjp//vx6+fLlL1VBjGqVQq3N/fvss890unTpdOLEiXWmTJl0vXr19JYtW56OiU6VQq21vnz5sm7Xrp3OmDGjdnJy0hkyZNBVq1bVixcvfm7c4cOHdd26dXWKFCl0kiRJdJ48ebSHh8fTx319fXW5cuW0i4uLBnTr1q3f+HriA6lSaL/kvsQ9ck/ipif3JTQ8VC8+uljnmZxHMxD94bQP9eoTq3W4Jdy2Adohu36vhIRoPXWq1unTm8qDTZpoffq0raPSWset+0IUqxQqM1Y8q3jx4trHx+eVj/v6+pIvXz6rxOLv7x+rRTPE25H7Ej3WeM94eno+11RbxA1yX+IeuSdx046dO7iW+hpDvIZw9t5ZCrkXYkCFATTK10hmtGzELt8rWpv9WX37wr//QoUKMGoUfPyxrSN7Ki7dF6XUIa118TeNk3bjQgghhBA2EmYJY9nxZfT9qy9Xg65S2L0w65qto0HeBpJoCevatQt69oSDB6FAAfj1V6hTRyoPxgBJuIQQQgghrCwkPISFRxbi4e2B330/cifLzfrP1lM/T31JtIR1HT8OffqY/lmZM8O8edCqFSSS6pcxRRIuIYQQQggrCQoNYu7fcxnpPZIrD69QPGNxxlUfh9t1NyrnrWzr8IQ9uXzZFMBYuBDc3MDDA378EV5TcVm8HUm4hBBCCCFiWUBIADN8ZjBm3xhuPLpB2SxlmVNvDtVzVUcphecNT1uHKOzF/fswYgRMmmT2bHXrZvZspU5t68gSLEm4hBBCCCFiyYPgB0z9ayrj9o3jbtBdPsnxCcsbL6ditooo2RsjrCk42DQqHj4c/vsPWraEIUMgWzZbR5bgScL1lrTW8j9KIaJAKqEKIezRvaB7TNw/kUkHJ/Ff8H/Ufr82P5f/mdJZSts6NGFvwsNh6VLo3x8uXYKaNc3ywcKFbR2Z3ZCE6y04OTkRFBSEq6urrUMRIs4LCgrCycnJ1mEIIYRV3Aq4xbh945j611QehTyiUd5G9Cvfj2IZi9k6NGFvtIbffoPeveHYMShWDObPhypVbB2Z3ZGE6y2kT5+eq1evkilTJlxcXGSmS4hIaK0JCgri6tWruLu72zocIYSIVVcfXmXM3jHMPDST4LBgPiv4GX3L9eVD9w9tHZqwRz4+psT7zp2QMyesWAFNm4KDVMC0BUm43oKbmxsA165dIzQ0NFavFRwcTJIkSWL1GiL65L5EjZOTE+7u7k/fM0IIkdBc/O8iI71HMvfvuYRbwmlZqCV9yvUhT9o8tg5N2KNz50wBjFWrIG1aUxjj228hcWJbR2bXJOF6S25ublb5JdLT05OiRYvG+nVE9Mh9EUII+/bvvX8Zvns4i48tRqFoW6Qtvcv1JkeqHLYOTdijW7dMAYwZM0xy1b8//PSTKfcubE4SLiGEEEKIKDp5+yTDdw9n+T/LSZwoMR2Ld6Rn2Z5kdsts69CEPXr0CMaNg9GjISgI2reHX36B996zdWTiGZJwCSGEEEK8wZEbRxjqNZR1vutwdXKlW6ludC/TnQzJMtg6NGGPQkNh7lwYOBBu3oRPPzXl3vPIUta4SBIuIYQQQohXOHj1IEO8hrD5zGbcnN3oW74vXUp1Ia1rWluHJuyR1rBundmndeYMlCsH69dDaftoN2Cx2DqCtyOlSoQQQgghXrD74m6qL67Ox3M+Zu/lvQyuNJiLXS4ytMpQSbaEbezeDWXKQJMm4OgImzaBl5fdJFs+PlCoEFy6FP/aMskMlxBCCCEEpp3FjvM7GOI1BK+LXqRPmp6RVUfSsXhHkjsnt3V4wl6dPGl6af36K2TMCHPmQOvWJumyEytWQNu2kD49hIbGv3ZM9nOnhBBCCCEiobVm69mtDPEawoGrB8iUPBMTa06k/UftcXWKf39NFwnElSumAMaCBZAsGYwYAT/+CK728zNpsZiCi8OHm9WTa9fCyZMBtg4r2iThEkIIIYRdsmgL633XM3T3UI7cOEK2FNmYUWcGbYq0wdnR2dbhCXv1338wciRMmGAyjs6doV8/SJPG1pFZlb8/tGxpVk62bw9Tp5qK9ydP2jqy6JOESwghhBB2JdwSzsoTKxm2exgnb5/k/dTvM7/BfFp82AKnRE62Dk/Yq8ePTVYxbBjcuwctWsDQoZA9u60js7rz56F+ffD1Nb2bf/gBVPxbSfiUJFxCCCGEsAuh4aEsObaEEXtGcPbeWQqkK8CyT5fRrEAzEjkksnV4wl5ZLLBsGfz8M1y8CNWrg4cHFC1q68hswtPT1AUJD4fffoOqVSMeOAHMBMdq8S99iX8RCyGEEEJEw+Owx8w/Mh+PPR5cfHCRohmKsrbZWhrmbYiDkoLNwka0ht9/h1694OhRk2DNmfNMhmF/ZsyATp0gd26zlPD97MBqYBrgCSQGt0xuUM+WUUafJFxCCCGESJACQwOZfWg2o/aO4pr/NT7O9DFTa0+l9vu1UfF5fZKI/w4dMonWjh2QI4eZ4frsM3Cwzz8AhIaarWrTp0Pt2rB8NLgtAWYBN4DswEigLdw7cc+Wob4VSbiEEEIIkaD4P/Znus90xu4by62AW1TIVoGFDRfySY5PJNEStuXnZ5YOLl9uimBMmAAdOoCz/RZpuXsXmjaFnTthZjP4OhRUIcAC1AK+A2oC8XjVryRcQgghhEgQ/gv+j8kHJjPhwATuBd2jeq7q9CvfjwrZKtg6NGHvbt82BTCmTzf9s/r1gx49IEUKW0dmUydOwBe14ZOrsP49SLEKSAN0B74Fcto2vpgiCZcQQggh4rU7gXeYsH8Ckw9O5uHjh9T7oB79yvfj48wf2zo0Ye8CAsws1siR5vN27WDgQNPA2M7tmgh+P8G+cHDVQFbAA2gGJLFtbDFNEi4hhBBCxEs3Ht1g7N6xTPeZTmBoII3zN6Zf+X4UyVDE1qEJexcWBvPmmeTq+nVo2NB0782Xz9aR2dZj0Kvhaj+oeAk+VhD+GfATUMzWwcUeSbiEEEIIEa9cfnCZ0XtHM/vwbELCQ/i84Of0Ld+X/Ony2zo0Ye+0ho0boU8fOHUKypSB1auhbFlbR2ZbF4CZoOeCug2BwKKi0HQzJLWDyT5JuIQQQggRL/jd98NjjwcLjixAo2lVqBW9y/Xm/TTv2zo0IcDbG3r2hL17IW9eWL8eGjSI3x1734UF+B2YCmwBrcDTDYYDlYdAn372862RhEsIIYQQcdrpO6cZsWcES44tIZFDItp/1J5eZXuRLWU2W4cmBPj6mhmtjRvhvfdg1ixo29YUx7BHd4H5wHTAD0gPV1tDg61wOhCWbDB5qD2x058EIYQQQsR1x28eZ9juYaw6sYokjknoVLITPcr2IGNyO1iDJOK+a9fMHq25cyFpUlOFsEsX87k9+gszm7UCeAyUB4bBsmD4qoOpE7JvBxQsaNMobUISLiGEEELEKYeuHWLo7qFsOLWBZImT0bNsT7qV7kb6pOltHZoQ8OABjBoF48eb4hidOpneWmnT2joy6wvCJFjTAB8gGfAV0BHC85uJv9Gjygb6EQAAIABJREFUoVIls5XNHr9FIAmXEEIIIeKIvZf3MtRrKP/793+kcE7BgAoD6FyqM6ldUts6NCHg8WPTR2voUNOt94svYMgQyJlAmkVFx7+YJYPzgftAfmAK8CXgZnLSL+rD1q3QsSNMnAhOTjaM18Yk4RJCCCGEzWit8bzgydDdQ/nz/J+kcUnDsCrD+L7E96RIYt9NYUUcYbHAihVmFuv8eaha1fTV+ugjW0dmXeHAFsxs1jZMFvEp8B1QAYgogPHvv1C/Ppw9C9OmmYTL3knCJYQQQgir01qz7dw2hnoNxfuyN+5J3RlTbQwdincgaWI73QMj4p4//oBeveDwYShSBLZtg+rVbR2Vdd0E5gIzgUtARmAQ0D7i82fs2AFNm5rqg7//DpUrWznWOEoSLiGEEEJYjdaaTac3MXT3UHyu+ZDZLTOTa02mXdF2uDi52Do8IYzjxynUowf4+EC2bLB4sVlC6OBg68isQwN7MbNZq4FQ4BNgPFAPeGF5oNYwZQp07Woq4m/aZJ8rLV9FEi4hhBBCxLpwSzhrfdcybPcwjt08Ro6UOZhVdxati7QmcaLEtg5PCMNigQkToE8fkidJAuPGwXffgbOzrSOzjkfAUkyidQxIgVky2AHIG/lTQkLghx9g9myzlHDJEkie3ErxxhOScAkhhBAi1oRZwlh+fDnD9wzn1J1T5EmTh0UNF/H5h5/j6CC/hog45No1aN3aLCNs0ICDbdtS1l4aRvliimAsBB4ChYFZwBfAa1b43r4NjRvD7t3Qt6+pIWIvk4DRIf+nE0IIIUSMCwkPYdHRRYzYMwK/+358mP5DVjZZSeN8jUnkkMjW4QnxvPXroX17CA42jYvbtyd01y5bRxW7QoGNmNmsnUBioBlmRqsUT4tgvMrRo6aB8c2bsGwZfP557IYbn1k9B1VKZVFKrVFKPVBKPVRKrVNKZY3C84orpWYppU4ppQKVUpeUUkuVUjkiGXtBKaUj+WgYO69KCCGEEADBYcFMPTiV3JNy8/WvX5MqSSo2fLaBIx2O0KxAM0m2RNwSEADffAOffgo5cpjiGF9/bao+JFTXgIFANqAp4AeMAC4Di4HSvDHZWr8eypaF0FDw8pJk602sOsOllHIF/sT0n26N2ZI3FNiplCqktQ54zdObAwWAScAJIBPQH/BRShXRWl9+Yfw2zI/Ts06/84sQQgghxEsCQgKYeWgmo/eO5sajG5TJUoZZ9WZRI1cNVEL+5VXEXz4+0KKFqV/euzcMGgSJE+h+Qg14Ymaz1gMWoCZm2WAtIIp/B9HatCEbMAA+/tgkXu+9FysRJyjWXlL4NZATyKO1/hdAKXUMOAt8C4x7zXNHaq1vP3tAKeUNnI8474AXxt/RWu+PqcCFEEII8bKHjx8y9eBUxu0fx53AO1TOXpllny6jUvZKkmiJuCk8HEaNMllDhgzw559QqZKto4odDzCzVtMw+7RSA10xRTByRe9UAQHQti2sXg1ffmlWXiZJEsPxJlDWTrjqA/ufJFsAWuvzEYlTA16TcL2YbEUcu6iUuo2Z7RJCCCGEldwLusekA5OYeGAi/wX/R63ctehXvh9ls5a1dWhCvNqlSyZb8PIyDaNmzoRUqWwdVcw7hkmylgABQElgAWaP1lt0X7h0CRo2hCNHTK76008Je9VlTLN2wlUAsz3vRScwq0ijRSmVD0iPydlfVE8pFYiZJP0b8NBab4juNYQQQgjx/24F3GL8vvFM/Wsq/iH+NMzbkH7l+1E8Y3FbhybE661cCd9+a2a4FiyAVq0SVtbwGFiLSbS8gSTA55giGO/w9ty7Fxo1MvVENm+G2rVjIFY7Y+2EKzVwP5Lj94Bo/XlBKeUIzABuY/pfP+tX4C/MckN34AdgvVLqS631kugGLYQQQti7a/7XGLN3DDN8ZhAcFkyzAs3oW74vhdwL2To0IV7v4UPo1AkWLTIbj5YuhVzRXE8Xl10CZgJzgFtAbmAs0Abzm/c7mD8fOnSArFnB0xPy5Xu389krpbW23sWUCgHGaq37vHB8GNBLax3lBFApNQNoB9TRWv/+hrGJgP1ABq11lleM+Qb4BsDd3b3YihUrohpKrHr06BHJkiWzdRjiBXJf4h65J3GT3Je4J7r35EbwDVZcXsHW61sJ1+FUda9Ki6wtyOr6xgLDIhrkvRI73E6cIN/w4SS5cYOLLVty8csv0Y5R+3UzTt8TC6TySUWmjZlIsz8NAHdL3+Vqg6vcL3b/neuQh4crZszIyZo1WShW7B4DBpzEzS0sBgJ/d3HpvlSuXPmQ1vrN84daa6t9ADeBmZEcnwbcjsZ5RmDqq3wZjef0xNRoee9NY4sVK6bjip07d9o6BBEJuS9xj9yTuEnuS9wT1Xty9u5Z/dWGr7TjYEftNNhJf73pa/3v3X9jNzg7Ju+VGBYaqvXAgVonSqR19uxa79kT7VPEyXtyV2s9VmudW5vfWtNprftqrS/E3CXu39e6Rg2tQetOncy3Mi6JS/cF8NFRyEOsvaTwBGYf14vyAyejcgKlVD+gN/Cj1npxNK79ZJGu9ab0hBBCiHjG97Yvw3YPY/k/y3FycKJDsQ70KNuDrClkRkvEE35+0LIl7Ntn/p0yBVKksHVU78YHMz2xHAgGygGDgU8B55i7zOnTUL8+nD9vqhB+/XXMndueWTvh2gSMUUrl1Fr7ASilsgNlMUnUaymlfsT07eqntZ4c1YtG7PdqClzSWt94i7iFEEKIBO3ojaMM3T2UtSfX4uLkQtdSXeleujvvJZcmOyKe0BqWLIHvvwcHB1i2LH535A0CVmESrYNAUkwX245A4Zi/3LZt8NlnphXZjh1QvnzMX8NeWTvhmo0pYLFRKfUzZrZpCKa39cwng5RS2YBzwGCt9eCIY82BCcBvwJ9KqVLPnPeh1vpkxLjPMSXmt0ac1x34HiiGqdUihBBCiAgHrx5kqNdQfj3zK8kTJ6dPuT50Ld2VtK5pbR2aEFH333/QsSOsWGEyhcWLIVs2W0f1ds5hysLNw5SVywdMBr4EYmGiTmsYPx569ICCBWHTpvj7rYurrJpwaa0DlFJVgPGYNmwK2AF00Vo/emaowpRzf3bLX82I4zUjPp61C6gU8fl5TKn40ZjaLIGYioU1tdbbYvL1CCGEEPHVnkt7GOI1hN/P/U6qJKkYVGkQnUp2IpVLAuxJJBI2Ly/TW+vqVRg6FHr3hkSJbB1V9IRjpgqmYaYWEgGNMFMGFfn/jTEx7PFjU4VwwQJT+n3RIogj9SgSFGvPcKG1vgQ0fsOYC7zwo6W1boMpcPmm8+8Hqrx1gEIIIUQCpbXm0P1DDFwwkF0Xd5HONR0en3jwXYnvSO6c3NbhCRE9oaEwcCCMGAE5c5qGUSVL2jqq6HnS3GgGcBHICAwEvo74PBbdvAmffmq+bb/8AgMGmJWYIuZZPeESQgghhHVZtIVNpzfhsceDA1cP8F6y9xhfYzzfFPsGVydXW4cnRPSdPQstWsBff8FXX8HEifFnakZjmhVNBVYDIUBlTO+s+oBT7Idw+DA0aAB378KqVdC0aexf055JwiWEEEIkUCHhISw7voyR3iM5decUOVLmoMv7XRjRbARJHJPYOjwhok9rmDcPfvwRnJ1hzRpo/NqFU3FHALAMs2zwCOAGfIspgmHFhsKrVkGbNpA2LXh7Q9Gi1ru2vZKJQyGEECKBCQgJYOL+ieSelJu2G9uSOFFiln26jDOdztAgYwNJtkT8dPcuNGkC7dtDqVJw7Fj8SLZOAZ2BTMA3mE6yM4GrwCSslmxZLGbZ4GefmSTrr78k2bKWKM9wKaUKAT8DFTDFKEpprQ8rpYYCXlrr32MpRiGEEEJEwb2ge0w5OIVJByZxN+gu5bOWZ0bdGdTKXQulYmnXvRDWsGMHtGoFt2/D6NHQrVvc3nAUhmmGNBX4E7NMsCnwHVCGWCuC8SqPHplv3/r1ZgXmtGlmglBYR5QSLqVUGUw1wUvAOswE6BMOQAdAEi4hhBDCBq48vMK4feOYdWgWAaEB1P2gLr3L9qZs1rK2Dk2Id/P4Mfz8M4wZA3nzwubNcXta5jqmCdIszAxWVmA40A5TQ9sGLlwwzYxPnDDl3zt3Bvn7i3VFdYZrJCbhqs//J1hP+AAtYjguIYQQQrzB6TunGeU9isXHFmPRFpoXbE6vsr340P1DW4cmxLvz9YUvvoAjR0yPrTFjwDUOFnnRgBdmb9Y6zOxWjYiv62BKvNuIl5dZdRkaClu3Qo0atovFnkU14SoGNNZaW9TLaxLuYJoLCyGEEMIKfK754LHHg3W+63B2dOabYt/QvXR3cqTKYevQhHh3WsP06dC9u6k8uGkT1Ktn66he9hDTVXYacBJIhdmr1QHIbcO4IsyeDd99B7lymW/hBx/YOiL7FdWE6zHg8orHMgAPYiYcIYQQQkRGa82f5/9kxJ4R7Di/gxTOKehTrg+dS3UmfVIbrVUSIqbdumU2GW3ZYqZjFiyADBlsHdXzjgPTMcnWI6A4MB/4jFf/tmxFoaFmi9uUKVCzJixfDilT2joq+xbVhGsP8KNSasMzx3TEv18BO2M0KiGEEEIAEG4JZ8OpDXh4e+BzzYcMyTIwquoovi3+LW7ObrYOT4iY87//mXrlDx6Yvlo//BB3CmOEYJYLTgN2A0mA5pgiGCVsGNcL7t0zPbX+/NMkXaNGQSIbLmkURlQTrgGYpOtvTIs2DbRUSo0CSgHxrK23EEIIEbeFhIew5NgSRnmP4vTd0+RKlYuZdWfSqnArKesuEpagIOjVCyZPhoIF4Y8/4MM4sg/xEqYAxmzgFpALGAO0AdLYLqzInDxpimNcvgzz55vcVcQNUUq4tNZ/K6UqYX7EBmKKWXYB9gKVtda+sRWgEEIIYU8ehTxi9qHZjN03lqv+VymSoQgrGq+gSf4mJHKQP1WLBOb4cVMY459/TPk8Dw9IYuM/KGhgJxT4pYD5TVcDdTGzWdWJk11st2yBzz83NUV27oQyZWwdkXhWlPtwaa3/AioqpVyBtMB9rbV/rEUmhBBC2JE7gXeYfGAykw9O5n7wfSpmq8jc+nOpnqu69NASCY/FYma0evUyG4z+9z+z4ciWQoFVmOmFI5AiZQrohWlWnN2Wgb2a1qYtWe/eplr+hg2QJYutoxIvimofrlnAcK31Ba11IGaC9cljWYGftdbfxFKMQgghRIJ16cElxu0bx+zDswkMDaRBngb0KtuL0llK2zo0IWLH9etmvdvvv5vqg3PnQrp0tovnIWbJ4ATgCpAPmAP7s+ynQvUKtovrDYKD4euvYckSaNbMLCOMi1XzRdRnuNoDc4ALkTyWDtPOTRIuIYQQIop8b/syau8olhxbAsAXH35Br7K9yJ8uv40jEyIWbdwI7dpBYCDMmAHffGO7LryXgUmYPVoPgcrADKAW4AAWT4tt4oqCa9egUSM4eBCGDoW+faWZcVwW5SWFr+EOBMXAeYQQQogE78CVA3h4e7Dh1AZcHF34rvh3dCvdjWwps9k6NCFiT0CA6as1c6ZZ+7ZsGeTNa5tY/gbGAisx+7OaAd0xXWfjgb/+goYNTTHH9evN5yJue2XCpZRqADR45lB/pdTtF4a5ABWBw7EQmxBCCJEgaK3Z7rcdjz0e7Lywk5RJUtK/Qn86lexEuqQ2XEolhDUcPmwKY5w5Az17wpAhkDixdWPQwDbM/qwdQDKgE6ZRcTz6W8eyZWaC0N0d9u6FQoVsHZGIitfNcOUEqkV8rjGl30NeGPMY8MFsKRRCCCHEM8It4azzXYeHtweHrx8mY/KMjKk2hm+KfUNy5+S2Dk+I2GWxwJgx8PPPkD69KfdepYp1Y3gMLMfMaP0DZAJGYjbCxKNmwBYL9OtnijhWqABr1th225uInlcmXFrr8cB4AKXUZaCu1vqotQITQggh4qvHYY9ZdHQRo/aO4t97//J+6veZU28OLQu1xNnR2dbhCRH7rlyBVq1MjfLGjc1SwjRWbFx1H7MfaxJwAygELAI+A6w8ufauHj6Eli3h11/NlrfJk60/QSjeTVT7cEmBSSGEEOIN/B/7M/PQTMbtG8f1R9f56L2PWN10NY3yNpIeWsJ+rF4N334LISGmAmHbttar6HAeU21wLhCA6Zu1CKiK6SIbz/j5mWbGp07BlCnw3XdSHCM+ilbRDKWUG5AbeKkjndZ6b0wFJYQQQsQntwNuM+nAJKb8NYX/gv+jSo4qLGy4kKo5q0oPLWE//P1N8+L586FkSVi6FHLnts61D2KWDa4BEgGfYwphxOM9Tjt3QpMmptfWtm3wySe2jki8raj24XLGdCj4nFf315Y/3QkhhLArF/+7yJi9Y5j791yCw4JplK8Rvcr2omSmkrYOTQjrOnAAWrSA8+fNnq0BA8DJKXavaQE2Ywph7AZSAD0wxTAyxe6lY9u0afDjj/DBB2YpYa5cto5IvIuoznD9jCmg0R6YD/yI2YbYBtOHq1tsBCeEEELERf/c+odR3qNYdnwZSim+LPQlPcr0IF+6fLYOTQjrCg+HESNg4EDIlAk8PaF8+di9ZhCwGDOjdQbIiqk60A6I57VoQkNNojVjBtSpY6oSurnZOirxrqKacDUFBgNLMAnXXq31YWC2Umod8AnmbwxCCCFEgrXv8j5G7BnBr2d+xdXJlU4lO9GtdDeypJCtzsIOXbgAX34Je/bA55+baZmUsVj67w4wDZgC3Mb0zVoONCFmOsva2J07Zgnhrl3QqxcMGwaJZP1YghDVH8+swAmtdbhSKhRI+sxjc4B5QNeYDk4IIYSwNa01285tY8SeEXhd9CK1S2oGVhzIDyV/II2rFauuCRGXLFsGHTuaDUZLlpjlhLHlDGYGawEQDNQFfgIqEC8LYUTm+HFTHOP69dj/dgrri2rCdRfTIg7gCmYL4u6Ir1NhGiALIYQQCUaYJYw1J9fgsceDozePktktM+NrjKf9R+1JljjZm08gREL04IEplbdsGZQtC4sXQ44cMX8dDezF7M/aCDgBrTCbWBLYyt2NG03Z9+TJwcvL1BsRCUtUE64DQGFgK7AOGKKUcgXCgJ6Ad+yEJ4QQQlhXcFgwC48sZNTeUfjd9yNPmjzMqz+PFoVakDiRNL8RdmzPHpMZXLkCgwdDnz7gGMNr+cKBDZhEaz+QGugHfA9kiNlL2ZrWMHy4qTFSogSsX2+2wYmEJ6rvklFAtojPhwIfACMwFQt9gO9iPjQhhBDCeh4+fsj0v6Yzfv94bgbcpETGEoypNoYGeRvgoF5VoFcIOxAaahKs4cMhe3aTeJUqFbPXCMBUCRgP+AG5gKlAa57fyJJABAbCV1/BypXwxRcwZw64yHqxBCuqjY8PYjocoLV+ADRQSrkASbTW92MxPiGEECJW3Xx0k4kHJjLtr2k8ePyAajmr0btcbypnryw9tIT491+zoejgQWjTBiZNMmvfYsoNTBGMacB9oBQwGmhAgm04dOUKNGwIhw+Dhwf07CnNjBO6NyZcSqnEwB6gn9Z6+5PjWusgTGFOIYQQIt45f/88Y/aOYd6ReTwOe0zj/I3pVbYXxTMWt3VoQtie1rBgAXTqZPpprVwJzZrF3PlPAuMw5d1DgYaYQhhlYu4ScdH+/SbZCgyETZugbl1bRySs4Y0Jl9Y6RCn1AWZVrRBCCBGvHb95HA9vD1b+sxIH5UCrwq3oWbYnH6T5wNahCRE33LsHHTrA6tVQsaIpjJElBlofaMATsz9rK6bkWnugC/D+u58+rlu0CL7+GjJnhh07oEABW0ckrCWqe7j+AKoCf8ZiLEIIIUSs2XNpDx57PNhydgtJnZLSpVQXupbqSiY32aUuxFM7d5reWjdvmvVuP/307s2gQoE1mETrMJAO0921I5D2HeONB8LDoXdvGDMGKlc2eWwa6ShhV6KacI0DlimlHDC1Y65j/k7xlNb6UgzHJoQQQrwTrTVbz25lxJ4ReF/2Jo1LGgZXGsz3Jb8ntUtqW4cnRNwREgL9+8Po0fD++2btW7Fi73bOh5hurROBS0AeYBbQErtpKPTgATRvDr/9Bt9/D+PHmxWawr5ENeHaE/FvT6DHK8Yk0K2NQggh4pswSxirTqzCY48Hx28dJ4tbFibWnEi7ou1ImjgBljwT4l2cOmUKYxw+DN9+C2PHQtJ3eJ9cASYBMzFJV0VMxcHamPrWduLsWahXD86dgxkzzLdW2KeoJlzf8MKMlhBCCBHXBIUGMf/IfEbvHc2F/y6QP11+FjZcyOcFP8cpkfxZWYjnaA2zZkHXruDqChs2QIMGb3++o8BYYDlgAZoC3YESMRFs/LJ9u6kxkigR/PGH2Qon7FdUy8LPie1AhBBCiLf1X/B/TP9rOhMOTOBWwC0+zvQxE2pMoF6eetJDS4jI3L4N7dubUnnVqpmKhBkzRv88Gvgdk2htx/TM+h7oDOSIuXDjC61h8mTo1g3y54eNGyGHHX4fxPNiuD24EEIIYT03Ht1g/L7xTPeZjn+IPzVy1aBPuT5UyFZBemgJ8Sq//w6tW5tqhOPHw48/gkM0/zARgpnJGgscB94DPDBrolLFcLzxxOPHZp/W3LlmonDx4phtWSbiL0m4hBBCxDvn7p1j9N7RLDiygFBLKE3zN6VX2V4Ufa+orUMTIu4KDoY+fWDCBFOTfNs2KFQoeuf4D7M3axJwDSgILAA+BxLHbLjxya1b8Omn4O0NP/8MgwZFP4cVCZckXEIIIeKNIzeOMNJ7JKtOrMLRwZE2hdvQo2wPcqfObevQhIjb/vkHvvgCjh83zYxHjgSXaJQKvABMAOYCjzDNguYB1QE7n0w+csTMaN2+DStWwGef2TqihCuEEHQ8LCth9dxbKZVFKbVGKfVAKfVQKbVOKZU1Cs8rrpSapZQ6pZQKVEpdUkotVUq9tDJWKeWglOqjlLqglApWSh1VSjWOnVckhBAiNmmt8broRa2ltSg6syibz2yme+nuXOh8gZn1ZkqyJcTrPNlUVLy46a21ZQtMmhT1ZMsHaA7kwlQabAT8jdmvVQO7T7bWroWyZcFigd27JdmKDRYs7GEPHehABjJwLtk5W4cUbVad4VJKuWKaJz8GWmO2Wg4FdiqlCmmtA17z9OZAAcwk9gkgE9Af8FFKFdFaX35m7BDgJ6AfcCjiuauVUnW11ltj+GUJIYSIBRZtYfOZzXjs8WDflX2kc03HsCrD6Fi8I6lc7HSTiBDRceMGtG1rmkDVqQPz5kH69G9+ngXYimlUvAtww1Qb/BHIHIvxxiMWCwwebJYOlioF69dDhgy2jiphOcUplrCEpSzlAhdwxZVGNMLREv8W6EU7YqWUC5AauKm1Dovm078GcgJ5tNb/RpzvGHAW+BbTYPlVRmqtb78QizdwPuK8AyKOpcckWx5a6zERQ3cqpXJjtnNKwiWEEHFYaHgoK/5ZwUjvkZy4fYJsKbIxpdYUvir6FS5OdtItVYh3tXkzfPUV+PvD1KnQsSO8qZBMMLAY89vYKSALpihGe0zSJQAICDA1R9auNf/OnAnOzraOKmG4wQ1WsIIlLOEQh3DAgWpUYwhDaEhDkpEMz0BPW4cZbVFOuJRStYBBwEcRh0oCh5VSM4GdWusVUThNfWD/k2QLQGt9PiJxasBrEq4Xk62IYxeVUrcxs11P1MBs21zywvAlwDylVA6t9fkoxCqEEMKKAkMDmff3PMbsHcPFBxcpkK4Aixst5rMCn0kPLSGiKjAQevSAadOgcGFYtszUJ3+dO8B0YApwCygKLMX00ZK33nMuXTL7tY4dM/2hu3Z9cx4rXu8Rj9jABpawhO1sx4KFYhRjPONpTnMyEP+nDqOUcCml6gEbAE/gZ2D4Mw9fBtoAUUm4CgAbIzl+AvO2jhalVD4gPeD7wjUeA/++MPxExL/5MbNiQggh4oD7QfeZ+tdUJh6YyJ3AO5TJUoYptadQ+/3a0kNLiOg4csQUxvD1he7dYdiw10+9/AuMB+YDQUBtzBqhStj93qzI7NljKhE+fmwmEGvVsnVE8VcYYWxnO0tYwgY2EEgg2clOH/rQghbkI5+tQ4xRUZ3hGggs0lq3VUo58nzCdRzoEMXzpAbuR3L8HtHs2hARxwzgNqZmzrPX+E9r/WIJk3vPPC6EEMLGrvlfY/y+8cw4NINHIY+o/X5tepftTfls5W0dmhDxi8UC48ZB376QNi1s3w5Vq756/F7MUsH1mBmslkA3zJ+sRaTmzjWrMrNnN72i8+a1dUTxj0bjgw9LWMIKVnCLW6QiFa1oRQtaUIYyOFi/np9VqJfzkkgGKRUE1Ndab1dKJQJCgeJa68NKqQrA71rrJFE4TwgwVmvd54Xjw4BeWuvoLHGcAbQD6mitf3/m+Gygrtb6vRfGvw+cAVpprRdHcr5vMO36cHd3L7ZiRVQm7GLfo0ePSJYsma3DEC+Q+xL3yD2JmyK7L1cCr7Di8gp+v/k74Tqcyukr0zxLc3Ink2qD1iDvlbjpbe9L4tu3yefhQarDh7ldvjynu3cnLEWKlweGQ1rvtGRZlYUUJ1IQmjyUa/WvcbXRVULShMTAK0h4Hj16hItLcqZPz8XatZkpXvweAwacJHny6JYwsG/XklzjD/c/+MP9Dy67XsbJ4kSZO2WoerMqJe+VJLGOXgO3uPT/sMqVKx/SWhd/40Ct9Rs/MCt6m0d8nghTv+ajiK+/BC5H8Tw3gZmRHJ8G3I7KOSLGj4iI4ctIHhuJ2fapXjheElMVsc6bzl+sWDEdV+zcudPWIYhIyH2Je+SexE3P3pdD1w7ppquaajVQaechzrrj5o763L1ztgvOTsl7JW56q/uydq3WqVNr7eqq9ezZWlssL48J0FpP1Vrn0ua3nBxa68la60fvEKyd2LRpt65WTWvQuksXrUNDbR1R/HFH39HT9DRdRpfRRPxXSVfSc/QcfV/ff6dzx6X/hwE+Ogq5S1RnlHYAvZWpXhufAAAgAElEQVRS/8fefcfXfH4BHP98k5DYxN5qVVEztbekSKr1Q1VRFKVaipaKVRq1asWmKCpW0RpNqJXYYpeido1QW2Qg4z6/P55I0SBkfO9NzjuvvCTXvfd7bm7GPd/zPOf4AY9atyvDMNICnwO/x/N+jhF3wbo0cDw+d2AYxiDAE/hCxVGpijmGI3pixOP7uB7tGI3XcYQQQiScUgr/8/6M3jmaDWc3kNkxM/1r9qdXtV7kyWj7G6GFMEVoKPTurde5Va6sG2OULPnkda6h52ZNB26hTzuPRs/Rsk/meG3QsWPw2WeVuHZNf5k7dTI7Iut3n/usZS0++LCOdUQRRRnKMJrRfMiHFOKFY3dTrPgmXAOBvegmob7oSlE/oDyQHWgZz/tZA4wzDKOoUuocgGEYRYCa6CTquQzD+AI9t2uQUmrKM662HogA2qK7Kj7SDvhTSYdCIYRIckop1pxcg+chT/7a9he5M+RmdMPRfOryKVmc4ljuJISIn337oG1bOHMGBgyAYcMg7WNLsk6gez4vRL8aehfdCKMm0ggjHm7d0vO1pk+HTJkc8PfXg41F3KKJZitb8cGHFawghBDykY8+9KEtbSlHOQz5xotfwqV063YXwAtoGnOxGzq5GayUuhzP480GegCrDcMYjE7chqM7Hc56dCXDMAoDZwEvpZRXzGWtAe+YY24xDKPaY/d7Tyl1PCbW64ZhTAQGGIYRAhwEPgAaoFvPCyGESEJbzm/Bc5Mn+67sI69TXmZ4zKBD+Q4yQ0uIhIiOhjFjYOhQyJsX/P2hbl39fwrYhh5U/BvgBHwM9AFKPuP+xBMiIvS4Mi8vuHcPunaFt9/eR03JtuJ0hCP44MNiFhNEEJnIREta0o521KUu9lJGfUJ828JnAK4opTok5GBKqTDDMBqgm5AuRJ9r2Qz0VkqFPn5IdMH78VYljWMubxzz/rit6CamjwwCQoFeQB7gJNBKKbU2IfELIYR4tgNXDjBg8wA2nttIwcwF+fHdHyl0txANXRqaHZoQtu3CBfjoI9i+HT74AGbMgGzZIApYiU609gM50H2lPwNymheuLVEKVq2Cr7/WRcNGjWDcOChbFgICIs0Oz6pc5jKLWYwPPhzlKA440IQmTGACTWlKOuSk2rO8MOEyDCMNEAw0Ry8JTBCl1EWgxQuu8zdPFb6VUh3R877ic4xo9NLD714lRiGEEPF36tYphvgP4edjP5M9XXbGvz2ez976DCcHJwICAswOTwjbtnQpfPqpbv3+00/Qrh2EGnrNjzdwASiBHpTTHuQ1b/wdOABffgnbtunZ0OvWQeOnT+mncsEEs5KV+OBDAAEoFNWpzjSm0YpW5CCH2SHahBcmXEqpSMMwrqPPowghhBAABN0LwmurF3MPzcXJwYkhdYbwVfWvZI+WEInh3j3o0QMWLoTq1cHHBxyLwgB0chUM1AYmA+9ACh1flCQuX4ZBg3T+mjOnLhh26QIO8R5OlLJFEMF61uODD2tYw0MeUoISDGMYbWlLMYqZHaLNie+31mL0amC/JIxFCCGEDbhz/w5jdo5hUuAkoi3RdHfpzuA6g8mdMbfZoQmRMuzapStZFy7oPVvvDQYvB/1qLBq9TugroKq5Ydqa0FAYO1a/R0dD//6670hcY8tSG4ViF7vwwYef+Znb3CYnOelGN9rRDhdcpPlFAsQ34ToFfGAYxm5gNXAVvUUzllLqp0SOTQghhBUJjwxncuBkxuwcQ/CDYNqWa8u39b6laLaiZocmRMoQFQXffQfDh0OhwjD+CKwro3supwc+BXoD8iP3UqKjdTVr0CC4elVvgxs1Cl57zezIzPcXf7Eo5u0850lHOv7H/2hHO1xxJQ1pzA4xRYhvwjUz5t/8xH0+RQGScAkhRAoUGR3J3ENz8drqxdXQq3iU8GBkw5GUy13O7NCESDGcrlyBOnVg936oOR2Cu0Afe936ayTQDXA2OUgb5O+v92kdPgxVq8LKlXqFZmp2jWssZSk++LCf/dhhhyuufMu3NKMZmchkdogpTnwTrhJJGoUQQgirY1EWlh9bzmD/wZy5fYaaBWuyrOUyaheubXZoQqQcSsFPP+HyqSfwCWTbBDvTQ2ngR6AN4GhuiLbo1CndeXD1aihUCJYs0ZUtI5WuigsjjFWswgcfNrKRaKKpRCUmMIHWtCYvec0OMUWL7xyus0kdiBBCCOuglGLD2Q0M2DyAQ/8comyusqz9cC0eJTwwUuurFSGSwu7d0GMsHKyFvd0ZsGSAGuhBxY+G4YiXcvu2nqU1bRqkS6eXDvbqpT9ObaKIYhOb8MGHVawijDAKUxhPPGlLW97gDbNDTDWkH4sQQohYgZcD8dzsScDfARTJWoSF/1vIh2U/xN5OhlgKkWjOnoVuc2BzBeBnsLPjer3r5B6XASqaHZxtioiA6dN1shUcDJ98At9+C7lTWS8fheIAB/DBhyUs4TrXyUY22sW81aAGdtLSMtnFd/DxaZ5qkvE0pZTMMhdCCBt14sYJBm0ZxK9//UrO9DmZ3HgyXSt3xdFB1jIJkWiu34JOq8HvdVCjwPEBfGqBrxw4cfYvclfMY3aENkcpvWywXz89uPjtt2H8eD24ODU5z3kWsQgffDjJSdKSlqY0pR3taEITHGVdqqniW+EK5L8JV3agGnAP2JaYQQkhhEgeF4MvMixgGAv+WECGNBnwqudF72q9yeQom6aFSDQ3H0CXHbC2GFg6Qcab8HUw9M5CbH8C2bzx0g4e1A0xtm5NnYOLb3GL5SzHBx92shOAutSlL31pSUuyktXkCMUj8d3D1S6uyw3DcAbWA76JGZQQQoikdTP8JqO2j2LavmkoFL2q9mJg7YHkSJ/D7NCESDkuWeDzE+BbACyukPUEfHMJehaUTR0JEBT07+DiHDlS1+Di+9znN35jEYvww49IIilNaUYxija0oRCFzA5RxCFB35pKqduGYXwPeAHLEickIYQQSSU0IpSJuycydtdYwiLD6FC+A8PqDaNQFvkjLUSiOQT0/wc25gBKQZYtMDwr9HzL7MhsWljYv4OLo6J0F8LUMLjYgoWtbMUHH1awgnvcIx/5+IIvaEc7ylNehhJbucQ4FxAOkk4LIYQ1i4iO4IcDPzB823Cuh12nWalmjGgwgtI5S5sdmhApgwXwA74Lg8AMQAbIuACGOUOf98BOGhW8Kovl38HFV65Aq1YwenTKH1x8lKP44MNiFnOZy2QkIy1pSTvaUY962CPNjGzFKydchmHYoadEfAOcSLSIhBBCJBqLsrD46GK+8f+G83fPU7dwXVa3Xk21AtXMDk2IlOE+8BMwLgrOOAC3wXE09HcGz09TZz/yRBQQoPdpHToEVarA8uVQo4bZUSWdy1xmCUvwwYcjHMEBBxrTmHGMoylNSU96s0MUryC+XQoj+W/TDDv0hIhQwCOR4xJCCJEASin8TvsxcMtAjlw7QoU8FVjfdj1vF3tbZmkJkRiuAdOA6QpuGWB3FOwmQDdn+HYw5MxpdoQ27fRpvWRw1So9uHjxYj24OCUWCoMJ5hd+wQcf/PFHoahGNaYylVa0IifyvWTr4lvhGsN/E64HwAXAVyl1J1GjEkII8cp2XNzBgM0D2HFxB8WyFWNJiyW0KtMKOyMFvlIRIrn9CUwEfBREAo4bgJHwXg4YPQpKypSchLh9G4YPh6lTwckJRo6E3r1TXqEwggjWsx4ffFjDGh7ykOIUZyhDaUtbilPc7BBFIopvl8LBSR2IEEKIhDl67SgDtwzkt1O/kSdjHmZ4zKBzxc6ksU9jdmhC2DYFbAQmAL8DjtGQcQXcHgLlnfXgp5o1zY3RxkVE6G6D336rBxd36aKHGKekwcUKxW5244MPy1jGbW6Tk5x0pSvtaMdbvCXNL1KoVNBAUwghUrbzd84zNGAoPkd8yOyYmVENR9GzSk8ypM1gdmhC2LaHwGJ0ovUnkCMSivnA2X6QPwvMHA0tW4Is031lSsGaNXpw8enT4Oam89c33zQ7ssRzkpMsink7xznSkY5mNKMd7XDDjTTISbGU7pkJl2EYP7zE/SilVLdEiEcIIUQ8XQu9xojtI5i5fyb2dvb0q9GP/rX645zO2ezQhLBtN4GZwFT0Xq1SEVDzJ9jZA6LTw8RvoHt3cHQ0N04bd/AgfPWVbozxxhvg56cHF6eE/PUa11jGMnzwYR/7sMOOhjRkKEP5H/8jEzJcPjV5XoXLnf/u23qW+F5PCCFEAt17eI/xu8Yzfvd4HkQ9oHPFznxT9xvyZ85vdmhC2LaTgDewAN190DUKGi6EXz6Hc9HQ9wsYOBCyZTM3ThsXFASDB8OCBZA9O0yfDp98YvuDi8MIYzWr8cGHDWwgmmgqUpHxjKc1rclHPrNDFCZ55re2UqpAcgYihBDi+R5EPWDGvhmM2D6CW/dv8X7p9xlefziv53jd7NCEsF0K2IpeNrgWSAu0tUC+ZfBDL7hxA9q0gREjoEgRMyO1eWFhMG4cfP+9Hlzcr5/OX215cHEUUWxmM4tYxC/8QhhhFKIQ/elPW9pSGpl1KGQPlxBCWL1oSzQLjyxkaMBQLgZfxK2oGyMbjsQln4vZoQlhuyKBn9GJ1kEgBzBEQbHfYVRvOHkS6tbVGYKL/KwlhMUCCxfq5ColDC5WKA5yEB98WMISrnGNrGSlLW1pRztqUhM7pCus+Nfz9nDlA64rpaJiPn4updSVRI1MCCFSOaUUq0+uZtCWQRy/cRyXfC78+O6PNCza0OzQhLBdd4DZwGQgCCgFzAJK7YPBX8Hw7VCqFKxeDU2bpowNRSbaulUPLj54UA8u/vln223oeJ7zLGYxPvjwF3+RlrS8wzu0ox3uuOOI7OkTcXtehesSUB3YC1zmxfu07BMrKCGESO22/r0Vz82e7Lm8h9ezv86K91fQ/I3mMrRYiFd1DpgEzAXCgAbEJFrnYfBA6LYUcuXSvcm7dLH9DUUmO30a+veHX3+FggVh0SJo3dr2Bhff5jbLWY4PPuxgBwB1qMOXfElLWpIN2c8nXux5v026Amcf+1gaYwghRBI7dPUQA7cMZP2Z9eTPlJ85TefQoUIHHOzkxZ8Qr2QXMB5YBdgBHwJfAoXv6H1ZzaeAvb3u4vD115BJusclxJ07/w4udnTUX+I+fWxrcPFtbvM7vzO9zHQCCSSSSEpTmpGMpA1tKExhs0MUNuZ5TTPmPvbxnOQJRwghUqczt88wxH8IS/9cSjanbIx1G8vnb31OujQ29CpFCGsRBfyK3p+1B8gKfA30AHI81G3xhg+Hu3ehY0f9cX7p8pkQkZH/Di6+exc6d9aDi/PkMTuyF1MojnIU35i33ezGgoXsmbPzBV/QjnaUp7wMJRavTE6ZCiGEia6GXMVrqxdzDs0hrX1aBtUeRN8afcnqlNXs0ISwPfeAH9FLB/8GiqFnaXUAMii9gWjAADh/Hho10u3yypUzL94UQClYu1Z3HDx1Clxd9eBia/+yhhPOZjbjiy9++HGJSwBUohKDGIQHHoTuDqVhPdkzKxIu3gmXYRg5gA+A1wGnp/5bBh8LIcRLuPvgLt/v/B7vPd5EWiLpWqkrQ+oOIU9GGzgdLIS1uYhugjEbnXTVAiYCTdE7zHfsgL59ITBQZwK//w5vv21evCnEoUN6cLG/v+4z4usLTZpYb5+R85yPrWL5489DHpKRjLjhxlCG0oQmT8zKCiDAvGBFihKvhMswjJLAbnSi5YTu8ZMVvRo6GAhJqgCFECIluR95nyl7pzB6x2juPLhDmzfb4FXPi2LOxcwOTQjbsx+9bPDnmM9bovdnVYn5/NQp3blh1SrIlw/mzYOPPtJ7tsQru3JFb3mbPx+cnWHaND24OE0asyN7UiSR7GRnbJJ1ghMAlKAE3emOBx7UprZ0FxRJLr4VrrHoKRXvAaHA28AxdJF+MOCRJNEJIUQKEWWJYt6heQzbOowrIVdoUrwJIxuOpEKeCmaHJoRtiQZ+QzfC2A5kAnoDPSG2l8GNG3oz0axZ4OQE332nOzekT29OzClEWJheLjhmjB5c3Levnq2V1YpWQF/nOutYhy++bGADwQSThjTUpS5d6YoHHpSghNlhilQmvgnXW8BnwIOYz+2UUg+BHwzDcAa8AVnkKoQQT1FKseL4Cgb7D+bUrVNUL1Cdxc0XU7dIXbNDE8K2hAHz0a84zqCTqwlAZyBzzHXu3wdvbxg1CsLDoWtXGDoUcuc2JeSUwmIBHx+dXAUFQcuWenBxMSsozFuwcJCD+OGHL77sYx8KRV7y0pKWeOCBK65kQrpPCvPEN+HKDNxSSlkMw7iHnsf+yF50lUsIIcRjNp3bhOcmTw5cPUCZnGVY3Xo1TUs2lVlaQryMK+jGFzPRGxqqAMuA5vz7KsZigYUL9Tq3y5fh3Xd1GaZUKXNiTkEeH1z81luwdCnUqmVuTPe4x0Y24osv61jHP/yDgUFVquKFFx54UIEK0lVQWI34Jlx/A49OD50EWgDrYz5vAtxN3LCEEMJ27Qvax4DNA9h8fjOFsxRmQbMFtH2zLfZ2sm9EiHj7A13BWoJu8/4/9P6sGvDE6+hNm3SLvMOHdUbg4wN1pYKcUGfO6LFkv/4KBQroL+uHH5ozuFihOMWp2L1Y29lOJJFkJSuNaIQHHjSmMTnJmfzBCREP8U24NgGuwAp035/FhmHUQP8KLAuMSprwhBDCdpy8eZLB/oNZcXwFOdLnwLuRN5+6fIqjg2zIFiJeLOjTuROAzUAG4FOgF7rF++P+/FNnBOvWQeHCsHgxfPCBORlBCvL44OK0ac3b/vaQh2xla2ySdZazAJShDH3ogwce1KAGDjLhSNiA+H6XegLpAJRSSw3DeIhuEZ8emIUu9AshRKp0+d5lvg34lnmH55EuTTqG1R3Gl9W/JJOj7BkQIl4eAAvRp3RPAPmA0UBXINtT171yBb75RncczJwZxo6FHj10cwzxyh4fXHznjh5cPHx48g4uDiIodi/WJjYRRhhOONGABnzJl7jjThGKJF9AQiSSeCVcSqkH/NswA6XUr+gZ7kIIkWrdCr/F6B2jmbJ3CgpFjyo9GFh7ILky5DI7NCFsw3Vgesz7DaACOvFqBaR96rqhoTq5GjdOZwe9esGgQZA9e/LGnMI8Pbi4YUPdibB8+aQ/djTR7GVvbBXrMIcBKEQh2tMeDzyoT33SI90lhW17ZsJlGEYDYK9SKjQZ4xFCCKsXFhGG9x5vvt/1PSEPQ2hfvj3D6g2jSNYiZocmhG04jq5mLQQeAu+g92fVg//0OYiKgh9/1FWta9egVSsYOdI6WuTZuMOHdUOMR4OLf/sN3N2TdnDxbW6zgQ344st61nOTm9hjTw1qMJrReOBBGcpIwwuRojyvwrURqI7uQohhGHZAANBZKXU66UMTQgjrEhEdwZyDc/Da6sW1sGu8+/q7jGgwgrK5ypodmhDWT6H3ZU0A1gFOQEf0DK24mgkqBX5+uvRy4gTUrKkHGFerlmwhp1RXrsCQIXpVprOz3q/VtWvSDC5WKP7kz9gq1i52YcFCdrLThCZ44EEjGpHtP2tHhUg5npdwPX1qwQBqgQwyEEKkLhZlYemfSxniP4Rzd85Ru1BtfvngF2oUrGF2aEJYvwh0p8EJwBEgF+CFbobxrKZyBw/qqbr+/lCiBPzyCzRrlrSll1QgPPzfwcUREfDVV3pVZmIPLg4nnC1swRdf/PDjIhcBqEhFBjAADzyoQhXskc6tInWQ1i5CCPEMSinWn1nPgM0D+OPaH5TPXR6/Nn40Lt5YZmkJ8SK30S21pgJXgTLAXKANuroVl4sXdQbg4wM5csCUKdCtW9KUXlIRiwUWLYIBA5JucPHf/B1bxfLHnwc8IAMZcMONIQyhCU3IT/7EO6AQNiTZEy7DMAqiV267oatmm4DeSqmL8bjtSMAFqAw4Ax8rpebHcb0AIK4hHH2UUt6vHLwQItXYfWk3nps92XZhG0WzFWVR80W0LtsaO0NaTgvxXKcBb2A+EA68DcyL+fdZ5ynu3oVRo2DSJF3F8vTU71myJEvIKdm2bXqf1oED4OKSeIOLI4lkF7tik6zjHAegOMXpRjc88KAOdXBExmII8aKEK79hGEVjPrZ/7LL/DDpWSp170cEMw0gPbEFvke2AXtH9HeBvGEY5pVTYC+6iJ3AY+A1o/4LrHgG6PXXZ3y+KUQiRuh27foxBWwax+uRqcmfIzTT3aXSp1IW09k+3TBNCxFLAdvSywTVAGqAt0Ad48zm3i4iAmTPBywtu34aPPtKDnwoWTPqYU7gzZ6B/f70aM7EGF9/gButYhy++/M7vBBNMGtJQhzp0oQseeFCSkon3IIRIIV6UcK2I47JVz7hufBbifgIUBV5XSp0BMAzjCPp8WDf0r+rnyaKUshiGUZwXJ1whSqk98YhJCCG4cPcCQwOG8tMfP5HJMRPf1f+O3tV6kyFtBrNDE8J6RaJfKUwA9gPZgUHA58Dz5jcppTMBT0+dGTRsqFu+V6yY9DGncHfu6Jx1yhQ9uHj4cF3hepXBxQrFIQ7FVrH2sheFIg95aEELPPDAFVcykznxH4gQKcjzEq6Pk+B47wJ7HiVbAEqp84Zh7ATe4wUJl1LKkgQxCSFSsRthNxi5fSTT90/HwOCr6l/hWcuT7Ollto8QzxQMzAYmA5eAksAM9KnQF72w371bN8TYtQvKlNGdCBs3loYYCRQZqYuFw4bppKtTJ51s5c37cvcTQggb2YgvvqxjHVe5ioHBW7zFMIbhgQcVqYgdsrxaiPh6ZsKllFqQBMcrA6yO4/JjwPuJfKyKhmEEo3/1nwAmKaXmJvIxhBA2KuRhCBN2T2Dc7nGER4bzcYWPGVp3KAWzyFImIZ7pPDrJmgOEoudmTQM84IWvv8+c0V0bVqyAPHlg9mzo2BEcpH9XQigFvr46hz15Eho0gAkTXm5w8SlOxVaxtrGNSCLJTGYa0QgPPGhCE3IhA92FeFWGUir5DmYYEcAEpZTnU5d/B3gqpeL1WzdmSeFpnt00wwt9zu0UkBV9zq05MEQp9d0z7rMr0BUgd+7clZcuXRrfh5WkQkNDyZgxo9lhiKfI82J94vucRFgiWHNlDT4XfQiODKZOjjp0fq0zhdIXSoYoUx/5WbE+r/KcZD6emQI/FyDn9pwoQ3Gj/g0uvX+J0JKhL7ytQ3AwRRYuJN/q1SgHBy62bs3lVq2ITpfuVR9CivQqz8uZMxmYMaM4Bw9mo2DBcLp3P0u1ardeWCyMMCI4kvUIe7LvYY/zHoLSBwFQOKww1W5Vo9rtapQNLotD/F6WpVjy+8s6WdPzUr9+/QNKKZcXXlEplWzv6Gkco+K4fAQQ9RL3Uxy9RbfjS9zmV+A+kPFF161cubKyFv7+/maHIOIgz4v1edFzEhUdpRYcXqAKTyysGIZqsKCBCrwcmDzBpWLys2J94v2cRCmlViilaij91zGLUuprpdSleB7o/n2lxoxRKksWpezslOraVakrV14+4FTiZX5WrlxRqnNnpQxDKWdnpaZMUSoi4vm3CVJBaraarZqpZiqjyqhQKEflqJqoJmqqmqrOqXMJewApkPz+sk7W9LwA+1U88pDkPnVxB93O/WnZYv4vKS0BmqH7Je1O4mMJIayEUoq1p9YycPNAjt04RuW8lZnddDauRV1llpYQcQlBt3H3Ri8hfA2YBHQC4nNS2WKBJUtg4EA9V8vDQ0/aLVMm6WJOJcLD9XLB0aN1g8cvv9Rjy7Jl++91o4lmH/tilwoe4hAABSlIO9rhgQcNaED6F266E0IkVHInXMfQ+7ieVhpiBjgknUevrJJvDaUQwlTbL2zHc7Mnuy7tooRzCX5u+TMtSreQWVpCxOUyMAWYhW6KUQMYiz5VGZ8+xAD+/tCvnx76VLEizJunNxWJBLFYYPFivQXu8mVo0ULnsE8PLr7LXX7n99iGFze5iR121KAGoxiFBx6UpSzGMweiCSGSQnInXGuAcYZhFFUxc7sMwygC1AQ8n3O7xNAGvaTwaBIfRwhhsj/++YOBWwbid9qPfJny8cM7P9CxQkfS2KcxOzQhrM9BdI/gZYAFaAF8CVR7ifs4cQK+/hp++03P0PrpJ2jbNmFDnwQA27frStb+/Xpw8eLFULu2/j+F4jjHY6tYO9lJNNFkJzuNaYwHHjSiEc5xLi4SQiSX5E64ZgM9gNWGYQxGV5uGoxtczHp0JcMwCgNnAS+llNdjl9cFcvLvdA8XwzBCAZRSK2KuUxudvP2CHnScBT1k+V10Y44XDVcWQtioc3fOMcR/CEuOLiGLUxbGuI6hR5UepE8jS2aEeIIF8EUnWgHopYI9gF5AkZe4n3/+0X3I58yBDBn0WrcvvgBpiJFgZ8/qwcUrV+rBxQsXQps28NDuPr5swQ8/fPHlAhcAKE95+tMfDzyoSlXs412WFEIktWRNuJRSYYZhNAAmAgvRy/w2A72VUo+3OjLQCxiePjX2LVD3sc8/j3l/dBuAqzG38wJyoMcyHgHaKKWWJN6jEUJYi6B7QUw6PYnftv9GGrs0eNbypF+NfmRLF8fGBiFSs3DItyYfdEP38S0IjAO6oE9PxldYGIwfD99/Dw8fwmefwTffQI4cSRF1qnL3rh5cPHnyv4OLW355kS3pf6MpvmxhCw94QHrS44orAxmIO+4UoIDZoQshniHZ+30qpS6iFyw87zp/w38XGCul6sXj/s8ATV4xPCGEDdkbtBfvPd4sP74ci8VC18pdGVJ3CPky5TM7NCGsy1H0OhIfKBlcElzQraRaAC+z0jY6GubPhyFD4OpVaN5cV7VKlEiCoFOXqCiDqVN1wfD2bYV7p38oPHwuS/MuZQjHAChGMbrSFQ88qEMdnHAyN2ghRLyk7gELQgibE2WJ4tcTv+Id6M2uS7vIlDYTPav05C3LW3zY5EOzwxPCeoSj92X9AOwBHIGWcKjKISr2rByKtmMAACAASURBVBjHac3nUAp+/13v0zp6FKpVg+XLoWbNpIg8VbFY9Na3z3pWIugi5GrwJxnGd8e3wg4ccKAOdehEJzzwoCQlpeGFEDZIEi4hhE24c/8Ocw7OYcreKVy6d4li2YoxqfEkOlboSGbHzAQEBJgdohDW4bFqFsFAKfRerfZAdggOCH65ZOvwYd15cNMmKFoUfv4ZWrbkhdN1xXOdD4pg5PwrrPwxM3fOOUPJK7CmL7yzj/cNdzzojRtuZCaz2aEKIRJIEi4hhFU7desUkwMnM//wfMIiw6hfpD5T3afiUcIDezvZFC4E8MxqFl2B2rxcgvXI5csweLDuOJgtG3h7Q/fuemOReGkKxeHIY0zxPYfv3Nxc93MBSxFosJliw7dS0+UKPUsOpRKVsPvPFnYhhC2ThEsIYXWUUmw+vxnvPd74nvYlrX1a2rzZhl5Ve1EhTwWzwxPCerygmvVK7t3TQ54mTNDr3fr21UOMs2ZNnJhTkSCC2MQmVp4+wpa5RQib/z5cK4t9vmtUHrCBzh/b82GxKmSlIQEBAbiUdDE7ZCFEEpCESwhhNe5H3mfR0UV47/Hm2I1j5MqQi2F1h/Gpy6fkzpjb7PCEsA5JUc0CiIyE2bN114YbN3QP8hEjoEiRRAg6dbjHPQIIYBOb2BC+g5Mry8CcLrCtA4Z9NBXeucwXXa7zUePcODhIfy8hUgtJuIQQprsacpXp+6Yz88BMbobfpHzu8sx7bx4flv0QRwdHs8MTwjokRTULdEOM1av10KdTp6BuXRg3Tk/ZFc8VSSSBBLKRjWxiE4EEEn2wHPZzu2EsGgnBGSlY/CGfjbbQob09efMWNjtkIYQJJOESQpjmwJUDeAd6s+zPZURZonj39XfpXa03dQvXxZAN+UJAGPAziV/NemTvXr1kcPt2KFUK1qyBd96RhhjPoFAc5zib2MRGNrKVrYQSinE3G4UWe5JjznKuHcpHGifF++8bdO4Mdeo4ypdTiFROEi4hRLKKtkSz+uRqvPd4s/3idjKmzchnb31Gzyo9KeZczOzwhLAOR9BJ1kLgHolXzXrk/Hm9L2vpUsiVC2bMgC5dwEFeFjwtiCA2s5lNMW9XuQpAcVWChtu8uDunBYErCnLhgUGlSvDNNGjTxpAtb0KIWPKbVQiRLIIfBDP30Fym7J3C33f/pkjWIkx4ewKdKnYii1MWs8MTwnzPqmZ1A2qR8GoWwK1bFJs+XS8htLfXA4z79YNMmRLhzlOGEEJi92FtYhPHOQ5ADnLgiisuV5tyfUETfv0xG6tPQ5Ys0KkTdO4MlSqZHLwQwipJwiWESFJnbp9hcuBk5h2eR2hEKHUK12HC2xN49/V3pa27EJD01SyAoCDddXDWLAqEh8PHH4OXF+TPn0gHsF2RRLKXvU/sw4oiinSkow51+JiPqRflStC6csyba0f/3yA6Wm91++YbaN4c0qc3+1EIIayZJFxCiESnlCLg7wC8A71Ze3ItDnYOtC7bml5Ve1E5X2WzwxPCfMlRzQI4fRq+/17P0oqOhtat2dewIVU+/jiRDmB7FIoTnIjdhxVAgN6HhYELLnzN17jiSnWqE3TWiR9/hHfnwdWrkDu33vLWqROULGn2IxFC2ApJuIQQieZB1AOWHF2Cd6A3R64dIUf6HAyuM5juLt3Jmymv2eEJYb64qlkTgY9IvGoWwKFDMHo0rFgBadLo9W79+sFrrxEeEJCIB7INV7jyxD6sK1wBoDjFaUc73HCjHvVwxpkHD+CXX8B9Dvj7g50duLvrLW7u7vrLKYQQL0MSLiFEgv0T+g8z989kxv4ZXA+7zpu53mTuu3P5sOyHpEuTzuzwhDBXXNWs99GdBhOzmqWU7jY4ahSsX6/3ZfXrB717Q548iXQQ2xBCCFvZGlvFenwfVkMa4hrzVoQisbf54w8YNhd8fODOHShaVI8h69BBVl4KIRJGEi4hxCs7/M9hvPd4s+TPJURER/BOyXfoXbU3DV5rIG3dhUiuapZS4OurE61duyBnTp0pfPYZqaVV3qN9WI8qWHvYQxRROOFEHerQkY644kp5ymOHXezt7t2DJUtgzhzYvx8cHfWerC5doF49Xd0SQoiEkoRLCPFSoi3RrD21Fu893my9sJUMaTLQtVJXelbtScnssqlBpHKPqlmzgECSrpoFEBUFP/+slw4ePQqFCsGUKXqDUQrv4qBQ/MVfsY0uAggghBAMDCpTmX70wxVXalADJ5yevK2CnTt1krV8OYSHw5tvwuTJ0LYtODub9KCEECmWJFxCiHi59/Ae8w7NY/LeyZy7c45CWQox1m0snSt2Jlu6bGaHJ4S5jqCTLB+StpoF8OABzJ8PY8fCuXNQurRuitG6dYreYHSVq2xmc2yS9WgfVjGK0YY2uOFGferjTNwZ07Vr+ss0dy6cPKlXXH70kd7e5uIis56FEElHEi4hxHOdv3OeyYGTmXtoLiERIdQsWJMxrmNoVqoZDnbyK0SkYslZzQK9/m3GDJg4UWcPVavqVu9Nm6bItW8hhLCNbbH7sI5xDIDsZH9iH9ZrvPbM+4iOhg0bdDVrzRpdFKxZEzw94f33IUOG5Ho0QojUTF4tCSH+QynF9ovb8d7jzeqTq7Ez7GhVphW9qvaiSv4qZocnhLmerma9QdJVswBu3IBJk2DqVAgOBjc3GDBAbzJKQWWZKKKe2Ie1m91EEYUjjtSmNu1pjyuuVKDCE/uw4vL33/DjjzBvHly+rLe19e6tq1mlSiXP4xFCiEck4RJCxHoY9ZBlx5bhvcebQ/8cwjmdM541Pfnsrc/In1nadIlULLmrWQAXLsD48bo88+CB7ubg6anXv6UACsVJTj6xD+se9zAwqEQlvuIr3HCjBjVIx4u7nT58CKtW6SWDmzbpyxo31rnqO+9A2rRJ/ICEEOIZJOESQnA97Doz989k+r7pXAu7RumcpfnhnR9oW64t6dOk7M33QjzXs6pZ7eEZW4US7vhxGDMGFi/Wn3/0EXz9dYoozfzDP0/swwoiCICiFKU1rXHFlQY0IPtLlAr//FMnWQsXwq1bULgwfPstdOwIBQsm0QMRQoiXIAmXEKnYkWtHmLRnEouOLuJh9EOaFG9C72q9cSvqJm3dReplRjULYO9e3dp91SrdZfDzz+Grr2w6awglNHYf1iY2cZSjADjj/MQ+rKIUfan7DQmBZct08S8wUFevmjXT7dwbNkyRW9qEEDZMEi4hUhmLsuB32o+Jeyay5fwW0jmko1PFTnxR9QtK5bD9M+hCvLI/0HOzkrOapRRs3qwTrS1b9NysIUPgiy8gR44kOmjSiSKK/eyPrWDtZjeRROKII7WoxWhGx+7Dssf+pe5bKdizRydZy5ZBWBiUKaN7iLRrZ5NfLiFEKiEJlxCpRGhEKPMPz2dS4CTO3D5DgcwFGN1wNJ9U/gTndDJ4RqRSYcAydKKVnNUsi0VXskaN0hN38+bVbd67ddP9ym2EQnGKU7GdBP3xj92HVZGK9KEPbrhRk5rx2ocVlxs39HLBuXP1assMGeDDD3UDjKpVU1TfECFECiUJlxAp3N93/2bq3qnMOTiH4IfBVCtQje/qf0fzN5qTxj7lzuwR4rniqmZ5ozsNJuX5h8hIWLRI79H66y8oVgxmzYL27cHJ6cW3twLXuMZmNscuE7zEJQCKUIQP+CB2H1YOXr3kZLHoxhdz5ui8NDISqlXTn7dqZVM5qRBCSMIlREqklGLXpV1M3DORX//6FQODlqVb0rtab6oVqGZ2eEKY41nVrG5ATZKumgUQHq6zhXHj4NIlKF8eliyBli3Bwbr/FIcR9sQ+rCMcASAb2WhIQwYxCFdcKUaxBB/r4kXdyv3HH/XH2bNDjx66mlWmTILvXgghTGHdv+WFEC8lIjqC5ceW4x3ozf4r+8nmlI1+Nfrx+VufUzCL7W68FyJBzKpmAdy5A9Om6d7kN29CrVowcyY0aWK1a+GiiOIAB2L3Ye1iF5FEkpa01KIWoxiFK65UpOJL78OKS0SEHko8dy78/ru+zM1Nr7B87z1wdEzwIYQQwlSScAmRAtwMv8kPB35g2r5pXAm5wuvZX2eGxww+KvcRGdJmMDs8IZKfmdUsgKtXdTeHGTMgNBTc3fWw4lq1kvjAL0+hOM3pJ/ZhBRMMQEUq0pvesfuw0pN4YyJOnNBJ1k8/6X1aBQrofiEffwxFiiTaYYQQwnSScAlhw45dP8akwEksPLKQB1EPeLvY28xpOodGxRthZ0hfZJEKmVnNAjh7Vpdm5s/XG49atdLDisuXT4aDx991rsfuw9rIxth9WIUpzPu8H7sPKyc5E/W4oaGwfLleXblrl15N+d57up27mxvYJ7xgJoQQVkcSLiFsjEVZWH9mPd57vNl4biNODk60L9eeL6p+QZlcsslBpEJmV7MAjhyB0aN1v3IHBz11t18/KF48GQ7+YpFEsotd+OHHSpeVnOUsAFnJSkMaMpCBsfuwjET+gikF+/bpJGvJEp10lSqlt7N99BHkypWohxNCCKsjCZcQNiIsIoyf/viJSYGTOHnrJPky5WNEgxF0rdyVHOllAI1IhcyuZgHs2KETLV9fyJgRvvwS+vSBfPmSKYBn+4d/WM96/PBjAxsIJhgHHCgbWZaRjMQVVypRKVH2YcXl1i3w8dHLBo8e1bOcW7XS1awaNax2C5sQQiQ6SbiEsHKXgi8xde9Ufjj4A3cf3MUlnwuLmi+iZemWpLVPa3Z4QiSvR9WsWcBedDWrFXpuVnJVs5SCdev0DK0dO3QrPS8v3U4vW7ZkCCBuFizsZz+++OKHH/vZD0Be8tKSlrjjjiuuHPzjIPXq1UuaGCzg76+rWb/8ohtivPWW7nzfujVkzpwkhxVCCKsmCZcQVmrP5T147/FmxfEVKBTN32hOn2p9qF6gOoacGhapjTVUs6Kj9Qak0aPhjz+gYEHdfbBzZz2N1wR3uMMGNuCLL+tZzw1uYIcd1ajGd3yHO+5UoEKiLxN82uXLetvajz/C+fM67/z0U/2lKVcuSQ8thBBWTxIuIaxIZHQkK0+sxHuPN4FBgWRxzEKfan3oUaUHhbMWNjs8IZKXNVSzAB4+hAUL4PvvdVOMUqX0sKg2bSBt8laZFYqjHMUPP3zxZTe7iSYaZ5xpQhPccacRjchO9iSPJTISfvtNLxlct05Xtxo0gBEj4H//s5k5zkIIkeQk4RLCCty+f5sfDvzA1L1TCQoJooRzCaY2mUqHCh3ImDaj2eEJkbysoZoFEBKi18JNmKDbvLu4wMqV0KwZ2CVfF9BQQtnMZvxi3i5zGdAt2z3xxAMPqlAlyfZiPe3UKZ1kLVgA167p7WoDBkCnTlC0aLKEIIQQNkUSLiFMdOLGCSYHTmbBHwu4H3Wfhq81ZOY7M3Ev4S5t3UXqYi3VLNADiidPhqlT9eDiBg30sKiGDZOt08NpTsfuxdrKViKIIBOZcMONYQyjCU3IR/I15ggPhxUr9N6s7dt1+/amTfWSwcaNdWNGIYQQcZNfkUIkM6UUG85uwDvQm/Vn1uNo70i7cu3oVbUXb+Z+0+zwhEhef6CTrEXoalZpzKlmAVy6BOPHw+zZOsNo1kzP0KpaNckP/YAHbGNbbJJ1hjMAvMEb9KQn7rhTi1qkJfmWMCoFBw/qJGvxYrh3T3e5Hz0aOnSAPHmSLRQhhLBpknAJkUzCI8PxOeKD9x5vTtw8QZ6MefCq58WnLp+SM0PiDhcVwqqFAUvRywYfr2Z1A2qQvNUsgJMnYcwY3cPcYoG2baF/fyhdOkkPe4lLscsEN7GJcMJxwon61Kc3vWlCE4qS/Gv07tzRCdacOXD4sN6L9f77up177drSzl0IIV6WJFxCJLGge0FM2zeNWQdmcfv+bSrmqchPzX6iVZlWODo4mh2eEMnnUTXLBwjB3GoWwIEDurX7L7+AoyN06wZ9+0LhpGlQE0VU7PBhP/w4ylEAClOYjnTEAw/qUY/0pE+S4z+PUrB1q06yVq6EBw+gUiWYNk33BsmaNdlDEkKIFCPZEy7DMAoCEwE39HnMTUBvpdTFeNx2JOACVEb/ef5YKTX/Gdf9BPgKeA34G5iolJqZCA9BiHjZG7QX7z3eLD++nGhLNM1KNaNPtT7UKlRL2rqLVMPuvh3MxXqqWUpBQIBOtDZuhCxZdMeHXr0gV65EP9x1rrOOdfjhx+/8Hjt8uDa1GctYPPCgFKWSvG37s1y9+m879zNn9JejUye9N6tSJVNCEkKIFCdZEy7DMNIDW4CHQAdAAd8B/oZhlFNKhb3gLnoCh4HfgPbPOc4n6POoo9AJXUNgumEYhlJqRoIfiBDPEGWJ4tcTv+Id6M2uS7vIlDYTPav0pEeVHhTNJu27RCoRBWwHlkGNhTUgHPOrWRYLrF2rE63AQMidW29G+vRTnWUk1mGwcIADsW3b97MfhSIPeWhBC9xxxw03MmPeBODoaIO1a3U1y9dXjxerWxeGDoUWLSBdOtNCE0KIFCm5K1yfAEWB15VSZwAMwzgCnEaf75zwgttnUUpZDMMozjMSLsMwHIARwEKl1KCYi/0Nw8gHDDcMY45SKjIRHosQse7cv8Ocg3OYsncKl+5domi2okxqPImOFTqS2dG8F1ZCJJtI9Om0lcCvwE0gHdysdZM8Q/OYU80CPSxq6VKdXB0/Dq+9BtOnQ8eOiZZZ3OUuG9iAH36sYx3XuY6BQVWq4oVX7PBhO8ztPBoSopsvTpxYjVu3dNOLfv10RatECVNDE0KIFC25E653gT2Pki0ApdR5wzB2Au/xgoRLKWWJxzGqAznRuwQetxD4GKgF+L9M0EI8y6lbp5gcOJn5h+cTFhlGvSL1mNJkCu+UfAd7u+SZiSOEaR4CG4EVwBrgDpARaAq0ABrDX/v+Ik9NE9rZ3b+v18mNHQsXLkDZsropxgcfJLiHuUJxjGOxHQV3spNooslGNhrTGHfcaUxjcpAjkR5Mwty/DzNm6OLezZtQpUooc+c64u4OadKYHZ0QQqR8yZ1wlQFWx3H5MeD9RDwGwJ9xHAP0whZJuMQrU0px4M4Bxi0eh+9pX9Lap6XNm23oVbUXFfJUMDs8IZJWOLAeXclai25+kRV9Oq0leneuk2nRQXCwrmB5e8P161C9OkyZAh4eCRpWHEYYW9gSm2Rd4hIAFahAf/rjjjtVqYqDFfWiiojQOed330FQELi66o/v3z9KvXr1zA5PCCFSjeT+y+CMPgf6tNtAtkQ8BnEc5/ZT/y/ES1FKsfbUWob4D+HItSPkypCLoXWH0t2lO7kz5jY7PCGSTgjgi06y/NBJV3bgA3QlqwEk43iouF27BhMn6lLOvXvQqJFuhlGnziv3MT/Dmdi9WAEEEEEEGcmIG258wzc0oQn5yZ/IDyThoqNh0SIYNgzOn4caNXRx71GOFRBgYnBCCJEKGUqp5DuYYUQA45VSA566fATQXykVrwQwZg/XaeLoUmgYxiB0Iw4npdTDxy53QO8y+EYpNTyO++wKdAXInTt35aVLl77MQ0syoaGhZMyY0ewwUr2Ddw4y5/wcToScoEC6ArTI1QL3Qu6ktTP7VaZ4RH5WEpdDqAPZd2Un59acOO9zxi7SjofOD7lZ6yY36t4guHwwyv7Ffz+S+nlxunqVgkuXknfdOoyoKG7UqcPFNm0ILVnype8rwojgSNYjBDoHEpg9kEvpdRWrYHhBqt2qRtVbVXkz+E3SKuv8ubdYYPv2nMybV4QLFzJQokQInTqdp2rV20/knPKzYp3kebE+8pxYJ2t6XurXr39AKeXyousld4XrDnFXmLIRd+XrVTxeybr62OXOT/3/E5RSP6AbF+Pi4qKsZblFQECALP0w0d6gvQzaMohN5zZRIHMBZjedTYfyHdi5fac8L1ZGflYSwU30ou+V6P6ukUAB4DOgBTjWcCS/ff6Xquok2fPy55+6EcbSpXqpYPv28PXX5CpZkpdp7n6Zy08MHw4jDEccqU99+tEPd9wplr4YpAcKJv7DSAxKwbp1MHgwHDoEb7wBy5dD8+aZsLMr95/ry8+KdZLnxfrIc2KdbPF5Se6E6xj/7rF6XGngeCIeg5jjPJ5wlY75N7GOI1KwP6//yRD/Iaz6axU50udgwtsT6P5Wd5wczNycIkQSuIbuKrgCCACi0dMLe6H3ZL0FJjfXe9Lu3br7w9q1kCEDfPEFfPklFCgQr5tHEcUe9sQuFTzCEQAKUYj2tMcddxrQwJThw68iIEAnWjt36gaMCxZA27ZgLz17hBDCaiR3wrUGGGcYRlGl1DkAwzCKADUBz0Q6xm70edq26HO0j7RDV7d2JtJxRAp07s45hgUMw+eIDxnTZuTbet/Sp1ofMjlmMjs0IRLPZeAXdCVrO3oiYkmgP3pPVkXMaeH+LErBhg060dq6FZyd9QalHj0ge/YX3vwGN1jP+tjhw3e4gwMO1KIW3/M97rhTmtKmDR9+FXv3wqBBsGkT5Munt6516gRprXO1oxBCpGrJnXDNBnoAqw3DGIz+Mz8cuIQeVAyAYRiFgbOAl1LK67HL66Jbvj/qMexiGEYogFJqRcy/kYZhDEEPOg5CJ10NgE5AT6VURNI+RGGLroZcZfi24cw+OBsHOwf61uhL/5r9yZ7+xS/mhLAJf6MTrBXAnpjLygLfoCtZZbCuJAt094dfftFLBw8ehPz5YcIE+OQTeM76fQsWDnIwdqngXvaiUOQmN+/xHh544IYbWUi8gcfJ5cgRGDIE1qyBHDlg/Hjo3l2GFQshhDVL1oRLKRVmGEYDYCJ6LpYBbAZ6K6VCH7uqAdjz34Us3wJ1H/v885j3R7d5dJyZhmEo4CugH3AR6KGUmp6ID0ekALfv32bMjjFM2TuFSEskXSp2YUjdIeTLlM/s0IRIuFP8m2QdjLmsIno0fAvgdZPiepGICFi4EL7/Hk6d0lN558yBdu3A0THOmwQTzEY24osv61jHNa5hYFCFKgxjGB54UJGKpg8fflWnTsHQobBsGWTODMOHQ69ekEmK70IIYfWSfWCIUuoi+k/9867zN3Gca1VK1XuJ48zisaqZEI8LjQjFe483Y3eNJeRhCG3LtWVY3WEUcy5mdmhCvDqF3qW6Ap1oHY25vCrwPfo3b1FzQouX0FCYPVuXbYKCoGJF+PlnaN78P5uSFIrjHI/di7WTnUQRRVayxg4fbkQjcr1UCw3rc+ECeHnpvVmOjuDpCX376lWVQgghbIP1TGgUIhk8iHrArP2zGLF9BDfCb/De6+8xvP5w3sz9ptmhCfFqFHCYfytZJ9Gnq2oB3kBzrLa7Xqzbt/Vw4smT9cd168LcufD220/M0AonnC1siV0qeIELAJSjXGxHwWpUs6rhw6/q6lUYORJmzdJfgh499Fix3DLyTwghbI7t/1USIh6iLFEsOLyAb7d+y6V7l2jwWgNGNhhJ1QJVzQ5NiJengH38W8k6h16AXQ/dXbAZkNes4F5CUJDekzVrFoSFQdOmOquoXj32Kuc4hy+++OGHP/485CEZyIArrgxiEE1oQgHi16HQFty6pVdSTpmiV1Z26qT3bBW09qRZCCHEM0nCJVI0i7Kw4vgKhvgP4dStU1TJX4V5782jYdGGZocmxMuxALvQCdZKdKshB8AVGAC8h24pZAtOn9ZZxYIFelpv69bQvz+8+SYRRLCdzbFJ1klOAlCSknSnO+64U4c6OBL3Xi5bde8eTJyo88+QEGjTRjdiLF7c7MiEEEIklCRcIkVSSrHuzDoGbRnE4X8OUyZnGVZ9sIp3X38Xw7C2VmxCPEMUum37CvSsrKuAI/A28B3QFD023lYcOqQ7Di5frvuXd+kCffsSVNSRdazDl2/YxCZCCcURR+pRj8/4DHfcKU7KzDzCw2HaNBgzRle3mjfXe7bKxDWxUgghhE2ShEukONsvbGfgloHsuLiD17K+xsL/LeTDsh9ibyeTQIUNiAS2oKtYv6KnCqYD3NFNLzyAzKZF9/KUgm3b9Ayt9eshUyYsX/dlf+9arM4TiC/N+YM/ACjI/9u77/ioqryP45+T0EEILYCA9JLQew1EwIriilgXAeuqa/exAhbAXfexre7qrq7uCuquPtZV111dSpAiSO8ICEjvLZSElPP8cSaZyTCQkExyZ5Lvm9d9Be7cOzl3Lknmm3PO7zRmJCNzFx+uSlWPG1980tNd4cVJk2DXLrjoIvf37t29bpmIiISbApeUGot3Lmbs9LH8Z8N/aFCtAa9f+jq3dL2FCrFaCVQiXDrwX1xP1hfAQaAacBlujayLIeqyR2YmfP01XZ54AlatIrtuHZY9ezWv3ZXNZ3Fvc4DniSWWfvTjOZ5jKENpR7uoWny4MDIzYcoU14v188+QlOQKMSYled0yEREpLgpcEvXW7lvLkzOe5KPVH1Grci3+d8j/8uuev6ZK+SpeN03k9I4D/8H1ZH0JpAI1cHOxrsING6zkWesKb/lymDwZ+/77mN27yTy3Ki/+oSlP3ryZ41U+Ip54LudyLuVSLuRC4ojzusUlIjvbBaunnnJranXv7mqFBBViFBGRUkiBS6LWz4d+ZsLMCbyz7B0ql6vM+AHjeajPQ9SoVMPrpomElgr8CxeyvsaFrtrANbierEFANHbI7tqF/fv7nJzyFhWXrSWzvOGboeV4axT8a+gxulRoxyOM4VIupRvdonbx4cKwFr76CsaNc1m0fXv47DO44goFLRGRskKBS6LO7qO7+c2s3/DnRX8G4N6e9/J40uPEV43uBU6llDqE68H6GPgGN3ywHjAa15M1kOj8TpyWxqF/TubYlD9T/5tlxGZZlvWAKX+A766rT7c6F3EVgxk1pypX9rvS69Z6Yto0GDsW5s931Qbffx+uvfaUNZxFRKSUi8Yf81JGHUo7xAtzX+D3835PWmYaN3W+ifEDx3NejfO8bppIXvuAf+J6sqbiCmE0An6F68nqiS56ZgAAIABJREFUC0Thm+5Ue4QVc9/ATJ5Cu/9bTdzhbI42hFcfrsjmG5Nok3gl9zKEP9Aqdy5WSkaKt432wNy5rkdrxgy3ftZf/gKjR0P58l63TEREvKDAJRHveMZxXp3/Kr+b8zsOpR3i2nbX8kzyM7Sp08brpon47cZVFfwYSAGygGa4hYivAnpCtI2kO8lJ5jOfxRs/ptq7nzHw3a30/QmOVYG5V9Vn36ihtDr/Nu6N7U5sNCbIMFuyxAWtr7+G+Hh45RW4/XaoFI1z8UREJGwUuCRincw6yV8W/YVJsyax6+guLm11Kc8OepbO9Tt73TQRZxvwKa4naxZggdbAo7iQ1QWiqeheNtmsZCVTmcrcw/+m3kffce2Uk9w3C7INbDq/CavHX0vzqx7mgmp1vG5uxFizBp58Ej7+GGrWdBXw77kHqkZbZUkRESkWClwScbKys3h/xfs8lfIUmw9tJum8JD66+iP6n9ff66aJwGZcwPoYmOfb1x54EjdcsB1RFbI2s5mpTGUa00jJnEqnqfsYPRne+9xQKc2S2vpcTjx7M5VH3kaL8zR8N9DGjfDMM/Dee1ClCowfDw8+CHFlo/CiiIgUkAKXRAxrLZ+v/ZxxM8axeu9qutTvwp9++ScuanERRuW8xEvrcCHrE2CRb18X4FlcT1YUjW7dxz5mMIOpvj8b2Uj7FfDryVX50/tZxO2C7Jo1iLn5lzBqFOf07KlyekG2b3eLFL/1FpQrBw88AI8+CnXret0yERGJRApc4jlrLVM3TuWJ6U+wcMdC2tRuw0dXf8TwhOHEmCib9CKlgwVW4+/JWuHb3wv4X1zIau5N087WMY4xm9m5vVhLWAJAi93VePwfTbhickPqLt2OLZeOGToURo0iZuhQqFjR45ZHnr174bnn4PXX3QLGt93mqhA2bOh1y0REJJIpcImnvt/6PU9Mf4KUzSmcV+M8/jrsr9zY6UbKxei/ppQwCyzF35O1Fjc0sB/we2A40Niz1hVYJpksYAHTmObmYjGXDDKoQAUGpvXi4y+vY9DkLcT9Zz4maxV06wavPoq57jp10ZzGoUPw4ovw+9/D8eNw441uAeNmzbxumYiIRAO9qxVPLN+9nHHTx/Hlui+JrxrPqxe/yu3dbqdiOf1WXUqQBRbgerE+ATbiKgkmA/cAVwINvGpcwVgsq1mdG7BmMpMjHMFg6EIX7rf3cdX359J1yirKf/gJHJoF554L//M/Ljm0a+f1JUSsY8fg1Vfh+efh4EG4+mo3ZyshweuWiYhINFHgkhK14cAGnkp5in+s+AfVK1bn2UHPcm+ve6lWoZrXTZOyIhuYi78nayvuO+Fg4HHgCiDCO3q2sjU3YE1jGrvYBUALWnA91zOEIQze3IKa734FU6bAhg1QuTJcdRWMGgWDBmn13TNIS4M33oDf/Ab27IGhQ2HiROjSxeuWiYhINFLgkhKx/ch2JsycwNtL3qZiuYo81v8xHu77MDUr1/S6aVIWZOLKtn+MWytrJ1ABuAiYCAwDIvi/4kEOMoMZuSFrHesAiCeewQF/mh6p5WqTT/4DfPedOzk52U00uuoqOOcc7y4iCmRkwDvvwIQJsG0bnH8+fP459OnjdctERCSaKXBJsdp3fB/PzX6OP/7wR7JtNnd2v5OxA8ZSv1p9r5smpV0GMB3Xi/UZsA+oDFyCK98+FKjuWevO6AQnmMvc3EqCi1lMNtlUpSrJJHMHdzCEIbSnPSYrG6ZOhSlj4bPP4MQJaNXKldEbORKaNPH6ciJeVhZ88IGbl/XTT9C7N0ye7DoCRUREikqBS4rFkfQjvPT9S7z0/UscyzjGjR1v5KmBT9GspmaZSzFKB/6L68n6AjgIVAMuw1UWvASIwMVos8hiMYtzhwjOZjbppFOOcvShD0/yJEMYQk96Up7y7qSVK2HKo24RqJ073eJPo0e7rVcvlXIvAGtdD9b48bBqFXTqBF9+6YYQ6uUTEZFwUeCSsDqRcYLXF7zOb2f/lv0n9jM8YTgTz59IYt1Er5smpdUWYCYkTE6AH4BUoAZumOAI4EKgkoftC8FiWce63IA1gxkc4hAAHenIr/k1gxnMAAZQjYD5jXv2wD/+4eZlLV7sFoG65BIXsi67TKXcC8ha+PZbGDcOFi6ENm3gww9hxAiI0UoUIiISZgpcEhYZWRn8benfmDBzAttTt3NhiwuZdP4kejTs4XXTpDSxuEqCMwO2n91DtarXgmtwIWsQbo5WBNnJzjyFLraxDYAmNGEEIxjMYAYxiHji856YlgZf+Ypf/PvfbgGorl1djfLrr4f4+BCfTU5n1iw3pW3WLDfa8q9/dcUay+mnoYiIFBP9iJEiybbZfLjyQ55MeZINBzbQp1Ef3hv+HslNk71umpQGFrce1ne4cPUdsN33WB1gAPAgMBDm7JtD8uBkL1oZ0mEOM5OZuQFrNasBqE1tBjHIVRJkMM1pjiFo/Jq1MG+eC1kffOAWgmrQAB54wFUZbN/egyuKbgsXuh6tb75xL+Vrr8Gtt0KFCAvmIiJS+ihwSaFYa/lq3VeMmzGO5buX07FeR768/kuGthqK0eQHKaxsYCV5A9Ye32P1gYEBWwLkySkpJdbKkNJJ53u+zw1YC1hAFllUpjIDGMBN3MRgBtOJTsRwmnFrP/8M777rgtb69a6U+5VXupA1ZIhKuRfCypXw5JOunkjt2m5NrbvugipVvG6ZiIiUFQpcctZSNqfwxLQn+H7b97Ss1ZK/D/8717a/lhijyQ9ylrKApfgD1izggO+xxrj5VzkBqyUEdwR5KZtslrI0d5jgLGZxghPEEktPevI4jzOEIfSmNxU5w9yq1FRXyn3KFEhJcfsGDoTHHnOTiqpHaCnFCLdhAzz9NPz9764a/jPPwP336+UUEZGSp8AlBbZg+wLGTh/Lfzf+l4bnNOTNy95kTOcxlI8t73XTJFpkAIvwB6zZwBHfYy1wiw7nBKymHrTvDCyWn/gpN2DNYAb72Q9AO9pxG7cxhCEMZCDV86s3n5UF06a5kPXpp66Ue8uWbgGoG2+Epk2L/4JKqa1b3SLFf/2rGy74yCPw8MOud0tERMQLClySr9V7VzN+xng+XfMptSvX5sULX+TO7ndSuXxlr5smkS4dVzkwJ2DNBY75HmsLXI+bhzUAaORFA89sN7uZzvTckPWzr0JHIxpxOZfnLjjcgAYFe8LVq90CT++9Bzt2uFLuo0a5rU8f1SIvgt274be/hT/9yf37rrvgiSegvpb8ExERjylwyWltOriJp2c+zXvL36Nq+ao8PfBpHujzANUrakyOnMZxYB7+gDUPSPM91gEYg+u9GgDU86B9+Uglle/4LjdgrWAFAHHEMYhBPMIjDGEIrWh1aqGL09m711/KfdEiNw/rkktclcHLL4dKEVazPsocPOjmZb3yCqSnw5gxbs7Weed53TIRERFHgUtOsTN1J8/OepY3F71JbEwsD/Z+kEf7P0qdKnW8bppEmqPAHPwFLn7ADRuMAToDd+LCVRIQgUO6MshgPvNzC13MYx6ZZFKRiiSRxA3cwBCG0IUuxHIWBSvS0/2l3L/+2pVy79IFXn4ZbrhBpdzDIDXVZdYXX4QjR+C669w8rVatvG6ZiIhIXgpckuvAiQM8P+d5Xpn/ChnZGdzS5RbGDxhPw+oNvW6aRIpDuHlXOQFrEa7wRSzQHXgAF7D64xYfjjDZZLOSlbkBayYzOcYxYoihG914mIcZwhD60pdKZ7tasrXwww9uyOAHH7iul/r1XaWGUaOgQ4fiuagy5sQJeP11eO452LcPrrjCzdnSyysiIpFKgUs4evIor8x7hefnPs+R9CNc3+F6nkl+hpa1WnrdNPHafvKWaF+KWxurAtATeAwXsPoC1TxqYz42sznPgsN72QtAG9owhjEMZjDJJFOTmoX7BFu2+Eu5r1vnhggGlnLXirphcfKkK4QxcaKb/nbBBTBpEvTs6XXLREREzkzvBMqw9Mx03lj0Bs/OepY9x/YwrM0wJp4/kY71OnrdNPHKLvIGrJW+/ZWAPsBTuIDVG4jQmin72McMZuQGrJ/4CYAGNOAiLspdcLhRUap0pKbCJ5+4kDVjhts3YIAriTdiBNSIwO69KJWVBe+/70q8b9oE/fq5Uu8DB3rdMhERkYJR4CqDMrMzeXfZuzw982m2HN5CctNkPr/2c/o07uN106SkbcOFq5yA9aNvf1WgH66K4EDccMEzLCXlpUMcYg5zeLf5uzzIgyxlKRZLdaqTTDL3cR+DGUwCCQUvdBFKVpYLV5Mnu1Lux49DixZu4tDIkdC8efguSsjOdpn2ySdh7Vro2hVeew0uvljFHEVEJLoocJUh2TabT1Z/wvgZ4/lx/4/0OLcHbw97m8HNBmP0Dqb0s8Bm8gasjb7HquMKW9yCC1hdgAhdXm0725nl+zOb2axgBRZL+Ubl6Uc/JjKRwQymO90pF45vcWvWuJ6s996Dbdtc79XIkW7IYN++evcfZta6OiPjx8OSJZCY6NaFHj5cL7WIiEQnBa4ywFrLNz99w9jpY1m8czGJdRP59JpP+UXbXyholWYWWE/egLXV91gt3NDAe3ABqyOcTRG+kmKxrGUts5mdG7I2sxmAalSjL30ZwQiSSCJtdhoXD7g4PJ943z5X+GLyZFi40JVyv/hiVxLv8suhcoSOp4xyM2bAuHEwd67rMHz3Xbj+evfyi4iIRCsFrlJu9pbZPDHtCWZtmUXTuKZM/sVkftnhl8TG6B1MqZMNrCFvwNrle6weLmA9igtYibjS7REmgwyWsCS392o2s9nHPgDiiSeJJO7nfvrTn050ytODlZKdUrRPfvIk/OtfLmT961+ulHunTvDSS+5dv1bQLTbz58PYsTBtGjRsCG+8ATfdBOUjtJdVRETkbChwlVJLdi5h3IxxfL3+a+pXq89rl77GrV1vpUJsBa+bJuGSBazAH7BmgS+bQENgEC5cDQRaQ1GmLxWXYxxjHvNye6/mMY/jHAegJS25jMtI8v1pScuizcEKxVpYsMANGfzHP+DAAahXD+691w0Z7NQpvJ9P8li+3PVoffkl1K3rlim74w6tBS0iIqVLiQcuY0xj4GXgAtxbwKnA/dbaLQU4txIwERgJxOGKVD9qrf0u6LjNQJMQT3GltfbzIl1AhFu3fx3jZ4zn/1b9HzUr1eS5wc9xT697qFK+itdNk6LKBJbgD1izcetiATQDhuIPWM2IyIC1l725PVezmMViFpNFFjHE0IlO3Mqt9Pf9aUCD4mvI1q1uTtaUKa4iQ8WK8ItfwOjRrt64SrkXqx9/hKeegg8/hLg4ePZZl3GrRejSAiIiIkVRou8qjDFVgOlAOjAaN8tkEjDDGNPRWnssn6d4G/e28mHcdP9fA98YY/pYa5cGHfsN8HTQvh8ppbYc3sKEmRN4Z+k7VCpXiXFJ43io70PEVYrzumlSWCeBhfgD1hzgqO+x1sDVuGGCA4HGXjTwzCyWzWzOU+BiLWsBqEhFetGLx3iM/vSnL32pTvXibdDRo6664JQpMH26693q3x/+8hdXyj1OXyvF7eefXVHHyZPdNLixY+Ghh6BmIZdAExERiQYl/Wvc24DmQBtr7QYAY8xy3NT+XwEvne5EY0wn4AbgZmvt33z7ZgKrgAnAsKBT9llr54X9CiLMnmN7+O2s3/L6wtcBuLvn3Tze/3HqVavnccvkrKUB8/EHrO+BE77H2gGjcAFrABRn509hZZHFSlbmKXCxgx0AxBFHP/oxhjEkkUQ3ulGxJOrMZ2VBSooLWZ98AseOQbNmrtb4jTe6su5S7HbudL1Yb74JMTFw333w2GMQH+91y0RERIpfSQeuYcC8nLAFYK3dZIyZA1zBGQKX79wM4MOAczONMR8AjxljKlpr04up3RHncNphXpj7Ai/Pe5kTmScY02kMTyU/xXk1zvO6aVJQx3ChKidgzcf1ahmgE3A7LlwlAXU9auMZpJPOAhbk9l7NYQ6HOQxAIxoxkIH0pz9JJNGOdsSUZJWOtWtdyHr3XVfKvXp1V/hi9Gi3cq6qc5aI/fvhz39uzhdfQEYG3HKLm7PVqAhrTouIiESbkg5c7YB/hti/CjdAKr9zN1lrj4c4twLQ0vf3HJcbY47jil0vAZ4rDfO3jmcc548//JHnZj/HwbSDXNPuGiYkT6BNnTZeN03ycwQ3LDAnYC3EzcuKBboC9+ICVn8gAodYHeYwc5mbG7B+4AfScb/jSCCBa7k2N2A1oUn4C1zko9zhw25l3ClT4IcfXFfKRRfB88/DFVeolHsxsxY2bnQVB+fPh3nzYOlSyMhozMiRbs6WOhRFRKQsKunAVQs4GGL/AfJ/i3mmc3Mez/ElsADYhCuIfTfwmTHmRmvte2fV4ghxMuskby1+i4nfTWTX0V1c0vISJg2aRNcGXb1umpzOAVzlwO9wAWsJrnR7eaAHbibiQKAvcI5HbTyDHezIMzxwOcuxWMpRjq505W7uJokk+tGPOtQp+QZmZbmVcadOhalT6Ttzpivl3qEDvPAC3HADNIjAsZelxOHDLtfmhKv5893yZQBVqkD37m7oYGLiAsaM6eltY0VERDxkrLUl98mMOQm8aK19PGj/s7hqg6cNgMaY/wLVrLV9gvZfAHwLDLDWzjrNubHAPKC+tTZkeQFjzO24QVzUq1ev2wcffFDwCytGh1MPM//4fN7Z/A4703bSoXoHbm12Kx3jOnrdtDLt6NGjVAsqqVb+YHnilsdRY1kN4pbFUXVTVYw1ZJfP5kjiEQ51OsShToc4kniE7ErZHrU8NItla+WtrIhbwYoabttR2c2/qpRViXaH29HhcAc6HO5AwpEEKmd70FtkLZV37KDmokXUXLSIuCVLKJ+aCsDR5s3Z3bEjB4cO5WjLliXftlIuK8uwaVNVVq8+hzVrqrNmTXV+/rlq7uNNmhwjIeEICQlHSExMpVmzY8TGup8tob5WxFu6J5FJ9yXy6J5Epki6L+eff/4ia233/I4r6R6ug+TticpRk9C9V4EOAKEmKNUMeDwka22WMeYj4HfGmAbW2p0hjnkTeBOge/fuNjk5OZ/mFL/pm6Zz/8f3s/n4ZjrX78zbg97m4pYXYzT/xHMpKSkkt072LzA8E7foMEAVXK/VTcBAiOkRQ1ylOOKInCp4mWSylKV5KgjuZS8AdambOzSwP/3pHNuZ8rXKh/7KLW579riKgr5eLH7+2e1v3NhVFhwyBAYNolr9+ixMSSESvm5Lg+3b8/ZcLVwIx32DuevUgd694dZboVcv6NED4uKqAlUJVc0lRfcl4uieRCbdl8ijexKZovG+lHTgWoWbixUsEVhdgHOvNMZUCZrHlYgrNbAh9Gm5clJKyXXpFVFqeipZNosPR3zIiMQRxJgSLDogfhbYCaz0bcuh59SesN33+Dm4eVejcUMEu+GGDUaQ4xxnHvNyhwh+z/ccw63C0JzmXMIluQsMt6Z1ic+/ynXsGMya5Q9Yy5a5/TVqwKBB8MgjLmS1aqXCF2Fy/DgsWuQPV/PnuzojABUqQJcu/nDVu7cr8qiXXkREpOBKOnB9AbxgjGlurd0IYIxpCvQDHivAuc/gimtM9p1bDrgW+PZMFQp9x10NbLHW7iriNZSYYW2GUa1HNQa3G+x1U8qOA/iDVeAW2P9aD463OE6VB6u4gNUJD5YQP7P97M8NV7OZzSIWkUkmBkNHOuaWZ+9PfxrS0LuGZma67pOcgDV3ritnV6GCWyPr2WddwOrWDWJjvWtnKZGdDevW5Q1Xy5e76XDgwlRSkj9cde7s1oQWERGRwivpt4l/wRWw+KcxZhyu72AisBV4I+cgY0wT4CdggrV2AoC1dqkx5kPg98aY8riCGHcCzYBfBpx7Pa7E/Ne+562HWyC5G3B9cV9gOBljiDV6k1ksjuL6VIODVeBg0xpAB1ykb+/b2gF1YGXKyojpzrZYtrAlz/DA1b4O4wpUoCc9eZiHcxcY9nRoo7WuZPvUqTBtGsyYAUeOuC6TLl3ggQdcwOrXz1VekCLZt88frHK2w65yP9WrQ8+ebj2s3r3d37UuloiISPiVaOCy1h4zxgwCXgbexQ3zmwbcb609GnCowRXLDh5DdxPwLDAJiAOWARdbaxcHHLMJiAeex806OY6rWHixtfabsF+URLaTwI/4A9UK38dNAcdUxg1MvRAXsHLC1bng1ci6M8kmm1WsylNBcBtuDFh1qtOPfoxkJEkk0Z3uVKKStw3escOFq5xerB2uGAfNm8N117mAdf75bnKQFNrJk24EZk7v1bx58NNP7rGYGFe88dprXbjq1QvatnX7RUREpHiV+EAoa+0W4Kp8jtlMiLe61toTwIO+7XTnzgMGFa2VEnWygI2c2mO1DrfWFbj/7W2AnsDN+INVM1y8j1AnOclCFuZZYPigb4zjuZybOzQwiSTa055Yry/myBGYOdMfsFb7pmfWrg2DB7uANXiwC1xSKNa6+iGB4WrJEkj3Daxu0MAFq9tvd+GqWzeIkIJOIiIiZU6EzTwRyYcFtnFqsFoNpPmOMUBzXJi6En+wao1bIjvCHeEI3/N9bu/VD/xAmu/i2tCGq7gqN2Q1o5l3BS5ynDzp3vXnBKz5892koEqVYMAAGDPGhaxOndSlUkhHjsCCBXkrB+7Z4x6rXNkFqnvuceGqVy9o1EiFLURERCKFApdErn2ELmBxOOCYc3Fh6i78wwETcBWqo8QuduX2Xs1iFstYRjbZxBJLF7pwJ3fmBqy61PW6ua57ZeVKf8CaOdNVF4yJcavdPvqoC1h9+rjQJWclKwtWrcobrlavdi87QJs2cMkl/nDVoQOUj7CqmCIiIuKnwCXeS8UV/Q8OVrsDjqmJC1S/JG8BCy/WhioCi2UDG/IUuNjgW9GgClXoTW/GMY4kkuhNb6oRIePAtmzxz8OaNg12+25OmzauB2vwYEhOhpo1z/QsEsLOnaeueXXUN6O1Vi03NPCaa1y46tlTL7GIiEi0UeCSkpOGv4BFTvGKlcDPAcdUxQWpofiDVXugPhFZwCI/mWSyjGV5SrTv9iXJ2tSmP/25gzvoT3+60pXykbKA18GDkJLi78Vat87tr1fP9V7lzMNq3NjTZkabEydg8eK8AWvLFvdYuXKuDPuYMf6y7C1aaGigiIhItFPgkvDLxBX1D+6xWo8rbgFuYeC2QF/gdlyo6gA04dTalFHkBCeYz/zccDWXuRzFdVc0pSkXcEHuAsNtaENMpFxsWppbAysnYC1a5BZtqlrV9VzdeacLWe3aKQEUkLWwfn3ecLVsmVt6DKBJEzfq8v77Xbjq0kUjMEVEREojBS4pPAts4dRgtQbIWYbaAC1xgepq/D1WrSBSOnOK4gAHmMOc3CGCi1hEBhkYDO1pzyhG5VYQbEQjr5vrl50NS5f6A9asWS50xca6d//jx7uA1bOnW4RY8nXgAPzwQ95FhQ/6FsyuVs29lA8/7C/LXq+et+0VERGRkqHAJQWzh7yhagVu3lVqwDGNcWHqAvzBqi1QStavPcpR1rKW1azmk1afcDd3s4pVAJSnPD3owYM8SBJJ9KUvNYmwyTYbN/oD1vTpsH+/29+uHfzqVy5gDRjgVsSVM8rIgOXL85ZlX7/ePWYMtG8PV13lD1cJCS7LioiISNmjwCV5HSZ0AYu9AcfUxg3/G03eAhZxJdrSYrOf/axhDatZzZqAP1vYkntMlXpVSCKJ67meJJLoQQ8qU9nDVoewb58LVjkha5NvteeGDeGyy/zzsBo08LadEc5a2Lo1b7havNh1CALUr+9C1c03u4/du8M553jbZhEREYkcClxl1Qnc0L/gYLU14JhquDB1BXkLWMQTlQUsAlks29meG6YCw9XegHRZmcq0pS1JJJEQ8GfH7B0MTh7s4RWEcPw4zJ7tD1hLlrj91avDoEHw0EMuZLVurXlYZ5Ca6ioFBs692rXLPVapEnTtCnfd5S/Lft55ejlFRETk9BS4SrsMYAOnBqsNQLbvmAq4tasGkjdYNSaqC1gAZJHFJjad0lu1hjWkBoyHrElNEkhgGMNIIIFEEkkggfM4L2Rhi915atZ7JCvLFbfICVhz5rhFiMuXh379YNIkF7C6dXMl8OQUWVmwZo1/ztW8eW4NrGzf10arVu4lzBka2LGjprSJiIjI2dG7sNIiG1dePThYrQVO+o6JwRWr6ABcjz9YtSTq/yekk8461p3SW7WOdaTnVvCABjQgkURGMzpPj1U96mEivdsup+xd4Dysw75VoDt3hnvvdemgf39XXVBOsXt33nC1YIHr0QK3vlXPnjB8uH/Nq9q1vW2viIiIRL8of5tdBlncgsDBa1mtAo4FHNcEF6YuIW8BiygvO51K6ik9VatZzUY2ku3rsjMYmtGMBBK4iItye6va0pa4aJtotmtX3gWHt/rGfDZpAldf7QLWoEFQt6637YxAaWluVGXg0MDNm91j5cq53qobb/SvedWqlYYGioiISPgpcEWyI1BjRQ3XSxXYa7U/4Jh4XJi6Bf9aVolAlBea28vekPOrtrEt95jylKcVrehMZ67n+tzeqja0ibwCFgWVmgrffefvxVq50u2vVcsFq7FjXchq3lzpIIC1sH17Zd5/3x+uli511QTBrc/cuzfcfbf72LUrVI7S/yIiIiISXRS4ItlfocsDXdzfq+MC1VXkrQwY71Xjis5i2crWU3qr1rCG/QGpsipVaUtbkknO7a1KIIHmNKd8tC/mlZHhFm/KCVjz5rmVcStVgqQk1wUzZIgbMhgT5RPqwmTvXlixwmXRlSvd31etgtTUXoAbTdmjBzz4oH/ulQoxioiIiFcUuCLZFbA8fTkdb+gIjYjayoCZZLKRjaf0Vq1lLUc5mntcLWqRSCLDGZ4bqhJJpBGNQhauiErWwurV/oCVkgJHj7requ7d3cq4Q4ZA374udJVhqamEKKq0AAAaEElEQVQuSAUGq5UrYc8e/zG1a0OHDjB6NFSs+COjRrUhMVE1QkRERCRy6G1JJGsGB3odcNUCo0AaafzIj6f0WK1nPSdzK3dAQxqSQAI3cVOeHqu61I38whWFsW2bfx7W1Kn+GuOtWvl7sJKT3bDBMig9HX78MW+oWrnSP98KXK9Vu3Zu+bD27V3Iat8e6tXzj6xMSdlJx45tPLkGERERkdNR4JKzdoQjIRcG3shGLBaAGGJoTnMSSGAoQ3N7q9rSlurRPsEsP4cPu56rnIC1dq3bX7euC1c5Cw43aeJpM0taVpZbezk4WK1b50ZRguuZatvWDQW87TYXqtq3h6ZNNaJSREREopMCl4RksexhT8j5VTvYkXtcBSrQmtZ0pSsjGZnbW9Wa1lSK9pKIBZWe7uZe5QSsH35wCzlVrQoDBrjkMGSISw5lIDVYCzt3njrPavVqOHHCf1zz5u4lufJKf7Bq3VrrXImIiEjposBVxmWTnVu4IrjH6gAHco+rRjUSSGAIQ/IsDNyMZpQra/+NsrOptmEDLFzoAtZ337kkERvrKjSMG+cCVq9epT49HDzoD1WBPVcHD/qPqV/fhak77vAHq8REqFbNu3aLiIiIlJQy9k657Mogg5/46ZTeqrWs5TjHc4+rQx0SSOBqrs6zMHAjGpXO+VU5srJg/35XkSFn2707779ztl276H7c95olJvp7sAYOhOqlc7jk8eOwZs2pwWr7dv8x1au7MHXNNf5g1b491KnjXbtFREREvKbAVcqc4AQ/8uMpvVXrWU8GGbnHNaYxCSRwG7fl6bGqQyl5d2ytq/4XHJZOF6L27XPnBIuNdXOv4uNdhYYWLaBuXdZUrkzC3XfDueeW/LUVo8xMWL/+1HlWGzb4X56KFSEhwS0LlhOqOnSARo20NJiIiIhIMAWuKHWIQyHnV21mc57CFS1oQSKJDGNYbm9VW9pyDud4fAWFkJHhFmEqSIDaswfS0kI/T40a/gDVpo1b7yo+PvRWs2bIeVe7U1JIiOKwZS1s2XJqsFqzBk76CkrGxEDLltCxI9xwgz9YtWihsusiIiIiBaW3TRHMYjlQ4QDTmZ4nXK1hDTvZmXtcRSrShjb0pCejGZ3bW9WKVlSkoodXkA9r4dChgvdCBU4MClShgj9Axce7+uGnC1B167oumjJk795Tg9XKlW6dqxyNG7tAdeGF/pLrbdtC5cretVtERESkNFDgimAv8zIP9X0o99/ncA6JJHIRF+VZGLgpTYkl1sOWBkhLCx2WQoWovXtdr1UotWv7A1SnTqcPUPHxbvKQxrKdslBwTsgKXCi4Vi0XqEaN8gerdu0gLs67douIiIiUZgpcEWwIQ7hn/T0Ma+WGA57LuSVfuCIrCw4cKHgvVGC3SaAqVfwBqnFj6Nbt9AGqTh2NWTuDkyfd0l7BBSwCFwquUsUFqaFD/cGqfXtXMVDZVERERKTk6F1tBOtIR4ZvH05yq+TwPam1cOxYwXuh9u1za0oFCywmER/vSqCfqReqatXwXUMZkZ0NGzeeGqyCFwpu08a9/Lfe6g9WzZqViSW/RERERCKeAldpkJHhglFBQ1Tg6rOBqlf390K1agX9+p0+QNWqpXf0YZKzUHDwPKtVq/LeqmbNXJj6xS/8wapNm1K/1JeIiIhIVFPgimR791JjxYpTh/QFh6gDB0KfX768P0DFx7ta3mcqJlGpUsleXxl08KALUsEFLAJvYb16Lkz96lf+YNWunRYKFhEREYlGClyR7MMP6XLvvXn31a7tD0kdOpx5GF+NGpqw45ETJ1yJ9cBgtWJF6IWCR4zIu1Bw3bretVtEREREwkuBK5JdfjnL0tLodMEF/mIS5ct73SoJkJnpFgUODlY//eSf+lahgutcPP98/1pW7du72iHKwyIiIiKlmwJXJGvShIPdu7uy6FLirIWjR0NPi5s5M4H77w+9UHCHDnD99f5g1bKlii6KiIiIlFV6GyhlSmamW/6roFXuT1dfpG7dGnTrBhdc4A9WCQlaKFhERERE8lLgkqhmLRw5UvACjfv3h36ecuX8U9/q1YO2bU+dEpdTf6RuXZg3bx7Jyckleq0iIiIiEn0UuCTinDx5dr1Q6emhnycuzh+SEhMhOfnU8JSzxcVpPpWIiIiIhJ8ClxQ7a+HQoYIHqIMHQz9PhQp5g1L79qHDU04vlNanEhERERGvKXBJoaSnFzxA7dnj1mYOJbDKfceOocNTzla9unqhRERERCS6KHAJ4EqYHzxYsAC1e7ebNxVKpUr+0HTuudClS+jwVK+eC1uqci8iIiIipZkCVyl24kTBeqF273ZzprKyTn0OY9zyXzkhqVu30xeTiI+HqlXVCyUiIiIikkOBK4pkZcGBAwXvhTp6NPTzVKvmD0hNmkCPHqcvJlG7NsTGlux1ioiIiIiUFiUeuIwxjYGXgQsAA0wF7rfWbinAuZWAicBIIA5YCjxqrf0u6LgY4FHgV0B94EdggrX2kzBeSrH74gt45plOZGS4ALVvnxv6Fyw21hWJyAlJvXqduZhE1aolfy0iIiIiImVRiQYuY0wVYDqQDowGLDAJmGGM6WitPZbPU7wNDAUeBjYCvwa+Mcb0sdYuDThuIvA/wFhgEXAd8JEx5jJr7dfhvKbilJkJ6ekxtGoFffuefi5UzZoQE+N1a0VEREREJFhJ93DdBjQH2lhrNwAYY5YD63G9US+d7kRjTCfgBuBma+3ffPtmAquACcAw3754XNh6zlr7gu/0GcaYlsBzQNQEruHDoVatJVpgV0REREQkSpV0v8gwYF5O2AKw1m4C5gBXFODcDODDgHMzgQ+Ai4wxFX27LwIqAO8Fnf8e0MEY06xIVyAiIiIiIlJAJR242gErQ+xfBSQW4NxN1trjIc6tALQMOC4d2BDiOArweURERERERMKipIcU1gIOhth/AKhZhHNzHs/5eMhaa/M5Lg9jzO3A7QD16tUjJSUln+aUjKNHj0ZMW8RP9yXy6J5EJt2XyKN7Epl0XyKP7klkisb74kVZ+OAgBK5aYX5MAc8t6HF5G2Xtm8CbAN27d7eRMm8qJSVFc7gikO5L5NE9iUy6L5FH9yQy6b5EHt2TyBSN96WkhxQeJHQPU01C914FOnCGc3Mez/lY05hTlt8NPk5ERERERKRYlXTgWoWbYxUsEVhdgHOb+UrLB597Ev+crVVARaBFiOMowOcREREREREJi5IOXF8AvY0xzXN2GGOaAv18j+V3bnng6oBzywHXAt9aa9N9u/+DC2C/DDp/JLDSVxVRRERERESk2JX0HK6/AHcD/zTGjMPNtZoIbAXeyDnIGNME+AmYYK2dAGCtXWqM+RD4vTGmPLAJuBNoRkC4stbuMca8DDxujEkFFuNC2SDyLz0vIiIiIiISNiUauKy1x4wxg4CXgXdxhSymAfdba48GHGqAWE7tgbsJeBaYBMQBy4CLrbWLg44bCxwF7gPqAz8C11hrvwzvFYmIiIiIiJxeiVcptNZuAa7K55jNhKgqaK09ATzo2850fhYulE0qdENFRERERESKqKTncImIiIiIiJQZClwiIiIiIiLFRIFLRERERESkmChwiYiIiIiIFBMFLhERERERkWKiwCUiIiIiIlJMFLhERERERESKiQKXiIiIiIhIMTHWWq/bEHGMMXuBn71uh08dYJ/XjZBT6L5EHt2TyKT7Enl0TyKT7kvk0T2JTJF0X5pYa+vmd5ACV4Qzxiy01nb3uh2Sl+5L5NE9iUy6L5FH9yQy6b5EHt2TyBSN90VDCkVERERERIqJApeIiIiIiEgxUeCKfG963QAJSfcl8uieRCbdl8ijexKZdF8ij+5JZIq6+6I5XCIiIiIiIsVEPVwiIiIiIiLFRIHLI8aYxsaYj40xh40xR4wxnxpjzivgub8xxnxrjNlvjLHGmDHF3NwyobD3xBjT3RjzpjFmrTHmuDFmizHmfWNMs5Jod2lXhPvSxBjzT2PMz8aYE8aYfcaYFGPMJSXR7tKsKN+/gp7ncd/3sNnF0c6ypIg/U+xpts7F3e7SrqhfK8aYBGPMR77vXyeMMT8aY+4rzjaXdkX4mfL0Gb5W0kqi7aVZEb+HnWeMmex7/3XcGLPOGDPJGFO1uNtdUBpS6AFjTBVgGZAOjAMsMAmoAnS01h7L5/xUYCmwERgF3GStfac421zaFeWeGGNeAPoA7wOrgIbAeCAe6Gyt3Vq8rS+9inhf2gEPAinANqA6cBswFLjKWvtpsTa+lCrq96+A52kOLAeOAeuttf2Lp8WlXxh+pljgHeCNoIeWW2uPh73BZUQY7kt3YDrue9hfgcNAK6Catfal4mt56VXEnymNgEZBu6sC/wE+s9ZeUyyNLgOKeF+qAkuA8sDTwBagB/AM8IW19tpibXxBWWu1lfAG3AdkAS0D9jUDMoEHC3B+jO9jS9x/yjFeX1O0b0W5J0DdEPuaANnABK+vLZq3on6thHi+csBW4Euvry1at3DdE+Ab3Bv8FGC219cVzVsYfqZYYJLX11HatiL+XInB/QLvM6+vozRtxfAz5Ubf189Qr68tmrcifq1c6LsHFwbtf853fhWvr89aqyGFHhkGzLPWbsjZYa3dBMwBrsjvZGttdjG2rawq9D2x1u4Nse9nYC+ut0sKr0hfK8GstZm43xJnhK2FZU+R74kx5gagK/B4sbSw7Anr14mETVHuSzKQCKgnK7zC/bUyGtiN+wWSFF5R7ksF38cjQfsP4X5xYcLVyKJQ4PJGO2BliP2rcN9gpeSF9Z4YYxJwQwrXFLFdZV2R74sxJsYYU84YU98YMx5oDbwWxjaWNUW6J8aYmsDLwCPW2gNhbltZFY7vX3caY9J98x+mG2OSwte8Mqso9yVniG0lY8w8Y0yGMWaPMeZVY0zlsLaybAnbz3rfEMPzgfd9v8yTwivKfZkKrAd+Z4xJNMZUM8YMwvWa/dkWcJh7cVPg8kYt4GCI/QeAmiXcFnHCdk+MMeWAP+N6uN4uetPKtHDcl//F9WjtBB4BrrPWTgtP88qkot6T54F1uDlDEh5FvSfvAXcBQ4DbgdrAdGNMcrgaWEYV5b6c6/v4IfAtcAHue9mtwN/D1cAyKJzvv27EvY+eXNRGSeHvi7U2DfcLipxhuKnANOAr4O7wNrPwynndgDIsVLWSiOj2LMPCdU/+CPTFjekO9Q1Ezk5R78vvgQ+A+rgiM383xoyw1n4VjsaVUYW6J75ek1FAV+sbZC9hU+ivE2vtjQH/nGWM+Sfut82T8Pe0SOEU9r7k/EL8PWvtk76/pxhjYoHnjDGJ1trVYWlh2ROun/WjgCXW2uVFbI84hf25Ugn3i4l4XAjeAvQEnsTN4bozjG0sNAUubxzEpflgNQmd8KX4heWeGGN+i/sN8Whr7bdhaltZVuT7Yq3dhqtSCPCVMSYFeAH32y85e0W5J2/gen23GWPifPvKAbG+f5+w1qaHraVlR1h/plhrU40x/wJuKWrDyrii3Jf9vo//Ddr/La4YQGdAgevshetnfU+gLXB/mNpV1hXlvtyCm/PY0lr7k2/fd8aYw8Cbxpg/W2uXha2lhaQhhd5YhRuvGiwRfQP1SpHviTFmLPAYcJ+19t0wtq0sK46vlYW4Cp9SOEW5JwnAHbgfoDlbP6C37+8R8ZvIKFQcXyeG0L9xloIryn1Z5fsYfA9yfuOv4lmFE66vldG43hMN7wyPotyXDsDBgLCV4wffx4Qiti0sFLi88QXQ27cODQDGmKa4Nx5feNSmsq5I98QYcy9u+M1Ya+0fiqmNZVFYv1aMMTG4IVLB35il4IpyT84PsS3DDV87H/g4/M0tE8L9dVIdt17d/DC1r6wqyn35N25NoouD9l/k+7gwPE0sc4r8tWKMqQBcB3wdqkqxFEpR7ssuoKYxJvgXqb18H7eHqY1F43Vd+rK44RbK2wCswJW7HIZ707ERt6BhznFNcL9BeTLo/IHACNxkQIubMzQCGOH1tUXrVpR7gvvGm437Adk7aEv0+tqieSvifXkaeBW41vc1cy1uOE42rnCG59cXjVtRv3+FeL4UtA6XZ/cE+B/gL8ANuGE5o33PcxJI8vraonkLw8/6p3z7f4MraPIYcAJ4x+tri9YtHN+/gOG+917Dvb6e0rIV8XtYU1xJ+HW+71/nAw/79i3Et3at15vmcHnAWnvMV7LyZeBd3BCBacD91tqjAYcaIJZTeyKfwb2BzPFr35ZzjpylIt6Ti337L+bU30bOxL2JkUIo4n1ZjBtffx1QA/dbsGW4N5FzSqD5pVIYvn9JmBXxnvwIXOnbauDepMwBbrHW/oAUWhi+VibgKq7dhQvGO3FVPicWc9NLrTB9/xqNq56necBhUpT7Yq3dbIzpjfsl6ySgDrAVeBN41kbI2rXGlw5FREREREQkzPSbRxERERERkWKiwCUiIiIiIlJMFLhERERERESKiQKXiIiIiIhIMVHgEhERERERKSYKXCIiIiIiIsVEgUtERM6KMeYtY4w1xrzkdVvOhjHmad9aL2WaMaap77Vo7nVbRETKAgUuEREpMGNMZeBq3z9/aYwp52V7ztJTQJkPXEBT3GuhwCUiUgIUuERE5GxcCVQHvgbigYu9bY4AGGMqet0GEREJTYFLRETOxmjgIDAGOAGMCnWQMaaTMeYzY8x+Y8wJY8yPxpjHg4650hgzxxhz1BhzxBjzgzFmWMDj5Ywxjxtj1hpj0o0xO4wxLxpjKgUc09Q3vPEuY8xLxpg9xpjjxpivjDFNA46zvr+O9R1vjTFP+x7rYYz52BizLaCtv/H15gW2N8UYM9sYM8QYs9j3eVYaY35RyOsfboyZ53ueQ8aYj4wx5+V3AwLacbkxZokxJh24y/fY3caY740xB3zPOc8YMzTg3GRghu+f/w14LZIDjrnNGLPMGJNmjNlnjHnbGFMrv3aJiEho0TQUREREPGSMORcYArxprd1rjPkcGG6MqWmtPRhwXE8gBdgAPABsA1oBHQOOuQd4FfgcF+KOAl1xw91yvAdcDvwOmAskABN9x1wV1LzHgaXATbiet98A3xpj2llrM4A+wPfAO8AbvnO2+T6e5zv3HSAVaAc8iRtyd13Q52kBvAL8FtgHPAR8bIxpa63dcBbXfwfwJ+BvwATgHOBpYKYxpqO1NpUza417/SYCG4EDvv1NgbeAzbif8ZcDXxljLrXW/htYDPwaeA24F1jgO2+1r13P+a7pVeBhoCEwCWhvjOlrrc3Kp10iIhLMWqtNmzZt2rTluwGPAhbo4/v3Rb5/3xF03HfAVqDKaZ6nOi7YfHqGz5Xke+5RQft/6dvf2ffvpr5/rwZiAo7r59t/S8A+C0zK5xoNLqiMBLKB2gGPpQAZQKuAffFAFvDEWVx/NeAw8Neg/U2Bk8D9+bQxxde2zvkcF+O7lm+BfwbsT/a9FkNCfP4s4Mmg/Tmv5S+8/j+oTZs2bdG4aUihiIgU1ChgvbX2e9+/pwI7CBhWaIypgnuD/r619vhpnqcvLnS8eYbPdTEufHziG1pYzleg41vf4wOCjv/YWpud8w9r7Rxcz1Kf/C7KGFPdGPM7Y8xPQDouVL2LC1+tgg5fb61dH/B59gB7cL1kBb3+PrjQ+X7QtW0D1oa4tlA2W2uXhriWbr7hlLuBTN+1XAC0KcBzXoALacHtmg8cKWC7REQkiIYUiohIvowxPYBE4HfGmLiAhz4F7jbGtLbWrgNq4t60bwvxNDlq+z6e6Zh4oAJuqOGZniPH7hDH7MYNicvP33BDJZ/EDS08BvTEDburFHTsAU6VHnBcQa4/3vdx6mkeP3ia/YF2Bu8wxjQGpuF6++4BtuBC10TccMz85LRrw2keD37NRUSkABS4RESkIEb7Pj7q24KNAsbhwkI2Zw46+3wfGwIrT3PMfiANN7QwlB1B/64X4ph6uAB1Wr4CHFcAT1trXwnY3+FM551BQa5/v+/jGGBViMfzm78FbohfsIuBGsA11trcwOfrdSuInHZdSOjQtz/EPhERyYcCl4iInJExpgKueMR84LEQh7wM3GiMGW+tPW6MmQ2MNMZMsNaeCHH8XFzP1e3AN6f5tP/BBbsa1tppBWjmCGPM0znDCo0x/YBGuEIZOU4ClYPOqwjE4obeBRpTgM95irO4/lSgpbV2cmE+z2nkBKvcazHGtMYNcQzscUv3fQx+Lf6LC4vnWWv/G8Z2iYiUaQpcIiKSn8tww8kestamBD9ojHkDV3EvGVdy/H+AmcD3xpgXcW/2m+OKPNxjrU31lUj/gzHmE+B9XADpDKRZa/9grU0xxvwDVwHwJeAHXBhoClwKPOobwpjjHOBzX1vq4qoIrgemBByzGhhqjPkPrgdnh7V2hzFmHvCQMWYnrvftZgo2FPF08rv+I8aYh4HXjDF1gX/jimg0BAYCKdbavxfi807FDSGc4vu8DYBncEMLA+dsr/Mdd7Mx5gAugP1orf3JGPM74I/GmDa+a0gDGuPmd71lrZ2BiIicFRXNEBGR/IzGBaKPTvP4P3Brco0GsNYuwPWqbAX+gFsk+WECelmstX8Ersb1Qr0PfAKMADYFPO9IXKn0EcA/gY+Bu3FBKnjO1m9xc4/eAV7HlT+/yLqS8Dnuxs3P+hJXDv123/7rgUW4OVvvALuA+077auSjgNf/BjAMV8ziXVzoegb3i9AzDoM8w+ddhavi2AT4AngE1yP5XdBx+3GvRSdcqFoAdPM99gTudRkA/B/udX8UF1DXIyIiZ81YG2oYuIiISOTzLW68CbjNWvuWt60RERE5lXq4REREREREiokCl4iIiIiISDHRkEIREREREZFioh4uERERERGRYqLAJSIiIiIiUkwUuERERERERIqJApeIiIiIiEgxUeASEREREREpJgpcIiIiIiIixeT/AdfTBJEUSn6hAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "failure_rates = np.zeros((8, 5))\n",
    "\n",
    "for r in np.arange(1, 9):\n",
    "    \n",
    "    #### True evaluation\n",
    "    # Sort by failure probabilities, subjects with the smallest risk are first. \n",
    "    df_sorted = test.sort_values(by='B_prob_0_logreg', inplace=False, \n",
    "                                 ascending=True)\n",
    "\n",
    "    to_release = int(round(df_sorted.shape[0] * r / 10))\n",
    "\n",
    "    # Failure was coded as zero.\n",
    "    failure_rates[r - 1, 0] = np.mean(df_sorted.result_Y[0:to_release] == 0)\n",
    "    \n",
    "    #### Labeled outcomes only\n",
    "    # Sort by failure probabilities, subjects with the smallest risk are first. \n",
    "    df_sorted = test_labeled.sort_values(by='B_prob_0_logreg', inplace=False,\n",
    "                                         ascending=True)\n",
    "    \n",
    "    # Ensure that only labeled outcomes are available\n",
    "    df_sorted = df_sorted[df_sorted.decision_T == 1]\n",
    "    \n",
    "    to_release = int(round(df_sorted.shape[0] * r / 10))\n",
    "\n",
    "    failure_rates[r - 1, 1] = np.mean(df_sorted.result_Y[0:to_release] == 0)\n",
    "    \n",
    "    #### Human error rate\n",
    "    # Get judges with correct leniency as list\n",
    "    correct_leniency_list = test_labeled.judgeID_J[\n",
    "        test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
    "\n",
    "    # Released are the people they judged and released, T = 1\n",
    "    released = test_labeled[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, 2] = np.sum(\n",
    "        released.result_Y == 0) / correct_leniency_list.shape[0]\n",
    "    # onko jakaja oikein\n",
    "    \n",
    "    #### Contraction, logistic regression\n",
    "    failure_rates[r - 1, 3] = contraction(\n",
    "        test_labeled, 'judgeID_J', 'decision_T', 'result_Y', 'B_prob_0_logreg',\n",
    "        'acceptanceRate_R', r / 10, False)\n",
    "\n",
    "    #### P(Y=0 | T=1, X=x)*P(T=1 | R=r, X=x)*P(X=x)\n",
    "    failure_rates[r - 1, 4] = si.quad(lambda x: f(np.array([x]), logreg, 0) * \n",
    "                                      f(np.array([[x, r/10]]), decision_model, 1) * \n",
    "                                      scs.norm.pdf(x), -np.inf, np.inf)[0]\n",
    "\n",
    "# Error bars TBA\n",
    "\n",
    "plt.figure(figsize=(14, 8))\n",
    "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 0], label='True Evaluation', c='green')\n",
    "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 1], label='Labeled outcomes', c='lime')\n",
    "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 2], label='Human evaluation', c='red')\n",
    "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 3], label='Contraction, log.', c='blue')\n",
    "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 4], label='Causal effect', c='magenta')\n",
    "\n",
    "plt.title('Failure rate vs. Acceptance rate')\n",
    "plt.xlabel('Acceptance rate')\n",
    "plt.ylabel('Failure rate')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 (0.018718463137853268, 7.749450073818988e-11)\n",
      "1.0 (0.33301477999280144, 6.337618003666896e-09)\n"
     ]
    }
   ],
   "source": [
    "# Below are estimates for P(Y=0 | do(R=0)) and P(Y=0 | do(R=1))\n",
    "r = 0.0\n",
    "print(r, si.quad(lambda x: f(np.array([[x, r]]), decision_model, 1) * \\\n",
    "                 f(np.array([x]), logreg, 0) * scs.norm.pdf(x), -np.inf, np.inf))\n",
    "\n",
    "r = 1.0\n",
    "print(r, si.quad(lambda x: f(np.array([[x, r]]), decision_model, 1) * \\\n",
    "                 f(np.array([x]), logreg, 0) * scs.norm.pdf(x), -np.inf, np.inf))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So it can be concluded that:\n",
    "\n",
    "\\begin{equation*}\n",
    "P(Y=0 | \\text{do}(R=0)) \\approx 0.018 \\\\\n",
    "P(Y=0 | \\text{do}(R=1)) \\approx 0.340 \\\\\n",
    "\\end{equation*}"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}