UF_MI.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "from proglearn.progressive_learner import ClassificationProgressiveLearner\n",
        "from proglearn.transformers import TreeClassificationTransformer\n",
        "from proglearn.voters import TreeClassificationVoter\n",
        "from proglearn.deciders import SimpleArgmaxAverage\n",
        "\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from joblib import Parallel, delayed\n",
        "from collections import defaultdict\n",
        "from sklearn.utils.fixes import _joblib_parallel_args\n",
        "import threading\n",
        "from sklearn.ensemble._base import _partition_estimators\n",
        "from sklearn.utils.validation import check_is_fitted\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.utils.validation import check_X_y, check_array\n",
        "\n",
        "\n",
        "from hyppo.tools import multimodal_independence, indep_sim, rot_ksamp\n",
        "from hyppo.tools import SIMULATIONS\n",
        "from hyppo.ksample._utils import k_sample_transform\n",
        "from tqdm import tqdm\n",
        "from hyppo.tools import * \n",
        "\n",
        "from joblib import Parallel, delayed\n",
        "from scipy.stats import entropy, multivariate_normal\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt"
      ],
      "outputs": [],
      "execution_count": 1,
      "metadata": {
        "gather": {
          "logged": 1670281026406
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class UncertaintyForest:\n",
        "    \"\"\"\n",
        "    A class used to represent an Uncertainty Forest.\n",
        "    Parameters\n",
        "    ----------\n",
        "    n_estimators : int, default=100\n",
        "        The number of trees in the UncertaintyForest\n",
        "    kappa : float, default=np.inf\n",
        "        The coefficient for finite sample correction. If set to the default\n",
        "        value, finite sample correction is not performed.\n",
        "    max_depth : int, default=None\n",
        "        The maximum depth of a tree in the UncertaintyForest.\n",
        "    tree_construction_proportion : float, default=0.5\n",
        "        The proportions of the input data set aside to train each decision\n",
        "        tree. The remainder of the data is used to fill in voting posteriors.\n",
        "    max_features : {\"auto\", \"sqrt\", \"log2\"}, int or float, default=\"auto\"\n",
        "        The number of features to consider when looking for the best split:\n",
        "        - If int, then consider `max_features` features at each split.\n",
        "        - If float, then `max_features` is a fraction and\n",
        "          `round(max_features * n_features)` features are considered at each\n",
        "          split.\n",
        "        - If \"auto\", then `max_features=sqrt(n_features)`.\n",
        "        - If \"sqrt\", then `max_features=sqrt(n_features)` (same as \"auto\").\n",
        "        - If \"log2\", then `max_features=log2(n_features)`.\n",
        "        - If None, then `max_features=n_features`.\n",
        "        Note: the search for a split does not stop until at least one\n",
        "        valid partition of the node samples is found, even if it requires to\n",
        "        effectively inspect more than ``max_features`` features.\n",
        "    poisson_sampler : boolean, default=False\n",
        "        To match the GRF theory [#1grf]_, if True, the number of features\n",
        "        considered at each tree are drawn from a poisson distribution with\n",
        "        mean equal to `max_features`.\n",
        "    n_jobs : int, default=None\n",
        "        The number of jobs to run in parallel. ``-1`` means use all\n",
        "        processors. None equates to 1.\n",
        "    max_samples : int or float, default=None\n",
        "        The number of samples to draw from X (without replacement) to train\n",
        "        each tree.\n",
        "        - If None, then draw `X.shape[0]` samples.\n",
        "        - If int, then draw `max_samples` samples.\n",
        "        - If float, then draw `max_samples * X.shape[0]` samples. Thus,\n",
        "          `max_samples` should be in the interval `(0, 1)`.\n",
        "        Note: The number of samples used to learn the tree will be further\n",
        "        reduced per the `tree_construction_proportion` value.\n",
        "    honest_prior : {\"ignore\", \"uniform\", \"empirical\"}, default=\"ignore\"\n",
        "        Method for dealing with empty leaves during evaluation of a test\n",
        "        sample. If \"ignore\", trees in which the leaf is empty are not used in\n",
        "        the prediction. If \"uniform\", the prior tree posterior is 1/(number of\n",
        "        classes). If \"empirical\", the prior tree posterior is the relative\n",
        "        class frequency in the voting subsample. If all tree leaves are empty,\n",
        "        \"ignore\" will use the empirical prior and the others will use their\n",
        "        respective priors.\n",
        "    tree_kwargs : dict, default={}\n",
        "        Named arguments to be passed to each\n",
        "        sklearn.tree.DecisionTreeClassifier tree used in the construction\n",
        "        of the forest in addition to the above parameters.\n",
        "    Attributes\n",
        "    ----------\n",
        "    transformers_ : list of sklearn.tree.DecisionTreeClassifier\n",
        "        The collection of fitted trees.\n",
        "    voters_ : list of proglearn.voter.TreeClassificationVoter\n",
        "        The collection of honest voters for leaves in matching trees in\n",
        "        `self.estimators_` at the same index.\n",
        "    n_features_ : int\n",
        "        The number of features when `fit` is performed.\n",
        "    tree_kwargs_ : dict\n",
        "        Full set of keyword arguments passed to the Forest transformer.\n",
        "    References\n",
        "    ----------\n",
        "    .. [#1grf] Athey, Susan, Julie Tibshirani and Stefan Wager.\n",
        "        \"Generalized Random Forests\", Annals of Statistics, 2019.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        n_estimators=100,\n",
        "        kappa=np.inf,\n",
        "        max_depth=None,\n",
        "        tree_construction_proportion=0.63,\n",
        "        max_features=\"auto\",\n",
        "        poisson_sampler=False,\n",
        "        max_samples=None,\n",
        "        n_jobs=None,\n",
        "        honest_prior=\"ignore\",\n",
        "        weighted_trees=False,\n",
        "        min_samples_leaf=1,\n",
        "        min_samples_split=2,\n",
        "        min_impurity_decrease=0.0,\n",
        "    ):\n",
        "        self.n_estimators = n_estimators\n",
        "        self.kappa = kappa\n",
        "        self.max_depth = max_depth\n",
        "        self.tree_construction_proportion = tree_construction_proportion\n",
        "        self.max_features = max_features\n",
        "        self.poisson_sampler = poisson_sampler\n",
        "        self.max_samples = max_samples\n",
        "        self.n_jobs = n_jobs\n",
        "        self.honest_prior = honest_prior\n",
        "        self.verbose = 0\n",
        "        self.weighted_trees = weighted_trees\n",
        "        self.min_samples_leaf = min_samples_leaf\n",
        "        self.min_samples_split = min_samples_split\n",
        "        self.min_impurity_decrease = min_impurity_decrease\n",
        "        \n",
        "\n",
        "    def fit(self, X, y):\n",
        "        \"\"\"\n",
        "        fits forest to data X with labels y\n",
        "        Parameters\n",
        "        ----------\n",
        "        X : array of shape [n_samples, n_features]\n",
        "            The data that will be trained on\n",
        "        y : array of shape [n_samples]\n",
        "            The label for cluster membership of the given data\n",
        "        Returns\n",
        "        -------\n",
        "        self : UncertaintyForest\n",
        "            The object itself.\n",
        "        \"\"\"\n",
        "        X, y = check_X_y(X, y)\n",
        "\n",
        "        self.n_samples_, self.n_features_ = X.shape\n",
        "        self.n_classes_ = len(np.unique(y))\n",
        "        self.empirical_prior_ = np.bincount(y, minlength=self.n_classes_) / len(y)\n",
        "\n",
        "        self.transformers_ = [\n",
        "            DecisionTreeClassifier(\n",
        "                max_features = self.max_features,\n",
        "                max_depth = self.max_depth,\n",
        "                min_samples_leaf = self.min_samples_leaf,\n",
        "                min_samples_split = self.min_samples_split,\n",
        "                min_impurity_decrease = self.min_impurity_decrease,\n",
        "                )\n",
        "            for _ in range(self.n_estimators)\n",
        "        ]\n",
        "\n",
        "        # Source https://github.com/scikit-learn/scikit-learn/blob/95119c13a/sklearn/ensemble/_forest.py#L387\n",
        "        self.transformers_, self.transformer_indices_ = list(zip(\n",
        "            *Parallel(n_jobs=self.n_jobs, verbose=self.verbose, **_joblib_parallel_args(prefer=\"threads\"))(\n",
        "                delayed(_parallel_build_trees)(\n",
        "                    X, y, tree, self.n_samples_, self.n_classes_,\n",
        "                    self.honest_prior, self.tree_construction_proportion,\n",
        "                    self.kappa, self.weighted_trees)\n",
        "                for tree in self.transformers_)\n",
        "                ))\n",
        "\n",
        "        return self\n",
        "\n",
        "    def predict_proba(self, X):\n",
        "        \"\"\"\n",
        "        estimates class posteriors for each example in input data X.\n",
        "        Parameters\n",
        "        ----------\n",
        "        X : array of shape [n_samples, n_features]\n",
        "            The data whose posteriors we are estimating.\n",
        "        Returns\n",
        "        -------\n",
        "        y_proba_hat : ndarray of shape [n_samples, n_classes]\n",
        "            posteriors per example\n",
        "        \"\"\"\n",
        "        X = self._validate_X_predict(X)\n",
        "        n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)\n",
        "\n",
        "        # avoid storing the output of every estimator by summing them here\n",
        "        posteriors = np.zeros((X.shape[0], self.n_classes_), dtype=np.float64)\n",
        "        lock = threading.Lock()\n",
        "\n",
        "        Parallel(n_jobs=n_jobs, verbose=self.verbose, **_joblib_parallel_args(require=\"sharedmem\"))(\n",
        "            delayed(_accumulate_prediction)(tree.tree_.predict, X, posteriors, lock, None, self.weighted_trees)\n",
        "            for tree in self.transformers_)\n",
        "\n",
        "        # Normalize to unit length, due to prior weighting\n",
        "        zero_mask = posteriors.sum(1) == 0\n",
        "        posteriors[~zero_mask] /= posteriors[~zero_mask].sum(1, keepdims=True)\n",
        "        posteriors[zero_mask] = self.empirical_prior_\n",
        "\n",
        "        return posteriors\n",
        "\n",
        "    def _validate_X_predict(self, X):\n",
        "        \"\"\"\n",
        "        From sklearn\n",
        "        Validate X whenever one tries to predict, apply, predict_proba.\"\"\"\n",
        "        check_is_fitted(self)\n",
        "\n",
        "        return self.transformers_[0]._validate_X_predict(X, check_input=True)\n",
        "\n",
        "    def predict(self, X):\n",
        "        \"\"\"\n",
        "        predicts class labels for each example in input data X.\n",
        "        Parameters\n",
        "        ----------\n",
        "        X : array of shape [n_samples, n_features]\n",
        "            The data on which we are performing inference.\n",
        "        Returns\n",
        "        -------\n",
        "        y_hat : ndarray of shape [n_samples]\n",
        "            predicted class label per example\n",
        "        \"\"\"\n",
        "        return self.predict_proba(X).argmax(1)\n",
        "\n",
        "    def predict_proba_honest(self, X, voters=True):\n",
        "        \"\"\"\n",
        "        Returns predicted posteriors of the training data, excluding trees a\n",
        "        sample was used in construction of.\n",
        "        Parameters\n",
        "        ----------\n",
        "        X : array of shape [n_samples, n_features]\n",
        "            The data on which the forest was fit to.\n",
        "        Returns\n",
        "        -------\n",
        "        y_proba_hat : ndarray of shape [n_samples, n_classes]\n",
        "            posteriors per example\n",
        "        \"\"\"\n",
        "        X = self._validate_X_predict(X)\n",
        "        n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)\n",
        "\n",
        "        # avoid storing the output of every estimator by summing them here\n",
        "        posteriors = np.zeros((X.shape[0], self.n_classes_), dtype=np.float64)\n",
        "        lock = threading.Lock()\n",
        "\n",
        "        if voters:\n",
        "            Parallel(n_jobs=n_jobs, verbose=self.verbose, **_joblib_parallel_args(require=\"sharedmem\"))(\n",
        "                delayed(_accumulate_prediction)(tree.tree_.predict, X, posteriors, lock, honest_indices)\n",
        "                for tree, honest_indices in zip(self.transformers_, self.voter_indices_))\n",
        "        else:\n",
        "            Parallel(n_jobs=n_jobs, verbose=self.verbose, **_joblib_parallel_args(require=\"sharedmem\"))(\n",
        "                delayed(_accumulate_prediction)(tree.tree_.predict, X, posteriors, lock, indices)\n",
        "                for tree, indices in zip(self.transformers_, self.transformer_indices_))\n",
        "\n",
        "        # Normalize to unit length, due to prior weighting\n",
        "        zero_mask = posteriors.sum(1) == 0\n",
        "        posteriors[~zero_mask] /= posteriors[~zero_mask].sum(1, keepdims=True)\n",
        "        posteriors[zero_mask] = self.empirical_prior_\n",
        "\n",
        "        return posteriors\n",
        "\n",
        "\n",
        "    @property\n",
        "    def voter_indices_(self):\n",
        "        if not hasattr(self, \"transformer_indices_\"):\n",
        "            raise AttributeError(\"Model has not been fitted. Please fit first.\")\n",
        "        return [\n",
        "            np.setdiff1d(np.arange(self.n_samples_), transformer_indices)\n",
        "            for transformer_indices in self.transformer_indices_]\n",
        "\n",
        "\n",
        "def _parallel_build_trees(\n",
        "    X, y, tree, n_samples_, n_classes_,\n",
        "    honest_prior, tree_construction_proportion,\n",
        "    kappa, weighted_trees):\n",
        "        # https://github.com/scikit-learn/scikit-learn/blob/95119c13a/sklearn/ensemble/_forest.py#L140\n",
        "        \"\"\"\n",
        "        Private function used to fit a single tree in parallel.\"\"\"\n",
        "\n",
        "        transformer_indices = np.random.choice(\n",
        "            n_samples_,\n",
        "            int(tree_construction_proportion * n_samples_),\n",
        "            replace=False)  # No bootstrapping\n",
        "        voter_indices = np.setdiff1d(\n",
        "            np.arange(n_samples_), transformer_indices)\n",
        "\n",
        "        sample_weight = np.ones((n_samples_,), dtype=np.float64)\n",
        "        sample_counts = np.bincount(\n",
        "            transformer_indices, minlength=n_samples_)\n",
        "        sample_weight *= sample_counts\n",
        "\n",
        "        #tree = tree.fit(X, y, sample_weight=sample_weight, check_input=False) ### Why using y, rather than X[transformer_indices,:],y[transformer_indices]\n",
        "        tree = tree.fit(X[transformer_indices,:],y[transformer_indices], sample_weight=sample_weight[transformer_indices], check_input=False)\n",
        "        \n",
        "        honest_leaves = tree.apply(X[voter_indices])\n",
        "        # empirical_prior = np.bincount(\n",
        "        #     y[voter_indices], minlength=n_classes_)\n",
        "\n",
        "        # if honest_prior == 'ignore':\n",
        "        #     posterior_dict = defaultdict(lambda: np.zeros(n_classes_))\n",
        "        # elif honest_prior == 'empirical':\n",
        "        #     posterior_dict = defaultdict(lambda: empirical_prior)\n",
        "        # elif honest_prior == 'uniform':\n",
        "        #     posterior_dict = defaultdict(lambda: np.ones(n_classes_) / n_classes_)\n",
        "\n",
        "        tree.tree_.value[:, :, :] = 0 # empirical_prior\n",
        "\n",
        "        for leaf_id, yval in zip(honest_leaves, y[voter_indices]):\n",
        "            # posterior_dict[leaf_id][yval] += 1\n",
        "            tree.tree_.value[leaf_id][0, yval] += 1\n",
        "\n",
        "        # for leaf_id in np.unique(honest_leaves):\n",
        "        #     leaf_id_indices = np.where(honest_leaves == leaf_id)[0]\n",
        "        #     correction = 1 / (kappa * len(leaf_id_indices))\n",
        "        #     posterior = correction * empirical_prior + \\\n",
        "        #         (1 - correction) * np.bincount(\n",
        "        #             y[voter_indices[leaf_id_indices]],\n",
        "        #             minlength=n_classes_) / len(leaf_id_indices)\n",
        "        #     posterior_dict[leaf_id] = posterior * (len(leaf_id_indices) if weighted_trees else 1)\n",
        "\n",
        "        return tree, transformer_indices\n",
        "\n",
        "\n",
        "def _accumulate_prediction(predict, X, out, lock, honest_indices=None, weighted_trees=False):\n",
        "    \"\"\"\n",
        "    See https://github.com/scikit-learn/scikit-learn/blob/95119c13af77c76e150b753485c662b7c52a41a2/sklearn/ensemble/_forest.py#L460\n",
        "    This is a utility function for joblib's Parallel.\n",
        "    It can't go locally in ForestClassifier or ForestRegressor, because joblib\n",
        "    complains that it cannot pickle it when placed there.\n",
        "    \"\"\"\n",
        "\n",
        "    # predict = DecisionTreeClassifier.tree_.predict\n",
        "    if honest_indices is not None:\n",
        "        proba = predict(X[honest_indices])\n",
        "    else:\n",
        "        proba = predict(X)\n",
        "    if not weighted_trees:\n",
        "        zero_mask = proba.sum(1) == 0\n",
        "        proba[~zero_mask] /= proba[~zero_mask].sum(1, keepdims=True)\n",
        "    with lock:\n",
        "        if honest_indices is not None:\n",
        "            out[honest_indices] += proba\n",
        "        else:\n",
        "            out += proba"
      ],
      "outputs": [],
      "execution_count": 2,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670281026599
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class UFTest_permute_tree:\n",
        "    def __init__(self, uf):\n",
        "        self.name = 'UF'\n",
        "        self.uf = uf\n",
        "        self.fit_ = False\n",
        "        \n",
        "    def statistic(self, X, y):\n",
        "        y = y.ravel()\n",
        "        if not self.fit_:\n",
        "            self.uf = self.uf.fit(X, y)\n",
        "            self.y_ = y\n",
        "            if hasattr(self, \"honest_leaf_indices_\"):\n",
        "                assert hasattr(self, \"transformer_leaf_indices_\")\n",
        "                del self.honest_leaf_indices_\n",
        "                del self.transformer_leaf_indices_\n",
        "            self.fit_ = True\n",
        "        if not hasattr(self, \"honest_leaf_indices_\"):\n",
        "            self.honest_leaf_indices_ = []\n",
        "            self.transformer_leaf_indices_ = []\n",
        "            for tree, voter_indices, transformer_indices in zip(self.uf.transformers_, self.uf.voter_indices_, self.uf.transformer_indices_):\n",
        "                self.honest_leaf_indices_.append(tree.apply(X[voter_indices]))\n",
        "                self.transformer_leaf_indices_.append(tree.apply(X[transformer_indices]))\n",
        "\n",
        "        _, counts = np.unique(y, return_counts=True)\n",
        "        H_Y = entropy(counts, base=np.exp(1))\n",
        "        H_YX = self._refit_apply_oob(X, self.y_) # changed from y to self.y_ as does the permutation internally per tree\n",
        "        return max(H_Y - H_YX, 0)\n",
        "        #return H_YX/100\n",
        "\n",
        "    def _refit_apply_oob(self, X, y):\n",
        "        posteriors = np.zeros((X.shape[0], self.uf.n_classes_), dtype=np.float64)\n",
        "        # posteriors = np.zeros((X.shape[0], self.uf.n_estimators, self.uf.n_classes_), dtype=np.float64)\n",
        "\n",
        "        for tree, honest_leaf_indices, voter_indices, tranformer_leaf_indices, transformer_indices in zip(\n",
        "            self.uf.transformers_, self.honest_leaf_indices_, self.uf.voter_indices_, self.transformer_leaf_indices_, self.uf.transformer_indices_):\n",
        "        # for tree_idx, (honest_leaf_indices, voter_indices) in enumerate(zip(self.honest_leaf_indices_, self.uf.voter_indices_)):\n",
        "            tree.tree_.value[:, :, :] = 0\n",
        "\n",
        "            y_voters = y[voter_indices]\n",
        "            np.random.shuffle(y_voters)\n",
        "            for leaf_id, yval in zip(honest_leaf_indices, y_voters):\n",
        "                tree.tree_.value[leaf_id][0, yval] += 1\n",
        "\n",
        "            leaf_indices = np.hstack((honest_leaf_indices, tranformer_leaf_indices))\n",
        "            sample_indices = np.hstack((voter_indices, transformer_indices))\n",
        "\n",
        "            proba = tree.tree_.value[leaf_indices][:, 0, :]\n",
        "            normalizer = proba.sum(axis=1)[:, np.newaxis]\n",
        "            normalizer[normalizer == 0.0] = 1.0 # solves divide by 0 error\n",
        "            proba /= normalizer\n",
        "            posteriors[sample_indices] += proba\n",
        "\n",
        "        # Normalize to unit length, due to prior weighting\n",
        "        zero_mask = posteriors.sum(1) == 0\n",
        "        posteriors[~zero_mask] /= posteriors[~zero_mask].sum(1, keepdims=True)\n",
        "        posteriors[zero_mask] = self.uf.empirical_prior_\n",
        "\n",
        "        return np.mean(entropy(posteriors, base=np.exp(1), axis=1))"
      ],
      "outputs": [],
      "execution_count": 3,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670281031208
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def _perm_stat(calc_stat,X, y, is_distsim = True, permuter = None): \n",
        "    if permuter is None: \n",
        "        order = np.random.permutation(y.shape[0])\n",
        "    else: \n",
        "        order = permuter()\n",
        "    \n",
        "    if is_distsim: \n",
        "        permy = y[order][:, order]\n",
        "    else: \n",
        "        permy = y[order]\n",
        "    \n",
        "    perm_stat = calc_stat.statistic(X, permy)\n",
        "    \n",
        "    return perm_stat\n",
        "\n",
        "\n",
        "def perm_test(calc_stat,X, y, workers = -1, is_distsim=True, perm_block = None, reps = 1000): \n",
        "\n",
        "    # calculate observed test statistic\n",
        "    stat = calc_stat.statistic(X, y)\n",
        "    #print(stat) \n",
        "    \n",
        "    # calculate null distribution\n",
        "    #null_dist = np.array(Parallel(n_jobs=-2)(delayed(_perm_stat)(test,X, y,is_distsim = False,permuter = None) for rep in range(0,reps)))\n",
        "    # null_dist = []\n",
        "    # for rep in range(0,reps):\n",
        "    #     null_dist.append(_perm_stat(calc_stat,X, y, is_distsim = False, permuter = None))\n",
        "    # #print(null_dist)\n",
        "\n",
        "    null_dist = np.asarray([_perm_stat(calc_stat, X, y,is_distsim = False) for rep in range(reps)])\n",
        "    pvalue = ((null_dist >= stat).sum() + 1) / (reps + 1)\n",
        "    #pvalue = (null_dist >= stat).sum() / reps\n",
        "    \n",
        "\n",
        "    # correct for a p-value of 0. This is because, with bootstrapping\n",
        "    # permutations, a p-value of 0 is incorrect\n",
        "    # if pvalue == 0:\n",
        "    #     pvalue = 1 / reps\n",
        "\n",
        "    #return stat, pvalue, null_dist\n",
        "    #print(stat, pvalue, null_dist)\n",
        "    return stat, pvalue, null_dist"
      ],
      "outputs": [],
      "execution_count": 4,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670281033980
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "simulations = [\n",
        "    # 'logarithmic',\n",
        "    'multimodal_independence',\n",
        "]\n",
        "test = UFTest_permute_tree(\n",
        "    uf = UncertaintyForest(\n",
        "        n_estimators=100,\n",
        "        tree_construction_proportion=0.4,\n",
        "        kappa=np.inf,\n",
        "        min_samples_leaf=5,\n",
        "        honest_prior=\"ignore\",\n",
        "        max_features=\"auto\",\n",
        "        n_jobs=-1,\n",
        "        max_samples = None\n",
        "    )\n",
        ")"
      ],
      "outputs": [],
      "execution_count": 5,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670281036114
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x,y_ = multimodal_independence(n = 100,p = 1,prob = 0.5)\n",
        "#x, y_= rot_ksamp('multimodal_independence', n=100, p=1,noise=False,degree  = 90)\n",
        "print(x.shape)\n",
        "X, y = k_sample_transform([x, y_])\n",
        "#print(X[100:])\n",
        "print(X.shape)\n",
        "# plt.scatter(x[:,0],x[:,1])\n",
        "# plt.show()\n",
        "#plt.scatter(X[:,0],X[:,1],c = y.astype(int))"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "(100, 1)\n(200, 1)\n"
        }
      ],
      "execution_count": 6,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670281037207
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ite = 100\n",
        "reps = 1000\n",
        "sample_size = 100 \n",
        "stat = []\n",
        "pvalue = []\n",
        "null_dist = np.zeros((ite,reps))\n",
        "\n",
        "for i in range(0,ite):\n",
        "    #x,y_ = multimodal_independence(n = sample_size,p = 1,prob = 0.5)\n",
        "    x, y_ = rot_ksamp('multimodal_independence', n=sample_size, p=1,noise=True)\n",
        "    X, y = k_sample_transform([x, y_])\n",
        "    y = y.astype(int)\n",
        "    print(X.shape)\n",
        "    stat_i, pvalue_i, null_dist_i = perm_test(test,X, y,is_distsim = False,reps = reps)\n",
        "    print(pvalue_i)\n",
        "    pvalue.append(pvalue_i)\n",
        "    stat.append(stat_i)\n",
        "    null_dist[i,:] = null_dist_i\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "(200, 2)\n0.7032967032967034\n(200, 2)\n0.7492507492507493\n(200, 2)\n0.003996003996003996\n(200, 2)\n0.0989010989010989\n(200, 2)\n0.942057942057942\n(200, 2)\n0.9110889110889111\n(200, 2)\n"
        }
      ],
      "execution_count": 7,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670280259997
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.save(\"NULL_DIS_w_100_1h_part.npy\",null_dist)\n",
        "np.save(\"pvalue_w_100_1h_part.npy\",pvalue)\n",
        "np.save(\"stat_w_100_1h_part.npy\",stat)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670280261089
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from statsmodels.distributions.empirical_distribution import ECDF\n",
        "ecdf = ECDF(pvalue) \n",
        "plt.plot(ecdf.x, ecdf.y,label = \"ECDF\")\n",
        "plt.plot(np.arange(0,1.1,0.1),np.arange(0,1.1,0.1),c = 'r',label = \"UDF\")\n",
        "plt.title(\"ECDF for p-value with 100 trees and 100 iterations, Structure Frac = 0.4\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 640x480 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 12,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670304906139
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.hist(null_dist[5,:],bins=20)\n",
        "print(stat[5])\n",
        "print(pvalue[5])\n"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670280261464
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#pvalue = np.load(\"pvalue_w_all_1k.npy\")\n",
        "from statsmodels.distributions.empirical_distribution import ECDF\n",
        "ecdf = ECDF(pvalue) \n",
        "plt.plot(ecdf.x, ecdf.y,label = \"ECDF\")\n",
        "plt.plot(np.arange(0,1.1,0.1),np.arange(0,1.1,0.1),c = 'r',label = \"UDF\")\n",
        "plt.title(\"ECDF for p-value with 100 trees and 1000 iterations,Structure Frac = 1\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 640x480 with 1 Axes>",
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAGzCAYAAACIKavMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdd3gU1dfA8e9m0xOSAAmkEEIICV0iLYJ00NClg0qVIkqRqqKioiAiUhQVCwIKFjq+gAIiICBNmgpSQgmdBAIpEFL3vn+Muz822VSSDSTn8zx5YO7enTm7M7Nz5t6ZOzqllEIIIYQQQliNTVEHIIQQQghR0kgCJoQQQghhZZKACSGEEEJYmSRgQgghhBBWJgmYEEIIIYSVSQImhBBCCGFlkoAJIYQQQliZJGBCCCGEEFYmCZgQQgghhJWVyAQsLS2Nl19+GX9/f2xsbOjSpUtRh2RVlSpVYuDAgUUdRq4NHDiQSpUq5bquq6tr4QYkHkgP23adH3nZFx4ULVq0oEWLFkUdhhAPnDwlYIsXL0an02X5t3fvXrP6SUlJzJkzh7CwMNzd3XF0dCQkJISRI0dy6tQpU723337bbD7Ozs5UrFiRTp06sWjRIpKTkzPFMnDgwCzj2LhxY7afY+HChcycOZMePXrwzTffMHbs2Lx8DaKIJSYm8vbbb7N9+/YCn/f+/ft58cUXqVevHnZ2duh0umzrf/3111SvXh1HR0eCg4OZN2+exXqXL1+mV69eeHh44ObmxlNPPcXZs2dzFdN7773H2rVr8/xZhGXLli2jb9++BAcHo9Ppsk0OkpOTeeWVV/D19cXJyYmwsDB+/fVXi3V3795NkyZNcHZ2xtvbm9GjR3P79u37mmdOCnNfyIt///2Xt99+m8jIyCKNIz/++ecfevToQUBAAI6Ojvj5+fHEE09k2pcfhP3wQYghK5UqVcrymJyUlFTU4RWo+fPn07NnTypWrIhOp8v3iZ9tft70zjvvEBgYmKm8SpUqpv/fuHGDtm3bcvDgQTp27MgzzzyDq6srJ0+e5Mcff+TLL78kJSXF7P3z58/H1dWV5ORkLl++zKZNm3juueeYO3cu69evx9/f36y+g4MDCxYsyBRHnTp1so1/69at+Pn5MWfOnLx8bFFEvvrqKwwGg2k6MTGRKVOmABT4mfXPP//MggULeOSRR6hcubLZiUJGX3zxBcOHD6d79+6MGzeOnTt3Mnr0aBITE3nllVdM9W7fvk3Lli2Ji4vjtddew87Ojjlz5tC8eXOOHDlC2bJls43pvffeo0ePHiWupbawzJ8/n4MHD9KgQQNiYmKyrTtw4EBWrlzJmDFjCA4OZvHixbRv355t27bRpEkTU70jR47QunVrqlevzuzZs7l06RIffvghERER/PLLL/mapyXW3Bfy4t9//2XKlCm0aNEiUwvd5s2biyaoXNi9ezctW7akYsWKDB06FG9vby5evMjevXv56KOPGDVqlKnug7AfPggxZCc0NJTx48dnKre3ty+CaArPjBkzSEhIoGHDhly9ejX/M1J5sGjRIgWoP//8M8e6HTp0UDY2NmrlypWZXktKSlLjx483Tb/11lsKUNevX89Ud+nSpcrGxkaFhYWZlQ8YMEC5uLjkJXyTli1bqpo1a+brvZakp6eru3fvFtj8CltAQIAaMGBAUYeRb9evX1eAeuuttzK9dj/bhVJKXbt2TSUmJiqllBoxYoTKahdJTExUZcuWVR06dDArf/bZZ5WLi4u6efOmqWzGjBkKUPv37zeVHT9+XOn1ejVp0qQcY3Jxccn1+rp9+3au6hVHud2uL1y4oNLT05VSStWsWVM1b97cYr19+/YpQM2cOdNUdvfuXRUUFKQaNWpkVrddu3bKx8dHxcXFmcq++uorBahNmzbla565kd2+cD/yuh2tWLFCAWrbtm0FGkdha9++vfLy8lK3bt3K9FpUVJTZ9IOwH+YlhtwqqONXQEBApt/DnNy5c+e+l1sUIiMjlcFgUErd3zoplARs7969ClBDhw7N1XyzS8CUUmrYsGEKUJs3bzaV5edAe+7cOQVk+jP+aNy+fVuNGzdOVahQQdnb26uQkBA1c+ZM0xdtBKgRI0aopUuXqho1aihbW1u1Zs2aLJdr3DA3bdqk6tSpoxwcHFT16tXVqlWrcoy5Zs2aqkWLFpnK09PTla+vr+revbupbObMmapRo0aqTJkyytHRUdWtW1etWLHCYjz3bjDG7z8j4/o+d+6cWfnPP/+smjRpopydnZWrq6tq3769Onr0aLaf49atW8rGxkZ99NFHprLr168rnU6nypQpY/YdDx8+XJUvX940PWDAABUQEKCUynodGg9Axu3i0qVL6qmnnlIuLi7K09NTjR8/XqWlpWUbY0bZJWAbNmxQgNqwYYNZ+e7duxWglixZYipr0KCBatCgQaZ5PPnkkyooKCjbGCx9VuO6M663Y8eOqaefflp5eHio0NBQ03uXLFmi6tatqxwdHVXp0qVV79691YULFzItY+/evSo8PFy5ubkpJycn1axZM7Vr1y6zOvHx8eqll15SAQEByt7eXnl5eak2bdqogwcPZht/ZGSkeuGFF1RISIhydHRUZcqUUT169Mi0TRm3tV27dqmxY8cqT09P5ezsrLp06aKio6PN6hoMBvXuu+8qPz8/5eTkpFq0aKGOHj2arxOL7BKwiRMnKr1eb5ZUKaXUe++9pwDTdxkXF6dsbW3VxIkTzeolJycrV1dXNXjw4DzPMyt52ReU0hL97t27q9KlSysHBwdVr1499dNPP5nN0/jdb9++Xb3wwgvKy8tLeXh4KKVyt/6M78/qd7V58+aZvuOoqCj13HPPqXLlyikHBwf1yCOPqMWLF5vVMX6+mTNnqi+++EJVrlxZ2dvbq/r165udzCil1NWrV9XAgQOVn5+fsre3V97e3qpz586ZtrOMqlatavH3NaP87oeWPrtS5uvRKD09Xc2dO1fVqlVLOTg4KE9PTxUeHm463mYXg6X53Rtbxs+S1fHr0qVLatCgQapcuXLK3t5e1ahRQ3399dc5fj9K5ZyANW/eXNWsWVMdOHBANW3aVDk5OamXXnpJKaXU2rVrVfv27ZWPj4+yt7dXlStXVu+8847F3+y9e/eqdu3aKQ8PD+Xs7Kxq166t5s6dm6sYC8P9JGD56oKMi4vjxo0bZmU6nc7UlfJ///d/APTr1y8/s8+kX79+fPnll2zevJknnnjC7LWMcdjZ2eHu7m5xPl5eXixZsoRp06Zx+/Ztpk+fDkD16tVRStG5c2e2bdvG4MGDCQ0NZdOmTUycOJHLly9n6q7cunUry5cvZ+TIkXh6euZ4YWxERAS9e/dm+PDhDBgwgEWLFtGzZ082btyY6TPdq3fv3rz99ttcu3YNb29vU/muXbu4cuUKffr0MZV99NFHdO7cmWeffZaUlBR+/PFHevbsyfr16+nQoUO28eXWkiVLGDBgAOHh4cyYMYPExETmz59PkyZNOHz4cJbfg4eHB7Vq1WLHjh2MHj3a9Bl0Oh03b97k33//pWbNmgDs3LmTpk2bWpyPl5cX8+fP54UXXqBr165069YNgEceecRUJz09nfDwcMLCwvjwww/ZsmULs2bNIigoiBdeeKFAvofDhw8DUL9+fbPyevXqYWNjw+HDh+nbty8Gg4G///6b5557LtM8GjZsyObNm0lISKBUqVIWl7NkyRKGDBlCw4YNGTZsGABBQUFmdXr27ElwcDDvvfceSikApk2bxuTJk+nVqxdDhgzh+vXrzJs3j2bNmnH48GE8PDwAbTtu164d9erV46233sLGxoZFixbRqlUrdu7cScOGDQEYPnw4K1euZOTIkdSoUYOYmBh27drF8ePHqVu3bpbf059//snu3bvp06cPFSpUIDIykvnz59OiRQv+/fdfnJ2dzeqPGjWK0qVL89ZbbxEZGcncuXMZOXIky5YtM9V58803mTp1Ku3bt6d9+/YcOnSIJ598MtMlDffr8OHDhISE4ObmZlZu/E6OHDmCv78///zzD2lpaZm2BXt7e0JDQ03bSl7mmRs57QvHjh3j8ccfx8/Pj1dffRUXFxeWL19Oly5dWLVqFV27djWb34svvoiXlxdvvvkmd+7cAXK3/po1a8bo0aP5+OOPee2116hevTqA6d+M7t69S4sWLTh9+jQjR44kMDCQFStWMHDgQGJjY3nppZfM6n///fckJCTw/PPPo9Pp+OCDD+jWrRtnz57Fzs4OgO7du3Ps2DFGjRpFpUqViI6O5tdff+XChQvZ/jYHBASwZ88ejh49Sq1atbKsl9/9MC8GDx7M4sWLadeuHUOGDCEtLY2dO3eyd+9e6tevn6sYcsvS8SsqKorHHnsMnU7HyJEj8fLy4pdffmHw4MHEx8czZsyYHOebmpqa6Zjs7Oxs2s9jYmJo164dffr0oW/fvpQvXx7Qri93dXVl3LhxuLq6snXrVt58803i4+OZOXOmaV6//vorHTt2xMfHh5deeglvb2+OHz/O+vXrM2039zIYDNy8eTNX3427u7tpuyp0ecnWsjrTAZSDg4OpXteuXRVgsVnXkpxawG7duqUA1bVrV1PZgAEDLMaR1dnsvYyZ+L3Wrl2rADV16lSz8h49eiidTqdOnz5tKgOUjY2NOnbsWK4+X0BAgALMWrzi4uKUj4+PevTRR7N978mTJxWg5s2bZ1b+4osvKldXV1N3mVLK7P9KKZWSkqJq1aqlWrVqlSme/LSAJSQkKA8Pj0wtm9euXVPu7u45tniOGDHCrGVr3LhxqlmzZqpcuXJq/vz5SimlYmJilE6nM2spy3h2l1MXJKDeeecds/JHH31U1atXL9v4LMWb1S4yYsQIpdfrLb7m5eWl+vTpYxZrxniUUurTTz9VgDpx4kS2cWR1hmVcb08//bRZeWRkpNLr9WratGlm5f/884+ytbU1lRsMBhUcHKzCw8PNWiATExNVYGCgeuKJJ0xl7u7uasSIEdnGaUnGbVIppfbs2aMA9e2335rKjNtamzZtzGIZO3as0uv1KjY2VimlVHR0tLK3t1cdOnQwq/faa6+ZtQjkVnYtYDVr1sy07yil1LFjxxSgPv/8c6XU/7rfduzYkaluz549lbe3d57nmZW87AutW7dWtWvXVklJSaYyg8GgGjdurIKDg01lxu++SZMmmVoccrv+suuCzNgKNHfuXAWopUuXmspSUlJUo0aNlKurq4qPj1dK/a8FrGzZsmZd+j/99JMC1Lp165RS/zs+3Nutm1ubN29Wer1e6fV61ahRI/Xyyy+rTZs2qZSUlEx187ofWvrsRhnX49atWxWgRo8enanuvdt5VjHktQXM0vFr8ODBysfHR924ccOsvE+fPsrd3d3itnAv43Eu459x22zevHmW27ileT///PPK2dnZtP2mpaWpwMBAFRAQkCm3yNhLlVFWrcWW/vLajX4/LWD5Gobi008/5ddffzX7u/dC0/j4eIAsz+rzyjisQEJCglm5o6NjpjhmzZqVr2X8/PPP6PV6U+uM0fjx41FKZbqQtnnz5tSoUSPX8/f19TU743Rzc6N///4cPnyYa9euZfm+kJAQQkNDzVoA0tPTWblyJZ06dcLJyclUfu//b926RVxcHE2bNuXQoUO5jjM7v/76K7GxsTz99NPcuHHD9KfX6wkLC2Pbtm3Zvr9p06ZERUVx8uRJQGvpatasGU2bNmXnzp2A1iqmlMqyBSy3hg8fnmnZub3rMDfu3r2b5YWljo6O3L1711QPtBtGLNW7t05+Zfysq1evxmAw0KtXL7P15O3tTXBwsGk9HTlyhIiICJ555hliYmJM9e7cuUPr1q3ZsWOH6YJvDw8P9u3bx5UrV/IU273bZGpqKjExMVSpUgUPDw+L2+WwYcPM7jxt2rQp6enpnD9/HoAtW7aQkpLCqFGjzOrl5uw8r+7evZur9ZbTOr53/eZ2nvfr5s2bbN26lV69epGQkGBatzExMYSHhxMREcHly5fN3jN06FD0er1ZWV7XX278/PPPeHt78/TTT5vK7OzsTHeN/v7772b1e/fuTenSpU3Txt8G4/7s5OSEvb0927dv59atW3mK5YknnmDPnj107tyZv/76iw8++IDw8HD8/PxMPTm5lXE/zItVq1ah0+l46623Mr2W053Y+ZHx+KWUYtWqVXTq1AmllNnvRnh4OHFxcbla38Y7eu/969+/v+l1BwcHBg0alOl9925nxu21adOmJCYmcuLECUBrPT537hxjxowxteAb5fQdeXt7Z4orq7+cbuIrSPnqgmzYsGGm5vZ7GZvXExISMn1R+WG8lTtjQqfX62nTps19zx/g/Pnz+Pr6ZlqGsRndeAAwsnQXaHaqVKmSaSMJCQkBIDIyEi8vL65fv272epkyZbC3t6d379689tprXL58GT8/P7Zv3050dDS9e/c2q79+/XqmTp3KkSNHzIbuKKgdOCIiAoBWrVpZfD1jt0pGxh/OnTt3UqFCBQ4fPszUqVPx8vLiww8/NL3m5uZ2XzuBo6MjXl5eZmWlS5fO849zdpycnLLs8kpKSjL9oBj/tTSUivHW7Ht/fPIj47YYERGBUorg4GCL9Y3N68b1OWDAgCznHRcXR+nSpfnggw8YMGAA/v7+1KtXj/bt29O/f38qV66cbWx3795l+vTpLFq0iMuXL5t1zcTFxWWqX7FiRbNp44HXuO6M+2HGz+bl5WV2kC4ITk5OuVpvOa3jjCdJhbktGJ0+fRqlFJMnT2by5MkW60RHR+Pn52eatvSbltf1lxvnz58nODgYGxvz8/+sfmtz2iYcHByYMWMG48ePp3z58jz22GN07NiR/v37m122kZUGDRqwevVqUlJS+Ouvv1izZg1z5syhR48eHDlyJNcn2nk9JtzrzJkz+Pr6UqZMmXzPIy8yxnr9+nViY2P58ssv+fLLLy2+Jzo6Osf5enp6ZntM9vPzs3jieuzYMd544w22bt1qasAxMm5nZ86cAci2qzgrjo6OBZYrFKR8JWA5qVatGqCNr3K/LRkAR48eBcyHuShqBfVDaXTx4sVMO8W2bdto0aIFvXv3ZtKkSaxYsYIxY8awfPly3N3dadu2ranuzp076dy5M82aNeOzzz7Dx8cHOzs7Fi1axPfff5/tsrNK0NLT082mja0hS5YssfjDZmub/ebk6+tLYGAgO3bsoFKlSiilaNSoEV5eXrz00kucP3+enTt30rhx40w/znmR8Sy+MPj4+JCenk50dDTlypUzlaekpBATE4Ovry+gJdEODg4Wb1U2lhnr5lfGbdFgMKDT6fjll18sfhfGFmXj+pw5cyahoaEW522s26tXL5o2bcqaNWvYvHkzM2fOZMaMGaxevZp27dplGduoUaNYtGgRY8aMoVGjRri7u6PT6ejTp4/ZcApGWa07lY9rau6Xj49PplYiyLzefHx8zMoz1r13/eZ2nvfL+N1OmDCB8PBwi3Uy/p5a+k3L6/orDLnZJsaMGUOnTp1Yu3YtmzZtYvLkyUyfPp2tW7fy6KOP5mo59vb2NGjQgAYNGhASEsKgQYNYsWKFxVYpSyx9fzqdzuK2m/G39X7l9jfcyNJvBkDfvn2zPCG79zrb/LL0HcXGxtK8eXPc3Nx45513CAoKwtHRkUOHDvHKK68UyHaWnp6eqYEjK8aGD2solASsU6dOTJ8+naVLlxZIArZkyRKALH9ICkJAQABbtmzJdEG0sfkzICDgvuZvPCO9d0cxjjFVqVIlPDw8Mg3GaGwFCgwMpGHDhixbtoyRI0eyevVqunTpYtaVsWrVKhwdHdm0aZNZ+aJFi3KMzXhGGRsba9ZimfFM1HjBZ7ly5fJ9NtG0aVN27NhBYGAgoaGhlCpVijp16uDu7s7GjRs5dOiQaVyjrBRGk3xeGROWAwcO0L59e1P5gQMHMBgMptdtbGyoXbs2Bw4cyDSPffv2Ubly5Ry76vP6eYOCglBKERgYaGplzaoeaC2XuVmfPj4+vPjii7z44otER0dTt25dpk2blm0CtnLlSgYMGGB2aUBSUhKxsbF5+ET/Y9wPIyIizFrfrl+/XqAtnKCt423bthEfH2/Wurtv3z7T66Cdkdva2nLgwAF69eplqpeSksKRI0fMynI7z9zKatswfjd2dnb3deaf2/WXl200ICCAv//+G4PBYHaidb+/tUFBQYwfP57x48cTERFBaGgos2bNYunSpXmel7GH596kOj+/O6VLl7Z46YOl39ZNmzZx8+bNbFvBsoqhdOnSFvepjMvJipeXF6VKlSI9Pd3qLUXbt28nJiaG1atX06xZM1P5uXPnzOoZf6+OHj2a5xgtNXBkxdjwYQ2F8iiiRo0a0bZtWxYsWGBx1N6UlBQmTJiQq3l9//33LFiwgEaNGtG6deuCDtWkffv2pKen88knn5iVz5kzB51Ol+1BJjeuXLnCmjVrTNPx8fF8++23hIaG4u3tbWoivffv3i6V3r17s3fvXhYuXMiNGzcydT/q9Xp0Op3ZGU9kZGSuRk02btg7duwwld25c4dvvvnGrF54eDhubm689957pKamZppPbs4wmjZtSmRkJMuWLTMl5zY2NjRu3JjZs2eTmpqaY9JuvKMmvwfxgtCqVSvKlCnD/Pnzzcrnz5+Ps7Oz2V2nPXr04M8//zRLwk6ePMnWrVvp2bNnjstycXHJ02ft1q0ber2eKVOmZDr7VkqZBh+tV68eQUFBfPjhhxZHbDeuz/T09EzdTeXKlcPX19did9q99Hp9phjmzZuX7xaANm3aYGdnx7x588zmO3fu3HzNLzs9evQgPT3drEsmOTmZRYsWERYWZrpb0d3dnTZt2rB06VKz61SXLFnC7du3zdZxbueZW1ntC+XKlaNFixZ88cUXFlvmctsakNv15+LiYjEOS9q3b8+1a9fMrmtNS0tj3rx5uLq60rx581zFZpSYmJhppPWgoCBKlSqV4/a5bds2iy1UP//8MwBVq1Y1leV1PzTGceLECbPv+6+//uKPP/4wq9e9e3eUUhZPPu+NL6sYgoKCiIuL4++//zaVXb161eyYkx29Xk/37t1ZtWqVqcfpXrndXvLD2MJ57+dMSUnhs88+M6tXt25dAgMDmTt3bqbvIKcW8mJ1Ddgvv/xiOlu5V+PGjU1nXt9++y1PPvkk3bp1o1OnTrRu3RoXFxciIiL48ccfuXr1qum6H6OVK1fi6upKSkqKaST8P/74gzp16rBixYr8hJprnTp1omXLlrz++utERkZSp04dNm/ezE8//cSYMWPyfbuvUUhICIMHD+bPP/+kfPnyLFy4kKioqFy1UIHWBTRhwgQmTJhAmTJlMp0BdOjQgdmzZ9O2bVueeeYZoqOj+fTTT6lSpYrZTmnJk08+ScWKFRk8eDATJ05Er9ezcOFCvLy8uHDhgqmem5sb8+fPp1+/ftStW5c+ffqY6mzYsIHHH388UwKbkTG5OnnyJO+9956pvFmzZvzyyy84ODjQoEGDbOfh5OREjRo1WLZsGSEhIZQpU4ZatWrl69qAjM6fP29qcTUmTFOnTgW0M3Pj0CpOTk68++67jBgxgp49exIeHs7OnTtZunQp06ZNMzuLffHFF/nqq6/o0KEDEyZMwM7OjtmzZ1O+fHmLo0ZnVK9ePbZs2cLs2bNN3bhhYWFZ1g8KCmLq1KlMmjSJyMhIunTpQqlSpTh37hxr1qxh2LBhTJgwARsbGxYsWEC7du2oWbMmgwYNws/Pj8uXL7Nt2zbc3NxYt24dCQkJVKhQgR49elCnTh1cXV3ZsmULf/75Z443vXTs2JElS5bg7u5OjRo12LNnD1u2bMlx9P+seHl5MWHCBKZPn07Hjh1p3749hw8f5pdffsHT0zNX89ixY4fpZOP69evcuXPHtI6bNWtmOgsPCwujZ8+eTJo0iejoaKpUqcI333xDZGQkX3/9tdk8p02bRuPGjWnevDnDhg3j0qVLzJo1iyeffNLsUoG8zDM3stsXPv30U5o0aULt2rUZOnQolStXJioqij179nDp0iX++uuvHOef2/UXGhqKXq9nxowZxMXF4eDgQKtWrcy6542GDRvGF198wcCBAzl48CCVKlVi5cqV/PHHH8ydOzfPN2+dOnWK1q1b06tXL2rUqIGtrS1r1qwhKirKbJiexYsXM2jQIBYtWmR6dMyoUaNITEyka9euVKtWjZSUFHbv3s2yZcuoVKmS2QXjed0PAZ577jlmz55NeHg4gwcPJjo6ms8//5yaNWuaXevUsmVL+vXrx8cff0xERARt27bFYDCwc+dOWrZsyciRI7ONoU+fPrzyyit07drV9DSO+fPnExISkuubJd5//322bdtGWFgYQ4cOpUaNGty8eZNDhw6xZcuWXA/jkFeNGzemdOnSDBgwgNGjR6PT6ViyZEmmpMrGxob58+fTqVMnQkNDGTRoED4+Ppw4cYJjx46xadOmLJdR0NeArVu3zrT/pKam8vfff5t+Qzp37pz77tq83DKZ3TAUgFq0aJFZ/cTERPXhhx+qBg0aKFdXV2Vvb6+Cg4PVqFGjzIZ1MN4qa/xzdHRUFSpUUB07dlQLFy40u43a6H5GPLc0DIVS2jALY8eOVb6+vsrOzk4FBwdnOxBrbt07EOsjjzyiHBwcVLVq1SwOkpqdxx9/XAFqyJAhFl//+uuvVXBwsGn+ixYtsngbsqUBKw8ePKjCwsKUvb29qlixopo9e3aWA7Fu27ZNhYeHK3d3d+Xo6KiCgoLUwIED1YEDB3L1OcqVK6cAs5Gmd+3apQDVtGnTTPUt3WK9e/duVa9ePWVvb292q3NW20VWQ21ktG3btiy3b0u3k3/55ZeqatWqyt7eXgUFBak5c+ZYvCX64sWLqkePHsrNzU25urqqjh07qoiIiBzjUUqpEydOqGbNmiknJyeLA0BmNXzLqlWrVJMmTZSLi4tycXFR1apVUyNGjFAnT540q3f48GHVrVs3VbZsWeXg4KACAgJUr1691G+//aaU0gYUnThxoqpTp44qVaqUcnFxUXXq1FGfffZZjrHfunVLDRo0SHl6eipXV1cVHh6uTpw4kWkbzGqQZ+P6uPfW8PT0dDVlyp/Em5cAACAASURBVBTl4+OTr4FYM/7e3PuXcTiHu3fvqgkTJihvb2/l4OCgGjRooDZu3Ghxvjt37lSNGzdWjo6OysvLS40YMcI0pEJ+55lRXvYFpZQ6c+aM6t+/v/L29lZ2dnbKz89PdezY0ewJJdkNsJ3b9aeUNvJ/5cqVlV6vN1tnWQ3Eapyvvb29ql27dqbjx70DsWZ07+e8ceOGGjFihKpWrZpycXFR7u7uKiwsTC1fvtzsPfPmzVOA2Xf9yy+/qOeee05Vq1bNdIyqUqWKGjVqVKaR8PO7Hy5dutQ0iGxoaKjatGmTxfWYlpamZs6cqapVq2Ya7Lhdu3Zmgx1nFYNS2pAatWrVUvb29qpq1apq6dKl2Q7EaklUVJQaMWKE8vf3V3Z2dsrb21u1bt1affnllxbr3yu3A7Fa8scff6jHHntMOTk5KV9fX9NwIBn3faW0Y8UTTzxh+i165JFHMg3TVNiyGgbLUh6UHZ1SRXB1awlTqVIlatWqxfr164s6FCGEKJF69epFZGQk+/fvL+pQhAAK6SJ8IYQQ4kGhlGL79u35uiBfiMIiCZgQQohiTafT5WocKyGsqVDughRCCCGEEFmTa8CEEEIIIaxMWsCEEEIIIaxMEjAhhBBCCCsr1hfhGwwGrly5QqlSpR6Ix9cIIYQQImdKKRISEvD19b2vZwM/yIp1AnblypU8P9pDCCGEEA+GixcvUqFChaIOo1AU6wTM+EiLixcvmj34VgghhBAPrvj4ePz9/fP8aKqHSbFOwIzdjm5ubpKACSGEEA+Z4nz5UPHsWBVCCCGEeIBJAiaEEEIIYWWSgAkhhBBCWFmxvgYsN5RSpKWlkZ6eXtShFBt6vR5bW9ti3XcvhBBC3I8SnYClpKRw9epVEhMTizqUYsfZ2RkfHx/s7e2LOhQhhBDigVNiEzCDwcC5c+fQ6/X4+vpib28vLTYFQClFSkoK169f59y5cwQHBxfbQfSEEEKI/CqxCVhKSgoGgwF/f3+cnZ2LOpxixcnJCTs7O86fP09KSgqOjo5FHZIQQgjxQCnxTRPSOlM45HsVQgghsiZHSSGEEEIIK5METAghhBDCyqyWgO3YsYNOnTrh6+uLTqdj7dq1Ob5n+/bt1K1bFwcHB6pUqcLixYsLP1AhhBBCiEJmtQTszp071KlTh08//TRX9c+dO0eHDh1o2bIlR44cYcyYMQwZMoRNmzYVcqQPvoEDB6LT6TL9tW3b1lTn8OHD9OzZk/Lly+Po6EhwcDBDhw7l1KlTAERGRpq9t1SpUtSsWZMRI0YQERFhtrzFixdbXN6CBQus+rmFEEKI4sJqd0G2a9eOdu3a5br+559/TmBgILNmzQKgevXq7Nq1izlz5hAeHm7xPcnJySQnJ5um4+Pj7y/oB1jbtm1ZtGiRWZmDgwMA69evp3v37oSHh/Pdd98RFBREdHQ0K1asYPLkySxbtsz0ni1btlCzZk0SExP5559/+Oijj6hTpw7r1q2jdevWpnpubm6cPHnSbHnu7u6F+AmFEEJYy6VbiXy96xweTva81CY4d29KTYXJk6FMGXj55cINsBh6YIeh2LNnD23atDErCw8PZ8yYMVm+Z/r06UyZMiXfy1RKcTe1aEbEd7LT52kcMgcHB7y9vTOVJyYmMmjQINq3b8+aNWtM5YGBgYSFhREbG2tWv2zZsqb5VK5cmU6dOtG6dWsGDx7MmTNn0Ov1gPZEekvLE0II8fC7npDMoj8iqVDaKXcJ2IUL8PTTsHs32NpCz54QGFj4gRYjD2wCdu3aNcqXL29WVr58eeLj47l79y5OTk6Z3jNp0iTGjRtnmo6Pj8ff3z/Xy7ybmk6NN4umi/Pfd8Jxtr//1bFp0yZu3LjBy1mcjXh4eGT7fhsbG1566SW6du3KwYMHadiw4X3HJIQQohhZtw4GDIBbt8DNDb7+WpKvfHhgE7D8cHBwMHXDFXfr16/H1dXVrOy1117D1lZbpdWqVcv3vI3vjYyMNCVgcXFxZstzdXXl2rVr+V6GEEKIh0xKCkyaBLNna9P168OyZVC5ctHG9ZB6YBMwb29voqKizMqioqJwc3Oz2PpVEJzs9Pz7juXrywqbk50+T/VbtmzJ/PnzzcrKlCnDV199dd+xKKUAzLpES5UqxaFDh0zTMtCqEEIUH3eSc7j85tw56NMH9u/XpseMgRkzQJ73m28PbALWqFEjfv75Z7OyX3/9lUaNGhXaMnU6XYF0A1qDi4sLVapUyVQeEhICwIkTJ/L9XR0/fhzQrhszsrGxsbg8IYQQD7+vdp4FoH5A6cwvrl4Nzz0HcXHg4QGLF8NTT1k3wGLIas0Yt2/f5siRIxw5cgTQhpk4cuQIFy5cALTrt/r372+qP3z4cM6ePcvLL7/MiRMn+Oyzz1i+fDljx461VsgPpSeffBJPT08++OADi69nvAg/I4PBwMcff0xgYCCPPvpoYYQohBDiAbLnTAy/n7qOrY2OMW1C/vdCcjKMGgXdu2vJ12OPwZEjknwVEKs19xw4cICWLVuapo0Xyw8YMIDFixdz9epVUzIGWuvLhg0bGDt2LB999BEVKlRgwYIFWQ5BUdIkJydnugbL1tYWT09PFixYQM+ePencuTOjR4+mSpUq3Lhxg+XLl3PhwgV+/PFH03tiYmK4du0aiYmJHD16lLlz57J//342bNhgugNSCCFE8aSUYsbGEwA83bAilTxdtBdOn4bevcF46cnEiTBtGtjZFVGkxY/VErAWLVqYri2yxNIo9y1atODw4cOFGNXDa+PGjfj4+JiVVa1alRMnTvDUU0+xe/dupk+fzjPPPGO6G7RVq1ZMnTrV7D3GoT6cnZ0JCAigZcuWfPnll9LdKIQQJcChC7EcuRiLg60No1r/97u/fDkMGQIJCVC2LHzzDXToULSBFkM6lV1W9JCLj4/H3d2duLg43NzczF5LSkri3LlzBAYG4ujoWEQRFl/y/QohxINv/PK/WHXoEt3rVmBWpxAYOxa++EJ7sUkT+OEHqFDB6nFld/wuLh6OK86FEEIIUaDiElNZ//cVAAZ5JmnXeP39N+h02nATU6Zog6yKQiHfrBBCCFEC7Tx9neQ0A8Mu7qFm57lw5w54ecHSpfDkk0UdXrEnCZgQQghRAqUl3OH9Xz6mz9+btYIWLeC778DXt0jjKikkARNCCCFKmn//pWX/rrifPYVBp8PmzTe1B2vL3e9WI8OZCyGEECXJ4sXQoAHuZ08R7VKaGeM/gbffluTLyiQBE0IIIUqC27e1h2gPGgSJieyqFEr7QR/j2altUUdWIkkXpBBCCFHc/fMP9OoFJ06gbGyY07Qv88J60LNBRYY0Dcz5/aLASQImhBBCFFPp6QZuffwZpSdNRJ+cRFxpL0Z2nMhO3xq0r+3N9G6PoNPpijrMEkkSMCGEEOIhdzclnTPXb2t/0bc5c/0OVy5EMXjpDDr++zsA2wPrMa7jOG46u9MsxIs5vUPR20jyVVQkARNCCCEeEjfvpHA6Wku0TkffNv3/cuxd7n2uTc2oM3zy0/sE3rpKms6GbzsO40jvIQwo70ZV71K0rl4OO71cBl6UJAF7CLVo0YLQ0FDmzp1rVr548WLGjBlDbGwsb7/9NlOmTAFAr9fj4eFBjRo16NatGy+88AIODg5m8/v9998zLSc1NRVbGQVZCCGKxOnoBLafvG6WbN1KTM2yfmlnO6p4udD38M90/O5D9KkppPlVwObHH3muyeNWjFzkhhxdi7GaNWuyZcsWDAYDMTExbN++nalTp7JkyRK2b99OqVKlTHWHDh3KO++8Y/Z+Sb6EEMK6YhNTWPfXFVYevMRfl+Is1qlQ2okgL1eqlHM1/VulnCtl0u5qD9FeuVKr2KkTtosWaQ/UFg8cOcLeSylITCyaZTs7a8/fKkC2trZ4e3sD4OvrS+3atXniiSeoU6cOM2bMYOrUqfcs3tlUVwghhPWkpRvYEXGdlQcvseXfaFLSDQDY2uhoGuxJbT93gv5LtoK8XHGytzBe14ED2l2O586BnR3MmAFjxhT4cUUUHEnA7pWYCK6uRbPs27fBxaXQF1OtWjXatWvH6tWrzRIwIYQQ1nXiWjyrDl5izeEr3LidbCqv4eNG93oVeCrUF09Xh2zmgNZw8PHHMHEipKZCpUqwbBk0bFi4wYv7JglYCVStWjU2b95sVvbZZ5+xYMEC0/Tzzz/PrFmzrB2aEEIUexdvJvLmT0fZdvK6qaysiz1dHvWje90K1PB1y92Mbt2C556DtWu16W7d4OuvwcOjEKIWBU0SsHs5O2stUUW1bCtRSmUa9+XZZ5/l9ddfN017yA4shBAFKjXdwFc7z/LxbxEkpRqwtdHRpnp5uterQIuqXnm7K3HvXujTB86fB3t7mDULRoyQLseHiCRg99LprNINeL/c3NyIi8t8cWZsbCzu7u45vv/48eMEBpqPfOzu7k6VKlUKLEYhhBD/cyDyJq+t+YdTUdpJ/mOVyzC1S22qlMvjZS8GA8yeDZMmQVoaBAVpXY716hVC1KIwSQL2EKpatWqmLkSAQ4cOERISku17T5w4wcaNG5k0aVJhhSeEEOI/UfFJzN58imUHLgJQxsWe19tXp1tdv7yPQB8Toz3LccMGbbpXL/jqK3DLZZeleKBIAvYQeuGFF/jkk08YPXo0Q4YMwcHBgQ0bNvDDDz+wbt06U720tDSuXbuWaRiK0NBQJk6cWISfQAghire4xFTm/36GxbvPkZSq3dXYq34FJrWrTmkX+7zPcNcuePppuHQJHBzgo49g2DDpcnyISQL2EKpcuTI7duzg9ddfp02bNqSkpFCtWjVWrFhB27b/e6r9sWPH8PHxQa/X4+7uTo0aNZg0aVKmgViFEEIUjLsp6SzeHcn87aeJT0oDoF5AaSa1q0b9SmXyPkODQRtSYvJkSE+HkBBYvhzq1CngyIW16ZS69+EFxUt8fDzu7u7ExcXhlqGJNikpiXPnzhEYGIijo2MRRVh8yfcrhChJDAbFsgMXmbvlFFHx2pASIeVdeTm8Gq2rl8vfA6+jo6FfPzBectK3L8yfX3TDJVlRdsfv4kJawIQQQoj7kJpuYPzyv/i/v64A4OfhxLgnQujyqF/+H3a9fTs88wxcvQpOTvDJJzBokHQ5FiOSgAkhhBD5dDclnRe/O8i2k9extdHxartq9GsUgIOthdHqcyM9HaZNgylTtO7H6tVhxQqoWbNgAxdFThIwIYQQIh/ik1IZsvgA+yNv4mhnw/y+9WhZtVz+Z3jtGjz7LGzdqk0PGgTz5j0UwyOJvJMETAghhMijtHQD/b/ez5GLsZRysGXhoAY0yM9F9kZbtmjXeEVFaQNzf/65dv2XKLbyMOxu8VSM70EoUvK9CiGKs9WHLnPkYixujrb8MOyx/CdfaWnaHY5PPqklX7Vrw8GDknyVACW2BczOzg6AxMREnJycijia4icxMRH43/cshBDFRVJqOrN/PQXA6NbB1PLL+QkkFl2+rF1ov2OHNj1sGMydq110L4q9EpuA6fV6PDw8iI6OBsDZ2Tl/twkLM0opEhMTiY6OxsPDA70+nxeiCiHEA+qb3ZFci0/Cz8OJvo8F5G8mGzdqrVw3bmjDSnz1lfZsR1FilNgEDMDb2xvAlISJguPh4WH6foUQojhZdegSAC+1DsbRLo8nmampWpfjjBnadGioNrBqcHABRykedCU6AdPpdPj4+FCuXDlSU1OLOpxiw87OTlq+hBDFksGgiIzRLrFoFFQ2b2++eFFr5dq9W5seMQI+/BBksOoSqUQnYEZ6vV4SBiGEEDmKTkgmJc2A3kaHj3seEqd162DgQLh5U3t49tdfQ48ehRanePCV+LsghRBCiNy6cFNr/fLzcMJWn4tDaEoKjB8PnTtryVf9+nD4sCRfQlrAhBBCiNw6H3MHgICyzjlXjoyE3r1h/35teswYeP99cHAovADFQ0MSMCGEECKXLv7XAuZfJocEbM0aeO45iI0FDw9YvBieeqrwAxQPDemCFEIIIXLh2JU4tp7U7pqvmFUClpwMo0dDt25a8vXYY3DkiCRfIhNpARNCCCGykG5Q/HY8ioV/nGPv2Zum8lB/j8yVz5zRuhwPHtSmJ07UHqwtA1ILCyQBE0IIITK4nZzGigMXWbw7kvP/DTuht9HRrpY3g5sE8mjF0uZvWL4chgyBhAQoWxa++QY6dCiCyMXDQhIwIYQQ4j/Gxwz9sO8CCclpALg52vJ0WEUGNKqEr0eGxwQlJcHYsdrDswGaNIEffoAKFawcuXjYSAImhBBC/GfD31f5csdZACp7ujDo8Up0r1cBZ3sLh8tTp6BXL/jrL2160iR45x2wlUOryJlsJUIIIcR/zt64DUCXUF9m9wrFxiaLZwR/9x08/zzcuQNeXrBkCYSHWzFS8bCTuyCFEEKI/xiv96rp6245+UpM1K716ttXS75atNDucpTkS+SRJGBCCCEEEJ2QxKHzt4Asxvk6fhzCwrTHCOl08NZbsGUL+PpaOVJRHEgXpBBCiBLv4s1E+n69jytxSZQr5ZD5QdvffAMvvqi1gHl7a12QrVoVTbCiWJAETAghRIkWEZVA36/3ERWfjH8ZJ5YODsPd6b+xu+7c0RKvb7/Vptu0gaVLoXz5ogtYFAuSgAkhhCixzl6/Ta8v9nArMZWQ8q4sGRxGeTdH7cV//tHucjxxAmxstDscX30V9PqiDVoUC5KACSGEKLE+236GW4mpPFLBnW8GNaS0iz0opV3nNWqUNs6Xr682tlezZkUdrihGJAETQghRIsXdTWX931cAeKtTDS35SkjQhpf44QetUtu2Wvejl1cRRiqKI0nAhBBClBhp6QauxiVxJfYuvxy9RlKqgarlS1G3YmltOIlevSAiQutmnDZNe56jjQwYIAqeJGBCCCGKjcSUNK7E3uXSrbtcjr3L5f/+vfLf/6/FJ2FQ5u95pqE/us8/1x4plJwM/v7w44/QuHHRfAhRIkgCJoQQ4qGglOJWYup/SVUil27d5UpsEpdjE03J1q3E1BznY6+3wcfDET8PJx4pBX3nvAyrVmovduoEixZpD9QWohBJAiaEEOKBoJTialzSf61XiVyJTbqnJUubvpuanuN8SjnY4lfaCT8PJ3w9nEz/9yvtRAUPJzxdHbRR7g8cgN694exZ7fmNH3wAY8Zog6wKUcgkARNCCFHk9pyJYcbGExy5GJtjXa9SDlpCdW9ydU+yZRrDKytKwccfw4QJkJoKlSrBsmXQsGHBfBghckESMCGEEEXm6OU4Pth0kh2nrgOgt9Hh+1/3oJ+Hs6nVyphc+bg74mh3H+Nw3boFzz0Ha9dq0127wsKF4OFRAJ9GiNyTBEwIIYTVRd64w6xfT7HuL20YCFsbHc+EVWRkqyqUK+VYOAvdt0/rcjx/HuztYdYsGDFCuhxFkZAETAghhNWcj7nD57+fZcWBi6T9dzviU6G+jHsihICyLoWzUIMB5szRRrFPS4OgIK3LsV69wlmeELlg9cFNPv30UypVqoSjoyNhYWHs378/2/pz586latWqODk54e/vz9ixY0lKSrJStEIIIQrC0ctxjPz+EC0/3M4P+y+QZlC0qOrFhtFN+KjPo4WXfMXEQOfO2vVeaWnaOF8HD0ryJYqcVVvAli1bxrhx4/j8888JCwtj7ty5hIeHc/LkScqVK5ep/vfff8+rr77KwoULady4MadOnWLgwIHodDpmz55tzdCFEELkkVKKPWdimP/7GXZG3DCVt6jqxYstqtAwsEzhBvDHH9CnD1y6BA4O8NFHMGyYdDmKB4JOKaVyrlYwwsLCaNCgAZ988gkABoMBf39/Ro0axauvvpqp/siRIzl+/Di//fabqWz8+PHs27ePXbt25bi8+Ph43N3diYuLw83NreA+iBBCiGxtPRHF3C0R/H0pDtAuru/4iA/PNwuihm8h/x4bDNqQEm+8AenpEBICy5dDnTqFu1xRYErC8dtqLWApKSkcPHiQSZMmmcpsbGxo06YNe/bssfiexo0bs3TpUvbv30/Dhg05e/YsP//8M/369bNYPzk5meTkZNN0fHx8wX4IIYQQOTp4/haDvzmAUuBoZ0Pv+v4MaVoZ/zLOhb/w6Gjo3x82bdKmn30W5s+HUqUKf9lC5IHVErAbN26Qnp5O+fLlzcrLly/PiRMnLL7nmWee4caNGzRp0gSlFGlpaQwfPpzXXnvNYv3p06czZcqUAo9dCCFE7i3ZE4lS0KpaOWb2eISyrg7WWfDvv8PTT8PVq+DkBPPmaUNOSJejeAA90E8Y3b59O++99x6fffYZhw4dYvXq1WzYsIF3333XYv1JkyYRFxdn+rt48aKVIxZCiJLt1p0Ufj56DYCXWgdbJ/lKT4d334VWrbTkq3p12L8fBg+W5Es8sKzWAubp6YlerycqKsqsPCoqCm9vb4vvmTx5Mv369WPIkCEA1K5dmzt37jBs2DBef/11bDI8od7BwQEHByudaQkhhMjk2z3nSUkzUNPXjUcquBf+Aq9dg759wXit8MCB8Mkn4FJId1UKUUCs1gJmb29PvXr1zC6oNxgM/PbbbzRq1MjiexITEzMlWXq9NgKyFe8dEEIIkQu7Im7w0W+nABjcJBBdYbc+/fYbhIZq/zo7wzffaA/SluRLPASsOgzFuHHjGDBgAPXr16dhw4bMnTuXO3fuMGjQIAD69++Pn58f06dPB6BTp07Mnj2bRx99lLCwME6fPs3kyZPp1KmTKRETQghR9C7eTGTkD4cwKOhetwJdH/UrvIWlpcE778DUqdpzHWvVghUroFq1wlumEAXMqglY7969uX79Om+++SbXrl0jNDSUjRs3mi7Mv3DhglmL1xtvvIFOp+ONN97g8uXLeHl50alTJ6ZNm2bNsIUQQmTjfMwdnl9ykNjEVOpUcGda11qF1/p15Yp2of2OHdr00KHa+F5OToWzPCEKiVXHAbO2kjCOiBBCFJXohCQ+2Xqa7/dpI9t7utqzblQTfNwLKRnauBH69YMbN8DVFb78UkvGRLFTEo7f8ixIIYQQeRKflMpXO86yYOc57qamA9A8xIvJHasXTvKVlgaTJ8P772vToaHasxxDQgp+WUJYiSRgQgghciU5LZ0le87z6bbT3EpMBSDU34NX2lajUVDZwlnoxYtaK9cff2jTL74Is2aBo2PhLE8IK5EETAghRI4ib9xhxPeHOHZFe8JIlXKuTHiyKuE1yxfe9V7r18OAAXDzJri5wYIF0LNn4SxLCCuTBEwIIUS2/u+vK7y2+h9uJ6dRxsWeV9tWo1tdP2z1hTSSUUoKvPaa1tIFUK+e1uUYFFQ4yxOiCEgCJoQQwqKk1HSmrPuXH/ZfAKBhpTJ8/PSjeLsXYvdfZCT06QP79mnTL70EM2aADLItihlJwIQQQmSilGLAwv3sO3cTnQ5GtKjCmDbBhdfqBbB2LQwaBLGx4OGhDarapUvhLU+IIiQJmBBCiExu3E5h37mbAHwzqCHNQrwKb2HJyfDyy/Dxx9p0WJjW5RgQUHjLFKKIPdAP4xZCCFH0CjX5OnMGHn/8f8nXhAmwc6ckX6LYkxYwIYQQmdy8k1L4C1mxAoYMgfh4KFMGvv0WOnQo/OUK8QCQBEwIIQQAd1PS2fzvNVYevMSu0zcAcLYvhOfuJiXBuHEwf742/fjj8MMP4O9f8MsS4gElCZgQQpRgSikOnL/FqoOX2PD3VRKS00yvNaxUhuEtKhfsAk+dgl694K+/tOlJk7QHa9vK4UiULLLFCyFECXTpViKrD11m9aFLRMYkmsorlHaiW90KdK/rR0BZl4Jd6Pffw/PPw+3b4OUFS5ZAeHjBLkOIh4QkYEIIUUKkpBnYcjyKH/ZfYNfpGyillTvb62lf24fudSsQFlgGG5sCHtk+MVEbz2vBAm26eXMtGfP1LdjlCPEQkQRMCCGKuTPXb7Psz4usOniJmHsurn+schl61POnXS1vXBwK6XBw/LjW5Xj0KOh02kO1J0+WLkdR4skeIIQQxdDdlHR+OXqVH/dfZH/kTVO5VykHetarQK/6/lTyLOAuxoy++UZ7eHZiIpQvD999B61bF+4yhXhISAImhBDFzLYT0Yz+8TAJSdoF9TY6aFm1HL0b+NOyWjnsCnM0e4A7d2DECC0BAy3pWroUvL0Ld7lCPEQkARNCiGLEYFC8ve4YCUlpVCjtRO/6/vSoXwEfdyfrBHD0KPTsCSdOgI0NvP229mBtfSEMZyHEQ0wSMCGEKEZ2n4nhfEwipRxs2Ty2Gc72VvqZVwq+/hpGjdLG+fL11S60b97cOssX4iEjCZgQQhQTd5LT+HrXWQC6POpnveQrIQGGD9cSLtCGlliyRBtqQghhkSRgQgjxEEtNN7Dj1HXWHrnCr/9eIynVAMAzYRWtE8CRI9C7tzbAql4PU6dqD9a2kUcNC5EdScCEEOIho5Ti4PlbrD1ymQ1/X+VWYqrptUBPF15oHkR1H7fCDgI+/xzGjoXkZKhQAX78UXuskBAiR5KACSHEQ+J0dAJrDl/mpyNXuHTrrqnc09WBTnV86BLqxyMV3NHpCngg1Yzi4mDoUO1h2gAdO8LixVC2bOEuV4hiRBIwIYR4CPz6bxRDvz1gmnax1xNey5suoX40DiqLbWEPLWF04IDW5Xj2rDaY6vvvaw/WLuykT4hiRhIwIYR4COw9GwNATV83hjcPok318jjZW3FoB6Vg3jyYMAFSUyEgQOtyfOwx68UgRDEiCZgQQjwEzv/3wOw+DfzpVMfKz1C8dQsGD4Y1a7TpLl1g4UIoXdq6cQhRjMhtKkII8YC7EJPI8avxAFQsW8iPD8po3z549FEt+bKzg48+gtWrJfkS4j5JC5gQQjygjl2J4/Pfz7Lh7ysYlPZIoZDyrtZZuFIweza8+iqkpUHlyrBsGdSvb53lC1HMSQImhBAPEKUUe87GHcoI1gAAIABJREFU8PnvZ9lx6rqpvFmIF6NbVbHOI4ViYmDgQFi/Xpvu0QMWLAB398JfthAlhCRgQgjxgNh2Ipq5v0Xw18VYQGvx6viIL883r0xNXyslP3/8AU8/DRcvgoMDzJmjjXIvdzkKUaAkARNCiAfAj/sv8OrqfwBwsLWhV31/hjatTMWyztYJwGCADz6AN96A9HQIDoblyyE01DrLF6KEkQRMCCGK2Lq/rjBpjZZ8Pd2wIuOfDMHT1cF6AVy/Dv37w8aN2vQzz2ij3JcqZb0YhChhJAETQogitO1ENGOXHUEp7fmN07rUKvyR7O/1++9awnXlCjg6amN9DR4sXY5CFDJJwIQQwoqS09I5ciGW3Wdi2HMmhkMXbpFmUHSu48u7T1kx+UpPh/feg7ff1rofq1XTuhxr17bO8oUo4SQBE0KIQpSWbuCfy3HsOaslXH9G3iQp1WBWp10tb2b1qoPexkrJ17Vr0Lcv/PabNj1gAHz6KbhYeYwxIUowScCEEKIAGQyKE9cS2H3mBnvOxLDv3E1uJ6eZ1fF0teexymVpHORJ46CyBJR1tl7L12+/wbPPQlQUODvDZ59pCZgQwqokARNCiPuUlm5gR8R1Vh26zO7TN7iVmGr2upuj7X8JV1kaV/EkuJyrda/zAq3L8Z134N13tUFWa9bUuhxr1LBuHEIIQBIwIYTIt4s3E1lx4CLLD1ziWnySqdzZXk/DwDI0DipLo8qe1PB1s173oiVXrmgX2v/+uzY9ZIj2SCFnKw1xIYTIRBIwIYTIg5Q0A1uOR/HD/gvsOn0DpbTy0s52dKtbgXa1vKnj74Gd/gF51O6mTdCvnzbUhKsrfPGFlowJIYqUJGBCCJELF28msmTveVYdvETMnRRTeZMqnvRu4M+TNcvjYKsvwggzSEuDyZPh/fe16Tp1tC7HkJCijUsIAUgCJoQQOVp96BJvrD1KYko6AOVKOdCrvj+96vtbb6T6vLh4UXuc0B9/aNPDh2uPFHJ0LNq4hBAmkoAJIUQW7qak8+ZPR1lx8BIADSqVZlizIFpW9cL2QelizGjDBm1U+5s3tZHsFyyAXr2KOiohRAaSgAkhhAURUQm8+N0hIqJvo9PBS62DGdUquGgvps9Oaiq89hp8+KE2Xbeu1uUYFFS0cQkhLJIETAhR4iWnpRMRdZtjV+L490o8x67E8/flOFLSDHiVcuCjPqE0DvIs6jCzdv489O4N+/Zp06NGwcyZ4GDF50kKIfJEEjAhRImSkJTK8asJHLsSx7H/kq3T0QmkpqtMdZsGezKnd6h1H4ydV2vXwqBBEBsLHh6wcCF07VrUUQkhciAJmBCi2IpOSOLYlXj+/e/v2JU4ImMSLdZ1d7Kjpq/bf3/u1PR1o0pRDJiaWykp8PLL2nheAA0bwrJlUKlSkYYlhMgdScCEEMXK+r+vsPLgJY5died6QrLFOj7ujtT0daPGf4lWTV83/DycHtxkK6OzZ7UuxwMHtOnx47UHa9vbF21cQohckwRMCFGsTFr1Dwn/PXtRp4NATxdTi5axdauMy0OcqKxcCYMHQ3w8lCkDixdDp05FHZUQIo8kARNCFCvJaQYAFvSvT6Ogsrg4FJOfuaQkraXrs8+06caN4YcfoGLFoo1LCJEvD+hANkIIcX9q+rkVn+QrIgIaNfpf8vXKK7B9uyRfQjzEismvkxBCFFM//ADDhsHt2+DpCUuWQNu2RR2VEOI+SQuYEP/f3p2HVVUtbhz/MuOIoIKAOGtqzqjkdLOi7GqZv7qJw3VKbVLzal3TLG24qZV1rbQsK21wbLBrZVpiNqipKZhDzgM4gCIKCDKds39/7KIsLVHY+5zD+3kenqd92ofzulN5W2vvtURc0blzZvHq188sX3/7GyQmqnyJeAgVMBERV7Nrl7msxJw55pMEjz4K8fEQGWl3MhEpIZqCFBGP8cOhdAqdTrtjXJl33oH77oOcHAgNhfnzITbW7lQiUsJUwETE7W08mM6L8XtYu+8UAJUCfalSzs2WmsjOhpEjzWUlAK6/Ht57D8LDbY0lIqVDBUxE3NaGA6d4MX4v6/abxcvX24s729bk/q4NKOfvY3O6YtixA3r3hp07wdsbJk+GiRPBx41+DSJSLCpgIuJ2Nh1K54Uv9rD+gFm8/Hy8+Ed0FPd3rU9USHmb0xWDYZh7N44aZd50Hx4OCxZA1652JxORUmb5TfizZs2iTp06BAYGEhMTw8aNG//0/DNnzjBixAjCw8MJCAigUaNGLF++3KK0IuJKfjqeyV3zNnHn7PWsP3AKPx8v+sXU4quHujL19ubuVb6ysmDAABg2zCxfN91kPuWo8iVSJlg6ArZ48WLGjh3L7NmziYmJYcaMGXTr1o3du3cTGhr6h/Pz8/O58cYbCQ0N5YMPPiAyMpLDhw9TpUoVK2OLiM2S03N44cs9fJx4FMMAH28veretycjrGxJZpZzd8Ypv61ZzynHPHnOa8amnzMVVvfVgukhZ4WUYhmHVh8XExNCuXTtmzpwJgNPpJCoqilGjRjF+/Pg/nD979myee+45du3ahZ+fX7E/LzMzk6CgIDIyMqhcufIV5xcRa6WdzWPm6n3M33CYAof5V1WPFuE8eGMj6lWvaHO6y2AY8PrrMHo05OWZy0osWgSdO9udTMSllIWf35b971Z+fj6bN28m9jePU3t7exMbG8v69esv+J5ly5bRoUMHRowYQVhYGM2aNWPKlCk4HI4Lnp+Xl0dmZuZ5XyLinr7YkcINz3/NvHWHKHAYdGlYjWUjOzGrXxv3LF+ZmdC3L9x7r1m+unc3pxxVvkTKJMumINPS0nA4HISFhZ33elhYGLt27brgew4cOMDq1avp378/y5cvZ9++fdx///0UFBQwefLkP5w/depUnnjiiVLJLyLWyC90Mu3zXby19iAATcMrM7FHEzo1qGZzsiuwZYs55bh/P/j6wpQp5sbamnIUKbNc+ilIp9NJaGgor7/+Oj4+PkRHR3P06FGee+65CxawCRMmMHbs2KLjzMxMoqKirIwsIlcgOT2HkQu2sPVIBgBDO9fl4Zsb4+/rpkXFMGDWLLNs5eebm2cvWmRurC0iZZplBaxatWr4+PiQmpp63uupqanUqFHjgu8JDw/Hz88Pn9+shdOkSRNSUlLIz8/H3//8hRYDAgIICAgo+fAiUqr2ncji44RjvL3+EFm5hQSV82P6nS25sWnYX77XZZ05A0OHwkcfmce33WYuORESYm8uEXEJlhUwf39/oqOjiY+Pp1evXoA5whUfH8/IkSMv+J5OnTqxYMECnE4n3j8P1e/Zs4fw8PA/lC8RcS8pGbl8svUYHyceZcexX+/XbF2rCi/3bU3NYDdaUuL3Nm6EuDg4dAj8/OC55+CBB8x9HUVEsHgKcuzYsQwaNIi2bdvSvn17ZsyYQXZ2NkOGDAFg4MCBREZGMnXqVADuu+8+Zs6cyejRoxk1ahR79+5lypQpPPDAA1bGFpESknGugBXbj/O/xGOsP3CKX57B9vX2outV1bmtVSQ3N6uBn48bTzn+97/mkhKFhVC3LixeDO3a2Z1MRFyMpQUsLi6OkydPMmnSJFJSUmjVqhUrVqwoujE/KSmpaKQLICoqipUrVzJmzBhatGhBZGQko0eP5uGHH7YytohcAcMw+GZvGgs3JLF69wnyC3/dLLtdnWBuaxVJj+bhBFdw81Ht9HQYPBg++cQ8vuMOeOMN0LqFInIBlq4DZrWysI6IiCvbm5rFk5/u5Nu9aUWvNQqryG2tIunZMsK9Vq7/M+vWQZ8+kJwM/v7mKNh992nKUeQylYWf3y79FKSIuKfT2fnMWLWH9zYk4XAa+Pt40/+aWtwZHUWT8Ep4eUoxcTph+nR45BFwOKBBA1iyBFq3tjuZiLg4FTARKTEFDifzvz/Mf1ftJeNcAQDdrg7jke5NqF21gs3pStjJkzBoEHz+uXncty+89hpUqmRvLhFxCypgIlIiTmfnc9fbm0hIOgNA4xqVmHRLUzq68wKqF/PNN2bhOnYMAgPhpZfMTbU9ZWRPREqdCpiIXLHUzFwGvLmBPalnCSrnx7ibr6JPu1r4eHtYIXE4YOpUmDzZnH686ipzyrFFC7uTiYibUQETkSuSdCqH/m9+T3L6OcIqB/De0BgahnngNFxqKvzzn7BqlXk8YAC88gpUdMN9KUXEdipgInJZHE6DlTtSeHzZDk5k5VG7anneGxrjOU82/tbq1dC/P6SkQPny5vZCgwfbnUpE3JgKmIgUS26Bg4+2HGXOtwc4mJYNmPd7vXNXe0IrB9qcroQ5HPDkk/DUU+Yiq1dfbU45Nm1qdzIRcXMqYCJySTJzC5j/fRJvrT3Iyaw8AKqU92NghzoM61KXyoF+NicsYceOmaNea9aYx0OHmjfbl/fAET4RsZwKmIj8qazcAmZ9tZ/53x8mK68QgIigQIZ1qUdcuygqBHjgXyNffGHe73XyJFSoYC4v0b+/3alExIN44N+cIlKSxn+0jc9+PA5Aw9CK3HttfXq2inDf/Rr/TGGh+YTj1KnmlGOLFuaU41VX2Z1MRDyMCpiIXFRqZi4rtqcA8HLf1vRoHo63py0t8YsjR8y1vb77zjy+91544QUoV87eXCLikVTAROSilmxKxuE0aFs7mFtbRtgdp/QsXw4DB8KpU+ZK9m+8Ab17251KRDyYB84hiEhJcDgNFm1KBqBfTC2b05SSggIYNw569DDLV5s2sGWLypeIlDqNgInIBX2z5yRHz5wjqJwf3ZuH2x2n5B0+DH36wPffm8ejRsFzz0FAgL25RKRMUAETkQuavyEJgDva1CTQz8fmNCXsf/+DIUPg9GkICoK33oLbb7c7lYiUIZqCFJE/SE7PYfWuVAD6xUTZnKYE5efDv/4FvXqZ5at9e0hIUPkSEcupgInIebYdyeDO2etxGnBNvRAahHrIvo4HDkCnTvDii+bx2LHw7bdQt669uUSkTNIUpIgU+ezH4zz4fiK5BU4ahFbkuX+0tDtSyfjwQ7jrLsjMhOBgePttuPVWu1OJSBmmAiYiGIbBjFV7eTF+LwDXXVWdF/u2dv/thXJz4aGHzM2zATp2hIULoZaHPtUpIm5DBUxEWLkjpah8De9Sl/F/b4KPuy+4uncvxMWZ93gBPPywuam2n5uXShHxCCpgIkJC8hkA7oyuycQeTW1OUwIWLYLhw+HsWahWDd59F26+2e5UIiJFdBO+iJCcngNAk/DKNie5QufOwT33mFsKnT0Lf/sbJCaqfImIy1EBEynjCh1OdqdkAVC7anmb01yBXbsgJgZefx28vODRRyE+HiIj7U4mIvIHmoIUKcOcToPxH21j/8ls/H29aR4ZZHeky/Puu3DffZCdDaGhMH8+xMbanUpE5KI0AiZSRhmGwVOf7eSDzUfw8fbipT6tCa0caHes4snONpeXGDjQ/OfrrzenHFW+RMTFaQRMpAxKz85n5up9zF17CIBn72jBzc1q2BuquHbsMDfN3rkTvL1h8mSYOBF8PGzbJBHxSCpgImWE02mwbv8pFm5K4osdKRQ4DACe6Hk1d0TXtDldMRgGzJ0LI0eaN92Hh8OCBdC1q93JREQumQqYiIdLycjlg83JLP4hmeT0c0WvN48MYliXutzWyo1uUj97Fu6917zHC+Cmm8z7v0JD7c0lIlJMKmAiHuhsXiHr9qWxeFMyX+0+gdMc7KJSgC+9WkcS1y6KZu52w/3WreaU45495jTjU0+Zi6t661ZWEXE/KmAibi7jXAE7jmWw/WgG249msv1YBgfTsjGMX89pVyeYPu1q0b15OOX83eweKcMwl5YYPRry8sxlJRYtgs6d7U4mInLZVMBE3Eh6dr5ZtH5TuJJ+XkT19yKCAunRIpy4drVoEFrR4qQlJDMT7r4bFi82j3v0gHnzzNXtRUTcmAqYiIs6kZX766jW0Qx2HMvk6JlzFzy3ZnA5mkUE0bxmEFdHVObqiCCqVwqwOHEJ27LFnHLcvx98fWHqVBg7VlOOIuIRVMBEXITDafD9gVN8nHCUr/ec5ERW3gXPq1utAldHVKZZZBDNI83CVaW8v8VpS5FhwKxZ8OCDkJ8PtWqZI2DXXGN3MhGREqMCJmIjwzDYcSyTjxOO8smPx0jN/LV0eXlB/eoVi0pWs8ggmkZUpnKgn42JS9mZMzB0KHz0kXl8223w1lsQEmJvLhGREqYCJmKDpFM5/C/xKB8nHmX/yeyi1ysH+tKjRTi3toigVa0qlPcvQ39EN26EuDg4dAj8/OC55+CBB8wmKiLiYcrQ3+4i9vtf4lHeXneILUlnil7z9/Umtkkot7WKpOtV1QnwdbOnFK+UYcCMGeaSEgUFULeuOeXYrp3dyURESo0KmIhFvtlzktGLEgHw9oKO9avRs1UENzer4dnTin8mPR0GD4ZPPjGP77gD3ngDqlSxNZaISGlTAROxgNNpMO3zXQDc1iqCR7o3IczdNr4uaevWQZ8+kJwM/v7w3//CffdpylFEygQVMBELfPLjMXYez6RSgC+Tb72akAoe9NRicTmdMH06PPIIOBzQoAEsWQKtW9udTETEMipgIqXsTE4+z67YDcA919Yr2+Xr5EkYNAg+/9w87tMHXnsNKle2N5eIiMVUwERKkcNpMGphAkfPnCMqpBx3da5rdyT7fPutWbiOHYPAQHjpJRg2TFOOIlImaUlpkVL07MpdfLs3jXJ+Prz2z7Zla1mJXzid8PTT0LWrWb6uugo2bIDhw1W+RKTMKoM/DUSssWL7cV77+gAAz93ZgqYRZXCaLTUVBgyAL780jwcMgFdegYpuujeliEgJUQETKSVzvj0IwPAudbmlRYTNaWywejX07w8pKVCunFm8Bg+2O5WIiEvQFKRIKcjMLSAx2VxsdVDHOvaGsZrDAY8/DrGxZvm6+mr44QeVLxGR39AImEgp2HAgHYfToG61CtQMLm93HOscPw79+sGaNebxXXfByy9D+TJ0DURELoEKmEgpiP8pFYBODaranMRCX3wB//ynudREhQowe7Z5LCIif6ApSJESlpVbwLKtxwDKxr1fhYUwcSLcfLNZvlq0gM2bVb5ERP6ERsBEStj/Eo+Rk++gfvUKxNQNsTtO6TpyxJxy/PZb8/iee8wthcqVszeXiIiLUwETKWGLNiUB0Ld9Lbw8eZ2r5cth4EA4dQoqVYI5cyAuzu5UIiJuQVOQIiUoNTOX7Ucz8fKC/2sdaXec0lFQAOPGQY8eZvlq0wa2bFH5EhEpBo2AiZSgtfvSAGgeGUTVigE2pykFSUnmdkLr15vHI0eaG2sHeOCvVUSkFKmAiZQQp9Pgix2/PP1YzeY0pWDZMnMtr9OnISgI3nwT7rjD7lQiIm5JBUykBBw9c45xH2xl7b5TAFzfONTmRCUoPx8efhhmzDCP27WDxYuhbhneWFxE5AqpgIlcAcMweP+HIzz56U7O5hUS6OfNxO5NaFfHQ55+PHjQvLdr0ybzeMwYmDYN/P3tzSUi4uZUwEQu04msXMZ/uI3Vu04AEF07mOl3tqRutQo2JyshH34IQ4dCRgYEB8O8edCzp92pREQ8guVPQc6aNYs6deoQGBhITEwMGzduvKT3LVq0CC8vL3r16lXKCUUuzYSfy5e/jzcT/t6YJfd08IzylZtr3lz/j3+Y5atDB0hIUPkSESlBlhawxYsXM3bsWCZPnsyWLVto2bIl3bp148SJE3/6vkOHDvHQQw/RpUsXi5KK/LX0nHwAnvlHc+65tj4+3h6w5te+fdCxI8yaZR6PGwdffw21a9ubS0TEw1hawF544QWGDx/OkCFDaNq0KbNnz6Z8+fK89dZbF32Pw+Ggf//+PPHEE9SrV8/CtCKXpmKAn90RSsaiReaaXgkJULUqfPYZPPMM+HnIr09ExIVYVsDy8/PZvHkzsbGxv364tzexsbGs/2VNoQt48sknCQ0NZejQoX/5GXl5eWRmZp73JVIacgscnMkpsDtGyTh3Du69F/r2haws6NwZEhOhe3e7k4mIeCzLClhaWhoOh4OwsLDzXg8LCyMlJeWC7/nuu+948803mTNnziV9xtSpUwkKCir6ioqKuuLcIr93IjOXuNe/52BaNr7eXjSuUcnuSJdv92645hp47TXw8oJHHoGvvoKaNe1OJiLi0Vx2K6KsrCwGDBjAnDlzqFbt0ha1nDBhAhkZGUVfycnJpZxSypptRzLoOXMtW5PPUKW8H+8MbU9USHm7Y12e996D6Gj48UcIDYWVK+Hpp8FXD0eLiJQ2y/6mrVatGj4+PqSmpp73empqKjVq1PjD+fv37+fQoUPceuutRa85nU4AfH192b17N/Xr1z/vPQEBAQRoSxQpJcu2HmPcB1vJLXDSILQibwxsSx13fOoxJ8d8ynHuXPP4uutg/nwID7c3l4hIGWLZCJi/vz/R0dHEx8cXveZ0OomPj6dDhw5/OL9x48Zs27aNxMTEoq+ePXty3XXXkZiYqOlFsUxugYNHlm7jgYUJ5BY46XpVdT66v6N7lq8dO8yV7OfONaccH38cvvxS5UtExGKWzjWMHTuWQYMG0bZtW9q3b8+MGTPIzs5myJAhAAwcOJDIyEimTp1KYGAgzZo1O+/9VapUAfjD6yKlZf/Js4yYv4VdKVkA3N+1Pg/edJX7LTlhGOZCqiNGmDfd16gBCxaYo18iImI5SwtYXFwcJ0+eZNKkSaSkpNCqVStWrFhRdGN+UlIS3t4ue1ualDEfJxzlkaXbyMl3ULWCPy/EteLaRtXtjlV8Z8/C/ffDu++axzfeaP7z7x6IERER63gZhmHYHaK0ZGZmEhQUREZGBpUrV7Y7jriRb/acZOBb5i4N19QL4cU+rQmrHGhzqsvw44/Qu7f5tKO3Nzz1FIwfb/6ziIiLKgs/v/W4k8gFzFt3CIDbW0fy3J0t3XPKcc4ceOAByMuDyEhYuBC0m4SIiEtQARP5naNnzrFmt7k91sjrG7hf+crMhHvuMVe2B/j73+Gdd+ASl3MREZHSp3kIkd84duYcTyzbgdOADvWqUq96RbsjFU9Cgrm216JF4OMDzz4Ln36q8iUi4mI0AiaCOer1ylf7WPJDMgUO87bI4X+ra3OqYjAMeOUVGDsW8vOhVi2zhF1giRcREbGfCpiUaUdO5/DKmv28/5vi1aFeVf4V25CYelVtTneJzpyBYcPgww/N4549zXW+QkLszSUiIhelAiZlUm6Bgyc/3Xle8epYvyqjb3Cj4gWwaRPExcHBg+DnZ045jh5tLrIqIiIuSwVMyqSZq/exYEMSAJ0aVGX0DY1oX9eNRowMA158EcaNg4ICqFMHliwxV7kXERGXpwImZU6Bw8niH8yN2p+5ozlx7WrZnKiY0tNhyBBYtsw8vv12ePNN+HmnCBERcX16ClLKnFU7UzmZlUf1SgHc3qam3XGKZ/16aN3aLF/+/jBzJnzwgcqXiIibUQGTMiUh6TRTP98FQO+2NfHzcZM/Ak4nPPcc/O1vkJQE9eubZWzECN3vJSLihjQFKWVCXqGDF1ftZfbX+3EaUKNyIIM61LE71qVJS4NBg2D5cvM4Lg5efx08dHsOEZGyQAVMPN6OYxk8uGQru1KyAOjVKoLHe15NlfL+Nie7BN9+C337wtGjEBAAL70Ew4dr1EtExM2pgIlH+1/iUR5cspVCp0HVCv48/X/NuLlZuN2x/prTCdOmwaRJ4HDAVVeZTzm2aGF3MhERKQEqYOLRXvhyD4VOgxubhjH19uZUqxhgd6S/duIEDBgAX3xhHv/zn/Dqq1DRzbZFEhGRi1IBE4+VnJ7D4VM5+Hp78d+4VlQMcIPf7mvWQL9+cPw4lCsHs2bB4MGachQR8TBu8giYSPGt2X0CgNa1qrh++XI44Ikn4IYbzPLVtKm5yv2QISpfIiIeyMV/KokUX2LyGWav2c/KnSkAdGlY3eZEfyElBfr3h9WrzeMhQ+Dll6FCBXtziYhIqVEBE49gGAbf7E1j9pr9rD9wquj1G5uGcVfnujYm+wurVpnl68QJs3C9+qp5/5eIiHg0FTBxa4UOJ8u3pzB7zX52Hs8EwNfbi56tIrj32vo0Cqtkc8KLKCyExx+HKVPMfR2bNzefcmzc2O5kIiJiARUwcVvZeYUMnruRTYdOA1De34c+7WoxtEtdIquUszndnzh61LzR/ptvzON77oH//te86V5ERMoEFTBxS7kFDu5+9wc2HTpNpQBfhnWpx8AOtQmu4OKLq37+OQwcaK5uX6mSuaJ9nz52pxIREYupgInbKXQ4eWBhAmv3naKCvw/vDouhVZSLb0ZdUACPPgrPPmset24NixdDw4b25hIREVuogInbmbh0O1/sTMXf15s5g9q6fvlKSjK3E1q3zjweMQKmT4fAQHtziYiIbVTAxK3sTsli8Q/JeHvBrH5t6Fi/mt2R/twnn5gbaZ8+DUFB8OabcMcddqcSERGbaSFWcSsLNhwG4KamNbixaZjNaf5Efj48+CD07GmWr3btYMsWlS8REQE0AiZu5Fy+g48SjgLQL6aWzWn+xKFDEBcHGzeax//6FzzzDPi7+AMCIiJiGRUwcRtf7T5BVm4hUSHl6NzARaceP/oI7roLMjIgOBjmzTNHwURERH5DU5DiNvafOAtATN2qeHu72P6IeXkwapQ5xZiRAddcAwkJKl8iInJBKmDiNg6n5wBQO6S8zUl+Z98+6NgRZs40j8eNMxdZrV3b3lwiIuKyNAUpLq/A4eTz7Sl8tzcNgFpVXaiALVkCw4ZBVhZUrQrvvAPdu9udSkREXJwKmLisMzn5LNyYzDvrD3E8IxeACv4+tKkVbG8wgHPnYOxYmD3bPO7cGRYuhJo17c0lIiJuQQVMXM6+E2eZu/YgH245Qm6BE4BqFQMYcE1t+l9Ti2oVA+wNuHs39O4NP/4IXl4wYQI88QT46o+TiIhcGv0Yvj7tAAAd2ElEQVTEEJdx6mwe//7gR1bvOlH0WtPwytzVuS63tgwnwNfHxnQ/mz/f3Dw7OxuqV4f33oObbrI7lYiIuBkVMHEZ07/Yw+pdJ/DyghubhHFX57rE1A3By8sFnnjMyYEHHjBXsgfo2hUWLIDwcFtjiYiIe1IBE5dwNq+QZYnmIqtzB7ej61WhNif6jZ07zSnHHTvMKcdJk+Cxx8DHBUbkRETELamAiUv4X+JRsvMd1KtegWsbVbc7zq/mzTM3z87JgRo1zCnI66+3O5WIiLg5rQMmtktMPsOMVXsB6Ne+lmtMOZ49a26iPWSIWb5iYyExUeVLRERKhEbAxFb/SzzKuA9+JK/QyVVhlYhrF2V3JNi2zZxy3LULvL3hySfNJx299f8rIiJSMlTAxBZOp8ELX+5h5lf7AIhtEsqMPq2pGGDjb0nDgDfeMG+2z82FiAhzba+//c2+TCIi4pFUwMRyR07nMHHpdr7ecxKA+7rW56GbrsLHzv0dMzPN5SUWLTKP//53ePttc6kJERGREqYCJpYpcDh567uDzFi1l3MFDvx9vJl2R3Nub2Pz6vEJCeaU47595pONU6bAQw9pylFEREqNCphYYvPh00xcuo1dKVkAtK8bwtO9mtEwrJJ9oQwDXn0VxoyB/HyIijJHwDp2tC+TiIiUCSpgUqoMw+CJT3by9vpDGAYEl/djQvcm3Bld096nHTMyzE20P/jAPL71VnPJiZAQ+zKJiEiZoQImpeq7fWnMW3cIgH9E1+SR7k0IqeBvb6gffjCnHA8eBD8/eOYZ+Ne/zEVWRURELKACJqVq34mzANzUNIzpd7a0N4xhwEsvwb//DQUFUKcOLF4M7dvbm0tERMocFTApVUnpOQDUrVbB3iCnT8Ndd8HHH5vHt99u7utYpYq9uUREpExSAZMSl1vg4Os9J/n0x+Os2pkKQFRIefsCff899OkDhw+Dvz88/7y5vZCmHEVExCYqYFIi8gudfLvXLF1f7kzlbF5h0b+rW60C1zW2YXNtpxNeeMFcxb6wEOrXN6cco6OtzyIiIvIbKmBy2QocTtbuS+PTH4/zxY4UMnN/LV3hQYH0aB7OLS0jaFkzyPonHtPSYPBg+Owz87h3b5gzBypXtjaHiIjIBaiAyWX5cmcq4z7YyumcgqLXQisF0L15OLe2DKd1VDDedq1s/9130LcvHDkCAQHw4otw992achQREZehAiaX5bWv93M6p4BqFf35e7NwbmkRTts6IfZuJ+R0mktKPPYYOBzQqBEsWQItbX76UkRE5HdUwKTYsnILSEg+A8DS+zvZe4P9L06cgAED4IsvzOP+/c1V7ivZuNK+iIjIRaiASbFtPJiOw2lQu2p51yhfa9ZAv35w/DiUKwczZ8KQIZpyFBERl6XdhqVYjpzO4T+f/QRAl4bV7A3jcMCTT8INN5jlq0kT2LjRXO9L5UtERFyYRsDkku07cZYBb27geEYukVXKcV/XBvaFSUkxpxlXrzaPBw82R74q2Lzgq4iIyCVQAZNLsu1IBoPmbiQ9O58GoRV5b2gMNYIC7QmzapVZvk6cgPLlzXu9Bg60J4uIiMhlsHwKctasWdSpU4fAwEBiYmLYuHHjRc+dM2cOXbp0ITg4mODgYGJjY//0fCkdWbkF/PPNDaRn59OyZhBL7ulgT/kqLDSfcLzpJrN8NWsGmzerfImIiNuxtIAtXryYsWPHMnnyZLZs2ULLli3p1q0bJ06cuOD5a9asoW/fvnz11VesX7+eqKgobrrpJo4ePWpl7DLvp+NZZJwrILRSAPOHX0NIBX/rQxw9at7r9Z//mJtqDx9u3u/VuLH1WURERK6Ql2EYhlUfFhMTQ7t27Zg5cyYATqeTqKgoRo0axfjx4//y/Q6Hg+DgYGbOnMnASxj1yMzMJCgoiIyMDCprBfTL9sHmIzz0/lY6N6jGe8NirA+wYoW5xERaGlSsCK+/bi60KiIiHqks/Py2bAQsPz+fzZs3Exsb++uHe3sTGxvL+vXrL+l75OTkUFBQQEhIyAX/fV5eHpmZmed9yZVLOpUN2LChdkEBjB8Pf/+7Wb5atYItW1S+RETE7VlWwNLS0nA4HISFhZ33elhYGCkpKZf0PR5++GEiIiLOK3G/NXXqVIKCgoq+oqKirji3QFJ6DgBRIeWs+9DkZOja1VzZHuD++2H9emjY0LoMIiIipcRt1gGbNm0aixYtYunSpQQGXvgG8AkTJpCRkVH0lZycbHFKz/RLAasdYtESD598Yo52rVtnbp69ZAnMmgUX+e8uIiLibixbhqJatWr4+PiQmpp63uupqanUqFHjT987ffp0pk2bxqpVq2jRosVFzwsICCAgIKBE8orp1Nk8Dp36uYBVLeUpyPx8mDABXnjBPG7bFhYvhnr1SvdzRURELGZZAfP39yc6Opr4+Hh69eoFmDfhx8fHM3LkyIu+79lnn+Xpp59m5cqVtG3b1qq4ZdaxM+fYeDCdDQfT2XQonX0nzhb9u1K9B+zQIYiLM59sBBg92px+VKEWEREPZOlCrGPHjmXQoEG0bduW9u3bM2PGDLKzsxkyZAgAAwcOJDIykqlTpwLwzDPPMGnSJBYsWECdOnWK7hWrWLEiFStWtDK6RzIMgwNp2Ww8mM6mn0vX0TPn/nBeo7CK3BkdRVA5v9IJsnSpuX3QmTNQpQrMnQs/l3QRERFPZGkBi4uL4+TJk0yaNImUlBRatWrFihUrim7MT0pKwtv719vSXn31VfLz8/nHP/5x3veZPHkyjz/+uJXRPYLDafDT8Uw2HUo3S9ehdNLO5p93jo+3F80iKtOuTgjt64bQrk4IwaW17ldeHvz73/Dyy+ZxTIw55Vi7dul8noiIiIuwdB0wq5WFdUQu1aZD6Yz74EcOpmWf97q/rzeto6rQvq5ZuNrUCqZCgAW9fP9+c8px82bz+KGHYMoU8CulUTYREXEbZeHnt/aC9HC5BQ6e/2I3b3x3EMOAigG+RNcOpn3dEGLqhtC8ZhABvj7WhlqyBIYNg6wsCAmBd96BHj2szSAiImIjFTAPlph8hgeXJLL/pDnqFdc2ikdvaUKlQJtGmXJzYcwYmD3bPO7UCRYuBK3XJiIiZYwKmAcyDIOX4vfx0uq9OJwG1SsF8Mwdzbm+cdhfv7m07NkDvXvD1q3m8YQJ8OST4KvfgiIiUvbop5+HcTgNHv14Ows3JgHQs2UET/S8uvRupL8U8+fDPfdAdjZUrw7vvgvdutmXR0RExGYqYB4kv9DJmCWJfPbjcby94On/a07f9rXsC5STAw88AG++aR537WqWsYgI+zKJiIi4ABUwD5GVW8DIBQl8veckfj5evNinNd2bh9sX6KefzCnH7dvBywseewwmTQIfi2/4FxERcUEqYG4uOT2HuWsPseSHZM7mFVLOz4fZA6K5tlF1+0K9/ba5eXZODoSFmaNeN9xgXx4REREXowLmhgzDYOPBdN5ae5Avd6bi/HkltwahFXnmjhZE1w62J1h2tlm83nnHPL7hBnjvPfiLvT5FRETKGhUwN5Jf6OTTH4/x1tqDbD+aWfT63xpVZ2jnunRpUA1vby97wm3bZk457toF3t7wxBPmk46achQREfkDFTA3kZFTwP+9upYDP6/pFeDrze1tanJXpzo0DKtkXzDDMG+yHzXKXOcrIgIWLIBrr7Uvk4iIiItTAXMTK3ekcOBkNsHl/RjWpR792teyd2kJMFeyv/des3AB3HyzOf1Y3cb7z0RERNyACpib+HZfGgADrqnNiOsa2JwGSEw0pxz37jWnGZ9+2txY+zebqYuIiMiFqYC5AafTYN3PBaxzQ5tHlwzD3EpozBjIy4OaNWHRInNbIREREbkkKmBuYNOhdE5l51PB34dWUVXsC5KRAcOHw/vvm8e33ALz5kHVqvZlEhERcUOaL3IDv2wrdEuLCPx9bfpP9sMP0KaNWb58feH552HZMpUvERGRy6ARMBd3Ojuf5dtTAOgXY8O2QoYBL78MDz0EBQVQuzYsXgwxMdZnERER8RAqYC7s1Nk8xizZSn6hk6sjKtOiZpC1AU6fhqFDYelS87hXL3jrLQi2aaFXERERD6EC5qI2HkzngYUJpGTmEuDrzbibG+PlZeEiqxs2QFwcHD4M/v4wfTqMHGnu6ygiIiJXRAXMxTidBq9+vZ8XvtyDw2lQr3oFZvVrQ5PwytYEMAx44QUYPx4KC6FePViyBKKjrfl8ERGRMkAFzMWMXpzIJ1uPAXB760ie6tWMCgEW/Wc6dQoGD4ZPPzWP77wT5syBIIunPkVERDycCpgLOXrmHJ9sPYa3F0y7owV3Rte0btpx7Vro0weOHIGAAJgxA+65R1OOIiIipUDLULiQ7/aeBKBVVBV6t42ypnw5nTBtmrl345Ej0LAhfP+9ucWQypeIiEip0AiYC/l2r8Wr3Z88CQMHwooV5nG/fuYq95Vs3NxbRESkDFABcyFbj5wB4Jp6IaX/YV9/bRauY8cgMBBmzoS77tKol4iIiAU0BelCCh0GAJUD/UrvQxwOeOopuP56s3w1aQKbNpnrfal8iYiIWEIjYGVJSgr8858QH28eDxoEs2ZBhQr25hIRESljVMBcRF6hg5x8R+l9QHw89O8PqalQvjy88opZwERERMRymoJ0ES/F7yXjXAFVK/hTr3oJjkg5HDB5Mtx4o1m+mjUzN9ZW+RIREbGNRsBcwNbkM8z++gAAT/9fM8r7l9B/lmPHzBvtv/7aPB42DF580RwBExEREduogNnsXL6Dh97fisNp0LNlBDc3Cy+Zb7xyJQwYYC41UbEivPaaWcZERETEdpqCtJFhGDz84Y/sPXGWahUDeKLn1Vf+TQsLYcIEuPlms3y1bAmbN6t8iYiIuBCNgNlozrcHWLb1GL7eXszq15rgCv5X9g2Tk6FvX3NbIYD774fnnzfX+RIRERGXoQJmk2/3nmTa57sAmHRrU2LqVb2yb/jZZ+aq9unpULkyvPGGuZm2iIiIuBxNQdrA4TSY8NE2nAb0bluTAdfUvvxvVlAADz0Et9xilq/oaNiyReVLRETEhWkEzAbf7DnJkdPnCCrnxxM9m13+ptuHDkGfPrBhg3k8ejQ88wwEBJRYVhERESl5KmA2mL8hCYA72tSknL/P5X2Tjz+GIUPgzBmoUgXmzoVevUowpYiIiJQWTUFa7ERWLqt3pQLQLyaq+N8gLw/+9S/4v/8zy1dMDCQkqHyJiIi4ERUwi/10PAunAQ1CK9IgtFLx3rx/P3TqZC6mCvDgg/DNN1CnTonnFBERkdKjKUiLJaXnAFCnajG3G3r/fXMl+8xMCAmBt982b7wXERERt6MRMIslncoGoFbIJW4HlJtrrufVu7dZvjp1gsRElS8RERE3pgJmofxCJyt3mPd/NQyr+Ndv2LsXOnSAV181jydMgK++gqjLuHdMREREXIamIC20cGMSSek5VK8UwG2tIv7i5IVw991w9ixUrw7vvgvdulkTVEREREqVRsAskp1XyMur9wLwwA0NKe9/ke577hwMH27u3Xj2LFx7rTnlqPIlIiLiMVTALPJi/F7SzuZTp2p5+rS7yBTiTz9B+/bmNkJeXjBpEqxaBRF/MVomIiIibkVTkBbYfDidOd8eAOCxW5ri53OB3vv22+bN9jk5EBYG8+fDDTdYnFRERESsoBGwUnYu38FD7/+IYZgr39/QJOz8E7KzYfBg8ysnxyxdiYkqXyIiIh5MBawUHT6VzT3vbeZgWjZhlQOYdGvT80/Yvh3atTNHv7y94amnYOVKqFHDnsAiIiJiCU1BloKs3AJmrt7H3LWHyHc48fX24tl/tCSonJ95gmHAW2/ByJHmOl8REbBggXnDvYiIiHg8FbAS5HAafLA5medW7ibtbD4AXRpW47FbmtIo7Odth7Ky4L77zHu8AG6+Gd55x1xqQkRERMoEFbAScigtmxELtrDjWCYAdatV4NEeTbi+cSheXl7mSYmJEBcHe/aAjw88/TT8+9/m9KOIiIiUGSpgJcAwDMZ9+CM7jmVSKdCX0Tc0ZGCHOvj7ev9yAsyeDWPGQF4e1KwJixaZ2wqJiIhImaMCVgLW7D7JxoPp+Pt6s/yBLkT9dp/HjAxzRfslS8zjW26BefOgalVbsoqIiIj9NPd1hZxOg2dW7AJgSMc655evzZuhTRuzfPn6wvPPw7JlKl8iIiJlnEbArtDXe06yKyWLyoG+3Ne1vvmiYcDMmfDQQ5CfD7Vrw+LFEBNjb1gRERFxCSpgV+inFPOm+xuahFGlvD+cPg1Dh8LSpeYJvXqZS04EB9uYUkRERFyJpiCvUHJ6DgC1QsrDhg3mlOPSpeDvDy+9BB99pPIlIiIi59EI2BU6fCoHDIMblr8LM6dBYSHUq2fe9xUdbXc8ERERcUGWj4DNmjWLOnXqEBgYSExMDBs3bvzT899//30aN25MYGAgzZs3Z/ny5RYlvTRnko/zxodP0mLGf8zydeedsGWLypeIiIhclKUFbPHixYwdO5bJkyezZcsWWrZsSbdu3Thx4sQFz1+3bh19+/Zl6NChJCQk0KtXL3r16sX27dutjH1xa9fy6dzRxO7fhBEQAK++at5sHxRkdzIRERFxYV6GYRhWfVhMTAzt2rVj5syZADidTqKiohg1ahTjx4//w/lxcXFkZ2fz6aefFr12zTXX0KpVK2bPnv2H8/Py8sjLyys6zszMJCoqioyMDCpXrlxyvxCnE559Fh59FBwOaNjQnHJs1arkPkNERKSMyszMJCgoqOR/frsQy0bA8vPz2bx5M7Gxsb9+uLc3sbGxrF+//oLvWb9+/XnnA3Tr1u2i50+dOpWgoKCir6ioqJL7BfzWunUwYYJZvvr1M9f7UvkSERGRS2RZAUtLS8PhcBAWFnbe62FhYaSkpFzwPSkpKcU6f8KECWRkZBR9JScnl0z43+vc2Sxgb7wB770HlSqVzueIiIiIR/KopyADAgIICAiw5sOmTLHmc0RERMTjWDYCVq1aNXx8fEhNTT3v9dTUVGrUqHHB99SoUaNY54uIiIi4A8sKmL+/P9HR0cTHxxe95nQ6iY+Pp0OHDhd8T4cOHc47H+DLL7+86PkiIiIi7sDSKcixY8cyaNAg2rZtS/v27ZkxYwbZ2dkMGTIEgIEDBxIZGcnUqVMBGD16NNdeey3PP/88PXr0YNGiRfzwww+8/vrrVsYWERERKVGWFrC4uDhOnjzJpEmTSElJoVWrVqxYsaLoRvukpCS8vX8dlOvYsSMLFizg0Ucf5ZFHHqFhw4Z8/PHHNGvWzMrYIiIiIiXK0nXArFYW1hERERHxNGXh57c24xYRERGxmAqYiIiIiMVUwEREREQspgImIiIiYjEVMBERERGLqYCJiIiIWEwFTERERMRiKmAiIiIiFrN0JXyr/bLGbGZmps1JRERE5FL98nPbg9eK9+wClpWVBUBUVJTNSURERKS4srKyCAoKsjtGqfDorYicTifHjh2jUqVKeHl5lej3zszMJCoqiuTkZI/dJsEV6DpbQ9fZOrrW1tB1tkZpXWfDMMjKyiIiIuK8PaI9iUePgHl7e1OzZs1S/YzKlSvrD7cFdJ2toetsHV1ra+g6W6M0rrOnjnz9wjNrpYiIiIgLUwETERERsZjP448//rjdIdyVj48PXbt2xdfXo2dybafrbA1dZ+voWltD19kaus6Xx6NvwhcRERFxRZqCFBEREbGYCpiIiIiIxVTARERERCymAiYiIiJiMRUwEREREYupgP2JWbNmUadOHQIDA4mJiWHjxo1/ev77779P48aNCQwMpHnz5ixfvtyipO6tONd5zpw5dOnSheDgYIKDg4mNjf3L/y5iKu7v518sWrQILy8vevXqVcoJPUNxr/OZM2cYMWIE4eHhBAQE0KhRI/3dcYmKe61nzJjBVVddRbly5YiKimLMmDHk5uZalNb9fPPNN9x6661ERETg5eXFxx9//JfvWbNmDW3atCEgIIAGDRowb9680g/qrgy5oEWLFhn+/v7GW2+9ZezYscMYPny4UaVKFSM1NfWC569du9bw8fExnn32WWPnzp3Go48+avj5+Rnbtm2zOLl7Ke517tevnzFr1iwjISHB+Omnn4zBgwcbQUFBxpEjRyxO7l6Ke51/cfDgQSMyMtLo0qWLcdttt1mU1n0V9zrn5eUZbdu2Nbp372589913xsGDB401a9YYiYmJFid3P8W91vPnzzcCAgKM+fPnGwcPHjRWrlxphIeHG2PGjLE4uftYvny5MXHiROOjjz4yAGPp0qV/ev6BAweM8uXLG2PHjjV27txpvPzyy4aPj4+xYsUKixK7FxWwi2jfvr0xYsSIomOHw2FEREQYU6dOveD5vXv3Nnr06HHeazExMcY999xTqjndXXGv8+8VFhYalSpVMt5+++3SiugRLuc6FxYWGh07djTeeOMNY9CgQSpgl6C41/nVV1816tWrZ+Tn51sV0WMU91qPGDHCuP766897bezYsUanTp1KNaenuJQCNm7cOOPqq68+77W4uDijW7dupRnNbWkK8gLy8/PZvHkzsbGxRa95e3sTGxvL+vXrL/ie9evXn3c+QLdu3S56vlzedf69nJwcCgoKCAkJKa2Ybu9yr/OTTz5JaGgoQ4cOtSKm27uc67xs2TI6dOjAiBEjCAsLo1mzZkyZMgWHw2FVbLd0Ode6Y8eObN68uWia8sCBAyxfvpzu3btbkrks0M/B4tG+AReQlpaGw+EgLCzsvNfDwsLYtWvXBd+TkpJywfNTUlJKLae7u5zr/HsPP/wwERERf/hDL7+6nOv83Xff8eabb5KYmGhFRI9wOdf5wIEDrF69mv79+7N8+XL27dvH/fffT0FBAZMnT7Yitlu6nGvdr18/0tLS6Ny5M4ZhUFhYyL333ssjjzxiReQy4WI/BzMzMzl37hzlypWzKZlr0giYuK1p06axaNEili5dSmBgoN1xPEZWVhYDBgxgzpw5VKtWze44Hs3pdBIaGsrrr79OdHQ0cXFxTJw4kdmzZ9sdzeOsWbOGKVOm8Morr7BlyxY++ugjPvvsM5566im7o0kZpRGwC6hWrRo+Pj6kpqae93pqaio1atS44Htq1KhRrPPl8q7zL6ZPn860adNYtWoVLVq0KM2Ybq+413n//v0cOnSIW2+9teg1p9MJgK+vL7t376Z+/fqlG9oNXc7v5/DwcPz8/PDx8Sl6rUmTJqSkpJCfn4+/v3+pZnZXl3OtH3vsMQYMGMCwYcMAaN68OdnZ2dx9991MnDgRb2+NR1ypi/0crFy5ska/LkC/4y7A39+f6Oho4uPji15zOp3Ex8fToUOHC76nQ4cO550P8OWXX170fLm86wzw7LPP8tRTT7FixQratm1rRVS3Vtzr3LhxY7Zt20ZiYmLRV8+ePbnuuutITEwkKirKyvhu43J+P3fq1Il9+/YVFVyAPXv2EB4ervL1Jy7nWufk5PyhZP1SfA3DKL2wZYh+DhaT3U8BuKpFixYZAQEBxrx584ydO3cad999t1GlShUjJSXFMAzDGDBggDF+/Pii89euXWv4+voa06dPN3766Sdj8uTJWobiEhT3Ok+bNs3w9/c3PvjgA+P48eNFX1lZWXb9EtxCca/z7+kpyEtT3OuclJRkVKpUyRg5cqSxe/du49NPPzVCQ0ON//znP3b9EtxGca/15MmTjUqVKhkLFy40Dhw4YHzxxRdG/fr1jd69e9v1S3B5WVlZRkJCgpGQkGAAxgsvvGAkJCQYhw8fNgzDMMaPH28MGDCg6PxflqH497//bfz000/GrFmztAzFn1AB+xMvv/yyUatWLcPf399o37698f333xf9u2uvvdYYNGjQeecvWbLEaNSokeHv729cffXVxmeffWZxYvdUnOtcu3ZtA/jD1+TJk60P7maK+/v5t1TALl1xr/O6deuMmJgYIyAgwKhXr57x9NNPG4WFhRandk/FudYFBQXG448/btSvX98IDAw0oqKijPvvv984ffq0Dcndw1dffXXBv29/ua6DBg0yrr322j+8p1WrVoa/v79Rr149Y+7cuZbndhdehqGxVxEREREr6R4wEREREYupgImIiIhYTAVMRERExGIqYCIiIiIWUwETERERsZgKmIiIiIjFVMBERERELKYCJiIiImIxFTARERERi6mAiYiIiFhMBUxERETEYv8PGwO+RxcZXV4AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 11,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670280261965
        }
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.hist(pvalue,bins=10)\n",
        "plt.title(\"Histogram for p-value with 100 trees and 100 iterations,Structure Frac = 0.4\")"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 13,
          "data": {
            "text/plain": "Text(0.5, 1.0, 'Histogram for p-value with 100 trees and 100 iterations,Structure Frac = 0.4')"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 640x480 with 1 Axes>",
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAApAAAAGzCAYAAACYZSdVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3dd3hU1b7G8TcJySSQRoBAQpcOUZBQDiBVBGmKSrNgxIJKRBFBRQ4CUgKCgBcRy5EiIk3Fo4AoIBxAUCnhHAsiCEGEQxUSaoBk3T+4M5dJJiErQiYh38/zzAPZs2bmN2v2XvPO2nv2+BhjjAAAAIAc8vV2AQAAAChYCJAAAACwQoAEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWrnmArFSpkh566KFr/TDXpYsXL+r5559X+fLl5evrq65du3q7pDxV0Nadhx56SJUqVcpx2+Dg4GtbEPKlgrZeOyUlJcnHx0ezZs3ydik5tmbNGvn4+GjNmjXeLgW47lgFyFmzZsnHx0ebN2/2eH2rVq0UExPzl4tatmyZRowY8Zfvp6CbMWOGJkyYoG7dumn27Nl69tlnvV0SLJw5c0YjRoy4Jm9e33//vfr166fY2Fj5+/vLx8cn2/bvvfeeatWqpcDAQFWrVk1Tp0712G7//v3q0aOHwsPDFRoaqjvvvFO7d+/OUU1jx47Vp59+av1c4NmCBQv0wAMPqFq1avLx8VGrVq2ybJuamqoXXnhB0dHRCgoKUuPGjbVixQqPbTds2KBbbrlFRYsWVZkyZfT000/r1KlTuaoxv4zVb775ZoEKtk7nz5/X66+/rptvvlmhoaEKDw9XnTp11LdvX/3yyy+udhs2bNCIESN04sQJr9WaH2rIijObeLq8+OKL3i7vqvsr4/TlTpw4ocjISPn4+Oijjz6yL8RYmDlzppFkNm3a5PH6li1bmjp16rgtO3funDl//rzNw5j4+HhjWdp1qWfPnqZs2bLeLsNrKlasaOLi4rxdRo6dP3/enDt3zvX3kSNHjCQzfPjwTG3j4uJMsWLFcv1Yw4cPN/7+/iY2NtZUr1492+3lrbfeMpLMPffcY9555x3Tu3dvI8mMGzfOrd3JkydNtWrVTGRkpBk/fryZNGmSKV++vClXrpw5evToFWsqVqxYgXq9vCWn63XLli1NcHCwad26tSlevLhp2bJllm179eplihQpYgYNGmTefvtt06RJE1OkSBGzbt06t3aJiYkmMDDQ3HzzzWb69Olm6NChxuFwmNtvv/2K9aSnp5uzZ8+aixcvupbll7G6Tp06HvsnLS3NnD171qSlpeV9UTnQuXNn4+fnZx544AEzbdo0M2XKFPPEE0+YcuXKmZkzZ7raTZgwwUgye/bs8Vqt+aGGrDizySuvvGLmzJnjdklMTPR2eVfVXx2nL9e/f39TrFgxI8ksWrTIupYi9pHTjsPhuNYPcdWdPn1axYoV83YZOnz4sMLDw6/a/aWnp+v8+fMKDAy8aveJ/+fv759nj/Xkk0/qhRdeUFBQkJ566in9+uuvHtudPXtWQ4cOVadOnVyfMB977DGlp6dr1KhR6tu3r4oXLy7p0izOzp079f3336thw4aSpA4dOigmJkavvfaaxo4de9Xqzy/bWH42Z84clS1bVr6+vtnu2fn+++81f/58TZgwQYMGDZIkPfjgg4qJidHzzz+vDRs2uNq+9NJLKl68uNasWaPQ0FBJl3apP/bYY/rqq6/Url27LB/Hx8cnT8YOY4zOnTunoKCgv3xfvr6++Xa827Rpk5YsWaIxY8bopZdecrvujTfeyPVMX0Eb56/mWNChQwc1aNAgR23PnTungIAA+foWrK+CXK1x+scff9T06dP18ssv6+WXX85dMTZpMzczkBk/bZ8/f96MGDHCVK1a1TgcDhMREWGaNWtmvvrqK2PMpZkZSZkuTqdOnTIDBw405cqVMwEBAaZ69epmwoQJJj093e1xz5w5Y/r3729KlChhgoODTZcuXcwff/yRaUZo+PDhRpL56aefzL333mvCw8NNvXr1jDHG/Pvf/zZxcXGmcuXKxuFwmNKlS5s+ffpkSvnO+9ixY4e5//77TWhoqClZsqT5+9//btLT083vv/9u7rjjDhMSEmJKly5tJk6cmG0/79mzx2MfrF692qoPJJn4+HjzwQcfmNq1a5siRYqYxYsXZ/m4FStWNJ06dTJffvmlqVu3rnE4HKZWrVrm448/zrZeYy7NALRq1SrT8rS0NBMdHW3uuece17IJEyaYJk2amIiICBMYGGjq16/v8dNPxnXH2c8ZOdfLjJ+Mly1bZm655RZTtGhRExwcbDp27Gh+/PHHbJ/H8ePHja+vr3n99dddy44cOWJ8fHxMRESEWx8/8cQTpnTp0q6/4+LiTMWKFY0xWb+GznXPOQP5xx9/mDvvvNMUK1bMlCxZ0jz33HNuMzw5kd0s0NKlS40ks3TpUrflGzZsMJLMnDlzXMsaNmxoGjZsmOk+2rVrZ6pUqZJtDZ6eq/O1y24bM8aYOXPmmPr165vAwEBTvHhx07NnT/P7779neoxvv/3WtG/f3oSGhpqgoCDTokULs379erc2KSkp5plnnjEVK1Y0AQEBplSpUqZt27Zmy5Yt2daflJRknnzySVO9enUTGBhoIiIiTLdu3TKtU851bf369ebZZ581JUuWNEWLFjVdu3Y1hw8fdmubnp5uRo0aZcqWLWuCgoJMq1atzI8//pirmfWsZtiMMWbw4MHGz8/PJCcnuy0fO3askeTqy+TkZFOkSBEzePBgt3apqakmODjYPPLII9nW4FynnTNjVxqr09LSzOTJk03t2rWNw+EwkZGRpm/fvubPP/90u1/nuLN8+XITGxtrHA6HmTx5sjHGmBkzZpjWrVubUqVKmYCAAFOrVi3z5ptvZrp9xhqcfbV69Wq3sdNp4cKFrnWuRIkS5v777zd//PGHWxubbXTevHmmfv36Jjg42ISEhJiYmBgzZcqUbPtz3rx5RpJZs2ZNtu2c20/Gi3PdzGqcz+q5Z3wdnbZv3266d+9uSpYsaQIDA0316tXNSy+9dMUasro/Z205fb81JudjQUZXyibOvpg3b54ZOnSoiY6ONj4+Pub48ePm2LFj5rnnnjMxMTGmWLFiJiQkxNx+++1m27Ztme7n7NmzZvjw4aZatWrG4XCYMmXKmLvuusvs2rXrijVeLX9lnL5cmzZtTPfu3V19k2czkMnJyTp69Gim5RcuXLjibUeMGKGEhAQ9+uijatSokVJSUrR582Zt3bpVt912mx5//HEdOHBAK1as0Jw5c9xua4zRHXfcodWrV+uRRx5RvXr19OWXX2rw4MHav3+/Jk+e7Gr70EMPaeHCherdu7f+9re/6V//+pc6deqUZV3du3dXtWrVNHbsWBljJEkrVqzQ7t271adPH5UpU0Y//fST3nnnHf3000/69ttvMx131rNnT9WqVUvjxo3T0qVLNXr0aEVEROjtt99WmzZtNH78eM2dO1eDBg1Sw4YN1aJFC4+1lCpVSnPmzNGYMWN06tQpJSQkSJJq1apl1QeS9PXXX2vhwoV66qmnVLJkySt+yWPnzp3q2bOnnnjiCcXFxWnmzJnq3r27li9frttuuy3L2/Xs2VMjRozQwYMHVaZMGdfy9evX68CBA+rVq5dr2euvv6477rhD999/v86fP6/58+ere/fuWrJkSbavkY05c+YoLi5O7du31/jx43XmzBlNnz5dt9xyixITE7Psh/DwcMXExGjt2rV6+umnXc/Bx8dHf/75p37++WfVqVNHkrRu3To1b97c4/2UKlVK06dP15NPPqm77rpLd999tyTppptucrVJS0tT+/bt1bhxY02cOFErV67Ua6+9pipVqujJJ5+8Kv2QmJgoSZk+lcfGxsrX11eJiYl64IEHlJ6erv/85z96+OGHM91Ho0aN9NVXX+nkyZMKCQnx+Dhz5sxxbdN9+/aVJFWpUsWtjadtbMyYMRo2bJh69OihRx99VEeOHNHUqVPVokULJSYmumbgv/76a3Xo0EGxsbEaPny4fH19NXPmTLVp00br1q1To0aNJElPPPGEPvroIz311FOqXbu2jh07pvXr12v79u2qX79+lv20adMmbdiwQb169VK5cuWUlJSk6dOnq1WrVvr5559VtGhRt/b9+/dX8eLFNXz4cCUlJWnKlCl66qmntGDBAlebl19+WaNHj1bHjh3VsWNHbd26Ve3atdP58+ezrCM3EhMTVb16ddeMopOzT7Zt26by5cvrhx9+0MWLFzOtCwEBAapXr55rXcmp7MZq5/WzZs1Snz599PTTT2vPnj164403lJiYqG+++cZtxn7Hjh2699579fjjj+uxxx5TjRo1JEnTp09XnTp1dMcdd6hIkSL6/PPP1a9fP6Wnpys+Pl6SNGXKFPXv31/BwcEaOnSoJKl06dJZ1u2sqWHDhkpISNChQ4f0+uuv65tvvnFb56ScbaMrVqzQvffeq1tvvVXjx4+XJG3fvl3ffPONnnnmmSzrqFixoiRp7ty5atasmYoU8fx2fPfdd+vXX3/VvHnzNHnyZJUsWVLSpTHGydM4bzOD+Z///EfNmzeXv7+/+vbtq0qVKum3337T559/rjFjxmRbw5EjR3L8OE5/ZSzIjqds4qxVkkaNGqWAgAANGjRIqampCggI0M8//6xPP/1U3bt3V+XKlXXo0CG9/fbbatmypX7++WdFR0dLurQudO7cWatWrVKvXr30zDPP6OTJk1qxYoV+/PHHTOPd5U6dOqVz585dsX5/f3+FhYVlef1fHaedFi1apA0bNmj79u1KSkq6Yl1ZskmbzpSf3eVKM5B169Y1nTp1yvZxsppR+fTTT40kM3r0aLfl3bp1Mz4+Pq5PAVu2bDGSzIABA9zaPfTQQ1l+Irr33nszPd6ZM2cyLXN+aly7dm2m++jbt69r2cWLF025cuWMj4+P27Fmx48fN0FBQTk+Bipjf+a0D4y59OnP19fX/PTTT1d8LGP+/5P85TOOycnJJioqytx8883Z3nbHjh1Gkpk6darb8n79+png4GC3vszYr+fPnzcxMTGmTZs2merJzQzkyZMnTXh4uHnsscfc2h08eNCEhYVlWp5RfHy828ziwIEDTYsWLUxkZKSZPn26McaYY8eOGR8fH7eZystnII258jGQ+r9jdi538803m9jY2Gzr81RvVptyfHy88fPz83hdqVKlTK9evdxqzViPMcZMmzbNSDK//PJLtnVkdQxkVttYUlKS8fPzM2PGjHFb/sMPP5giRYq4lqenp5tq1aqZ9u3bu80AnzlzxlSuXNncdtttrmVhYWEmPj4+2zo98bStb9y40Ugy77//vmuZc11r27atWy3PPvus8fPzMydOnDDGGHP48GETEBBgOnXq5NbupZdecpudzansZiDr1KmTadsxxpiffvrJSDJvvfWWMcaYRYsWZRq7nLp3727KlCmTbQ2eZpqyWvfWrVtnJJm5c+e6LV++fHmm5c5xZ/ny5Znux9Pr0r59e3PDDTe4LcuqfzLOwp0/f95ERkaamJgYc/bsWVe7JUuWGEnm5Zdfdi3L6Tb6zDPPmNDQUOs9B+np6aZly5ZGkildurS59957zbRp08zevXsztc3u+MOsxnmbGcgWLVqYkJCQTI99+bqbVQ25mYHM7ViQleyyyeV9ccMNN2Rap86dO5fpGNk9e/YYh8Ph9trPmDHDSDKTJk3K9PgZ9/5llNVsfcZLdsc5G3N1xukzZ86YChUqmCFDhhhjzF+agczVzv9p06ZpxYoVmS6Xz65kJTw8XD/99JN27txp/bjLli2Tn5+fa2bI6bnnnpMxRl988YUkafny5ZKkfv36ubXr379/lvf9xBNPZFp2+TE4586d09GjR/W3v/1NkrR169ZM7R999FHX//38/NSgQQMZY/TII4+4loeHh6tGjRq5+saUlPM+cGrZsqVq166d4/uPjo7WXXfd5fo7NDRUDz74oBITE3Xw4MEsb1e9enXVq1fPbQYmLS1NH330kbp06eLWl5f///jx40pOTlbz5s099mlurFixQidOnNC9996ro0ePui5+fn5q3LixVq9ene3tmzdvrkOHDmnHjh2SLs00tmjRQs2bN9e6deskXZqVNMZkOQOZUxnXu+bNm+d63fDk7NmzCggI8HhdYGCgzp4962oneT5m2XkslbNNbmV8rp988onS09PVo0cPt9epTJkyqlatmut12rZtm3bu3Kn77rtPx44dc7U7ffq0br31Vq1du1bp6emSLm1f3333nQ4cOGBV2+Xr5IULF3Ts2DFVrVpV4eHhHtfLvn37uu2BaN68udLS0rR3715J0sqVK3X+/Hn179/frd2AAQOs6sqJs2fP5uh1u9Jr/Fdf38stWrRIYWFhuu2229xe29jYWAUHB2faBitXrqz27dtnup/LXxfn7FLLli21e/duJScnW9e1efNmHT58WP369XM7RrBTp06qWbOmli5dmuk2V9pGw8PDdfr06Sy/9Z4VHx8fffnllxo9erSKFy+uefPmKT4+XhUrVlTPnj2tZhBtx/nLHTlyRGvXrtXDDz+sChUqZKrxWsjtWHAlnrLJ5eLi4jIdW+twOFzHQaalpenYsWMKDg5WjRo13Lb9jz/+WCVLlvSYI67UT88//7zHzJTx8tprr2V7P1djnB43bpwuXLiQ6bjb3MjVLuxGjRp5PFC1ePHiHndtX+6VV17RnXfeqerVqysmJka33367evfunaPwuXfvXkVHR2eanq1Vq5breue/vr6+qly5slu7qlWrZnnfGdtK0p9//qmRI0dq/vz5Onz4sNt1ngavjBtfWFiYAgMD3abQncuPHTuWZS3ZyWkfOHl6XtmpWrVqpo2hevXqki6dB87TLouIiAgFBASoZ8+eeumll7R//36VLVtWa9as0eHDh9WzZ0+39kuWLNHo0aO1bds2paamupZfrcHK+eGkTZs2Hq/PuKsvI2coXLduncqVK6fExESNHj1apUqV0sSJE13XhYaGqm7durmuMzAw0G03lHRpGzp+/Hiu7zOjoKCgLHeZXv5FBee/l78el7e7vE1uZVwXd+7cKWOMqlWr5rG9cxen8/WMi4vL8r6Tk5NVvHhxvfrqq4qLi1P58uUVGxurjh076sEHH9QNN9yQbW1nz55VQkKCZs6cqf3797t2qznvO6OM27rzi0jO1865HWZ8bqVKlXK1vVqCgoJy9Lpd6TW+Gl9acdq5c6eSk5MVGRnp8fqM42lW49Q333yj4cOHa+PGjTpz5ozbdcnJydnu7vPE+bo4d5FfrmbNmlq/fr3bspxso/369dPChQvVoUMHlS1bVu3atVOPHj10++23X7Eeh8OhoUOHaujQofrvf/+rf/3rX3r99de1cOFC+fv764MPPsjR87Id5y/nDMNX4xR8OZXbseBKssomWT2udGm38Ouvv64333xTe/bsUVpamuu6EiVKuP7/22+/qUaNGlkeapCd2rVr5zrgX+6vjtNJSUmaMGGCpk2bdlXOQ3zNv4WdUYsWLfTbb7/pn//8p7766iv94x//0OTJk/XWW2+5zeDlNU+d3qNHD23YsEGDBw9WvXr1FBwcrPT0dN1+++2uGY/L+fn55WiZJLc3qGvpar4pSNK+ffsybYSrV69Wq1at1LNnTw0ZMkSLFi3SgAEDtHDhQoWFhbkNpOvWrdMdd9yhFi1a6M0331RUVJT8/f01c+ZMffjhh9k+dlYB8/INXpLrtZkzZ47b8ZhOVxoAoqOjVblyZa1du1aVKlWSMUZNmjRRqVKl9Mwzz2jv3r1at26dmjZt+pe+wZfVunE1RUVFKS0tTYcPH3Z7Mz9//ryOHTvmOr4nIiJCDodD//3vfzPdh3OZs21uZVwX09PT5ePjoy+++MJjXzgHOOfrOWHCBNWrV8/jfTvb9ujRQ82bN9fixYv11VdfacKECRo/frw++eQTdejQIcva+vfvr5kzZ2rAgAFq0qSJwsLC5OPjo169euV4W5fybru+XFRUlPbv359pecbXLSoqym15xrZ/9fW9XHp6uiIjIzV37lyP12cMZZ7Gqd9++0233nqratasqUmTJql8+fIKCAjQsmXLNHnyZI+vy9WWk200MjJS27Zt05dffqkvvvhCX3zxhWbOnKkHH3xQs2fPzvFjRUVFqVevXrrnnntUp04dLVy4ULNmzcpRYPHUfzkdL/+q3DxObseCv8pTP40dO1bDhg3Tww8/rFGjRikiIkK+vr4aMGDAVVvHkpOTczTDHxAQoIiIiCyv/6vj9Msvv6yyZcuqVatWrmMfnXsWjxw5oqSkJFWoUCHH72t5HiClS53Qp08f9enTR6dOnVKLFi00YsQIV4DMaoWsWLGiVq5cmekgUecJV50HJVesWFHp6enas2eP2yeaXbt25bjG48ePa9WqVRo5cqTbV9xzs+v9asppH+TWrl27ZIxxew2cp4ipVKmSwsPDM+0WcM7CVa5cWY0aNdKCBQv01FNP6ZNPPlHXrl3dpts//vhjBQYG6ssvv3RbPnPmzCvW5py5OXHihNsB1RlnXZ0HM0dGRqpt27Y5et4ZNW/eXGvXrlXlypVVr149hYSEqG7dugoLC9Py5cu1detWjRw5Mtv7uFa7f2w4A9fmzZvVsWNH1/LNmzcrPT3ddb2vr69uvPFGjz8S8N133+mGG2644oHZts+3SpUqMsaocuXKrlnurNpJl2aOc/J6RkVFqV+/furXr58OHz6s+vXra8yYMdkGyI8++khxcXFuu5DOnTuX61OpOLfDnTt3us1+Hjly5KrOMEuXXuPVq1crJSXFbXb9u+++c10vXZphKlKkiDZv3qwePXq42p0/f17btm1zW5ZTWb3mVapU0cqVK9WsWbNcf4j9/PPPlZqaqs8++8xtxtfT7sycrnvO12XHjh2Z9lDs2LEj1+NnQECAunTpoi5duig9PV39+vXT22+/rWHDhmW758sTf39/3XTTTdq5c6drN25uxpLLx8vLZRwvnevnjz/+mO39ZVVDTh8nOzkdC66Fjz76SK1bt9Z7773ntvzEiRNuew+rVKmi7777ThcuXLA+ZdszzzyTow8TLVu2zPaHJ/7qOP37779r165dHvfIOA/5O378eI5PH5jnJ0DKuOs2ODhYVatWdZuSdZ4TKuMK2bFjR6WlpemNN95wWz558mT5+Pi43iCcx9K8+eabbu2y+vUNT5yfgjLOKEyZMiXH93Et5LQPcuvAgQNavHix6++UlBS9//77qlevnsqUKaPAwEC1bdvW7XL5LrmePXvq22+/1YwZM3T06NFMu6/9/Pzk4+Pj9uk0KSkpR79g4gwSa9eudS07ffp0pg2zffv2Cg0N1dixYz2eGSAn3xps3ry5kpKStGDBAtcubV9fXzVt2lSTJk3ShQsXrnj8o/Obu9785YY2bdooIiJC06dPd1s+ffp0FS1a1O1b7926ddOmTZvcBqcdO3bo66+/Vvfu3a/4WMWKFbN6rnfffbf8/Pw0cuTITNuZMcY1VsTGxqpKlSqaOHGix19Mcb6eaWlpmXY3R0ZGKjo62uMun8v5+fllqmHq1Km5nq1p27at/P39NXXqVLf7vRbjR7du3ZSWlqZ33nnHtSw1NVUzZ85U48aNVb58eUmXDp1p27atPvjgA508edLVds6cOTp16lSOXuOMshqre/ToobS0NI0aNSrTbS5evJij9cTTGJycnOzxw2ZO170GDRooMjJSb731lts68cUXX2j79u25OgtExvc0X19f1yFZ2a13O3fu1O+//55p+YkTJ7Rx40YVL17cNVObVT9np2LFivLz83MbL6XM74ulSpVSixYtNGPGjEz1XN73WdUQGhqqkiVLXvFxspPTseBa8LTtL1q0KNOs/j333KOjR49meu911pidq3UMpGQ3Tv/yyy9ur+no0aO1ePFit4tzG33++ee1ePFiq3Ny5vkMZO3atdWqVSvFxsYqIiJCmzdvdp12wyk2NlaS9PTTT6t9+/by8/NTr1691KVLF7Vu3VpDhw5VUlKS6tatq6+++kr//Oc/NWDAAFfAiI2N1T333KMpU6bo2LFjrtP4OGfScvJpLjQ0VC1atNCrr76qCxcuqGzZsvrqq6+0Z8+ea9ArOZfTPsit6tWr65FHHtGmTZtUunRpzZgxQ4cOHcrRDKF06Y1j0KBBGjRokCIiIjLNGHXq1EmTJk3S7bffrvvuu0+HDx/WtGnTVLVqVf3nP//J9r7btWunChUq6JFHHtHgwYPl5+enGTNmqFSpUm4bSWhoqKZPn67evXurfv366tWrl6vN0qVL1axZM4+DwOWc4XDHjh1uJ2Zt0aKFvvjiCzkcDtdJXLMSFBSk2rVra8GCBapevboiIiIUExNzVY412rt3r+vUKc6BZPTo0ZIuvXH07t3bVcOoUaMUHx+v7t27q3379lq3bp0++OADjRkzxm13Sb9+/fTuu++qU6dOGjRokPz9/TVp0iSVLl1azz333BVrio2N1cqVKzVp0iTXYQCNGzfOsn2VKlU0evRoDRkyRElJSeratatCQkK0Z88eLV68WH379tWgQYPk6+urf/zjH+rQoYPq1KmjPn36qGzZstq/f79Wr16t0NBQff755zp58qTKlSunbt26qW7dugoODtbKlSu1adOmKw7MnTt31pw5cxQWFqbatWtr48aNWrlypdsxUDZKlSqlQYMGKSEhQZ07d1bHjh2VmJioL774ItMx0VlZu3at6035yJEjOn36tOs1btGihes0YI0bN1b37t01ZMgQHT58WFWrVtXs2bOVlJSUaVZlzJgxatq0qVq2bKm+ffvqjz/+0GuvvaZ27drl6Ji9jLIaq1u2bKnHH39cCQkJ2rZtm9q1ayd/f3/t3LlTixYt0uuvv65u3bple9/t2rVzzew9/vjjOnXqlN59911FRkZm2oUXGxur6dOna/To0apataoiIyM9HgPt7++v8ePHq0+fPmrZsqXuvfde12l8KlWqlKufi3300Uf1559/qk2bNipXrpz27t2rqVOnql69egSKOacAACAASURBVK5j0yW5Th3m3HX473//W/fdd586dOig5s2bKyIiQvv379fs2bN14MABTZkyxRWinf08dOhQ9erVS/7+/urSpUu2b/ZhYWHq3r27pk6dKh8fH1WpUkVLlizJdPypJP3P//yPbrnlFtWvX199+/ZV5cqVlZSUpKVLl2rbtm1XrOHRRx/VuHHj9Oijj6pBgwZau3Ztlj9u4ElOx4JroXPnznrllVfUp08fNW3aVD/88IPmzp2baZbuwQcf1Pvvv6+BAwfq+++/V/PmzXX69GmtXLlS/fr105133pnlY1ytYyAlu3G6Vq1abrOat9xyS6b7c842NmzYUF27drUrxuYr21fjROKjR482jRo1MuHh4SYoKMjUrFnTjBkzxu3nDi9evGj69+9vSpUqZXx8fNxOE3Hy5Enz7LPPmujoaOPv72+qVavm8STap0+fNvHx8SYiIsIEBwebrl27uk41c/lpdZynFThy5Eim5/PHH3+Yu+66y4SHh5uwsDDTvXt3c+DAgSxPTZDxPrL6uTpP/eRJVu1y2gf6vxPM5tTlJxK/6aabjMPhMDVr1rT+en+zZs2MJPPoo496vP69995znYi1Zs2aZubMmR5P0ePphMtbtmwxjRs3NgEBAaZChQpm0qRJWZ5IfPXq1aZ9+/YmLCzMBAYGmipVqpiHHnrIbN68OUfPIzIy0kgyhw4dci1bv369kWSaN2+eqX3G0/gYc+mE3bGxsSYgIMBtvclq3cjqVEUZOU+94Oni6VQQ77zzjqlRo4YJCAgwVapUMZMnT/Z46ol9+/aZbt26mdDQUBMcHGw6d+5sdu7cecV6jDHml19+MS1atDBBQUFup6rJbhszxpiPP/7Y3HLLLaZYsWKmWLFipmbNmiY+Pt7s2LHDrV1iYqK5++67TYkSJYzD4TAVK1Y0PXr0MKtWrTLGXDoh9uDBg03dunVNSEiIKVasmKlbt26mE097cvz4cdOnTx9TsmRJExwcbNq3b29++eWXTOtgVmOgp1OmpKWlmZEjR5qoqKhcnUg8q5M3Zxx/jLl0guNBgwaZMmXKGIfDYRo2bOjxtDjGXDrFTtOmTU1gYKApVaqUiY+PNykpKVesx9PpWrIbq425tN7FxsaaoKAgExISYm688Ubz/PPPmwMHDrjaOMcdTz777DNz0003mcDAQFOpUiUzfvx41+lULt/eDx48aDp16mRCQkLctoGsTmWzYMECc/PNN7t+zCK7E4lnlHEb/eijj0y7du1MZGSka1x6/PHHzX//+1+325UsWdL87W9/c/196NAhM27cONOyZUsTFRVlihQpYooXL27atGljPvroo0yP6zwpva+vr9vzz26cP3LkiLnnnntM0aJFTfHixc3jjz9ufvzxR4+n3fnxxx9d73eBgYGmRo0aZtiwYTmq4cyZM+aRRx4xYWFhJiQkxPTo0cMcPnw4x++VTjkdCzLK6YnEPb2XnTt3zjz33HOu7bRZs2Zm48aNpmXLlpnG0jNnzpihQ4eaypUrG39/f1OmTBnTrVs389tvv2Vb39WW03E6q/eDy/2V0/j4/N+DFArbtm3TzTffrA8++ED333+/t8vJdypVqqSYmBgtWbLE26UAwHXD+QMEV/PHEgBvK1g/AmnB0zeepkyZIl9f3yx/AQYAgKtt9erVatKkCeER1xWvfAs7L7z66qvasmWLWrdurSJFirhOr9C3b1/XQeUAAFxr8fHxrp9eBK4X122AbNq0qVasWKFRo0bp1KlTqlChgkaMGOH6rVQAAADkTqE6BhIAAAB/3XV7DCQAAACuDQIkAAAArFy3x0DmhfT0dB04cEAhISH54mfrAADAlRljdPLkSUVHR+f4t5/hjgD5Fxw4cIBvdAMAUEDt27dP5cqV83YZBRIB8i9w/mj5vn37FBoa6uVqAABATqSkpKh8+fKu93HYI0D+Bc7d1qGhoQRIAAAKGA4/yz12/AMAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBAgAQAAYKWItwsAYK/Si0u9XYK1pHGdvF0CUKgxbuBqYgYSAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYuW4D5Nq1a9WlSxdFR0fLx8dHn376qeu6Cxcu6IUXXtCNN96oYsWKKTo6Wg8++KAOHDjgxYoBAAAKhus2QJ4+fVp169bVtGnTMl135swZbd26VcOGDdPWrVv1ySefaMeOHbrjjju8UCkAAEDBUsTbBVwrHTp0UIcOHTxeFxYWphUrVrgte+ONN9SoUSP9/vvvqlChgsfbpaamKjU11fV3SkrK1SsYAACggLhuA6St5ORk+fj4KDw8PMs2CQkJGjlyZB5WVfBUenGpt0uwljSuk7dLAACgQLlud2HbOHfunF544QXde++9Cg0NzbLdkCFDlJyc7Lrs27cvD6sEAADIHwr9DOSFCxfUo0cPGWM0ffr0bNs6HA45HI48qgwAACB/KtQB0hke9+7dq6+//jrb2UcAAABcUmgDpDM87ty5U6tXr1aJEiW8XRIAAECBcN0GyFOnTmnXrl2uv/fs2aNt27YpIiJCUVFR6tatm7Zu3aolS5YoLS1NBw8elCRFREQoICDAW2UDAADke9dtgNy8ebNat27t+nvgwIGSpLi4OI0YMUKfffaZJKlevXput1u9erVatWqVZ3UCAAAUNNdtgGzVqpWMMVlen911AAAAyBqn8QEAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABg5boNkGvXrlWXLl0UHR0tHx8fffrpp27XG2P08ssvKyoqSkFBQWrbtq127tzppWoBAAAKjus2QJ4+fVp169bVtGnTPF7/6quv6n/+53/01ltv6bvvvlOxYsXUvn17nTt3Lo8rBQAAKFiKeLuAa6VDhw7q0KGDx+uMMZoyZYr+/ve/684775Qkvf/++ypdurQ+/fRT9erVKy9LBQAAKFCu2xnI7OzZs0cHDx5U27ZtXcvCwsLUuHFjbdy4McvbpaamKiUlxe0CAABQ2Fy3M5DZOXjwoCSpdOnSbstLly7tus6ThIQEjRw58prWBlyvKr241NslFApJ4zp5u4RCgfUZhV2hnIHMrSFDhig5Odl12bdvn7dLAgAAyHOFMkCWKVNGknTo0CG35YcOHXJd54nD4VBoaKjbBQAAoLAplAGycuXKKlOmjFatWuValpKSou+++05NmjTxYmUAAAD533V7DOSpU6e0a9cu19979uzRtm3bFBERoQoVKmjAgAEaPXq0qlWrpsqVK2vYsGGKjo5W165dvVg1AABA/nfdBsjNmzerdevWrr8HDhwoSYqLi9OsWbP0/PPP6/Tp0+rbt69OnDihW265RcuXL1dgYKC3SgYAACgQrtsA2apVKxljsrzex8dHr7zyil555ZU8rAoAAKDgK5THQAIAACD3CJAAAACwQoAEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBTxdgHIWqUXl3q7BAAFTEEcN5LGdfJ2CQAsMQMJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAICVQhsg09LSNGzYMFWuXFlBQUGqUqWKRo0aJWOMt0sDAADI14p4uwBvGT9+vKZPn67Zs2erTp062rx5s/r06aOwsDA9/fTT3i4PAAAg3yq0AXLDhg2688471alTJ0lSpUqVNG/ePH3//fdergwAACB/K7S7sJs2bapVq1bp119/lST9+9//1vr169WhQ4csb5OamqqUlBS3CwAAQGFTaGcgX3zxRaWkpKhmzZry8/NTWlqaxowZo/vvvz/L2yQkJGjkyJF5WCUAXP8qvbjU2yUAsFRoZyAXLlyouXPn6sMPP9TWrVs1e/ZsTZw4UbNnz87yNkOGDFFycrLrsm/fvjysGAAAIH8otDOQgwcP1osvvqhevXpJkm688Ubt3btXCQkJiouL83gbh8Mhh8ORl2UCAADkO4V2BvLMmTPy9XV/+n5+fkpPT/dSRQAAAAVDoZ2B7NKli8aMGaMKFSqoTp06SkxM1KRJk/Twww97uzQAAIB8rdAGyKlTp2rYsGHq16+fDh8+rOjoaD3++ON6+eWXvV0aAABAvlZoA2RISIimTJmiKVOmeLsUAACAAqXQHgMJAACA3CFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYIkAAAALBCgAQAAIAVAiQAAACsECABAABghQAJAAAAKwRIAAAAWCFAAgAAwAoBEgAAAFYKdYDcv3+/HnjgAZUoUUJBQUG68cYbtXnzZm+XBQAAkK8V8XYB3nL8+HE1a9ZMrVu31hdffKFSpUpp586dKl68uLdLAwAAyNcKbYAcP368ypcvr5kzZ7qWVa5c2YsVAQAAFAyFdhf2Z599pgYNGqh79+6KjIzUzTffrHfffTfb26SmpiolJcXtAgAAUNgU2hnI3bt3a/r06Ro4cKBeeuklbdq0SU8//bQCAgIUFxfn8TYJCQkaOXJkHleKa63Si0u9XQIAAAWKjzHGeLsIbwgICFCDBg20YcMG17Knn35amzZt0saNGz3eJjU1Vampqa6/U1JSVL58eSUnJys0NPSq10iwAQAUZknjOl2T+01JSVFYWNg1e/8uDArtLuyoqCjVrl3bbVmtWrX0+++/Z3kbh8Oh0NBQtwsAAEBhU2gDZLNmzbRjxw63Zb/++qsqVqzopYoAAAAKhkIbIJ999ll9++23Gjt2rHbt2qUPP/xQ77zzjuLj471dGgAAQL5WaANkw4YNtXjxYs2bN08xMTEaNWqUpkyZovvvv9/bpQEAAORrhfZb2JLUuXNnde7c2dtlAAAAFCiFdgYSAAAAuUOABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIP/PuHHj5OPjowEDBni7FAAAgHyNAClp06ZNevvtt3XTTTd5uxQAAIB8r9AHyFOnTun+++/Xu+++q+LFi3u7HAAAgHyv0AfI+Ph4derUSW3btr1i29TUVKWkpLhdAAAACpsi3i7Am+bPn6+tW7dq06ZNOWqfkJCgkSNHXuOqAAAA8rdCOwO5b98+PfPMM5o7d64CAwNzdJshQ4YoOTnZddm3b981rhIAACD/KbQzkFu2bNHhw4dVv35917K0tDStXbtWb7zxhlJTU+Xn5+d2G4fDIYfDkdelAgAA5CuFNkDeeuut+uGHH9yW9enTRzVr1tQLL7yQKTwCAADgkkIbIENCQhQTE+O2rFixYipRokSm5QAAAPh/hfYYSAAAAOROoZ2B9GTNmjXeLgEAACDfYwYSAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgJVCHSATEhLUsGFDhYSEKDIyUl27dtWOHTu8XRYAAEC+VqgD5L/+9S/Fx8fr22+/1YoVK3ThwgW1a9dOp0+f9nZpAAAA+VYRbxfgTcuXL3f7e9asWYqMjNSWLVvUokULL1UFAACQvxXqAJlRcnKyJCkiIsLj9ampqUpNTXX9nZKSkid1AQAA5CeFehf25dLT0zVgwAA1a9ZMMTExHtskJCQoLCzMdSlfvnweVwkAAOB9BMj/Ex8frx9//FHz58/Pss2QIUOUnJzsuuzbty8PKwQAAMgf2IUt6amnntKSJUu0du1alStXLst2DodDDocjDysDAADIfwp1gDTGqH///lq8eLHWrFmjypUre7skAACAfK9QB8j4+Hh9+OGH+uc//6mQkBAdPHhQkhQWFqagoCAvVwcAAJA/FepjIKdPn67k5GS1atVKUVFRrsuCBQu8XRoAAEC+VahnII0x3i4BAACgwCnUM5AAAACwR4AEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBAgAQAAYIUACQAAACsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoAEAACAFQIkAAAArBT6ADlt2jRVqlRJgYGBaty4sb7//ntvlwQAAJCvFeoAuWDBAg0cOFDDhw/X1q1bVbduXbVv316HDx/2dmkAAAD5VqEOkJMmTdJjjz2mPn36qHbt2nrrrbdUtGhRzZgxw9ulAQAA5FtFvF2At5w/f15btmzRkCFDXMt8fX3Vtm1bbdy40eNtUlNTlZqa6vo7OTlZkpSSknJNakxPPXNN7hcAgILgWr2/Ou/XGHNN7r8wKLQB8ujRo0pLS1Pp0qXdlpcuXVq//PKLx9skJCRo5MiRmZaXL1/+mtQIAEBhFjbl2t7/yZMnFRYWdm0f5DpVaANkbgwZMkQDBw50/Z2enq4///xTJUqUkI+Pz1V5jJSUFJUvX1779u1TaGjoVblPeEZf5x36Ou/Q13mHvs5bV7O/jTE6efKkoqOjr1J1hU+hDZAlS5aUn5+fDh065Lb80KFDKlOmjMfbOBwOORwOt2Xh4eHXpL7Q0FAGpDxCX+cd+jrv0Nd5h77OW1erv5l5/GsK7ZdoAgICFBsbq1WrVrmWpaena9WqVWrSpIkXKwMAAMjfCu0MpCQNHDhQcXFxatCggRo1aqQpU6bo9OnT6tOnj7dLAwAAyLf8RowYMcLbRXhLTEyMwsPDNWbMGE2cOFGSNHfuXNWoUcOrdfn5+alVq1YqUqRQ5/s8QV/nHfo679DXeYe+zlv0d/7hY/gOOwAAACwU2mMgAQAAkDsESAAAAFghQAIAAMAKARIAAABWCJAAAACwQoD0gmnTpqlSpUoKDAxU48aN9f3332fbftGiRapZs6YCAwN14403atmyZXlUacFn09fvvvuumjdvruLFi6t48eJq27btFV8b/D/b9dpp/vz58vHxUdeuXa9xhdcP274+ceKE4uPjFRUVJYfDoerVqzOO5JBtX0+ZMkU1atRQUFCQypcvr2effVbnzp3Lo2oLrrVr16pLly6Kjo6Wj4+PPv300yveZs2aNapfv74cDoeqVq2qWbNmXftC8f8M8tT8+fNNQECAmTFjhvnpp5/MY489ZsLDw82hQ4c8tv/mm2+Mn5+fefXVV83PP/9s/v73vxt/f3/zww8/5HHlBY9tX993331m2rRpJjEx0Wzfvt089NBDJiwszPzxxx95XHnBY9vXTnv27DFly5Y1zZs3N3feeWceVVuw2fZ1amqqadCggenYsaNZv3692bNnj1mzZo3Ztm1bHlde8Nj29dy5c43D4TBz5841e/bsMV9++aWJiooyzz77bB5XXvAsW7bMDB061HzyySdGklm8eHG27Xfv3m2KFi1qBg4caH7++WczdepU4+fnZ5YvX55HFYMAmccaNWpk4uPjXX+npaWZ6Ohok5CQ4LF9jx49TKdOndyWNW7c2Dz++OPXtM7rgW1fZ3Tx4kUTEhJiZs+efa1KvG7kpq8vXrxomjZtav7xj3+YuLg4AmQO2fb19OnTzQ033GDOnz+fVyVeN2z7Oj4+3rRp08Zt2cCBA02zZs2uaZ3Xm5wEyOeff97UqVPHbVnPnj1N+/btr2VpuAy7sPPQ+fPntWXLFrVt29a1zNfXV23bttXGjRs93mbjxo1u7SWpffv2WbbHJbnp64zOnDmjCxcuKCIi4lqVeV3IbV+/8sorioyM1COPPJIXZV4XctPXn332mZo0aaL4+HiVLl1aMTExGjt2rNLS0vKq7AIpN33dtGlTbdmyxbWbe/fu3Vq2bJk6duyYJzUXJrw3eh+/BZSHjh49qrS0NJUuXdpteenSpfXLL794vM3Bgwc9tj948OA1q/N6kJu+zuiFF15QdHR0pkEK7nLT1+vXr9d7772nbdu25UWJ143c9PXu3bv19ddf6/7779eyZcu0a9cu9evXTxcuXNDw4cPzouwCKTd9fd999+no0aO65ZZbZIzRxYsX9cQTT+ill17Ki5ILlazeG1NSUnT27FkFBQV5qbLCgxlIwINx48Zp/vz5Wrx4sQIDA71dznXl5MmT6t27t959912VLFnS2+Vc99LT0xUZGal33nlHsbGx6tmzp4YOHaq33nrL26Vdd9asWaOxY8fqzTff1NatW/XJJ59o6dKlGjVqlLdLA646ZiDzUMmSJeXn56dDhw65LT906JDKlCnj8TZlypSxao9LctPXThMnTtS4ceO0cuVK3XTTTdeyzOuCbV//9ttvSkpKUpcuXVzL0tPTJUlFihTRjh07VKVKlWtbdAGVm/U6KipK/v7+8vPzcy2rVauWDh48qPPnzysgIOCa1lxQ5aavhw0bpt69e+vRRx+VJN144406ffq0+vbtq6FDh8rXlzmbqyWr98bQ0FBmH/MIa3MeCggIUGxsrFatWuValp6erlWrVqlJkyYeb9OkSRO39pK0YsWKLNvjktz0tSS9+uqrGjVqlJYvX64GDRrkRakFnm1f16xZUz/88IO2bdvmutxxxx1q3bq1tm3bpvLly+dl+QVKbtbrZs2aadeuXa6QLkm//vqroqKiCI/ZyE1fnzlzJlNIdAZ3Y8y1K7YQ4r0xH/D2t3gKm/nz5xuHw2FmzZplfv75Z9O3b18THh5uDh48aIwxpnfv3ubFF190tf/mm29MkSJFzMSJE8327dvN8OHDOY1PDtn29bhx40xAQID56KOPzH//+1/X5eTJk956CgWGbV9nxLewc862r3///XcTEhJinnrqKbNjxw6zZMkSExkZaUaPHu2tp1Bg2Pb18OHDTUhIiJk3b57ZvXu3+eqrr0yVKlVMjx49vPUUCoyTJ0+axMREk5iYaCSZSZMmmcTERLN3715jjDEvvvii6d27t6u98zQ+gwcPNtu3bzfTpk3jND55jADpBVOnTjUVKlQwAQEBplGjRubbb791XdeyZUsTFxfn1n7hwoWmevXqJiAgwNSpU8csXbo0jysuuGz6umLFikZSpsvw4cPzvvACyHa9vhwB0o5tX2/YsME0btzYOBwOc8MNN5gxY8aYixcv5nHVBZNNX1+4cMGMGDHCVKlSxQQGBpry5cubfv36mePHj3uh8oJl9erVHsdfZ//GxcWZli1bZrpNvXr1TEBAgLnhhhvMzJkz87zu8Bv0pAAAAFhJREFUwszHGObVAQAAkHMcAwkAAAArBEgAAABYIUACAADACgESAAAAVgiQAAAAsEKABAAAgBUCJAAAAKwQIAEAAGCFAAkAAAArBEgAAABYIUACAADAyv8C68GoVJTOKqYAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 13,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1670304944008
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ite = 100\n",
        "reps = 1000\n",
        "sample_size = 100 \n",
        "stat = []\n",
        "pvalue = []\n",
        "null_dist = np.zeros((ite,reps))\n",
        "\n",
        "for i in range(0,ite):\n",
        "    #x,y_ = multimodal_independence(n = sample_size,p = 1,prob = 0.5)\n",
        "    x, y_ = rot_ksamp('multimodal_independence', n=sample_size, p=1,k=2,noise=True)\n",
        "    X, y = k_sample_transform([x, y_])\n",
        "    y = y.astype(int)\n",
        "    print(X.shape)\n",
        "    stat_i, pvalue_i, null_dist_i = perm_test(test,X, y,is_distsim = False,reps = reps)\n",
        "    print(pvalue_i)\n",
        "    pvalue.append(pvalue_i)\n",
        "    stat.append(stat_i)\n",
        "    null_dist[i,:] = null_dist_i"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "(200, 2)\n0.8851148851148851\n(200, 2)\n0.06793206793206794\n(200, 2)\n0.07692307692307693\n(200, 2)\n0.014985014985014986\n(200, 2)\n0.6593406593406593\n(200, 2)\n0.0939060939060939\n(200, 2)\n0.929070929070929\n(200, 2)\n0.8621378621378621\n(200, 2)\n0.8101898101898102\n(200, 2)\n0.8851148851148851\n(200, 2)\n0.06893106893106893\n(200, 2)\n0.23076923076923078\n(200, 2)\n0.34965034965034963\n(200, 2)\n0.46053946053946054\n(200, 2)\n0.003996003996003996\n(200, 2)\n0.8411588411588412\n(200, 2)\n0.5044955044955045\n(200, 2)\n0.43756243756243757\n(200, 2)\n0.2967032967032967\n(200, 2)\n0.26673326673326675\n(200, 2)\n0.5734265734265734\n(200, 2)\n0.32667332667332666\n(200, 2)\n0.6613386613386614\n(200, 2)\n0.33166833166833165\n(200, 2)\n0.8171828171828172\n(200, 2)\n0.4875124875124875\n(200, 2)\n0.7182817182817183\n(200, 2)\n0.2037962037962038\n(200, 2)\n0.21078921078921078\n(200, 2)\n0.5054945054945055\n(200, 2)\n0.4695304695304695\n(200, 2)\n0.5134865134865135\n(200, 2)\n"
        }
      ],
      "execution_count": 13,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python38-azureml",
      "language": "python",
      "display_name": "Python 3.8 - AzureML"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.5",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernel_info": {
      "name": "python38-azureml"
    },
    "microsoft": {
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      }
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}