Paper_TRUNK_vs_samples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import os\n",
    "import sys\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "# import pandas as pd\n",
    "import scipy\n",
    "# import seaborn as sns\n",
    "from joblib import Parallel, delayed\n",
    "from scipy.integrate import nquad, quad, simps\n",
    "from scipy.stats import entropy, gamma, multivariate_normal, norm\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.preprocessing import normalize\n",
    "# from sktree.datasets import make_trunk_classification\n",
    "from sktree.ensemble import HonestForestClassifier\n",
    "from sktree.stats import build_hyppo_oob_forest\n",
    "from sktree.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import roc_auc_score, roc_curve\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "SIMULATIONS = {\n",
    "    \"1\" : {\"m_factor\" : -1,'cov_par': 1}, ###\"mu = 1.5*1/sqrt(i)\"\n",
    "    \"2\" : {\"m_factor\" : 1},\n",
    "    \"3\" : {\"m_factor\" : -1,\"mix\" : 0.5}\n",
    "}\n",
    "\n",
    "SAMP_SIZES = [2**i for i in range(7, 11)]\n",
    "SAMP_SIZES_plot = [2*2**i for i in range(7, 11)]\n",
    "REPS = range(100, 1000)\n",
    "P = 2048\n",
    "SAVE_PATH  = '/Users/baiyuxin/Desktop/JHU/NDD/Cancer/paper_trunk'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_jobs = -3\n",
    "n_estimators = 2000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sensitivity_at_specificity(y_true, y_score, target_specificity=0.98, pos_label=1):\n",
    "    n_trees, n_samples, n_classes = y_score.shape\n",
    "\n",
    "    # Compute nan-averaged y_score along the trees axis\n",
    "    y_score_avg = np.nanmean(y_score, axis=0)\n",
    "\n",
    "    # Extract true labels and nan-averaged predicted scores for the positive class\n",
    "    y_true = y_true.ravel()\n",
    "    y_score_binary = y_score_avg[:, 1]\n",
    "\n",
    "    # Identify rows with NaN values in y_score_binary\n",
    "    nan_rows = np.isnan(y_score_binary)\n",
    "\n",
    "    # Remove NaN rows from y_score_binary and y_true\n",
    "    y_score_binary = y_score_binary[~nan_rows]\n",
    "    y_true = y_true[~nan_rows]\n",
    "\n",
    "    # Compute ROC curve\n",
    "    fpr, tpr, thresholds = roc_curve(y_true, y_score_binary, pos_label=pos_label)\n",
    "\n",
    "    # Find the threshold corresponding to the target specificity\n",
    "    index = max(np.argmax(fpr > (1 - target_specificity))-1, 0)\n",
    "    threshold_at_specificity = thresholds[index]\n",
    "\n",
    "    # Compute sensitivity at the chosen specificity\n",
    "    # sensitivity = tpr[index]\n",
    "    # return sensitivity\n",
    "\n",
    "    # Use the threshold to classify predictions\n",
    "    y_pred_at_specificity = (y_score_binary >= threshold_at_specificity).astype(int)\n",
    "\n",
    "    # Compute sensitivity at the chosen specificity\n",
    "    sensitivity = np.sum((y_pred_at_specificity == 1) & (y_true == 1)) / np.sum(\n",
    "        y_true == 1\n",
    "    )\n",
    "\n",
    "    return sensitivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "SAMP_SIZES = [2**i for i in range(7, 11)]\n",
    "Reps = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.stats import multivariate_normal, entropy\n",
    "from scipy.integrate import nquad\n",
    "\n",
    "def make_trunk_classification(\n",
    "    n_samples,\n",
    "    n_dim=10,\n",
    "    n_informative=10,\n",
    "    m_factor: int = -1,\n",
    "    cov_par: int = 1,\n",
    "    rho: int = 0,\n",
    "    band_type: str = \"ma\",\n",
    "    return_params: bool = False,\n",
    "    mix: int = 0,\n",
    "    seed=None,\n",
    "\n",
    "):\n",
    "    \"\"\"Generate trunk dataset.\n",
    "\n",
    "    For each dimension in the first distribution, there is a mean of :math:`1 / d`, where\n",
    "    ``d`` is the dimensionality. The covariance is the identity matrix.\n",
    "    The second distribution has a mean vector that is the negative of the first.\n",
    "    As ``d`` increases, the two distributions become closer and closer.\n",
    "\n",
    "    See full details in :footcite:`trunk1982`.\n",
    "\n",
    "    Instead of the identity covariance matrix, one can implement a banded covariance matrix\n",
    "    that follows :footcite:`Bickel_2008`.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    n_samples : int\n",
    "        Number of sample to generate.\n",
    "    n_dim : int, optional\n",
    "        The dimensionality of the dataset and the number of\n",
    "        unique labels, by default 10.\n",
    "    n_informative : int, optional\n",
    "        The informative dimensions. All others for ``n_dim - n_informative``\n",
    "        are uniform noise.\n",
    "    m_factor : int, optional\n",
    "        The multiplicative factor to apply to the mean-vector of the first\n",
    "        distribution to obtain the mean-vector of the second distribution.\n",
    "        By default -1.\n",
    "    rho : float, optional\n",
    "        The covariance value of the bands. By default 0 indicating, an identity matrix is used.\n",
    "    band_type : str\n",
    "        The band type to use. For details, see Example 1 and 2 in :footcite:`Bickel_2008`.\n",
    "        Either 'ma', or 'ar'.\n",
    "    return_params : bool, optional\n",
    "        Whether or not to return the distribution parameters of the classes normal distributions.\n",
    "    mix : float, optional\n",
    "        Whether or not to mix the Gaussians. Should be a value between 0 and 1.\n",
    "    seed : int, optional\n",
    "        Random seed, by default None.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    X : np.ndarray of shape (n_samples, n_dim), dtype=np.float64\n",
    "        Trunk dataset as a dense array.\n",
    "    y : np.ndarray of shape (n_samples,), dtype=np.intp\n",
    "        Labels of the dataset.\n",
    "    means : list of ArrayLike of shape (n_dim,), dtype=np.float64\n",
    "        The mean vector for each class starting with class 0.\n",
    "        Returned if ``return_params`` is True.\n",
    "    covs : list of ArrayLike of shape (n_dim, n_dim), dtype=np.float64\n",
    "        The covariance for each class. Returned if ``return_params`` is True.\n",
    "\n",
    "    References\n",
    "    ----------\n",
    "    .. footbibliography::\n",
    "    \"\"\"\n",
    "    if n_dim < n_informative:\n",
    "        raise ValueError(\n",
    "            f\"Number of informative dimensions {n_informative} must be less than number \"\n",
    "            f\"of dimensions, {n_dim}\"\n",
    "        )\n",
    "    rng = np.random.default_rng(seed=seed)\n",
    "\n",
    "    mu_1 = np.array([1.2/ np.sqrt(i) for i in range(1, n_informative + 1)])\n",
    "    mu_0 = m_factor * mu_1\n",
    "\n",
    "    if rho != 0:\n",
    "        if band_type == \"ma\":\n",
    "            cov = _moving_avg_cov(n_informative, rho)\n",
    "        elif band_type == \"ar\":\n",
    "            cov = _autoregressive_cov(n_informative, rho)\n",
    "        else:\n",
    "            raise ValueError(f'Band type {band_type} must be one of \"ma\", or \"ar\".')\n",
    "    else:\n",
    "        cov = cov_par*np.identity(n_informative)\n",
    "\n",
    "    if mix < 0 or mix > 1:\n",
    "        raise ValueError(\"Mix must be between 0 and 1.\")\n",
    "\n",
    "    if n_informative > 1000:\n",
    "        method = \"cholesky\"\n",
    "    else:\n",
    "        method = \"svd\"\n",
    "\n",
    "    if mix == 0:\n",
    "        X = np.vstack(\n",
    "            (\n",
    "                rng.multivariate_normal(mu_0, cov, n_samples // 2, method=method),\n",
    "                rng.multivariate_normal(mu_1, cov, n_samples // 2, method=method),\n",
    "            )\n",
    "        )\n",
    "    else:\n",
    "        mixture_idx = rng.choice(\n",
    "            [0, 1], n_samples // 2, replace=True, shuffle=True, p=[mix, 1 - mix]\n",
    "        )\n",
    "        X_mixture = np.zeros((n_samples // 2, len(mu_1)))\n",
    "        for idx in range(n_samples // 2):\n",
    "            if mixture_idx[idx] == 1:\n",
    "                X_sample = rng.multivariate_normal(mu_1, cov, 1, method=method)\n",
    "            else:\n",
    "                X_sample = rng.multivariate_normal(mu_0, cov, 1, method=method)\n",
    "            X_mixture[idx, :] = X_sample\n",
    "\n",
    "        X = np.vstack(\n",
    "            (\n",
    "                rng.multivariate_normal(\n",
    "                    np.zeros(n_informative), cov, n_samples // 2, method=method\n",
    "                ),\n",
    "                X_mixture,\n",
    "            )\n",
    "        )\n",
    "\n",
    "    if n_dim > n_informative:\n",
    "        # X = np.hstack((X, rng.uniform(low=0, high=1, size=(n_samples, n_dim - n_informative))))\n",
    "        X = np.hstack((X, rng.multivariate_normal(np.zeros(n_dim - n_informative), cov_par*np.identity(n_dim - n_informative), n_samples, method=method)))\n",
    "\n",
    "    y = np.concatenate((np.zeros(n_samples // 2), np.ones(n_samples // 2)))\n",
    "\n",
    "    if return_params:\n",
    "        return X, y, [mu_0, mu_1], [cov, cov]\n",
    "    return X, y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Dimension1\n",
      "1.0 [0.5]\n",
      "[[0.90888025 0.09111975]\n",
      " [0.99319888 0.00680112]\n",
      " [0.8414429  0.1585571 ]\n",
      " ...\n",
      " [0.00253796 0.99746204]\n",
      " [0.02767178 0.97232822]\n",
      " [0.23907992 0.76092008]]\n",
      "pAUC 0.9158151410105263\n",
      "S@98 0.781038\n"
     ]
    }
   ],
   "source": [
    "n = 1000000\n",
    "\n",
    "DIMENSIONS = [2**i for i in range(2,9)]\n",
    "# DIMENSIONS = [i for i in range(2, 100,2)]\n",
    "for i in [\"1\"]:\n",
    "    print(int(i))\n",
    "    MIs = []\n",
    "    pAUCs = []\n",
    "    tprs = []\n",
    "    for p in [1]:\n",
    "        print(\"Dimension\" + str(p))\n",
    "        ### sample from TRUNK\n",
    "        x,y,mu,cov = make_trunk_classification(n_samples=n, n_dim=p,n_informative=p, **SIMULATIONS[i],return_params = True)\n",
    "        p_class0 = 0.5\n",
    "        p_class1 = 0.5\n",
    "        x = np.float32(x)\n",
    "        y = np.float32(y)\n",
    "        ## Get the pdf for class one and class two\n",
    "        pdf_class0 = multivariate_normal(mean = mu[0], cov = cov[0],allow_singular=True)\n",
    "        pdf_class1 = multivariate_normal(mean = mu[1], cov = cov[1],allow_singular=True)\n",
    "        print(mu[1][0],cov[0][0])\n",
    "        \n",
    "        p_x_given_class0 = np.nan_to_num(np.float128(pdf_class0.pdf(x)))\n",
    "        p_x_given_class1 = np.nan_to_num(np.float128(pdf_class1.pdf(x)))\n",
    "\n",
    "\n",
    "        p_x = p_x_given_class0*p_class0 + p_x_given_class1*p_class1\n",
    "        # pos_class0 = p_x_given_class0*p_class0/p_x\n",
    "\n",
    "        pos_class0 = (np.array([p_x_given_class0[i]*p_class0/p_x[i] if p_x[i] != 0 else 0 for i in range(p_x.shape[0])]).reshape(-1,1))\n",
    "        pos_class1 = np.ones(pos_class0.shape) - pos_class0\n",
    "\n",
    "        posterior = np.hstack((pos_class0.reshape(-1,1),pos_class1.reshape(-1,1)))\n",
    "        print(posterior)\n",
    "        # posterior = posterior[~np.isnan(posterior)].reshape(-1,2)\n",
    "        # stats_conen = np.mean(entropy(posterior, base=np.exp(1), axis=1))\n",
    "        prior_y = np.array([p_class0,p_class1])\n",
    "        # entropy_y = entropy(prior_y, base=np.exp(1))\n",
    "        # print('entropy'+str(stats_conen))\n",
    "        # MI = entropy_y - stats_conen\n",
    "        # print(\"MI\"+str(MI))\n",
    "        # MIs.append(MI)\n",
    "        # # plt.scatter(x[:,0],x[:,-1],c = y,alpha = 0.3,s=2)\n",
    "        # # plt.show()\n",
    "        pauc = roc_auc_score(y, posterior[:,1], max_fpr=0.1)\n",
    "        print('pAUC '+ str(pauc))\n",
    "        pAUCs.append(pauc)\n",
    "\n",
    "        fpr, tpr, thresholds = metrics.roc_curve(y, posterior[:,1], pos_label=1,drop_intermediate = False)\n",
    "        tpr_s = np.max(tpr[fpr<=0.02])\n",
    "        print('S@98 '+ str(tpr_s))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(300000,) (150337,) (149663,)\n",
      "MI0.5489146602809801\n",
      "pAUC 0.9521535728654971\n",
      "S@98 0.8778666666666667\n"
     ]
    }
   ],
   "source": [
    "#### Mixture Gaussian\n",
    "n = 300000\n",
    "MIs = []\n",
    "pAUCs = []\n",
    "tprs = []\n",
    "p_class0 = 0.5\n",
    "p_class1 = 0.5\n",
    "for p in [1]:\n",
    "    mu_class0 = np.array([0 for i in range(p)])\n",
    "    mu_class1 = np.array([3.5*1/np.sqrt(i+1) for i in range(p)])\n",
    "    sig = np.identity(p)\n",
    "    pdf_class0 = multivariate_normal(mean = mu_class0, cov = sig,allow_singular=True)\n",
    "    pdf_class1_1 = multivariate_normal(mean = mu_class1, cov = sig,allow_singular=True)\n",
    "    pdf_class1_2 = multivariate_normal(mean = -mu_class1, cov = sig,allow_singular=True)\n",
    "\n",
    "    n1 = np.random.binomial(n, 0.5)\n",
    "    n2 = n - n1\n",
    "    # print(n1,n2)\n",
    "    x_0 = pdf_class0.rvs(size = n)\n",
    "    x_1_1 = pdf_class1_1.rvs(size = n1)\n",
    "    x_1_2 = pdf_class1_2.rvs(size = n2)\n",
    "    print(x_0.shape,x_1_1.shape,x_1_2.shape)\n",
    "    x = np.vstack((x_0.reshape(-1,1),x_1_1.reshape(-1,1),x_1_2.reshape(-1,1)))\n",
    "    y = np.array([0]*n+[1]*n).reshape(-1,1)\n",
    "\n",
    "    p_x_given_class0 = np.nan_to_num(pdf_class0.pdf(x))\n",
    "    p_x_given_class1_1 = np.nan_to_num(pdf_class1_1.pdf(x))\n",
    "    p_x_given_class1_2 = np.nan_to_num(pdf_class1_2.pdf(x))\n",
    "    p_x_given_class1 = 0.5*p_x_given_class1_1+0.5*p_x_given_class1_2\n",
    "\n",
    "    p_x = p_x_given_class0*p_class0 + p_x_given_class1*p_class1\n",
    "\n",
    "    pos_class0 = np.array([p_x_given_class0[i]*p_class0/p_x[i] if p_x[i] != 0 else 0 for i in range(p_x.shape[0])]).reshape(-1,1)\n",
    "    pos_class1 = np.ones(pos_class0.shape) - pos_class0\n",
    "\n",
    "    posterior = np.hstack((pos_class0.reshape(-1,1),pos_class1.reshape(-1,1)))\n",
    "    # print(posterior.shape)\n",
    "    # posterior = posterior[~np.isnan(posterior)].reshape(-1,2)\n",
    "    stats_conen = np.mean(entropy(posterior, base=np.exp(1), axis=1))\n",
    "    prior_y = np.array([p_class0,p_class1])\n",
    "    entropy_y = entropy(prior_y, base=np.exp(1))\n",
    "    # print('entropy'+str(stats_conen))\n",
    "    MI = entropy_y - stats_conen\n",
    "    print(\"MI\"+str(MI))\n",
    "    MIs.append(MI)\n",
    "    # plt.scatter(x[:,0],x[:,-1],c = y,alpha = 0.3,s=2)\n",
    "    # plt.show()\n",
    "    pauc = roc_auc_score(y, posterior[:,1], max_fpr=0.1)\n",
    "    print('pAUC '+ str(pauc))\n",
    "    pAUCs.append(pauc)\n",
    "\n",
    "    fpr, tpr, thresholds = metrics.roc_curve(y, posterior[:,1], pos_label=1,drop_intermediate = False)\n",
    "    tpr_s = np.max(tpr[fpr<=0.02])\n",
    "    print('S@98 '+ str(tpr_s))\n",
    "    tprs.append(tpr_s)\n",
    "# np.savetxt(\"/Users/baiyuxin/Desktop/JHU/NDD/Cancer/Truth_Calculation/Mixture_Gaussian.csv\", tprs, delimiter=\",\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2 [1.]\n",
      "0 128 0.0625\n",
      "1.2 [1.]\n",
      "0 256 0.6015625\n",
      "1.2 [1.]\n",
      "0 512 0.28125\n",
      "1.2 [1.]\n"
     ]
    }
   ],
   "source": [
    "for i in range(2):\n",
    "    S98 = []\n",
    "    for n in SAMP_SIZES:\n",
    "        est = HonestForestClassifier(\n",
    "        n_estimators=2000,\n",
    "        max_samples=1.6,\n",
    "        max_features=0.3,\n",
    "        bootstrap= True,\n",
    "        random_state= 10000*i+n,\n",
    "        tree_estimator=DecisionTreeClassifier(),\n",
    "        # max_depth = 1,\n",
    "        honest_fraction=0.5,\n",
    "        stratify=True,\n",
    "        # permute_per_tree=True,\n",
    "        n_jobs=n_jobs,)\n",
    "\n",
    "        x,y,mu,cov = make_trunk_classification(n_samples=n, n_dim=2048, **SIMULATIONS[\"1\"],n_informative=1,return_params = True)\n",
    "        print(mu[1][0],cov[0][0])\n",
    "        x = np.float32(x)\n",
    "        y = np.float32(y)\n",
    "        est,prob = build_hyppo_oob_forest(est,x, y)\n",
    "        sas98 = sensitivity_at_specificity(y, prob, target_specificity=0.98)\n",
    "        print(i,n,sas98)\n",
    "        S98.append(sas98)\n",
    "    np.savetxt(SAVE_PATH + \"/Trunk_1_dim2048_1.2mean1var1info_reps{}.csv\".format(i), S98, delimiter=\",\")\n",
    "\n",
    "    # S98_array[i,:] = S98\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABtoAAAHWCAYAAAD5HV1XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACPY0lEQVR4nOzdd3hc5Z328XvUe7OKZVwkN7nijrGNgyGAA8b0hBIWTA2hvCGB7IbdLJDsbrLJhgQ2kN1kEwKEAA5gimnBFFNNsTEGgy1j425LsiSrl5FmzvvHw2g00kiaGU2Vvp/rmks6Z055Zkb2OWfu8/wem2VZlgAAAAAAAAAAAAD4JS7SDQAAAAAAAAAAAABiEUEbAAAAAAAAAAAAEACCNgAAAAAAAAAAACAABG0AAAAAAAAAAABAAAjaAAAAAAAAAAAAgAAQtAEAAAAAAAAAAAABIGgDAAAAAAAAAAAAAkDQBgAAAAAAAAAAAASAoA0AAAAAAAAAAAAIAEEbAAAAMMStX79eNptN69evj3RTAAAY1h544AHZbDbt2bMn0k0BAABBQtAG+Mlms/n0WL9+vfbs2eMxLy4uTnl5eTr99NO1YcOGXttetWqVMjIy+tx3RkaGVq1a1TXt+tLMZrNp06ZNPm1v2bJlmjFjRq9lX331VaWlpWnu3Lmqra314x0BAMDgGCnt27dP1113nUpKSpScnKzCwkKdc845euedd/pdDwCAWDScj/3Lli2TzWbTpEmTvD6/bt26rvY88cQTfb4OAAAQ+xIi3QAg1vzlL3/xmH7ooYe0bt26XvOnTp2q1tZWSdLFF1+sM844Qw6HQzt27NDvfvc7nXTSSfrwww81c+bMoLTrzjvv1Nq1awNa97XXXtPKlStVVlamV155RXl5eUFpEwBgeBnux8h33nlHZ5xxhiTp6quv1rRp01RRUaEHHnhAS5cu1T333KObbropoHYAABCNhvuxPyUlRTt37tQHH3yg4447zuO5v/71r0pJSVFbW5vH/H/4h3/QRRddpOTk5IDaBwAAog9BG+CnSy+91GP6vffe07p163rNl9RVCmLu3Lkezy9dulSnn366/ud//ke/+93vBt2m2bNn67nnntNHH32kuXPn+rXuG2+8oZUrV2ry5MmEbACAQRnOx8ijR4/qggsuUGpqqt555x1NmDCh67kf/OAHWr58uW6++WbNmzdPixcvDvj1+KutrU1JSUlh2x8AYHgZzsd+SZowYYI6Ozv16KOPegRtbW1teuqpp7RixQo9+eSTHuvEx8crPj7er3YBAIDoRulIIAKWLl0qSdq1a1dQtnfTTTcpNzdXd955p1/rvfXWW1qxYoUmTpyoV155RSNGjAhKewAACFSsHiN///vfq6KiQv/1X//lEbJJUmpqqh588EHZbDb99Kc/lSRt3LhRNptNDz74YK9t/f3vf5fNZtNzzz3XNe/gwYO68sorVVRUpOTkZE2fPl3333+/x3quklmPPfaYfvzjH+uYY45RWlqaGhoa+nyN3/zmNzV27FglJydrzJgx+v73v9/V48DFVWrryy+/1PLly5Wenq5Ro0bppz/9qSzL6vd9AQBgILF67He5+OKLtXr1ajmdzq55a9euVUtLi771rW/1Wr7nGG2vvfaa4uLidPvtt3ss98gjj8hms+l//ud//HodAAAg/AjagAhwnVDn5uYGZXtZWVn6/ve/r7Vr1+qjjz7yaR1XeavS0lK9+uqrys/PD0pbAAAYjFg9Rq5du1YpKSlev1CTpNLSUp1wwgl67bXX1Nraqvnz52v8+PH629/+1mvZ1atXKzc3V8uXL5ckVVZW6vjjj9crr7yiG2+8Uffcc48mTpyoq666SnfffXev9f/t3/5Nzz//vG699Vb97Gc/67NH2+OPP66WlhZ997vf1W9/+1stX75cv/3tb3XZZZf1WtbhcOgb3/iGioqK9Mtf/lLz5s3THXfcoTvuuGPA9wYAgP7E6rHf5ZJLLtHhw4e1fv36rnmPPPKIvv71r6uwsHDA9U8++WRdf/31+vnPf97V3sOHD+umm27SKaecouuuu87ntgAAgMggaAPCoKWlRdXV1aqsrNTbb7+tK664QpJ0wQUXBG0f/+///T/l5ubqJz/5yYDLHj58WKeffrrGjRun1157jZANABAxQ+UY+fnnn6usrKzf8VZmzZqljo4O7dy5U5J04YUXat26dTp69GjXMna7XU899ZTOPfdcJSYmSpL+5V/+RQ6HQ5s3b9a//uu/6rrrrtMzzzyjiy66SHfeeWevHmhtbW1699139f3vf18/+tGPlJaW5rU9v/jFL/T888/rtttu07XXXqs//vGP+vd//3c9+eST2rdvX69tfuMb39BDDz2kG264Qc8++6xWrFihX/ziF6qurvbpPQIAQBo6x36XSZMmaf78+XrkkUckSXV1dXrhhRd0ySWX+LyNX/7ylyopKdFll12m9vZ2XXPNNers7NSf/vQn2Ww2v9oDAADCj6ANCIM77rhDBQUFGjlypJYuXapt27bprrvuCuqFRHZ2tm6++WY9++yz2rx5c7/LNjc3q7GxUUVFRcrKygpaGwAA8NdQOUY2NjYqMzOz32Vcz7tKOV544YXq6OjQmjVrupZ5+eWXVVdXpwsvvFCSZFmWnnzySa1cuVKWZam6urrrsXz5ctXX1/e6W//yyy9XamrqgG3uvkxzc7Oqq6u1ePFiWZbl9X268cYbu3632Wy68cYbZbfb9corrwy4LwAAXIbKsb+7Sy65RGvWrJHdbtcTTzyh+Ph4nXvuuT6vn5aWpgceeEDbtm3T1772NT3//PP6zW9+o7FjxwbUHgAAEF4EbUAYXHvttVq3bp3Wrl3bNfaJw+EIaFv93c32ve99Tzk5OQPWop84caJ+8Ytf6LXXXtPFF18ccFsAABisWDpGNjU1qaKioutx5MiRrucyMzPV2NjY77Zdz7sCt1mzZmnKlClavXp11zKrV69Wfn6+Tj75ZEnSkSNHVFdXpz/84Q8qKCjweLh6AFRVVXnsp7S0tN92uOzbt0+rVq1SXl6eMjIyVFBQoBNPPFGSVF9f77FsXFycxo8f7zFv8uTJktwlvwAA8MVQOfZ3d9FFF6m+vl4vvvii/vrXv+rMM88c8AacnpYsWaLvfve7+uCDD7R8+XJdeeWVfq0PAAAiJyHSDQCGg0mTJumUU06RJJ155pmKj4/Xj370I5100kmaP39+13IpKSlqb2+XZVm9Lhgsy1JbW5tSUlL63I/rrr0777xzwLv2/vEf/1E1NTX65S9/qWuuuYaSFACAiIilY+SvfvUrjxJU48aN6wqZpk6dqs2bN6u9vb3P8pGffPKJEhMTNWnSpK55F154of7jP/5D1dXVyszM1LPPPquLL75YCQnmNN3pdEqSLr30Ul1++eVet3vsscd6TPvSm83hcOjUU09VbW2t/umf/klTpkxRenq6Dh48qFWrVnXtFwCAYBsqx/7uiouLtWzZMt11111655139OSTT/ryVnhob2/vGudt165damlp6bP8MwAAiC70aAMi4F/+5V+UmZmpH//4xx7zx40bp87OTu3atavXOjt37pTD4dC4ceP63fbNN9+snJwcn2rR/+IXv9DVV1+tP//5z7r11lv9exEAAIRANB8jL7vsMq1bt67r8de//rVr+TPPPFNtbW16/PHHvW5vz549euutt3TyySd7BGEXXnihOjs79eSTT+rFF19UQ0ODLrrooq7nCwoKlJmZKYfDoVNOOcXro7CwcMDX09Onn36qHTt26K677tI//dM/6eyzz9Ypp5yiUaNGeV3e6XTqyy+/9Ji3Y8cOSVJJSYnf+wcAwCVWj/09XXLJJXrrrbeUlZWlM844Y8D99XTHHXdo27Zt+tWvfqXdu3frRz/6kd/bAAAAkUHQBkRATk6OvvOd7+jvf/+7Pv744675p59+uiTp3nvv7bXOfffd57FMX1x37T3zzDMe2+7L73//e11wwQX69a9/rX//93/3/UUAABAC0XyMHD9+vEfAtWTJkq5lv/Od76iwsFA//OEPewVSbW1tuuKKK2RZlm6//XaP56ZOnaqZM2dq9erVWr16tYqLi/W1r32t6/n4+Hidf/75evLJJ7V169ZebeyrhNVA4uPjJZkeAS6WZemee+7pc53u771lWbr33nuVmJior3/96wG1AQAAKXaP/T1dcMEFuuOOO/S73/1OSUlJA+6ru/fff1+/+tWvdPPNN+uWW27RD3/4Q91777164403/NoOAACIDEpHAhHyve99T3fffbf+8z//U4899pgkafbs2br66qt1zz336IsvvtCpp54qSVq3bp1eeOEFXX311Zo1a5ZP2/7Nb36jLVu2KD09vd9l4+Li9Ne//lX19fX613/9V+Xl5en6668f/AsEACBAsXiMHDFihJ544gmtWLFCc+fO1dVXX61p06apoqJCDzzwgHbu3Kl77rlHixcv7rXuhRdeqNtvv10pKSm66qqrFBfneS/cf/7nf+r111/XwoULdc0112jatGmqra3VRx99pFdeeUW1tbUDvu6epkyZogkTJujWW2/VwYMHlZWVpSeffFJHjx71unxKSopeeuklXX755Vq4cKFefPFFPf/88/rnf/5nFRQU+L1/AAC6i8Vjf0/Z2dkDjgfnTVtbmy6//HJNmjRJ//Ef/yFJ+slPfqK1a9fqiiuu0KeffjpguwEAQGTRow2IkFGjRumSSy7RE0884VEK4/e//73uueceHTx4ULfddptuu+02HTx4UP/93/+t3//+9z5tOycnRzfffLPPbUlKStJTTz2l448/XjfddJMeeeQRf18OAABBE6vHyKVLl+qTTz7Rt771LT3++OO67rrr9Jvf/EZTp07Vm2++qZtuusnrehdeeKGcTqdaWlp04YUX9nq+qKhIH3zwga644gqtWbNGN954o+655x7V1tbqF7/4hc+vpbvExEStXbtWs2fP1s9//nP95Cc/0aRJk/TQQw95XT4+Pl4vvfSSKioq9MMf/lAffvih7rjjDv3bv/1bQPsHAKC7WD32B8M///M/a+fOnXrwwQe7xpxLSkrSgw8+qP379+uHP/xhSPcPAAAGz2Z1rxcDAAAAAN2sWrVKTzzxhJqamiLdFAAAAAAAog492gAAAAAAAAAAAIAAELQBAAAAAAAAAAAAASBoAwAAAAAAAAAAAALAGG0AAAAAAAAAAABAAOjRBgAAAAAAAAAAAASAoA0AAAAAAAAAAAAIQEK4d+h0OnXo0CFlZmbKZrOFe/cAgCHOsiw1NjZq1KhRiovjfpJAcbwGAIQSx+vg4HgNAAg1jtkAMLCwB22HDh3SmDFjwr1bAMAws3//fo0ePTrSzYhZHK8BAOHA8XpwOF4DAMKFYzYA9C3sQVtmZqYk859zVlZWuHcPABjiGhoaNGbMmK7jDQLD8RoAEEocr4OD4zUAINQ4ZgPAwMIetLnKWWRlZXEhAAAIGconDQ7HawBAOHC8HhyO1wCAcOGYDQB9o7AuAAAAAAAAAAAAEACCNgAAAAAAAAAAACAABG0AAAAAAAAAAABAAMI+RhsAAAAAAAAAAAB8Y1mWOjs75XA4It2UYSM+Pl4JCQk+jVFJ0AYAAAAAAAAAABCF7Ha7Dh8+rJaWlkg3ZdhJS0tTcXGxkpKS+l2OoA0AAAAAAAAAACDKOJ1O7d69W/Hx8Ro1apSSkpJ86mGFwbEsS3a7XUeOHNHu3bs1adIkxcX1PRIbQRsAAAAAAAAAAECUsdvtcjqdGjNmjNLS0iLdnGElNTVViYmJ2rt3r+x2u1JSUvpctu8IDgAAAAAAAAAAABHVX28qhI6v7zufDgAAAAAAAAAAABAAgjYAAAAAAAAAAAAgAARtAAAAAAAAAAAAiDnr16+XzWZTXV1dxNrgd9D25ptvauXKlRo1apRsNpuefvrpEDQLAAAMBsdrAACiH8drAAAADEU2m63fx5133hnQdpctW6abb745qG0NBr+DtubmZs2aNUv33XdfKNoDAACCgOM1AADRj+M1AAAAhqLDhw93Pe6++25lZWV5zLv11lu7lrUsS52dnRFs7eD5HbSdfvrp+vd//3ede+65oWgPAAAIAo7XAABEP47XAAAACKfy8nK99NJLKi8vD+l+Ro4c2fXIzs6WzWbrmt6+fbsyMzP14osvat68eUpOTtbbb7+tVatW6ZxzzvHYzs0336xly5ZJklatWqU33nhD99xzT1fPuD179nQtu2nTJs2fP19paWlavHhxyF9jdwmh3kF7e7va29u7phsaGkK9SwAA4CeO1wAARD+O1wAAAHDZsGGDNmzYMOByxcXFuvjii1VeXq677rpLVVVVamho0HHHHafCwsJ+1120aJEWLVoUrCZ7+NGPfqRf/epXGj9+vHJzcwdc/p577tGOHTs0Y8YM/fSnP5UkFRQUdIVt//Iv/6K77rpLBQUFuu6663TllVfqnXfeCUnbewp50Pbzn/9cP/nJT0K9GwAAMAgcrwEAiH4crwEAAODS3t7u041XWVlZkqTdu3erqqpKs2bN0rPPPqsDBw4oJSVlwH2Eyk9/+lOdeuqpPi+fnZ2tpKQkpaWlaeTIkb2e/4//+A+deOKJkkyIt2LFCrW1tQ34GoPB79KR/rrttttUX1/f9di/f3+odwkAAPzE8RoAgOjH8RoAAAAuycnJysrKGvCRnp4uSSotLVVhYaG2bNmi3NxcjR49esB1k5OTQ9b++fPnB3V7xx57bNfvxcXFkqSqqqqg7qMvIe/RlpycHNIPAwAADB7HawAAoh/HawAAALj4W9axrKxMt9xyi/bs2aOSkhKVlZWFsHUDcwWALnFxcbIsy2NeR0eHz9tLTEzs+t1ms0mSnE7nIFrou5AHbQAAAAAAAAAAAIissrKyiAdsfSkoKNDWrVs95n388cceAVpSUpIcDke4mzYgv4O2pqYm7dy5s2t69+7d+vjjj5WXl6exY8cGtXEAACAwHK8BAIh+HK8BAAAA4+STT9Z//dd/6aGHHtKiRYv08MMPa+vWrZozZ07XMiUlJXr//fe1Z88eZWRkKC8vL4ItdvN7jLaNGzdqzpw5XS/uBz/4gebMmaPbb7896I0DAACB4XgNAED043gNAAAAGMuXL9e//uu/6h//8R+1YMECNTY26rLLLvNY5tZbb1V8fLymTZumgoIC7du3L0Kt9WSzeha9DLGGhgZlZ2ervr5eWVlZ4dw1AGAY4DgTHLyPAIBQ4jgTHLyPAIBQ41gDRFZbW5t2796t0tJSpaSkRLo5w46v77/fPdoAAAAAAAAAAAAAELQBAAAAAAAAAAAAASFoAwAAAAAAAAAAAAJA0AYAAAAAAAAAAAAEgKANAAAAAAAAAAAACABBGwAAAAAAAAAAABAAgjYAAAAAAAAAAAAgAARtAAAAAAAAAAAAQAAI2gAAAAAAAAAAAIAAELQBAAAAAAAAAAAAASBoAwAAAAAAAAAAQNCsWrVKNptN1113Xa/nbrjhBtlsNq1atapr2XPOOcdjmYqKCn3ve9/TxIkTlZKSoqKiIi1ZskT/8z//o5aWlq7lSkpKdPfdd/fax5133qnZs2d3LWOz2fp8uNoRqIRBrQ0AAAAAAAAAAAD0MGbMGD322GP6zW9+o9TUVElSW1ubHnnkEY0dO7bP9b788kstWbJEOTk5+tnPfqaZM2cqOTlZn376qf7whz/omGOO0VlnneVzOz788EM5HA5J0rvvvqvzzz9f5eXlysrKkqSutgWKoA0AAAAAAAAAAGCoe/ZZ6fXXpZNOkvwIqgI1d+5c7dq1S2vWrNG3v/1tSdKaNWs0duxYlZaW9rne9ddfr4SEBG3cuFHp6eld88ePH6+zzz5blmX51Y6CgoKu3/Py8iRJhYWFysnJ8Ws7fSFoAwAAAAAAAAAAiBXz50sVFf6t09oq1daa3+++W8rLk/ztyTVypLRxo1+rXHnllfrzn//cFbTdf//9uuKKK7R+/Xqvy9fU1Ojll1/Wz372M4+QrTubzeZXG0KNoA0AAAAAAAAAACBWVFRIBw8Obhuu0C3ELr30Ut12223au3evJOmdd97RY4891mfQtnPnTlmWpbKyMo/5+fn5amtrk2TGePvFL37R9dw//dM/6cc//rHH8na7XdOmTQviK+kbQRsAAAAAAAAAAECsGDnS/3W692iTAu/R5qeCggKtWLFCDzzwgCzL0ooVK5Sfn+/3dj744AM5nU59+9vfVnt7u8dzP/zhD7Vq1SqPef/93/+tN9980+/9BIKgDQAAAAAAAAAAIFb4Wb6xy7PPSuvXS8uWhWWMNpcrr7xSN954oyTpvvvu63fZiRMnymazqby83GP++PHjJUmpXsLB/Px8TZw40WOeayy2cIgL254AAAAAAAAAAAAQGWedJf3612EN2STpG9/4hux2uzo6OrR8+fJ+lx0xYoROPfVU3XvvvWpubg5TCweHoA0AAAAAAAAAAAAhER8fr23btunzzz9XfHz8gMv/7ne/U2dnp+bPn6/Vq1dr27ZtKi8v18MPP6zt27f7tI1wonQkAAAAAAAAAAAAQiYrK8vnZSdMmKDNmzfrZz/7mW677TYdOHBAycnJmjZtmm699VZdf/31IWyp/2yWZVnh3GFDQ4Oys7NVX1/v1xsLAIAvOM4EB+8jACCUOM4EB+8jACDUONYAkdXW1qbdu3ertLRUKSkpkW7OsOPr+0/pSAAAAAAAAAAAACAABG0AAAAAAAAAAABAAAjaAAAAAAAAAAAAgAAQtAEAAAAAAAAAAAABIGgDAAAAAAAAAACIUpZlRboJw5Kv7ztBGwAAAAAAAAAMJU5npFsAIAgSExMlSS0tLRFuyfDket9dn0NfEsLRGAAAAAAAAABAELW2SrW1Uk2N+VlbK1VUSAcPSjab9M//LKWlRbqVAAYhPj5eOTk5qqqqkiSlpaXJZrNFuFVDn2VZamlpUVVVlXJychQfH9/v8gRtAAAAAAAAABBtLMt7mHb4sAnTjh41z7e2Sg6HCdcSvvq6Nz1damsjaAOGgJEjR0pSV9iG8MnJyel6//tD0AYAAAAAAAAAkWBZUkuLO0RzBWqHDplHXZ0J0lpaTDlIV5iWmmoe+fnmZ0K3r3nr6qTGxki9IgBBZrPZVFxcrMLCQnV0dES6OcNGYmLigD3ZXAjaAAAAAAAAACBULEtqbvYeph08KNXXu3umWZZZJzHRHaYVFJifPn7hC2Boio+P9zn4QXgRtAEAAAAAAADAYFiW1NTkGabV1Lh7pjU0uHumuXQP0woLCdMAIEYRtAEAAAAAAADAQCzLlGQcKExrbXUvn5zsDtOysqSUFMI0ABhiCNoAAAAAAAAAQDLhWEND7zDt4EHp8GETtPUXpmVnm59xcZF9HQCAsCFoAwAAAABgmCsvL9fu3btVWlqqsrKySDcnKIbiaxqq+KwQdk6nZ5hWWysdOWJ6pXUP09ra3Ot0D9NyckzPtCgN08qPHtXuigqVfvGFyhYujHRzAGDII2gDAAAAAGAYKy8v11133aXt27fLbrdr2bJlKiws7HP54uJiXXzxxR7zHn30UR0+fHjAfS1atEiLFi3qmm5vb9d9993nUzsvuugijRo1qmt6x44deu6557wuW1VVpfXr16upqUnZ2dm6//77PQKcl19+WVu3bh1wn5MmTdLKlSs95v3hD39QU1PTgOueeuqpmjlzZtd0dXW1HnrooQHXk6RrrrlGmZmZXdObNm3SG2+8MeB6I0aM0OWXX+4x78knn9TevXsHXHfu3LlatmyZx7xf//rXPrX3vPPOU0lJSdf0nj17tGbNGp/WXbFihe666y5VVVWpsLBQJ5xwgqqrqwdcb9y4cTr//PM95j344IOqqakZcN0TTzxR8+bN65pubGzU//3f//nU3ssuu0z5+fld059++qnWrVs34HoZGRm69tprPeatXbtWX3zxxYDrzpgxQ6eddprHvHvvvVd2u33Adc8880xNnjy5a/rQoUN67LHHBlxPkm644QYlJyd3TW/YsEEbNmwYcL2o+T9i+3Y998QTZkw016O5WaqvNyGb3S51dCjJ4dCNEyealb4K014+ckRbGxrMGGo2m3musbHXPifl5Wllj3D4D5s2qcmHz+bU8eM1s6ioa7q6pUUPbdni02u9Zu5cZXb7bDYdOqQ3vvp3XtXcrPU7dypJ0pT77tMtOTkE2AAQYgRtAAAAAAAMY7t371ZVVZVKS0v1/vvv68CBA0pJSelz+aysrF7zmpub1dDQMOC+2tvbe83zZT1JcjgcHtMdHR19rnvgwAHV1dWpqKhIR44c0Z49ezy+aG5ra/Npv62u0nDdNDU1+bRuR0eHx7TT6fT5tVqW5TFtt9t9Wrd7KOLS0tIS8s+ms7Oz17Sv67r+/mbNmqUtW7Zo//79vd47b1paWnrN8/Wz6RlQWZblc3udTqfHdH9/hwNpbW31ad227r2qvtLY2Oj1M+up53vpcDgCbm97e7tP64b1/wjLMr3OWlvl2LRJ+uQT0zPt4EF1fPaZGj77TOrokLr//xEfbwK0xEQpJcX8u5kxw2Ozbc3NaqivN2FcP1p7/O1LUpPdrgZfPpsef0tOy/JpPUmyekzbHY6udQ80NKjObtfCvDxVVVf3+v8PABB8BG0AAAAAAAxjpaWlKiws1Pbt25WTk6PRo0d7/aLcJT093eu8/tZx8RYE+bKeJMXHx3tMJyYm9rnu6NGjtXPnTtXU1Cg3N9ejt5UkpaSk+LTf1NTUXvMyMjJ8am9iYqLHdFxcnM+v1ebqQfOVpKQkn9b11ra0tLSQfzYJCQm9pn1d1/X3t2XLFhUWFmrMmDE+9WhLS0vrNS8jI8On8CkpKclj2maz+dzeuB6lAvv7O+zZtp5SU1N9Wtdb8J2Zmen1M+up599hfHy8z6+1p+TkZJ/WDfr/ERkZpoxjz55pdXWml9lXPdPid+0yZR0lKSVFiXa7stLTTaCWkODumdZDUo//WyQpJSFBWT68v6kJvb9azejx99WXxB5/S3E2m0/7lKSeryQpPt6sa1kqS03VYrtdx+3bp80jR/b6/w8AEHw2q+dtUiHW0NCg7Oxs1dfXB3xgBwCgLxxngoP3EQAQShxngiOY72N5ebn27NmjkpKSIdPzYSi+pqGKzwpyOKSjR3uPmXbggFRZaYK11lZ3DzObzZR5TEtzj5uWnNxnmDbkOJ2mBOaRI1J1teejZ0/cZ56Rzjor4F1xzAaAgdGjDQAAAACAYa6srGzIBRxD8TUNVXxWw0Rnp/cwbf9+qarK9FRrbZXa292BmStEy8iQCgqGV5gmmbKXNTW9w7SaGvN+DsRmk9avH1TQBgAYGEEbAAAAAAAAgMHr6OgdplVVmZ5p3cM0u92EQDablJJiwrTMTKmwUEpKGl5hmmTel+rq3j3U6ur8205WlnkvKyvNtGVJy5YFu7UAgB4I2gAAAAAAAAD4pqPDM0hzhWn795ugqLXVPDo6zPI2m7tnWlaWVFQ0PMM0yzLBWc/eadXVJmjzVVyclJcn5ee7HwUF0ogRpsefJH30kfTll9Jtt9GbDQDCgKANAAAAAAAAgJvd7luY5ipf2D1My86WRo6UEhOHX5gmmfekZ7nHI0d8L/fokpRkArTugVp+vpSbK8XH97/u+PFm3dNPH9xrAQD4hKANAAAAAAAAGG7a23uHaZWVpsxjdbVnzzSbzfSkcoVpOTlScfHwDdMk8970Ve7RsnzfTmZm7zCtoMCMS+fPe9vRITU2Sg0NUn29KcMJAAgLgjYAAAAAAABgKGpr8y1M6+z0HqaNGiUlJAzfMM2yTGjlrdxjc7Pv27HZ+i73mJLif7scDqmpyR2sORyml1tWlglATzpJKi01nyEAIOQI2gAAAAAAAIBY1draO0yrqJAOHjTlCl1hmsNhlo+Pd4dpeXnmZ2JiZF9DpHV2mvete5lH10/XWHO+SErq3TstP9+8zwOVe+yLZZkx3BoaTLDW3m6Cu4wMU0Zy3jwTqh1zjHnk5g7fYBQAIoSgDQAAAAAAAIhmLS2+hWlOp1meMM27trbepR6rq6WjR/0r95iR4b3cY2bm4EIuyzJBmqunWmurmZeWZnqrzZ0rTZrkDtUKCwMP8AAAQUPQBgAAAAAAAESSZZlQpabGM0w7fNiEaUeP9g7TEhLcYVp+vvmZwFd9siwTUrlCtO491Pwt95ib6y7xWFDgDtUCKffoTWenO1RrajKfbVKSCdUmTpQmT5bGjDGh2qhRUnJycPYLAAgqjr4AAAAAAABAqLlKAPYM0w4dMo/uYZqrdxVhWt8cDu/lHqur/Sv3mJjYd7nHYL7XTmfvcdXi4kwvuKIiaelSadw4d2+1zMzg7RsAEFIcmQEAAAAAAIBgsCzTa8pbmHbwoFRf3ztMS0x0h2mFheYn5QDd2tp6l3qsrjbvqz/lHtPTe5d6zM83vceCPaaZq4eia1y1tjb3uGo5OdLs2Z7jqo0YwbhqABDDCNoAAAAAAAAAX1mW6ZlUW+sO1Gpq3D3TGhpMz7XWVvc6hGn9sywTSHkr99jU5Pt2bDYTZHkr95iaGrLme4yr1tJiXk9qqgnxZs3yHFetqIheiQAwxPC/OgAAAAAAANCdK/jpL0xz9UxzSUpyh2kjR5pxvAjTPDkcpkSmq8Rj94fd7vt2EhK8l3scMSL0IZZrXLXGRve4aomJptTj+PG9x1UL1nhuAICoRdAGAAAAAACA4ceyTGDWM0w7eNCEaU1NpndSW5t7ne5hWna2+RkXF7nXEK3a2/su9+h0+r6dtDTv5R6zs8NTatHpNKVAXSUgOzvd46rl50tLlniOq5aVFfo2AQCiDkEbAAAAAAAAhians3eYVl1tgrTDh0144uqZ5gpukpPdYVpOjumRRJjWm6uEprdyj42N/m0rN9d7D7W0tNC03RvXuGquEpCucdXS083fwbHHmh5rrlAtP59x1QAAkgjaoktHh7Rpkzkpyc01j5wc85Nu5gAAAAAAAL05nVJ9fe8w7eBBE6Y1N5sApXvPtO5hmut7F8I075zOvss9trf7vp2EBFPasWcPtbw8U3ox3Ox2d0+15mb3uGqZmdLMmaYEpCtUGzmScdUAAH3iCBENHA7p44+lF16Qtm4105ZlTjJSUtx3UBUXm4crhHM9srKo+Q0AAAAAAIYuh8MdprkCNVeYVlFhela5wjRXLyPXdyqpqSbMSU4mTOuP3e693GNNjX/lHlNTTYA2YoS71KOr3GOk3v/OTvM34grWLMsEZ1lZpvRjWZnnuGqpqZFpJwAgJhG0RZJlSZ99Jj3/vAnaLEsqKTEHc8syPdza2syjokLas8ec9Nhs5nnXCWNamjlxGTXK/OwZxKWm0pUdAAAAAABEN4dDqqvrHaYdOGC+F2lp6TtMS0szwU5KCt+B9MeyTO8tV6nH7oFaQ4N/28rJ8V7uMT09JE33mWtcNVcJyM5O8zeRmWn+RhYv7j2uGn8zAIBBIGiLBMuSdu6UXnxR+uAD081+3DgpI8O9jM1mBthNSvI+kKrTadZznWB+8YX0ySdm25K5Qyg11ZxgZmW5e8Pl5XmGcDk5dH0HAAAAAACRYVlmGI116zzLPLa3m+9GbDZ3mJaeboKc5GSCkYG4yj1666HWvYTmQOLjvZd7HDEiMuUee7Is83pcPdVcY+2lp5sedDNm9B5XjV6NAIAgI2EJt337TMC2YYPpsj5mjDnw+8sVpPXVlb2z0x3C1daaUgp2u/v5pCT3iWpBgQnhCgt794bLyODkFQAAAAAABF9bm/TMM9Jzz5nvLLKzzfcQBQWEab6y2909/3qWe3Q4fN9OSor3co85OdEVTNnt7p5qrnHVXDeZT58uTZokjR7tHlctGsJAAMCQR9AWLhUV0ssvS2+8Ye4oOuYY04stVCeNCQmmS3xmZu/nLMvcGdbWZsK43bulbdvcJ2A2m7s3XEaGOTEpLjYnWz2DuKSk0LQfAAAAAAAMXQcPSg89JG3caL53KCiIdIuil2WZspneyj3W1/u3rezs3qUeCwpM6c1oCzYdDhOquR5Op/v7rrFje4+rlpYW6RYDAIYpgrZQq62VXnlFevVVqarKBFYzZ0b25MVVdiElxdyZ1JPD4Q7hGhqkykrpww/NiZ1lefaGy8szr2nkSLOt7iFcVlZ03fUEAAAAAAAiy7JMlZ9HHzVh26RJfVfrGW6cTjNGnbdyj62tvm8nLs7dM617D7URI6L3hmnX2HGuEpAdHe5x1fLypIULpZISdwnI7OzoCwYBAMMWQVuoNDRI69ebXmwHD5qTmpkzYyN4io83tay9DV5rWeZkx1WW8sABM95cZ6d7me4DERcVmbuK8vPdY8K5gjhOpAEAAAAAGD6am6Unn5Reesl89zBjRmx8TxJsHR3uco9HjpjfXT/9KfeYnOxZ5tH1yM2N7vfVNa6aqwSka8y4tDQToE2bJk2Y4A7VCgqi+/UAAIY9grZga2mR3n7bjMO2d685uZkxw5xADgU2m7n7KSnJ+9hyTqc5QWprM+/Ftm3S5s1mvmS6+LvKUubkuHvD5eV5BnE5OUPnPQMAAAAAYLjbs8eUivz4YxOejBgR6RaFXktL71KP1dWm15o/srK8l3tMT4+NXl0dHe6eak1N7nHVMjOlqVOlyZM9x1WL1l53AAD0gaAtWOx26b33pOefNz28MjLMHTgJw+wtjoszdyB5q4ttWabnm6ssZVWVCSPtdveJYXKyOdlKSzMnjaNGmZ/dS1Lm5MTOySQAAAAAAMOZ0ym9+aa0erUJncrKzLX/UGFZ3ss9Hjnif7nHvDzv5R5j6f1yOEyY5grWHA73uGrHHGM+/7Fj3eOqeaumBABAjBlmKVAIdHZKmzaZgG3bNnPyU1bG3Tfe2GxSYqJ5ZGb2ft6ypPZ2d1nKnTulrVvdZRPi491lKTMzzV1OxcXmpLNnEJeYGNaXBgAAAAAAemhsNAHbK6+Y6/np02P3ptnOzr7LPXYfTmMgSUl9l3uMtco+rnHVXCUg7XYTGGZkmNdz3HGe46rl5MTu5w8AQD8I2gLldEqffCK98IL5abOZ+tEpKZFuWeyy2cz719d76OoN19YmHT0qHT5sehFK5uQuKcldljI/34RwRUWeIVxurgnpOLEDAAAAACB0vvjClIrculUaN86ELLGgtdV7ucejR/3bTmZm71KP+fkmhIrF7yRcN0e7eqq5euulppqhRRYskCZO9BxXLdaCQwAAAkTQ5i/LkrZvNwHbpk2mt9XYsXR1D4eEBHNCmpHR+znLMndOuXrD7dsnlZd7DiLsCuHS001vuFGjeveGy82NrZIMAAAAAABEE4dDevVV6fHHTUnFqVOjr+qPZUn19Z5lHl091FpafN+OzeYu99izh1qsf7fQ0eHuqdbcbG44T042AeLkyaaak2tcteLi6PuMAQAII4I2f3z5pfTii9L775sTr3HjvJdARPjZbOaEr68TWYfD3RuuqcncUbdxo/v5hAR3WcrcXHdZyp4hXFYWd2QBAAAAAODN0aPSo49K69eb70umTYts763OTqm2tncPtZoaEyT5Kimpd5CWn29CtqHwHYFrXDVXsOZwmNeVlWW+H5kyxT2u2jHHeL8BGgCAYYygzRcHDkh//7v09tvmhGP0aGn8+Ei3Cv6Ijzc92bz1PLQsc4Ld1mZ6xB0+LO3ebXrIuS4IkpNNCJeWJhUWmhAuP9+MBRcXZx4228C/+7pcqNaPxfIUAAAAAIDo9/nn0l/+YqoAlZaakCZc2tr6LvdoWb5vJyPDe7nHoTQEhWWZm8ddJSDb281rc42rNneu+fxcoVpe3tB57QAAhEjMBm3l5eXavXu3SktLVVZWFpqdVFWZAXtff93c7TRqlLmDJ4QnGOXV1dpdV6fSnByV5eeHbD/oxmYzd6clJXm/EHA6zYmnqyxlebnK335bu5uaVJqerjLXOpbl/tvo60S++3ybzfPhbV5/8wNdJy7OBI+u8C0+3jxsNu+/d1+m+++u5RISPLcXK6GjL8txMRE2Yfk/HQAAAEDwdXRIL70kPfWUKTE4fbq5Tgw2yzLhkLdyj83Nvm/HVe7RWw+1vsaMj1WuYTZcoZqrLGZqqvn+Y84cadIkd6hWVDQ0eugBABBmMRm0lZeX66677tL27dtlt9u1bNkyFRYW9rl8cXGxLr74Yo95jz76qA4fPux9hdZWM2jvjh1alJioRVOnSjNnSjab2js7dd+HH/rUzotmzNCobqUld9TU6LkdO/pcvqq5Wev37FFLR4eOHz1atyxa1BW2vbxrl7ZWVQ24z0l5eVrZ40vqP2zapCa7fcB1Tx0/XjOLirqmq1ta9NCWLQOuJ0nXzJ2rzG5lGzcdOqQ39u4dcL0Rqam6fPZsj3lPfv659tbXD7ju3OJiLSsp8Zj36w0bfGrveVOnqqTbQMx76uq0Zts2n9ZdMWmS7vr8c1U1N6uwtVUnpKWp2oca7uOys3X+tGlm4qvA7cGPP1aNa93uIZxluactSyeOHq15RUVd8xvb2/V/n37qsYzXn5IumzRJ+SkpXet+WlOjdQcP9ruOLEsZCQm6duJEj7asPXBAXzQ29r+upBlZWTpt5EiPeffu2iW709k7kOwRTp5ZXKzJ3f7dHGpp0WMHDpiJnkGiy1e/31BWpmTXBZ3Npg3V1dpw5Ei/68hmU3F6ui6eONEjkHz0iy902DW4syt06xnG2WxaNHasFpWWdoWT7Zal+959t3dg5+XnRYsXa1R+fte8HYcP67mPPvJ8rV4eSYmJuvGCCzza8/IHH2jrl1/2u55sNk0qKdHKU07xaMcfHn1UTS0tA6576skna+bMmV3rVtfW6qG//tVM93x/e7jmmmuU2e1z3bRpk9544w1JUlVVldavX6+kpCRNmTJFt9xyC2EbAAAAEAuqq6WHHzYVgPLyTInBwd6w6HB4L/dYXe1fucfExN5BWkGB6bUViiAwGnR2uss/NjWZ6+zERBOqTZhgxlYbM8aEaqNGxf44cgAARImYPLPYvXu3qqqqVFpaqvfff18HDhxQSj93HWV56aXU3NyshoYGz5l2u7R3r7RzpzkpSU1V+8SJph51Nw3t7T610+F0ekx3OBz9rnugoUF1bW0alZGhquZm7amr6wra2jo7fdpva2dnr3lNdrtP63b0aK/Tsnx+rT37b9kHeK0uyV7ulGrp6PBp3XYvr9XX9nb2eK2dTqfP6+6uq1NVc7NmFRVpS2Wl9tfX93rvvGnpfkHw1YVHU0eHGny4ULAnJXmUvbSSktTQPXTqh7OgwGPdDptNDTU1A66n5GRp4kSPWa0dHWpwhSr9aCsuNgMjd9N49KjaHY4B1+2YMMGU5/yKo75eDd3vTuwjGJRkLhTi47um29vb1XD0qPf1ugWIWQ6HOyyyLMnpVHN7uxpaWrzvp9vPdrMj9/Y6O9Xw5Zd977PbthzV1Z6fTUODGlyhYj+S4+OlQ4c8ttd28KAa6us9w0upV8jYmp0tvfmmR4DWtG2b+++wZyjZbVsdGzeaC9Ov1nO2tqrhs8/cy/XTi9KqrDR3TX7VG9K+f78adu6UbDYdqKlR3f79Wjh+vKr27tWePXsI2gAAAMKtqcmMSb58eXhL/iF2ffyxCdl27TIhTqDjdrW2Si+8IB08aIIiV0Dkq/R0c50yYoS71GN+vvk7HspVSpzO3uOqxcWZMpdFRdLSpdK4ce7eat1ufAQAAMEVk0FbaWmpCgsLtX37duXk5Gj06NFewzSXdC/jcqWnp7vX6eiQ9uyRtm0zd02lpJhx2OLilJyY2GvdLB/v+InvEUgkxsf3u+7orCztrK1VdWurJo4Y4dHjKiUhwaf9pnq5KysjKcmn9ib2aG+czebza+156po0wGvtr21piYk+rZvs5bX62t6EHq81IS7O53VLc3JUmJ6uLZWVKkxP15jsbJ96tKV5+VvKSEryKXxK6hFI2uT7a43rcWGR6ONr9fbZpPr4d5ji5bPJTE5Wsg+vNbHHa42Pi1OWr+U7UlM97kxMzsjo9/8Gl/SMDI9wT5LSjxzxab/Jo0ebOwJdOjuV5Qr3BhA/bZrHxU5iTY2yfLgQTIqPN+VYuklJTVWWq9drP+Fgak6OudhyBYOWpYzKSnOjgbd1um0rMTnZ3A351fw4SVmuv+vuy3YPnr+aZztwwHw2X00nVVcrq7ZWsiyNbmvTTodDu3fu1JQlS1TSo6cqAAAAwqCmRlq3TqqslL7zHXPeB3hjt0tr10rPPmtuOpwxI/Byg19+KT3xhAnb+mOzmZ5o3so9pqYGtu9YYlnmPXKVgGxrU9e4ajk50uzZnuOqjRgxtENGAACijM2y/LlNaPAaGhqUnZ2t+vp6n74A70t5ebn27NmjkpKSwHs+dHRI779v7trbscOcnI0ZE9ELivLqau2pq1MJY7RFNT4nILjKq6u15+OPVXLTTSq78MJBbStYx5nhjvcRABBKHGeCI6jv49690o9/bHrIXHyx9M1v8kU9equokP7yF+m998zNit2Gn/BLR4f06qvmO5me0tKk8eM9yz3m5Q3dco/etLe7e6q5Kq24xlUrKek9rtpwem8QdhyzAWBgMXskLisrCzxgczikzZtNaYKtW80JycSJUVGbuiw/n+AmBvA5AcFVlp+vspEjTW87AAAARE5OjvTMM1JxsSk9B0gm6PnwQ+mRR6R9+8x3KGlpgW2rokJas8aMwdadzWb2c9ZZvYYiGNJc46o1Npqg2+k0N4BnZprAsee4ar5WfAEAAGETs0FbQCzLBGsvvGBqiVuW6Vo/HMoMAAAAAAAwkIICqarK9FoqKJCmTIl0ixBpra3S009Lzz9vvkeZMcM9xrU/nE7p3Xel1193l5uPj5dOOcUEvHv3mt5aQzlkczql5mZ3CcjOTve4avn50pIlnuOq0XsIAICYMDyCNsuSvvjCBGwbN5p64mPHBj5QLwAAAAAAQ9W4cdL27dKf/iTdemvg5QER+/bvN6Hrxo2ml2NBQWDbqauTnnrK9IZzGTlSOvdc93jZQy3UdY2r5ioB6RpXLT3dBIvHHmt6rLlCtfx8yrUCABCjhn7QtnevGYNtwwZz19CYMVJ2dqRbBQAAAABAdLLZTLm6zz4zYdv3vmfCAQwfliW984702GPS4cPm7yGQkoWWJX3yibnx2W53z1+yRDrpJNOjbaiw29091Zqb3eOqZWZKM2ea99AVqo0cybhqAAAMIUP3qH74sPTyy9Kbb0pHj0qjR5sSBNwdBAAAAABA/+LjTTCwcaMZl+vKK4dWKIK+NTdLjz8u/f3vZqyw6dMDKxXZ0mLKTX7+uXtedrbpxRbrYzN3dprx1FzBmmWZ4Cwry7y2sjLPcdUYsgQAgCFt6AVtNTXSK69Ir75qBtYtLjZ3DhGwAUBkOZ3ui9Huj8ZGMyB6XZ1UXy+tWxfplgIAAEAyPZjGjTPnZ0VF0sqVXFsPdbt3Sw8+KG3ZYoKivLzAtrNzp/TMM+b832XWLOkb3wisZ1wkucZVc5WA7Ow0/w4yM6URI6TFi3uPq8a/EwAAhpWhE7Q1NJgBdV9+WTp0yNT4PvZYTm4AIBw6O90Xnq7wrGeg1tRk7vTszyuvSM8+K511VnjaDQAAgP5lZ5ueSU88YcrdHXdcpFuEUHA6pTfekFavlqqrzXhpycn+b6ejw5zTf/CBe15qqnTmmdK0acFrb6hYlhlLzXVN09rqHlctO1uaMaP3uGqB9PYDAABDSuwHbS0t0ltvSS+9ZMZjy801Pdg40QGA4LDbvQdn3ec1NwdnXzabtH49QRsAAEA0KS42PZQefNAEC+PHR7pFCKaGBjMW22uvmVBs+vTAblo+fFhas8YEdS4TJkhnn216f0Wj7tc6rnHVUlJMr7Tp06VJk8xQJK5x1RITI91iAAAQhWI7aPvwQ3NX3c6d5qRt2jQGkwUAX1mW1N7eO0DrGaK1tQ1+X+np5mK15yMz05T8ff55czFvWdKyZYPfHwAAAIJrwgQz1taf/iT94AemZB5i344d0kMPSZ99Zsa1z872fxtOp/TOO+aGOafTzEtIkE49VVqwIHoqDTkc5jrH9XA43OOqjR3be1y1tLRItxgAAMSI2E6lnnhC2rXLnAwlJUW6NQAQPSzL9PjtKzxzPTo6Brcf19gE3YMzb2FafHzf2ygtNcts3Chdey292QAAAKKRzWauvT/7TPrzn6Ubb4y9sbbg5nCYEo+PP26uC6ZNC6y31tGj0lNPSfv3u+eNHCmdd55UUBC89vrLskwPNdd1kN3uvnbJy5MWLjTBoqsEZHZ29ASCAAAg5sR20OZwmJMhQjYAw4lrMO6BeqI5HIPbT3x878CsZ4iWnh6cUr1lZSb0W7p08NsCAABAaCQkmFJ6775rxkW/9FKGbYhFtbXSI49Ib75pzumnTvU/ZLIs6eOPzTAedruZZ7NJS5aYChX93WgXbK5x1VzXQq2tZr6rqsZxx0kTJ7pDtYIC/m4BAEBQxXbQBgBDjaucSX8BWmOjuZgcjMRE76UcuwdqaWnc1QkAAABPaWlmzKoXXjA9l047LdItgj+2bpX+8hdTMnL8+MDGTmtpkdaulbZvd8/LyZHOPdeUYAy1jg73dVFTk7k2Sk52h4aTJ3uOq8bN2QAAIMQI2gAgXFwXhP2Vc2xuHvx+XIN399ULLSvLXIgSogEAACAQeXkmbHnsMdOzbfbsSLcIA+nokF580ZR5bGmRpk8PbIz7L76Qnn3WBFwus2dL3/iGucYINofD7Mt17eQaVy0z0wRpZWUm3HONq5aeHvw2AAAADICgDQCCob3deynH7mGaq4TJYLjKn/Q3Hhp3bAIAACDUjjnG9Ir685+lW2+VxoyJdIvQlyNHpIcfNiU/8/JMMOXvTXcdHdLLL5txlV1SU6WVK00vsmBwjavmun6y202Jx4wMKTdXWrDAc1y13FxuHgQAAFGBoA0A+mNZJiAbqCeaa1yCQNls5gKyv1KOmZmB3XUKAAAABJvNZsZr++wz6U9/kr7/fTOGOqKHaxy1hx+WvvzSjFMWSI+vQ4ekNWukmhr3vIkTpbPOCqz0pLd2HjggHT1q2pedLc2f7zmuWmFheMd9AwAA8APf2AIYvpxOc8dkfwFaQ4MpTzIYcXHeg7Puj4wMBuQGAABAbImLM6X7tmyRHnpIuu46MxYwIq+93ZR4XLvW9EabMcP/oMrplN5+W3rjDfO7ZG78O+00E4QFozeZ02l6RqanS1dfLU2bJhUXh6YMJQAAQIgQtAEYmrrX8u+rN1pjo/uCMVCJiQOHaGlplDQBAADA0JSUJE2YYMKYwkLpW9/i3DfSDh2S/vIX6YMPpKIi87n4q7bWjOd24IB73qhR0rnnSvn5wWlne7tUXm7KQV5xhTRzZnC2CwAAEGYEbQBiT0eH955n3ed1H5w7UMnJ3ks5dg/UUlL4IgEAAADDW0aGCXSeeUYaOVI68cRIt2h4siwTrj3yiLR/vyntmZrq/zY2b5b+/nd3eXybTTrhBPO5Bqt8Y0ODtHu3NHeudNVVJsQDAACIUQRtAKJLe/vA46G1tg5+P2lp/fdCy8oyd+cCAAAAGFhBgSnL/vDDpgfV1KmRbtHw0tpqeqC98IKZnjHD/9L0zc2m1GR5uXtebq7pxTZmTPDaWlFhxntbvly69FIT1AIAAMQwgjYA4WFZ5uLPW0+07mFae/vg99U9OPMWomVmmrEFAAAAAATPuHHS9u3Sn/4k3Xqr6d2G0Nu3z5SK3LTJ9AwLpLTjjh1mTLfmZve8OXNMGBas8dIsS9q1y/SQ+/a3pTPP5LoMAAAMCZzRABg8yzIXZAP1ROvsHNx+4uL67n3mmp+REbxyJgAAAAB8Z7NJkydLn31mwrabb5bS0yPdqqHLsqS335Yee8z0Eps82ZS294fdLr38sgnpXNLSpJUrpSlTgtfWjg7TU66wULrsMmnhQkrwAwCAIYOgDUD/nM6Bx0NrbDTLDUZCgvfgrPsjPZ2LMQAAACCaxcebwGfjRlNG8uqruREuFJqapL/9TXrlFSkx0ZSK9Pda6eBBac0aqbbWPW/SJOmss4JbzrGlRfriC2naNOnKK6UJE4K3bQAAgChA0AYMZ52d3nuedQ/QmprMnZKDkZw88HhoKSmEaAAAAMBQkJIilZaaEGjkSBPccK4fPLt2SQ89JH3yiTR2rBlHzR9Op/Tmm+bhutZLTJROO02aNy+4n1VNjQn0li6VVq2S8vKCt20AAIAoQdAGDFV2e/9joTU0mDsLBys11Xtw1j1UC1ZNfwAAAACxIStLGjFCevJJqahIOv74SLco9jmd0uuvm55sNTXS1KlSUpJ/26ipkZ56yoRfLsccI517rvm8gsWypP37zTjd554rfetbXBcCAIAhi6ANiDWWJbW1DRyitbcPfl8ZGf33RMvMNHc+AgAAAEBPI0e6e18VFFAycDDq66VHHzVBW3q6NH26fz3PLEv66CPp738346VJZv2vfc30NgtmeU+Hw5SKTE83pUNPOsmMtw0AADBEEbQB0cSypObmgcs5ui6MAhUX5xmceQvRMjIYSwEAAADA4IwfL33+ufTHP0q33hrcXlPDxfbt0l/+Yt7HkhIpO9u/9ZubpWeflXbscM/LyzM9zUaPDmpT1d4ulZeb0qFXXGHGjgMAABjiCNqAcHE6zXhn/fVCa2gwyw1GfPzApRzT07mjEAAAAEDo2WxSWZkJie6/X7rpJjOGGwbW2SmtWyc98YS5bpw2zf+KIuXlJmTrPmzA3LnS8uX+l50cSEODtHu32f7VV0vFxcHdPgAAQJQiaAOCobPTew+07vOamtwDTQcqKcl7cNb9kZrKQOMAAAAAokdCgjRpkrRhgykhedll3Pg3kJoa6ZFHpDfflHJyzHhs/lzn2e2mTORHH7nnpadLK1ea4DPYKipMm5cvly691FRIAQAAGCYI2gB/1ddLr7wiHThgpu12z7sDA5Wa2n+AlpXF4NEAAAAAYlNqqjRmjPTSS6an0/LlkW5R9Pr0U1Mq8osvTOnNzEz/1j9wQHrqKam21j1v8mTprLNM2BZMlmXG4YuLMwHbihUmWAUAABhGOPsBfOG6eNi40ZTe8Fd6+sDlHP0tAQLEEqfTDIru7eF6brBlUwEAABDdcnPNTYqPPSYVFkpz5kS6RdHFbpdeeEF6+mmprU2aPt2/0MrhMD3g3nrLXU0lMdGEmnPnBr/ySUeHuT4uKjK9FI87juoqAABgWCJoA/rT3Cxt3ixt2iTV1XlfJinJXCT21RMtM9OMmwbEAssaOBDr7+G6sHb97F4uNT6+70diojRlijRiRPhfMwAAAMJn1CjTU+vPfzbnfmPHRrpF0aGqSnr4Yendd6X8fGncOP9Cq5oaac0a6dAh97xjjpHOO0/Kywt+e5ubpZ07zbhxV11let4BAAAMUwRtQE+WJe3bZ8K1zz834UF3qalSa6u56LEsc+ESihr3QH8sq+/gy5dAzLLM33D3i3dXKBYX138olpZmBrBPSTH/HlJSzLzUVFPeNCmp70diYt/zufsVAABg6LPZpIkTpc8+k/74R+mWW6Ts7Ei3KnIsy4yj9vDD0t690oQJ/pV3tCxz7fr3v5uxwyXzHp94orR0aWjGwqupMYHe0qXSqlWhCfIAAABiCEEb4NLeLm3ZYi5Sqqp6Pz9hgjR/vqlt/8UX0p49UkkJIRsGNphAzOn0HohZ1sCBmCsEc/3sHoilpAQWiCUlMXA9AAAABicuzlQz+PRT6cEHpeuuM+eZw01bm/TMM9Lzz5uQbPp0/6qhNDVJzz5rrk9d8vLMzaDHHBP89lqWtH+/ufH0vPOkCy5gHHEAAAARtAHS4cNm7LVPPzU15rtLTTXjBsyb53mXXlkZAdtQ1FfZRF8CMVfZRG89xGy2/kOxxERTYtRbIJaaGnggFh9PLzEAAABEp8REczPjG2+YUvwXXji8zl0PHpT+8hfpww/NGGeFhf6tv327tHatGfPOZf586dRTQxNaOhwm0MvIkK65RjrppOH1eQEAAPSDoA3DU0eHKVWycaO5wOlpzBhzkTJtmn+DTyM8+iqb6GsgFoyyia4yiampvpVN7C8Qo2wiAAAAhqOMDKm42PTKGjlSWrYs0i0KPcuS3ntPevRRcy06caK5lvBVe7spE7l5s3teerp09tnSpEnBb69rn+XlUmmpdMUV0owZodkPAABAjCJBwPBSXW3CtS1bTJmO7pKSpGOPNQFbUVFk2jcUDSYQ669sYnx8/6GYKwzzt2ziQIGYP6VcAAAAAPQvP19qbpb++lepoMCUTxyqWlqkJ5+UXnrJXMtMn+5fWfb9+6WnnpKOHnXPKyuTVq70b1w3f9TXm2ET5s+XrrzSBKMAAADwQNCGoc/hMGU1Nm2Sdu/u/fzIkeaiYcaM4V1f3lvZRF8DsWCUTew+lpgvZRP7C8QomwgAAADEjrFjTY+p+++Xbr11aIY5e/dKDz1keqIdc4w0YoTv6zocpsTm22+7r7OSkqRvfEOaPTt01z2HD0u1tWY/3/626YEIAACAXgjaMHTV15twbfNmM0h0d/HxJlibP99c5MRSIOOtbKI/gZiLt1BsoF5iaWnucok9QzFvZRMHCsMomwgAAADAZjNlDz/7zIRt3/ve0Al1nE7prbek1aulqirTA82fGzyrq6U1a0zo5TJmjHTuuVJubvDbK5nrw127zLXhpZdKK1YwpAIAAEA/OFPC0OJ0mguCjRvNQM2uAMklL8+Ea7Nn+1cHfzDtCTQQ694jzMWfsok9Syf2VzbR10CMsokAAAAAQiE+3oRQmzZJDz8sXX117Ic7jY3S3/4mvfKKCdemT/f9JkPLkj78UFq3TursNPPi4qQTT5ROOMG/kpP+6OgwvQuLiqTLL5cWLODGSAAAgAHE+Fkr8JXmZtNzbdMmqa7O8zmbTZoyxQRspaWDv0iwLFMTv6bGXIQ4ne79dF/GNa+/UMzfsom+BGKUTQQAAAAQi5KTpZIS6dVXTdBzzjmxe12zc6cpFfnpp9K4cVJOju/rNjZKzz5rtuEyYoR03nnSqFFBb2qX5mazz2nTTNBZWhq6fQEAAAwhBG2IXZYl7dtneq99/rk78HLJypLmzjWPzMzB76u+3pT6aG+XsrNN6cnCQu9lE30NxCibCAAAAABuWVlSfr4plzhypLRoUaRb5B+HQ3rtNdOTra5OmjrVXPv5ats2ae1aqbXVPW/BAunUU831Y6jU1EiHDklf+5q0alXoylICAAAMQQRtiD1tbdKWLab32pEjvZ+fONH0Xps0aXDlNCzL3ElYVSW1tJgLvmnTpOOOMyFbcTEhGQAAAAAEW1GRGWf7oYdM6DZpUqRb5Ju6OunRR6XXXzc3e06b5vs1Y3u79NJL0scfu+dlZEhnn22ucUPFsqT9+8119vnnm4c/Y8gBAACAoA0x5NAh03tt61ZTsrG7tDRpzhxp3rzB3XlnWaZcRlWVubDLyJAmTJCOP96Ea6NHE64BAAAAQKiNH28ql/zxj9IPf2gCt2i2bZsJBrdvNyUXs7J8X3ffPumppzyHQZg6VTrzTHOtGyoOhxnbPCPDlIo86SSudwEAAAJA0Ibo1tFhgrWNG03Q1tPYsab32tSpgxsou7nZ9I5raJDS0812XeHauHGhG2gaAAAAANCbzSaVlUmffSb9+c/SjTeasv3RprPT9ER76ilzs+b06b5fmzoc0vr10jvvuMf5TkqSTj9dmjUrtKFXe7tUXm5CwSuvNO0GAABAQAjaEJ2qq024tmWLKWHRXVKSueiYP9+MkRao1lbTc62+3lywjR4tnXWWNHOmuXsyPn5wrwEAAAAAELiEBGnyZGnDBmnECDN2WDTdBFldLT3yiPTWW1JOjjRliu/h2JEjZhy6igr3vDFjpHPPDf34aPX10t69piLMlVeaYREAAAAQMII2RA+Hw5TZ2LhR2rOn9/MjR5pwbeZM/waT7q693YRrdXVmG6NGmbsFjz3W1L0fTK84AAAAAEBwpaaaAOrvfzeB0OmnR7pFxpYt0sMPSzt3muEGMjJ8W8+ypA8+kF55xfSGk0x4eNJJ0uLFoQ8SDx+Wamul5culSy81FV0AAAAwKKQKiLy6OmnTJmnzZlPCsbuEBFO+cf58E4oFUjrDbjd3Cx49anqpFRdLX/+6CdcmTw48tAMAAAAAhF5urtTSIq1eLRUVSXPnRq4tdrv03HPSs8+a6iszZvheDaWxUXrmGWnXLve8/HzpvPNC36vMssx+4+Kkf/gHacUKqrgAAAAECUEbIsPpNHf+bdpkBl921aN3GTHChGuzZgVWh7+jw5TxqKkxFxJFRdLKlWZ7U6ZIKSnBeR0AAAAAgNA75hhpxw7pgQfM9eK4ceFvQ0WF6cX23nsmICsp8X3dzz83AV1rq3veccdJp5wiJSYGvakeOjrMeGxFRdLll0sLFoR2/DcAAIBhhqAN4dXUZHqubdpk6sJ3FxdnQrD5880Fi78n/p2dJlirrjbTBQWmrMjs2dLUqVJaWjBeAQAAAAAgEiZONIHVH/8o3XKLGRctHCzLDHHwyCNmbLOJE32/vmxrk158UfrkE/e8jAzpnHNMyclQa242N7lOmyZdfbVUWhr6fQIAAAwzBG0IPcsyFyMbN0rbtpnebN1lZZlBmOfMkTIz/du2w2Hqyx85YrY7YoQpCzlnjrmQ8Hd7AAAAAIDoFBcnlZVJW7eanm3XXx/6oQDa2qSnn5aef95cc86Y4fs4anv3Sk895XmT6bRppmxjOG4Era42Y7J97WvSqlWmBCcAAACCjqANodPWZgaI3rjR3cusu4kTTe+1SZP8G/DZ6XSHaw6HlJcnLV1q6vRPnx6+uxoBAAAAAOGVmGiuJd96SyoslC6+OHRlEA8ckB56yFzTFhebqim+6OyUXn9devdd97zkZFNx5dhjQ1+20bKkffuk9nbp/PPNIzk5tPsEAAAYxgjaEHyHDkkffmjuMuzs9HwuLc30Nps3z7+76SxLOnpUqqoy9eVzc009+wULTLg2YkRwXwMAAAAAIDqlp5vg67nnpJEjpZNPDu72LcuEZI8+anqETZ7s+zjfVVXSmjVSZaV73rhxplRkOG4KdTjMWHZZWdJll0nLljEeGwAAQIgRtCE4OjqkTz81Y68dOtT7+XHjTO+1KVOkBB//7CzLlNioqjJ34mVnm5BuwQJTrqOwMLivAQAAAAAQG/LzpZYWM25aYaG5RgyG5mbpySell14y167Tp/tWgcWypPffl155xYRdklnv5JOlRYv8q+ISqLY2E7KNHy9deaUpUwkAAICQI2jD4Bw5YspobNliwrDukpOlWbNM7zVfQzHLkhobTbjW0mLuwps2zfRemzHD3LXI3XgAAAAAgDFjpPJy6f77pVtvlUaNGtz2du+W/vIX6eOPpdGjzTAFvmhoMOO47d7tnldQIJ13nulxFw719dKePeYG16uuCt9+AQAAQNCGADgc0rZtJmDbu7f388XF5uR+xgzfBqa2LHPXYFWV1NQkZWRIEyZIxx9vtjF6NOEaAAAAAMCTzWbG/P78c+lPf5JuvlnKzPR/O06n9MYb0t/+Zm4mLSvzfUyzrVul5583vclcFi6UTjnF92oug3X4sBlq4YwzpEsuMaU1AQAAEDYEbfBdXZ0pDbl5swnGuktIMKHY/PnSMcf4tr2WFhOuNTSYsdvGjjUlNWbMMKUmw1FaAwAAAAAQu+LjzRhqH30kPfywdM01/gVcDQ3S6tXSq6+acdimT/ftRs+2NumFF8wQCi6ZmWYstvHj/X4ZAbEsaedO83r/4R9M0BYfH559AwAAoAtBG/rndJoT940bpS++6P18fr4pDTlrlpSaOvD2Wlvd4VpKiumtdtZZ0syZ5mKEiwIAAAAAgD+Sk6XSUhOWFRaako2+hGU7dphSkVu3mps9c3J829+ePdJTT5nrWpfp06UVK3y7Lg6Gjg5TNnPkSOnyy81Y5gAAAIgIgjZ419Rk7gj86CNT6727uDhp6lTTe23cuIEvYNrbTbhWV2dKSY4aJZ1+ugnXJk0KXzkNAAAAAEBvzc3SXXdJH3xgAqNjj410i/yXlWXGRXvqKRM+LVnS97IOhwnlHn/cXKdOmyYlJg68j85O6bXXpA0b3POSk01PspkzwzfkQXOzuSF2xgwzHltJSXj2CwAAAK9IOOBmWebOvE2bzBhsTqfn89nZ0ty55pGR0f+27HZT2/7oUROkFRVJX/+6uWCbPNm3sdsAAAAAAKH3y19Kv/2t+X3HDvNYsMBUIImlqiNFRSaE+stfTOg2eXLvZY4elR55xIzJlplpQjZfArLKShPiVVa655WUmFKR2dnBegUDq642Y7KdeKLpyZabG759AwAAwCuCNphyjlu2mICturr385Mmmd5rEyf2P25aR4dZv6bGLFdUJK1cacpKTpliSkUCAAAAAKLLc895Tn/2mXkkJpoqJqWlptR/UVH4em0FqrRU+vxz6U9/km691QRuLp99Jj30kAkSx483QdtALEt67z3TA87hMPPi46WTTzZjjIfr/bAsad8+UzHmgguk88/nBlYAAIAoQdA2XFmWdOiQGXtt61ZTAqO79HRpzhwz/lp/deo7O02w5groCgpMWcjZs015ybS0UL0CAAAAAEAwnHuuGTagp44OU6Jw504znZZmgixX8BaNvalsNqmszIRt998v3XSTCQxfesn0SGtuNuUxfRnCoL5eevppU/nFxTUGXFFRqF5Bbw6HCQezskwvthNPjP7AEwAAYBghaBtu7HYTrG3caMpN9DRunOm9NnVq3yVCHA6pttaUhnQ6pREjTFnIOXNM2Q1f7goEAAAAAESHH//YjGt2113mmjAlRdq9W/rySzN+t0tLi7u3m2Ruyhw/3jxKSswNm9EgIcFUZnn/fXO92tQkvf22lJdnqq34ElJ9+qn0/POmB5nL8ceba99wjjPe1ubugXflleaaGwAAAFGFoG24qKoy4donn3heKEhm8OZZs0zA1r2sRndOp6llX1VlgrbcXOmEE0yPt+nT++/1BgAAAACIbqeeasYtKy42PddmzzaVUKqrTeC2e7d52O3uderqTE84V2+4kSPdvd3Gjo1sacPUVNOGF14w0xMm+BYEtraadbZudc/LyjJjsZWWhqSpfaqvN73pFiwwIdvIkeHdPwAAAHxC0DaUdXZK27aZsdf27u39/KhRJlybPt37BZBlucO1jg4Trh13nDnJnz7d3BkIAAAAABiabDZzM2ZBgbRwobkB89Ahd/C2f7973DJJqqgwjw0bzLjdY8a4g7dRo/qumhIqOTnmxtKkJN/2vXu3KRXZ0OCeN3OmdMYZ4R9z/PBhcz2+YoV08cXR01sQAAAAvRC0DUVHj5pwbfNmU9qju4QEc6Ewf7650OnJssxdc1VVpkRFTo4pCblggTRjhqlHDwAAAAAYfuLipNGjzeNrXzM3ZO7b5w7eug9P4HSaGz737pXWrzdhV0mJO3grKAjPOGOpqQMv09kpvfqq9N577nkpKSbkmjEjdG3zxumUdu0y1+6XXWbGQA93QAkAAAC/ELQNFU6n9MUXpjyka6Dq7vLzTbg2a1bvO/EsS2psNOFaS4spizFtmum9NmOGKR3CQMsAAAAAgO4SE01JxgkTzHRLiyl1+OWX5nH0qHtZu92MNbZjh5lOTzeBmyt4y84Oe/MlmR54Tz1lroddSkuls88Of5s6OqTyclMictUqcw0PAACAqEfQFusaG03PtU2bPMtbSOZuw6lTzcn5uHGeYZllSc3N5mKiqUnKyDAXR8cfb8pCjhlDuAYAAAAA8F1amrlpc9o0M11X5zm+W3Oze9nmZunTT81DkvLy3KFbaalvPdEGw+k0JS5ff91d/jI+Xvr61811cbivh5ubzU2zM2ZIV11lev8BAAAgJhC0xSLLMncJbtwobd9uLhC6y86W5s0zJR8zMjyfa2kx4VpDg7kIGjtWWrTInMyPG2fCOQAAAAAABisnR5o71zwsy1yLuoK3PXtMDy6X2lrz2LTJTBcXu4O3sWNN77lgqaszY7F1H8u8qEg677zIDJdQXW3Kbp54ounJlpMT/jYAAAAgYARtsaS1Vfr4Y3PhUVPT+/nJk03vtQkTPAOz1lbpyBFzMZGSYurpn3WWGatt/HjqvQMAAAAAQstmM2FWUZG52dPhkA4edAdvBw543kR6+LB5vPuuuWYdM8YdvI0aFdhNopZletC98ILU3u6ev3ixdNJJZly0cLIsM8Zde7v0zW+aoC8pKbxtAAAAwKARtEU7yzIXHxs3Sp99ZgZp7i493X2HYPe73trbzd2CdXXmRH3UKOkb3zDh2qRJ4b+AAAAAAADAJT7e9FQbO1ZatsyM4bZ3rzt4q6x0L+twmB5we/aYUo/Jyaa0oit4y88fuNRja6v0/PPmutolO1s655zIlGl0OMx4dVlZ0uWXm95sDN8AAAAQk0hbopXdbu6027jRDM7cU0mJ6b02ZYq7R5rdbnquHT1qgrSiIlNf/thjTW837owDAAAAAESjpCRzU+ikSWa6udkEbq7gra7OvWx7u1Rebh6SlJnpOb5bVpbntr/80pSKbGx0zzv2WOn0003Vl3BrazMh24QJ0pVXmrHVAQAAELMI2qLN++9Lmzeb0pA9e6+lpEizZpmALT/fzOvoMD3XampM6YzCQmnlSrPclCmRuWgAAAAAAGAw0tPNWOIzZpjpo0fdoduXX5oeai6NjdInn5iHZK6XS0tNeLdrl+fNqykp0plnStOnh++1dFdXZ8pFLlhgQraiosi0AwAAAEFD0BYtOjqkRx4xpTB6OuYYad48c4GRmGgCuMpKM2CyJBUUmDvxZs2Spk2T0tLC2nQAAAAAAEIqN9dcF8+bZ4ZYqKx0B29795prapfqavf1cnfjx0tnn927x1u4HDpkgrYzzpAuuYRrdwAAgCGCoC0aHD0q/e1vvUtEFhSYevGjRpn67bW1pjSk0ymNGGHKQs6ZY8K1zMyINB0AAAAAgLCy2aSRI81j8WJzvXzggDt4O3DAhHHdjRsnXXppZMZBczpNz7rEROmyy8yNsq4hIAAAABDzCNoibdcu6YknTI12F5vNXBScdJIZ5HnbNtOLLS9POuEEcwff9OlSTk7Emg0AAAAAQFSIjzdB2rhx5jq6vV165x3prbfcyyxaFJmQraPDjCU3cqS0apUZCgIAAABDCkFbpFiW9Pbb0muvueeNGGHqtFdUmB5qnZ1SS4t03HHmZHzGDLMMAAAAAADwLjlZOvlkMwzDnj1SSYlUVhb+djQ1mZtrZ8yQrr7aBIEAAAAYcgjaIqG9XXr6aWn7dve8sjJpxQpzETBnjjR5sgnYZsyQCgsj1VIAAAAAAGJTWVlkAjbJjBFXUWF62F12GRVpAAAAhjCCtnCrrpZWr/YcmPmkk6SFC005iWnT3He6RaKsBQAAAAAACIxlSXv3Sna7dMEF0nnnSUlJkW4VAAAAQoigLZy2b5eeesqccEtSSoo56R471jw3a5Z0/fX0YAMAAAAAINY4HNKOHVJ2tnTFFdLXvsYNtAAAAMMAQVs4OJ3S66+bMdlcCgulCy+UUlNNyDZ/vvTd70p5eZFrJwAAAAAA8F9bmwnZJk40IdvUqZFuEQAAAMKEoC3UWlulNWuknTvd82bMkFaulDo6zIn44sXStdeau94AAAAAAEDsqKsz5SIXLjQhW1FRpFsEAACAMCJoC6WKCjMeW12dmbbZpFNPlY4/Xmpqknbvlk480YzJlpER0aYCAAAAAAA/HTpkrvnPPFO6+GIpLS3SLQIAAECYEbSFyqefSs8+K3V2mum0NDMQcmmpVF8v7dsnff3r0pVXmvKRAAAAAAAgNjid0q5dUmKidPnl0je+IcXHR7pVAAAAiACCtmBzOKR166T333fPGzVK+ta3TGnIo0elgwfNSfhll0nJyZFrKwAAAAAA8E9Hh1ReLhUXS6tWSfPmRbpFAAAAiCCCtmBqapKeeMLUZneZM0c64wwpIUGqrpYqK834bJdcYu58AwAAAAAAsaGpyfRkmzlTuuoqady4SLcIAAAAEUbQFiwHDkh/+5vU2Gim4+JMwDZ3rhmbrarKBG3nnSd985smeAMAAAAAALHhyBFz8+xJJ5kKNTk5kW4RAAAAogBpTzBs2iS9+KIpGylJmZmmVOTo0Wb68GGpoUG68ELp3HNNCAcAAAAAAKKfZZnKNXa7uXH23HOlpKRItwoAAABRgqBtMDo7pRdekDZvds8bO9aceGdkmOkDB6TWVunb35ZWrDC92wAAAAAAQPRzOKQdO8yY61deKS1dynU9AAAAPBC0BaqhwZSKPHjQPe+446TTTpPi480db/v2mZPyVaukU07hZBwAAAAAgFjR1mZCtokTTcg2ZUqkWwQAAIAoRNAWiD17pMcfl1pazHRCgrRypXTssWbasqTdu03gdvXV3PEGAAAAAEAsqaszN88ed5wJ2QoLI90iAAAARCmCNn9YlvT++9LLL5vfJTP48YUXSiNHupfZuVNKTTUh2/HHR6y5AAAAAADAT4cOmaBtxQrp4oultLRItwgAAABRjKDNVx0d0tq10qefuudNmCCdd577pNuypPJyE75de600d25EmgoAAAAAAPzkdEq7dkmJiWYIiOXLTaUaAAAAoB8Ebb44elRavVqqrHTPO+EE6aSTpLg4M+10mpCtoED6znekmTMj01YAAAAAAOAfu92MxzZqlAnZuHEWAAAAPiJoG8jOndKTT5pBkCUpKUk65xxp6lT3Mg6HtH27OSG//nqprCwiTQUAAAAAAH5qajI92Y49VrrqKmns2Ei3CAAAADGEoK0vliW99Zb0+uvueSNGmPHYCgrc8zo7TchWUmJCtvHjw95UAAAAAAAQgCNHpIoK6eSTpcsuk7KzI90iAAAAxBiCNm/a26WnnjKlIF3KyqRzz5WSk93zOjqkbdukSZOkG27grjcAAAAAAGKBZUl795rr+m99y4y/npgY6VYBAAAgBhG09XTkiBmPrabGPe+kk6SlSyWbzT3Pbjc92aZPNz3ZiovD31YAAAAAAOAfh8PcWJuTY0pFnnCC5/U+AAAA4AeCtu62bZOeftqEaJKUkiKdf740caLncm1t5qR89mwTsnUvJQkAAAAAAKJTa6v0xRfmOv+qqxhjHQAAAING0CZJTqcZi+3tt93ziorMeGy5uZ7LtrZKO3ZICxZI110n5eWFt60AAAAAAMB/dXXSvn3SccdJV14pFRZGukUAAAAYAgjaWlqkNWukXbvc82bOlM48U0pK8ly2uVnauVNavFi69loGSQYAAAAAIBYcPCg1NEgrVkgXXyylpUW6RQAAABgihnfQdviw9Le/mbvaJFOT/bTTpIULe9dnb2yUdu+WTjxRuvpqKSMj7M0FAAAAAAB+cDrNDbPJydKqVdLy5VJcXKRbBQAAgCFk+AZtn3wirV0rdXaa6fR06YILpJKS3svW15vyEqecIl1xhZSaGtamAgAAAAAAP1mWGYu9uNhcy8+ZE+kWAQAAYAgafkGbwyG9/LL0wQfuecccI33rW1JWVu/ljx6VDhyQTj9d+od/MHfBAQAAAACA6NbYaG6U/e53palTI90aAAAADFHDK2hrapIef9z0TnOZO9eEaAle3orqaqmyUjr7bFPDPTExfG0FAAAAAACBq6gwAVtZWaRbAgAAgCFs+ARt+/ebkK2x0UzHx5uAbd4878tXVkq1tdL550vf/KZZHgAAAAAARD+nU2pvlxYvZkw2AAAAhNTQD9osS9q0SXrxRXOiLUmZmaZU5OjR3tc5fFhqaJAuusj0ZuOkHAAAAACA2FFdLY0YIc2aFemWAAAAYIgb2kFbZ6f0wgvS5s3ueePGSRdcIGVkeF/nwAGptVW69FLpjDMkmy08bQUAAAAAAMFx5Ih00klSfn6kWwIAAIAhbugGbfX10t/+Jh065J63cKF06qney0BalrR3r+n1dsUV0te/TsgGAAAAAECssdtNZZoFCyLdEgAAAAwDQzNo271beuIJqaXFTCckSGedJc2c6X15y5K+/FJKTJSuukpaujR8bQUAAAAAAMFTWSmNHCnNmBHplgAAAGAYGFpBm2VJ770nrVtnfpeknBzpwgvNSXZf63zxhZSebkK2448PW3MBAAAAAEAQWZZ09Kh02mlSamqkWwMAAIBhYOgEbXa7tHattHWre96ECdL55/d9cm1Z0o4dJoy79lppzpywNBUAAAAAAIRAU5OUlsb1PQAAAMJmaARttbXS6tVSVZV73tKl0rJlpi67N06ntH27VFgoXXcdJSUAAAAAAIh1FRXSxInmAQAAAIRB7Adt+/dLb70ltbWZ6aQk6ZxzpKlT+17H4ZC2bZPGjDEhW1lZWJoKAAAAAABCxOmUWlulxYv7vukWAAAACLLYDdqeflp65BHp8GH3vPx8Mx5bfn7f63V2mpBt/Hjpu981PwEAAAAAQGyrrZXy8qTZsyPdEgAAAAwjsRm0PfqodMklnvOmTDE92ZKT+16vo8OUi5w8Wbr+etOjDQAAAAAAxL6qKmnJEqmoKNItAQAAwDASm0Hb//6v5/SYMdK3viXZbH2vY7ebnmwzZpiQrbg4tG0EAAAAAADh0dEhWZa0cGGkWwIAAIBhJjaLln//+57TS5b0H7K1tZmQbc4c6f/9P0I2AAAAAACGkqoqaeRIaebMSLcEAAAAw0xsBm3nnCM9/LDpnXbKKVJZWd/LtrZK5eXSccdJN90kFRSErZkAAAAAACAMamul44+X0tMj3RIAAAAMM7FZOlKSvv1tafNm6ejRvpdpbpZ27jQ93q69VsrKCl/7AAAAAABA6DU3Sykp0ty5kW4JAAAAhqHYDdoG0tgo7d4tnXSSdNVV3NUGAAAAAMBQVFEhlZRIkyZFuiUAAAAYhoZm0FZXJ+3fL516qrRqlZSaGukWAQAAAACAYLMs06NtyRIpYWh+xQEAAIDoNvTOQmtrpUOHpDPOkC69VEpOjnSLAAAAAABAKBw9KuXkSLNmRbolAAAAGKbiIt2AoKqulg4fls4+W7rsMkI2AAAAAACGsspKafp0adSoSLcEAAAAw9TQ6dFWWWl6s11wgXnEx0e6RQAAAAAAIFQ6OyWHQzr+eMlmi3RrAAAAMEwNjaDt0CGpqUm66CLTmy1uaHXUAwAAAAAAPVRVSYWF0rHHRrolAAAAGMZiP5GqrJRaWqRvf1s65xxCNgAAAAAAhoOaGmnhQikzM9ItAQAAwDAW2z3abDZpxAgzHtvJJ1MqAgAAAACA4aClRUpKkubOjXRLAAAAMMzFdtA2fbrpxbZkSaRbAgAAAAAAwqWyUho7VpoyJdItAQAAwDAX20HbqlWRbgEAAAAAAAgny5IaGqTzz5cSEyPdGgAAAAxzDGgGAAAAAABiR12dlJ0tzZ4d6ZYAAAAABG0AAAAAACCGVFZKU6dKY8ZEuiUAAAAAQRsAAAAAAIgRDofU2Skdf7xks0W6NQAAAABBGwAAAAAAiBFHjkj5+dKsWZFuCQAAACCJoA0AAAAAAMSK6mpp/nwpJyfSLQEAAAAkEbQBAAAAAIBY0NYmxceboA0AAACIEgRtAAAAAAAg+lVWSmPGSFOnRrolAAAAQBeCNgAAAAAAEN0sS6qvlxYvlpKTI90aAAAAoAtBGwAAAAAAiG4NDVJmpjRnTqRbAgAAAHggaAMAAAAAANGtokKaNEkqKYl0SwAAAAAPBG0AAAAAACB6ORyS3W7KRtpskW4NAAAA4IGgDQAAAAAARK+aGmnECGnWrEi3BAAAAOiFoA0AAAAAAESvqipp7lwTtgEAAABRhqANAAAAAABEp/Z2KT5emj8/0i0BAAAAvCJoAwAAAAAA0amyUho1SpoxI9ItAQAAALwiaAMAAAAAANHHsqS6OmnRIiklJdKtAQAAALwiaAMAAAAAANGnqUlKT5fmzIl0SwAAAIA+EbQBAAAAAIDoU1EhTZhgHgAAAECUImgDAAAAAADRxemU2tqkxYulOL66AAAAQPTibBUAAAAAAESXmhopN1eaPTvSLQEAAAD6RdAGAAAAAACiy5EjJmQrLIx0SwAAAIB+EbQBAAAAAIDoYbdLliUtWBDplgAAAAADImgDAAAAAADRo6pKKi6WZs6MdEsAAACAARG0AQAAAACA6FFbKx1/vJSWFumWAAAAAAMiaAMAAAAAANGhqUlKTZXmzo10SwAAAACfELQBAAAAAIDoUFkplZZKkyZFuiUAAACATwjaAAAAAABA5FmW1NwsLVkixcdHujUAAACATwjaAAAAAABA5NXWSrm50uzZkW4JAAAA4DOCNgAAAAAAEHlVVdKMGdLIkZFuCQAAAOAzgjYAAAAAABBZHR2S0yktXCjZbJFuDQAAAOAzgjYAAAAAABBZR45IhYXSzJmRbgkAAADgF4I2AAAAAAAQWTU1pjdbZmakWwIAAAD4haANAAAAAABETkuLlJwszZ0b6ZYAAAAAfiNoAwAAAAAAkVNRIY0dK02ZEumWAAAAAH4jaAMAAAAAAJFhWVJTk3TCCVJCQqRbAwAAAPiNoA0AAAAAAERGXZ2UnS3NmhXplgAAAAABIWgDAAAAAACRUVkpTZ0qjR4d6ZYAAAAAASFoAwAAAAAA4dfZaR7HHy/ZbJFuDQAAABAQgjYAAAAAABB+R45IBQWUjQQAAEBMI2gDAAAAAADhV1MjzZ9vxmgDAAAAYhRBGwAAAAAACK/WVikhwQRtAAAAQAwjaAMAAAAAAOFVWSmNGSNNnRrplgAAAACDQtAGAAAAAADCx7KkhgZp8WIpKSnSrQEAAAAGhaANAAAAAACET0ODlJkpzZkT6ZYAAAAAg0bQBgAAAAAAwqeiQiork8aNi3RLAAAAgEEjaAMAAAAAAOHhcEh2u7RokWSzRbo1AAAAwKARtAEAAAAAgPCorpby86VZsyLdEgAAACAoCNoAAAAAAEB4HDkizZ0r5eVFuiUAAABAUBC0AQAAAACA0Gtvl+LjpQULIt0SAAAAIGgI2gAAAAAAQOhVVkrHHCNNmxbplgAAAABBQ9AGAAAAAABCy7Kkujpp8WIpJSXSrQEAAACChqANAAAAAACEVmOjlJEhzZ4d6ZYAAAAAQUXQBgAAAAAAQquiQpowQRo/PtItAQAAAIKKoA0AAAAAAISO0ym1t5uykXF8DQEAAIChhTNcAAAAAAAQOjU1Ul4eZSMBAAAwJBG0AQAAAACA0KmqMiFbQUGkWwIAAAAEHUEbAAAAAAAIDbtdstmkBQsi3RIAAAAgJAjaAAAAAABAaFRVScXF0owZkW4JAAAAEBIEbQAAAAAAIDRqa6Xjj5fS0iLdEgAAACAkCNoAAAAAAEDwNTWZgG3u3Ei3BAAAAAgZgjYAAAAAABB8FRXS+PHSxImRbgkAAAAQMgRtAAAAAAAguJxOqaVFWrxYio+PdGsAAACAkCFoAwAAAAAAwXX0qJSbK82eHemWAAAAACFF0AYAAAAAAIKrslKaOVMaOTLSLQEAAABCiqANAAAAAAAET0eHZFnSwoWRbgkAAAAQcgRtAAAAAAAgeKqqpKIi06MNAAAAGOII2gAAAAAAQPDU1prebBkZkW4JAAAAEHIEbQAAAAAAIDhaWqTkZGnu3Ei3BAAAAAgLgjYAAAAAABAcFRVSSYlUVhbplgAAAABhQdAGAAAAAAAGz7KkpiZpyRIpISHSrQEAAADCgqANAAAAAAAM3tGjUk6ONGtWpFsCAAAAhA1BGwAAAAAAGLzKSmnaNOmYYyLdEgAAACBsCNoAAAAAAMDgdHZKTqe0cKFks0W6NQAAAEDYELQBAAAAAIDBOXJEKiigbCQAAACGHYI2AAAAAAAwODU10oIFUlZWpFsCAAAAhBVBGwAAAAAACFxrq5SQIM2bF+mWAAAAAGFH0AYAAAAAAAJXWSmNHStNnRrplgAAAABhR9AGAAAAAAACY1lSQ4O0eLGUmBjp1gAAAABhR9AGAAAAAAACU19vxmWbMyfSLQEAAAAigqANAAAAAAAEprJSKiszpSMBAACAYYigDQAAAAAA+M/hkOx2adEiyWaLdGsAAACAiCBoAwAAAAAA/quulvLzpVmzIt0SAAAAIGII2gAAAAAAgP+OHJHmzZNycyPdEgAAACBiCNoAAAAAAIB/2tqkhARpwYJItwQAAACIKII2AAAAAADgn8pK6ZhjpGnTIt0SAAAAIKII2gAAAAAAgO8sS6qvlxYvlpKTI90aAAAAIKII2gAAAAAAgO8aG6WMDGn27Ei3BAAAAIg4gjYAAAAAAOC7igpp0iSptDTSLQEAAAAijqANAAAAAAD4xumU2ttN2cg4vlIAAAAAOCsGAAAAAAC+qa6WRoyQZs2KdEsAAACAqEDQBgAAAAAAfHPkiBmbLT8/0i0BAAAAogJBGwAAAAAAGJjdbspFLlgQ6ZYAAAAAUYOgDQAAAAAADKyyUho5UpoxI9ItAQAAAKIGQRsAAAAAAOifZUlHj0qLFkmpqZFuDQAAABA1CNoAAAAAAED/mpqktDRp7txItwQAAACIKgRtAAAAAACgf5WV0oQJ5gEAAACgC0EbAAAAAADom9MptbZKixdL8fGRbg0AAAAQVQjaAAAAAABA32prpdxcafbsSLcEAAAAiDoEbQAAAAAAoG9VVdLMmVJRUaRbAgAAAEQdgjYAAAAAAOBdR4dkWdLChZFuCQAAABCVCNoAAAAAAIB3VVXSyJGmRxsAAACAXgjaAAAAAACAd7W10vHHS+npkW4JAAAAEJUI2gAAAAAAQG/NzVJKijR3bqRbAgAAAEQtgjYAAAAAANBbRYVUUiJNmhTplgAAAABRi6ANAAAAAAB4sizTo23JEikhIdKtAQAAAKIWQRsAAAAAAPB09KiUkyPNmhXplgAAAABRjaANAAAAAAB4qqqSpk+XRo2KdEsAAACAqEbQBgAAAAAA3Do7zWPhQslmi3RrAAAAgKhG0AYAAAAAANyqqqTCQunYYyPdEgAAACDqEbQBAAAAAAC32lrTmy0rK9ItAQAAAKIeQRsAAAAAADBaW6XERGnu3Ei3BAAAAIgJBG0AAAAAAMCorJTGjpWmTIl0SwAAAICYQNAGAAAAAACM5mZpyRLTqw0AAADAgAjaAAAAAACAUVAgzZ4d6VYAAAAAMYOgDQAAAAAAGFOnSmPGRLoVAAAAQMwgaAMAAAAAAFJOjnT88ZLNFumWAAAAADGDoA0AAAAAgOEuK0uaMIGykQAAAICfEiLdAAAAAAAAEGG5udLNN0e6FQAAAEDMoUcbAAAAAAAAAAAAEACCNgAAAAAAAAAAACAABG0AAAAAAAAAAABAAAjaAAAAAAAAAAAAgAAQtAEAAAAAAAAAAAABIGgDAAAAAAAAAAAAAkDQBgAAAAAAAAAAAASAoA0AAAAAAAAAAAAIAEEbAAAAAAAAAAAAEACCNgAAAAAAAAAAACAABG0AAAAAAAAAAABAAAjaAAAAAAAAAAAAgAAQtAEAAAAAAAAAAAABIGgDAAAAAAAAAAAAAkDQBgAAAAAAAAAAAASAoA0AAAAAAAAAAAAIAEEbAAAAAAAAAAAAEACCNgAAAAAAAAAAACAABG0AAAAAAAAAAABAAAjaAAAAAAAAAAAAgAAQtAEAAAAAAAAAAAABIGgDAAAAAAAAAAAAApAQ6QYAAIChrby8XLt371ZpaanKysoi3ZygGIqvaSjicwKCj39XAAAAAOCJoA0AAIRMeXm57rrrLm3fvl12u13Lli1TYWFhn8sXFxfr4osv9pj36KOP6vDhwwPua9GiRVq0aFHXdHt7u+677z6f2nnRRRdp1KhRXdM7duzQc88953XZqqoqrV+/Xk1NTcrOztb999/v8WXzyy+/rK1btw64z0mTJmnlypUe8/7whz+oqalpwHVPPfVUzZw5s2u6urpaDz300IDrSdI111yjzMzMrulNmzbpjTfeGHC9ESNG6PLLL/eY9+STT2rv3r0Drjt37lwtW7bMY96vf/1rn9p73nnnqaSkpGt6z549WrNmzYDrVVVVqba2VlVVVSosLNQtt9yiw4cP66OPPhpw3XHjxun888/3mPfggw+qpqZmwHVPPPFEzZs3r2u6sbFR//d//zfgepJ02WWXKT8/v2v6008/1bp16wZcLyMjQ9dee63HvLVr1+qLL74YcN0ZM2botNNO85h37733ym63D7jumWeeqcmTJ3dNHzp0SI899tiA60nSDTfcoOTk5K7pDRs2aMOGDQOuFwv/R3SXlJSkG2+80WNeLP8f4fr/LykpSVOmTNEtt9xC2AYAAABg2CNoAwAAIbN7925VVVWptLRU77//vg4cOKCUlJQ+l8/Kyuo1r7m5WQ0NDQPuq729vdc8X9aTJIfD4THd0dHR57oHDhxQXV2dioqKdOTIEe3Zs8fji+a2tjaf9tva2tprXlNTk0/rdnR0eEw7nU6fX6tlWR7Tdrvdp3W7hyIuLS0tIf9sOjs7e037su6BAwfU1NSkWbNmacuWLdqzZ4/P+21paek1z9fPpmdAZVmWz6/V6XR6TPf3dziQ1tZWn9Zta2vrNa+xsdHrZ9ZTz79Dh8MRcHvb29t9WjcW/o/oztu/m1j+P8L1/9/ChQtVVVXV6/8/AAAAABiOCNoAAEDIlJaWqrCwUNu3b1dOTo5Gjx7t9Ytyl/T0dK/z+lvHxdsX2r6sJ0nx8fEe04mJiX2uO3r0aO3cuVM1NTXKzc316G0lSSkpKT7tNzU1tde8jIwMn9qbmJjoMR0XF+fza7XZbB7TSUlJPq3rrW1paWkh/2wSEhJ6Tfuy7ujRo1VbW6stW7aosLBQJSUlOnz4sE/rpqWl9ZqXkZHhU/iUlJTkMW2z2Xx+rXFxnsMn9/d32LNtPaWmpvq0rrfgOzMz0+tn1lPPv8P4+HifX2tPycnJPq0bC/9HdNfz70H66v+IzEzJ4ZCcTs+frofTqdTKSmnzZslulzo6pM5OZezfLzU1eV/P6eyaTmxultatkzo7pc5OxTU0KGvzZvfyltV7G1+tb/vwQ9PQr9ZNqq1VVl2d5HBotN2unUePaveuXZpy0km9/v8DAAAAgOHIZvW8ZTHEGhoalJ2drfr6+oAvxAEA6AvHmeAI5vtYXl6uPXv2qKSkZMj0fBiKr2koCurnZFnuR8/pQOezLXfg81Woo85OE/p0/9l9fvd53ZfzNt/1cAVJ3tbp69Ez+OoRZPWadv3ubdrbI4aVS9ojqURS2TPPSGedFdB2OF4HB+8jACDUONYAwMDo0QYAAEKqrKxsyIVRUf+aXEGG0+n+2d/vvi4X6fX7C0N6BhwOh8ocDpU5ndK773oGPK7t9jXPFYR4m+7+Hg80L5DnvH1uPXsh9Xzfej7X33vb1/vbc173tvT3fvV83wJ5HjGl7KuH4uOl9esDDtoAAAAAYKgIKGi777779F//9V+qqKjQrFmz9Nvf/lbHHXdcsNsGAAAGgeP1IDgcplxbe7t5dP/dNW23Dz506t7bpq/waIAwqc9eNuHqydTzOZvNPa97mUrX765lXL+7nvO2j55hTXfd9919W93nV1VJtbVSbq40YkTfQVt/AVHPoMnb830FV90DsIHCL4Kn2BUXZx7x8ebR/ff4eCkhwcxLSHBPd3/O9dP1iI+XEhM957kervndf/b8PTFRSkrqezopyf3oPu1tPz3nvfiidO65po0Oh7RsWaTf/SGDYzYAAAAQu/wO2lavXq0f/OAH+t///V8tXLhQd999t5YvX67y8nIVFhaGoo0AAMBPw/J47XT2HYr1Nd3WJjU3Sy0tno/2ds9ydD3LzVmW+eK8Z2jkLUDqr0dPd74ER95+ent+oKDN26N7r62+2jxQb6WBwidfQslQ2L8/NNtFbzabO2jqGTj1DJd6zusrdOorcOoeBnkLnlzhkb+hk+tnXyFXz0ePcQ+HtHPOkZ55xvRkW7aM3mxBMiyP2QAAAMAQ4vcYbQsXLtSCBQt07733SpKcTqfGjBmjm266ST/60Y8GXJ+6vgCAUOI4Y0TN8frcc6UNG6TWVik1VUpP772Mv72n+guCXOt5+9kf1xfl3npgeftpt0sdHe6QoL8ACcObt55OrgCp+3M9ezn17P3UM9yJj+8/DOr+07Vc97CpZ/DUPWxKTJSSkz2DJ29Bk7fgKS4u0u84YgTHa7fBHLN5HwEAocaxBgAG5lePNrvdrk2bNum2227rmhcXF6dTTjlFGzZs8LpOe3u72tvbu6YbGhoCbCoAAPBFVB2vt26VKitdGw3ONhHdXGX0uj9coVLPnk59ldvrqydUXz2jupfmc807dEh65RV3Wcqzz5amTPHs6eStl1NfPxMTpZQU772o+gqf4uKGV28nAH7z95jN9TUAAAAQffwK2qqrq+VwOFRUVOQxv6ioSNu3b/e6zs9//nP95Cc/CbyFAADAL1F1vLbbPaddYUUsa2szvdlcUlKkrCzfAyRXANM9IOoZGvXVy8k1dpNrnrffXUGPt99dj+7TPQMiVwjlT5u699CKJs8+S4k7AFHN32M219cAAABA9PF7jDZ/3XbbbfrBD37QNd3Q0KAxY8aEercAAMAPITte//a3pidRfLwZ2+yJJ2I/8Hj2Wc/XtHp17L+moeqss/hsAAwpXF8DAAAA0cevoC0/P1/x8fGqdJWA+kplZaVGjhzpdZ3k5GQlJycH3kIAAOCXqDpen3WW9MwzQ6tX0VB8TQCAiPD3mM31NQAAABB9/Krvk5SUpHnz5unVV1/tmud0OvXqq69q0aJFQW8cAADwX9Qdr886S/r1r4dWIDUUXxMAIOyi7pgNAAAAwG9+l478wQ9+oMsvv1zz58/Xcccdp7vvvlvNzc264oorQtE+AAAQAI7XAADEBo7ZAAAAQGzzO2i78MILdeTIEd1+++2qqKjQ7Nmz9dJLL/UavBkAAEQOx2sAAGIDx2wAAAAgttksy7LCucP6+nrl5ORo//79ysrKCueuAQDDQENDg8aMGaO6ujplZ2dHujkxi+M1ACCUOF4HB8drAECoccwGgIH53aNtsBobGyVJY8aMCfeuAQDDSGNjIxcBg8DxGgAQDhyvB4fjNQAgXDhmA0Dfwt6jzel06tChQ8rMzJTNZvN4znWHxHC7G2+4vu5YwecDBC4S/34sy1JjY6NGjRqluLi4sOxzKOJ43dtwfd2xgs8HGJxw/xvieB0cHK+9G86vPRbw+QCB4xobAKJT2Hu0xcXFafTo0f0uk5WVNSxPtobr644VfD5A4ML974e77AaP43XfhuvrjhV8PsDghPPfEMfrweN43b/h/NpjAZ8PEDiusQEgunAbAgAAAAAAAAAAABAAgjYAAAAAAAAAAAAgAFEVtCUnJ+uOO+5QcnJypJsSVsP1dccKPh8gcPz7GZqG6+c6XF93rODzAQaHf0NDz3D+TIfza48FfD5A4Pj3AwDRyWZZlhXpRgAAAAAAAAAAAACxJqp6tAEAAAAAAAAAAACxgqANAAAAAAAAAAAACABBGwAAAAAAAAAAABAAgjYAAAAAAAAAAAAgACEN2n7+859rwYIFyszMVGFhoc455xyVl5d7LNPW1qYbbrhBI0aMUEZGhs4//3xVVlZ6LLNv3z6tWLFCaWlpKiws1A9/+EN1dnaGsumDduedd8pms3k8pkyZ0vX8UH3d0erNN9/UypUrNWrUKNlsNj399NMez1uWpdtvv13FxcVKTU3VKaecoi+++MJjmdraWn37299WVlaWcnJydNVVV6mpqcljmU8++URLly5VSkqKxowZo1/+8pehfmlAyIXz//L169dr7ty5Sk5O1sSJE/XAAw+E+uXhK8P1mM3xOrpwvAYCx/F6eBiux2uJY3a04ZgNBIbjNQAMTSEN2t544w3dcMMNeu+997Ru3Tp1dHTotNNOU3Nzc9cy3//+97V27Vo9/vjjeuONN3To0CGdd955Xc87HA6tWLFCdrtd7777rh588EE98MADuv3220PZ9KCYPn26Dh8+3PX4/+3deWwU9f/H8VcRKF1KDwRajlAuOYvlUEs9UDm6xQOCRAtBVARFBKUJiqISiErkCJAgCJgYIEDkMgVFLCJQgaYSIOVGtFDEgxYCVG5a6Pv3h2F+rBS+sPZYOs9Hsgmzn/fMvD87ZF7Gz+yyefNmZ6wizzsQnTt3TnFxcZo5c2ax45MmTdL06dM1e/ZsbdmyRdWrV5fX69XFixedmv79+2vv3r1au3atVq1apY0bN+rVV191xk+fPq3ExETFxMRo+/btmjx5ssaNG6fPP/+81OcHlKayupfn5OToySef1OOPP64dO3YoJSVFgwcP1po1a8p0vm7l5swmrwMHeQ34j7x2BzfntURmBxIyG/APeQ0AFZSVoWPHjpkk+/HHH83MLD8/36pUqWLLli1zavbv32+SLDMz08zMVq9ebZUqVbLc3FynZtasWRYWFmaXLl0qy/Zvy9ixYy0uLq7YsYo87zuBJEtNTXW2i4qKLDo62iZPnuy8l5+fb8HBwfbll1+amdm+fftMkm3dutWp+e677ywoKMj+/PNPMzP77LPPLDIy0uf6vPPOO9aiRYtSnhFQtkrrXj5q1Chr06aNz7mSk5PN6/WW9pRQDLdkNnkduMhr4L8hr93BLXltRmYHMjIb8B95DQAVQ5n+G21///23JKlmzZqSpO3bt6uwsFDdunVzalq2bKmGDRsqMzNTkpSZmam2bdsqKirKqfF6vTp9+rT27t1bht3fvl9//VX16tVTkyZN1L9/fx05ckRSxZ/3nSYnJ0e5ubk+1yM8PFzx8fE+1yMiIkL33XefU9OtWzdVqlRJW7ZscWo6d+6sqlWrOjVer1cHDhzQqVOnymg2QOkrrXt5ZmamzzGu1lw9BsqWmzKbvL4zkNfA7SGv3cFNeS2R2XcKMhu4deQ1AFQMZbbQVlRUpJSUFD300EOKjY2VJOXm5qpq1aqKiIjwqY2KilJubq5Tc21wXB2/Ohao4uPjNW/ePKWlpWnWrFnKycnRI488ojNnzlToed+Jrn6exX3e116POnXq+IxXrlxZNWvW5JrBVUrzXn6jmtOnT+vChQulMR3cgJsym7y+c5DXwK0jr93BTXktkdl3EjIbuDXkNQBUHJXL6kTDhg3Tnj17fH5DvSLr0aOH8+d7771X8fHxiomJ0dKlSxUSElKOnQGA/9x2L3crN11n8hpAReSm+7ibue06k9kAKhq33ccBoCIrk2+0DR8+XKtWrdKGDRvUoEED5/3o6GgVFBQoPz/fpz4vL0/R0dFOTV5e3nXjV8fuFBEREWrevLmys7NdNe87wdXPs7jP+9rrcezYMZ/xy5cv6+TJk1wzuEZp38tvVBMWFsb/PClDbs9s8jpwkdfArSGv3cHteS2R2YGMzAb+N/IaACqWUl1oMzMNHz5cqampWr9+vRo3buwz3rFjR1WpUkXr1q1z3jtw4ICOHDmihIQESVJCQoJ2797t8x9ga9euVVhYmFq3bl2a7Zeos2fP6uDBg6pbt66r5n0naNy4saKjo32ux+nTp7Vlyxaf65Gfn6/t27c7NevXr1dRUZHi4+Odmo0bN6qwsNCpWbt2rVq0aKHIyMgymg1Q8srqXp6QkOBzjKs1V4+B0kVm/4O8DlzkNXBz5LU7kNf/j8wOXGQ2cGPkNQBUUFaKhg4dauHh4Zaenm5Hjx51XufPn3dqXnvtNWvYsKGtX7/etm3bZgkJCZaQkOCMX7582WJjYy0xMdF27NhhaWlpVrt2bRs9enRptv6fjRw50tLT0y0nJ8cyMjKsW7duVqtWLTt27JiZVdx5B6ozZ85YVlaWZWVlmSSbOnWqZWVl2W+//WZmZhMmTLCIiAhbuXKl7dq1y3r16mWNGze2CxcuOMdISkqy9u3b25YtW2zz5s12zz33WL9+/Zzx/Px8i4qKsgEDBtiePXts8eLF5vF4bM6cOWU+X6AkldW9/NChQ+bxeOztt9+2/fv328yZM+2uu+6ytLS0Mp2vW7k1s8nrwEJeA/4jr93BrXltRmYHGjIb8A95DQAVU6kutEkq9jV37lyn5sKFC/b6669bZGSkeTwe6927tx09etTnOIcPH7YePXpYSEiI1apVy0aOHGmFhYWl2fp/lpycbHXr1rWqVata/fr1LTk52bKzs53xijrvQLVhw4Zi/y6++OKLZmZWVFRkY8aMsaioKAsODrauXbvagQMHfI5x4sQJ69evn4WGhlpYWJgNHDjQzpw541Ozc+dOe/jhhy04ONjq169vEyZMKKspAqWmLO/lGzZssHbt2lnVqlWtSZMmPudA6XJrZpPXgYW8BvxHXruDW/PajMwONGQ24B/yGgAqpiAzs5L8hhwAAAAAAAAAAADgBqX6b7QBAAAAAAAAAAAAFRULbQAAAAAAAAAAAIAfWGgDAAAAAAAAAAAA/MBCGwAAAAAAAAAAAOAHFtoAAAAAAAAAAAAAP7DQBgAAAAAAAAAAAPiBhTYAAAAAAAAAAADADyy0AQAAAAAAAAAAAH5goQ0IYEFBQVqxYkWpnmPcuHFq165dqZ4DAICKjswGACDwkdcAAKA0sNAGVzt+/LiGDh2qhg0bKjg4WNHR0fJ6vcrIyCjv1kpMamqqOnXqpPDwcNWoUUNt2rRRSkqKM/7WW29p3bp15dcgAAC3gMwmswEAgY+8Jq8BAHCjyuXdAFCe+vTpo4KCAs2fP19NmjRRXl6e1q1bpxMnTpR3ayVi3bp1Sk5O1vjx49WzZ08FBQVp3759Wrt2rVMTGhqq0NDQcuwSAID/jcwmswEAgY+8Jq8BAHAlA1zq1KlTJsnS09NvWjdlyhSLjY01j8djDRo0sKFDh9qZM2ec8blz51p4eLh988031rx5cwsJCbE+ffrYuXPnbN68eRYTE2MRERH2xhtv2OXLl539YmJi7MMPP7S+ffuax+OxevXq2YwZM3zOLclSU1Od7SNHjtizzz5r4eHhFhkZaT179rScnJwb9j5ixAh77LHHbjq/sWPHWlxcnM85//2KiYlxxnfv3m1JSUlWvXp1q1Onjj3//PN2/Pjxm54DAID/gsz+B5kNAAhk5PU/yGsAANyHn46Ea119ymzFihW6dOnSDesqVaqk6dOna+/evZo/f77Wr1+vUaNG+dScP39e06dP1+LFi5WWlqb09HT17t1bq1ev1urVq7VgwQLNmTNHy5cv99lv8uTJiouLU1ZWlt59912NGDHC50m4axUWFsrr9apGjRratGmTMjIyFBoaqqSkJBUUFBS7T3R0tPbu3as9e/bc8udy9OhR55Wdna1mzZqpc+fOkqT8/Hx16dJF7du317Zt25SWlqa8vDw999xzt3x8AABuF5ldPDIbABBIyOvikdcAALhAea/0AeVp+fLlFhkZadWqVbMHH3zQRo8ebTt37rzpPsuWLbO7777b2Z47d65JsuzsbOe9IUOGmMfj8Xkqz+v12pAhQ5ztmJgYS0pK8jl2cnKy9ejRw9nWNU/bLViwwFq0aGFFRUXO+KVLlywkJMTWrFlTbK9nz561J554wnliLjk52b744gu7ePGiU/Pvp+2uKioqst69e1vHjh3t/PnzZmb20UcfWWJiok/d77//bpLswIEDxfYAAEBJILPJbABA4COvyWsAANyIb7TB1fr06aO//vpLX3/9tZKSkpSenq4OHTpo3rx5Ts0PP/ygrl27qn79+qpRo4YGDBigEydO6Pz5806Nx+NR06ZNne2oqCg1atTI53fZo6KidOzYMZ/zJyQkXLe9f//+YnvduXOnsrOzVaNGDedJwZo1a+rixYs6ePBgsftUr15d3377rbKzs/XBBx8oNDRUI0eO1AMPPODTf3Hee+89ZWZmauXKlQoJCXF62LBhg3P+0NBQtWzZUpJu2AMAACWBzL4xMhsAECjI6xsjrwEAqLgql3cDQHmrVq2aunfvru7du2vMmDEaPHiwxo4dq5deekmHDx/WU089paFDh2r8+PGqWbOmNm/erEGDBqmgoEAej0eSVKVKFZ9jBgUFFfteUVGR332ePXtWHTt21KJFi64bq1279k33bdq0qZo2barBgwfr/fffV/PmzbVkyRINHDiw2PqFCxdq2rRpSk9PV/369X16ePrppzVx4sTr9qlbt+5tzggAgNtDZl+PzAYABBry+nrkNQAAFRsLbcC/tG7dWitWrJAkbd++XUVFRZoyZYoqVfrnC6BLly4tsXP99NNP1223atWq2NoOHTpoyZIlqlOnjsLCwvw+Z6NGjeTxeHTu3LlixzMzMzV48GDNmTNHnTp1uq6Hr776So0aNVLlytw+AADli8wmswEAgY+8Jq8BAKjo+OlIuNaJEyfUpUsXLVy4ULt27VJOTo6WLVumSZMmqVevXpKkZs2aqbCwUJ9++qkOHTqkBQsWaPbs2SXWQ0ZGhiZNmqRffvlFM2fO1LJlyzRixIhia/v3769atWqpV69e2rRpk3JycpSenq4333xTf/zxR7H7jBs3TqNGjVJ6erpycnKUlZWll19+WYWFherevft19bm5uerdu7f69u0rr9er3Nxc5ebm6vjx45KkYcOG6eTJk+rXr5+2bt2qgwcPas2aNRo4cKCuXLlSYp8LAADXIrPJbABA4COvyWsAANyKhTa4VmhoqOLj4zVt2jR17txZsbGxGjNmjF555RXNmDFDkhQXF6epU6dq4sSJio2N1aJFi/TJJ5+UWA8jR47Utm3b1L59e3388ceaOnWqvF5vsbUej0cbN25Uw4YN9cwzz6hVq1YaNGiQLl68eMOn7x599FEdOnRIL7zwglq2bKkePXooNzdX33//vVq0aHFd/c8//6y8vDzNnz9fdevWdV7333+/JKlevXrKyMjQlStXlJiYqLZt2yolJUURERHO04gAAJQ0MpvMBgAEPvKavAYAwK2CzMzKuwnAjRo1aqSUlBSlpKSUdysAAOAmyGwAAAIfeQ0AAMoLj8cAAAAAAAAAAAAAfmChDQAAAAAAAAAAAPADPx0JAAAAAAAAAAAA+IFvtAEAAAAAAAAAAAB+YKENAAAAAAAAAAAA8AMLbQAAAAAAAAAAAIAfWGgDAAAAAAAAAAAA/MBCGwAAAAAAAAAAAOAHFtoAAAAAAAAAAAAAP7DQBgAAAAAAAAAAAPiBhTYAAAAAAAAAAADAD/8HmIhYTyLdv6gAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1800x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "REPs = 5\n",
    "STATS_S98_TRUNK = np.zeros((REPs,len(SAMP_SIZES)))\n",
    "STATS_S98_TRUNKOVERLAP = np.zeros((REPs,len(SAMP_SIZES)))\n",
    "STATS_S98_TRUNKMIX = np.zeros((REPs,len(SAMP_SIZES)))\n",
    "for k in range(REPs):\n",
    "    for p in SAMP_SIZES:\n",
    "        s98 = np.genfromtxt(SAVE_PATH + \"/Trunk_1_dim2048_1mean0.5var1info_reps{}.csv\".format(k),delimiter=',')\n",
    "        s98_over = np.genfromtxt(SAVE_PATH + \"/Trunk_overlap_reps{}.csv\".format(k),delimiter=',')\n",
    "        s98_mix = np.genfromtxt(SAVE_PATH + \"/Trunk_3_dim2048_3.5mean1var1info_reps{}.csv\".format(k),delimiter=',')\n",
    "    STATS_S98_TRUNK[k,:] = s98\n",
    "    STATS_S98_TRUNKOVERLAP[k,:] = s98_over\n",
    "    STATS_S98_TRUNKMIX[k,:] = s98_mix\n",
    "\n",
    "median_MIGHT_TRUNK = np.quantile(STATS_S98_TRUNK, 0.5, axis=0)\n",
    "mean_MIGHT_TRUNK = np.mean(STATS_S98_TRUNK,axis = 0)\n",
    "q25_MIGHT_TRUNK = np.quantile(STATS_S98_TRUNK, 0.25, axis=0)\n",
    "q75_MIGHT_TRUNK = np.quantile(STATS_S98_TRUNK, 0.75, axis=0)\n",
    "\n",
    "median_MIGHT_TRUNKOVERLAP = np.quantile(STATS_S98_TRUNKOVERLAP, 0.5, axis=0)\n",
    "mean_MIGHT_TRUNKOVERLAP = np.mean(STATS_S98_TRUNKOVERLAP,axis = 0)\n",
    "q25_MIGHT_TRUNKOVERLAP = np.quantile(STATS_S98_TRUNKOVERLAP, 0.25, axis=0)\n",
    "q75_MIGHT_TRUNKOVERLAP = np.quantile(STATS_S98_TRUNKOVERLAP, 0.75, axis=0)\n",
    "\n",
    "median_MIGHT_TRUNKMIX = np.quantile(STATS_S98_TRUNKMIX, 0.5, axis=0)\n",
    "mean_MIGHT_TRUNKMIX = np.mean(STATS_S98_TRUNKMIX,axis = 0)\n",
    "q25_MIGHT_TRUNKMIX = np.quantile(STATS_S98_TRUNKMIX, 0.25, axis=0)\n",
    "q75_MIGHT_TRUNKMIX = np.quantile(STATS_S98_TRUNKMIX, 0.75, axis=0)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "fig, axs = plt.subplots(1, 3,figsize=(18, 5))\n",
    "axs[0].plot(SAMP_SIZES_plot,median_MIGHT_TRUNK,\n",
    "                        'r',marker='o', markersize=2,label = 'MIGHT',linewidth =2)\n",
    "axs[0].fill_between(SAMP_SIZES_plot,q25_MIGHT_TRUNK,q75_MIGHT_TRUNK,\n",
    "                                alpha = 0.5,color ='red')\n",
    "axs[0].plot(SAMP_SIZES_plot, 0.782* np.ones(len(SAMP_SIZES_plot)) , 'black',linestyle='dashed',marker='o', markersize=2,label = \"Truth\",linewidth =2,alpha = 0.5)\n",
    "axs[0].set_title(\"TRUNK\")\n",
    "\n",
    "axs[1].plot(SAMP_SIZES_plot,median_MIGHT_TRUNKOVERLAP,\n",
    "                        'r',marker='o', markersize=2,label = 'MIGHT',linewidth =2)\n",
    "axs[1].fill_between(SAMP_SIZES_plot,q25_MIGHT_TRUNKOVERLAP,q75_MIGHT_TRUNKOVERLAP,\n",
    "                                alpha = 0.5,color ='red')\n",
    "axs[1].plot(SAMP_SIZES_plot, 0.02 * np.ones(len(SAMP_SIZES_plot)) , 'black',linestyle='dashed',marker='o', markersize=2,label = \"Truth\",linewidth =2,alpha = 0.5)\n",
    "axs[1].set_title(\"TRUNK-Overlap\")\n",
    "\n",
    "\n",
    "\n",
    "axs[2].set_title(\"TRUNK-Mix\")\n",
    "\n",
    "axs[2].plot(SAMP_SIZES_plot, 0.881 * np.ones(len(SAMP_SIZES_plot)) , 'black',linestyle='dashed',marker='o', markersize=2,label = \"Truth\",linewidth =2,alpha = 0.5)\n",
    "axs[2].plot(SAMP_SIZES_plot,median_MIGHT_TRUNKMIX,\n",
    "                        'r',marker='o', markersize=2,label = 'MIGHT',linewidth =2)\n",
    "axs[2].fill_between(SAMP_SIZES_plot,q25_MIGHT_TRUNKMIX,q75_MIGHT_TRUNKMIX,\n",
    "                                alpha = 0.5,color ='red')\n",
    "axs[2].legend(bbox_to_anchor = (1.8,1),loc = 'upper right')\n",
    "\n",
    "for sim in [\"1\",\"2\",\"3\"]:\n",
    "    axs[int(sim)-1].set_ylim(-0.02, 1.05)\n",
    "    axs[int(sim)-1].set_yticks([])\n",
    "    axs[int(sim)-1].set_xticks([])\n",
    "    axs[int(sim)-1].set_yticks([0, 1])\n",
    "    axs[int(sim)-1].set_xticks([200,500,1000,2000])\n",
    "    axs[int(sim)-1].set_xlabel(\"Sample Size\")\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "might_bootstrap",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}