Forest Hypothesis Testing SampleSize Origin.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",
        "import joblib\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 scipy.stats import entropy, multivariate_normal\n",
        "from math import ceil\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": "2023-01-30 18:58:41.744987: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA\nTo enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n2023-01-30 18:58:42.640688: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n2023-01-30 18:58:42.640780: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n2023-01-30 18:58:42.640790: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n2023-01-30 18:58:43.855977: E tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:267] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n2023-01-30 18:58:43.856043: I tensorflow/compiler/xla/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (ybai312): /proc/driver/nvidia/version does not exist\n2023-01-30 18:58:43.858693: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA\nTo enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
        }
      ],
      "execution_count": 1,
      "metadata": {
        "gather": {
          "logged": 1675105124448
        }
      }
    },
    {
      "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": {
        "collapsed": false,
        "gather": {
          "logged": 1675105133190
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "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",
        "            H_YX = np.mean(entropy(self.uf.predict_proba(X), base=np.exp(1), axis=1))\n",
        "\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",
        "        else:\n",
        "            H_YX = self._refit_apply_oob(X, self.y_) # changed from y to self.y_ as does the permutation internally per tree\n",
        "            ### y has been permuted\n",
        "\n",
        "        _, counts = np.unique(y, return_counts=True)\n",
        "        H_Y = entropy(counts, base=np.exp(1))\n",
        "        return max(H_Y - H_YX, 0)\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",
        "        # np.random.shuffle(y)\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))\n",
        "    "
      ],
      "outputs": [],
      "execution_count": 3,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1675105137401
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def _perm_stat(calc_stat,sim,sample_size = 100,dim = 2): \n",
        "    \n",
        "    if hasattr(calc_stat, \"fit_\"):\n",
        "        calc_stat.fit_ = False\n",
        "    \n",
        "    x, y = rot_ksamp(sim, n=sample_size, p=dim,degree = 90, noise=False)\n",
        "    #print(np.var(y))\n",
        "    if np.var(y) == 0:\n",
        "        observe_stat = 0\n",
        "        null_dist = 0\n",
        "    else:\n",
        "        X, y = k_sample_transform([x, y])\n",
        "        #print(X.shape)\n",
        "        y = y.astype(int)\n",
        "\n",
        "        observe_stat = calc_stat.statistic(X, y)\n",
        "        # Refit Forests at each permutation\n",
        "        permy = np.random.permutation(y)\n",
        "        \n",
        "        if hasattr(calc_stat, \"fit_\"):\n",
        "            calc_stat.fit_ = False\n",
        "        \n",
        "        null_dist = calc_stat.statistic(X, permy)\n",
        "    #print(observe_stat,null_dist)\n",
        "    \n",
        "    return observe_stat,null_dist\n",
        "\n",
        "\n",
        "def estimate_power(calc_stat,sim,sample_size_power = 100 ,dim_power = 2,reps = 1000): \n",
        "    alt_dist, null_dist = map(np.float64,\n",
        "                              zip(*[_perm_stat(calc_stat,sim,sample_size_power,dim_power) for _ in range(reps)]),)\n",
        "    \n",
        "    # Obtain power by cutoff\n",
        "    cutoff = np.sort(null_dist)[ceil(reps * (1 - 0.05))]\n",
        "    print(\"cutoff \" + str(cutoff))\n",
        "    empirical_power = (1 + (alt_dist >= cutoff).sum()) / (1 + reps)\n",
        "    print('power ' + str(empirical_power))\n",
        "    return empirical_power"
      ],
      "outputs": [],
      "execution_count": 33,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1675551701312
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "POWER_REPS = 1000\n",
        "#sample_size = 100\n",
        "\n",
        "test = UFTest_permute_tree(\n",
        "    uf = UncertaintyForest(\n",
        "        n_estimators=100,\n",
        "        tree_construction_proportion=0.8,\n",
        "        kappa=np.inf,\n",
        "        # min_samples_leaf=5,\n",
        "        honest_prior=\"ignore\",\n",
        "        max_features=1.0,\n",
        "        n_jobs=-1,\n",
        "    )\n",
        ")\n",
        "\n",
        "simulations = SIMULATIONS.keys()\n",
        "#simulations = 'linear'"
      ],
      "outputs": [],
      "execution_count": 5,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1675105144105
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "SIMULATIONS.keys()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 6,
          "data": {
            "text/plain": "dict_keys(['linear', 'exponential', 'cubic', 'joint_normal', 'step', 'quadratic', 'w_shaped', 'spiral', 'uncorrelated_bernoulli', 'logarithmic', 'fourth_root', 'sin_four_pi', 'sin_sixteen_pi', 'square', 'two_parabolas', 'circle', 'ellipse', 'diamond', 'multiplicative_noise', 'multimodal_independence'])"
          },
          "metadata": {}
        }
      ],
      "execution_count": 6,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1675105146124
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "power_reps =5\n",
        "sample_size = range(5,105,5)\n",
        "POWER = []\n",
        "for sample_size_i in sample_size:\n",
        "    print('multimodal_independence',sample_size_i)\n",
        "            # Calculate the mean power over 5 times\n",
        "    power= np.mean([estimate_power(test,'multimodal_independence',sample_size_i,1) for _ in range(power_reps)])\n",
        "    print(power)\n",
        "    POWER.append(power)\n",
        "print(POWER)\n",
        "\n",
        "sample_size = range(5,105,5)\n",
        "alpha = 0.05*np.ones((len(POWER)))\n",
        "\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "multimodal_independence 5\ncutoff 0.2913741718369504\npower 0.04595404595404595\ncutoff 0.26135029552120026\npower 0.056943056943056944\ncutoff 0.253153021769463\npower 0.055944055944055944\ncutoff 0.24469709695631908\npower 0.05094905094905095\ncutoff 0.20125288067985359\npower 0.07792207792207792\n0.05754245754245755\nmultimodal_independence 10\ncutoff 0.1670337810231335\npower 0.04895104895104895\ncutoff 0.15542616854878621\npower 0.05194805194805195\ncutoff 0.17381649563828083\npower 0.03696303696303696\ncutoff 0.16451584903324168\npower 0.04995004995004995\ncutoff 0.1587479881534941\npower 0.04695304695304695\n0.04695304695304695\nmultimodal_independence 15\ncutoff 0.14019679439388244\npower 0.04495504495504495\ncutoff 0.12635146895191107\npower 0.058941058941058944\ncutoff 0.13173530414659695\npower 0.06493506493506493\ncutoff 0.13353822426793116\npower 0.04795204795204795\ncutoff 0.13303406601820122\npower 0.04695304695304695\n0.05274725274725275\nmultimodal_independence 20\ncutoff 0.11713940496577713\npower 0.04995004995004995\ncutoff 0.11442116786437873\npower 0.06393606393606394\ncutoff 0.11735566452185275\npower 0.053946053946053944\ncutoff 0.1245306705789666\npower 0.04195804195804196\ncutoff 0.11639116384998971\npower 0.04595404595404595\n0.05114885114885115\nmultimodal_independence 25\ncutoff 0.10951223444671532\npower 0.04595404595404595\ncutoff 0.10926932261935562\npower 0.03996003996003996\ncutoff 0.10723532383635759\npower 0.03796203796203796\ncutoff 0.12223302052424811\npower 0.030969030969030968\ncutoff 0.10158453874592066\npower 0.06693306693306693\n0.044355644355644354\nmultimodal_independence 30\ncutoff 0.0984138967249838\npower 0.04495504495504495\ncutoff 0.102368645088463\npower 0.05194805194805195\ncutoff 0.09975464189768846\npower 0.055944055944055944\ncutoff 0.10266059418349072\npower 0.05094905094905095\ncutoff 0.09787475087931619\npower 0.06393606393606394\n0.05354645354645354\nmultimodal_independence 35\ncutoff 0.09465399234707994\npower 0.052947052947052944\ncutoff 0.09502914697577425\npower 0.054945054945054944\n"
        }
      ],
      "execution_count": 8,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot (sample_size,alpha,c = 'r',linestyle='--',label = \"alpha = 0.05\")\n",
        "plt.plot(sample_size,POWER,label = \"power\")\n",
        "plt.yticks(np.arange(0,1.1,0.1))\n",
        "plt.xticks(np.arange(0,110,10))\n",
        "plt.title(\"Statistical Power for MutiModal Independent Simulation with 100 trees (Incresing Sample Size)\")\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": 10,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1675185076173
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "power_reps = 5\n",
        "fig, ax = plt.subplots(nrows=4, ncols=5, figsize=(25, 20))\n",
        "plt.suptitle(\n",
        "    \"Multivariate Independence Testing (Increasing Dimension)\",\n",
        "    y=0.93,\n",
        "    va=\"baseline\",\n",
        "    )\n",
        "## Interupt once\n",
        "for i, row in enumerate(ax):\n",
        "    for j, col in enumerate(row):\n",
        "        count = 5 * i + j\n",
        "        sim = list(SIMULATIONS.keys())[count]\n",
        "        # if sim in list(SIMULATIONS.keys())[0:8]:\n",
        "        #     print(sim)\n",
        "        #     POWER = np.load(\n",
        "        #         \"POWER_1D_multi_cutoff_0130{}.npy\".format(sim))\n",
        "        # #sim = ['linear','exponential']\n",
        "        # else: \n",
        "        POWER = []\n",
        "        sample_size = range(5,105,5)\n",
        "        #dim = range(1,20,1)\n",
        "        for sample_size_i in sample_size:\n",
        "            print(sim,sample_size_i)\n",
        "            # Calculate mean power over 20 times\n",
        "            power= np.mean([estimate_power(test,sim,sample_size_i,1) for _ in range(power_reps)])\n",
        "            print(power)\n",
        "            POWER.append(power)\n",
        "        np.save(\n",
        "            \"POWER_1D_multi_cutoff_0130{}.npy\".format(sim),\n",
        "            POWER)\n",
        "           \n",
        "        #est_power = np.genfromtxt( \"{}_{}.csv\".format(sim, 'uf'),delimiter=\",\",)\n",
        "        col.plot(sample_size,POWER)\n",
        "        col.set_yticks(np.arange(0,1.1,0.1))\n",
        "        col.set_xticks(range(0,120,20))\n",
        "        col.set_title(list(SIMULATIONS.keys())[count])\n",
        "        #col.yticks(np.arange(0, 1.2, step=0.2))\n",
        "        #col.show()"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "linear\nexponential\ncubic\njoint_normal\nstep\nquadratic\nw_shaped\nspiral\nuncorrelated_bernoulli 5\ncutoff 0.27080924449338023\npower 0.13986013986013987\ncutoff 0.2781515987769301\npower 0.1048951048951049\ncutoff 0.281054282434871\npower 0.1038961038961039\ncutoff 0.27711201519177964\npower 0.13086913086913088\ncutoff 0.3030929463749609\npower 0.07892107892107893\n0.1116883116883117\nuncorrelated_bernoulli 10\ncutoff 0.18975346446905472\npower 0.45454545454545453\ncutoff 0.2026999617101966\npower 0.3826173826173826\ncutoff 0.19033545805549734\npower 0.45854145854145856\ncutoff 0.19762405021205165\npower 0.41058941058941056\ncutoff 0.20521606532829795\npower 0.3706293706293706\n0.41538461538461535\nuncorrelated_bernoulli 15\ncutoff 0.14760839220636623\npower 0.7152847152847153\ncutoff 0.13952626500596443\npower 0.7792207792207793\ncutoff 0.1417928637844611\npower 0.7602397602397603\ncutoff 0.1420735414060057\npower 0.7712287712287712\ncutoff 0.13901695135334324\npower 0.7952047952047953\n0.7642357642357643\nuncorrelated_bernoulli 20\ncutoff 0.11213248578950297\npower 0.9470529470529471\ncutoff 0.1083170227900837\npower 0.9600399600399601\ncutoff 0.1116594665134707\npower 0.939060939060939\ncutoff 0.10511479628938447\npower 0.97002997002997\ncutoff 0.1183540318392644\npower 0.935064935064935\n0.9502497502497501\nuncorrelated_bernoulli 25\ncutoff 0.08732936622148357\npower 0.995004995004995\ncutoff 0.09164186204258895\npower 0.993006993006993\ncutoff 0.09300396779297027\npower 0.988011988011988\ncutoff 0.08966911101086505\npower 0.9920079920079921\ncutoff 0.07204361664917902\npower 1.0\ncutoff 0.07870035971126099\npower 0.998001998001998\n0.9992007992007992\nuncorrelated_bernoulli 35\ncutoff 0.06123532076237548\npower 1.0\ncutoff 0.06256437302512063\npower 0.999000999000999\ncutoff 0.06228144801682789\npower 1.0\ncutoff 0.0658047944036847\npower 1.0\ncutoff 0.06322592762787427\npower 1.0\n0.9998001998001997\nuncorrelated_bernoulli 40\ncutoff 0.052845848633892856\npower 1.0\ncutoff 0.056741295886280296\npower 1.0\ncutoff 0.054329224518587016\npower 1.0\ncutoff 0.05621299240246658\npower 1.0\ncutoff 0.05677151610075026\npower 1.0\n1.0\nuncorrelated_bernoulli 45\ncutoff 0.04888031330657305\npower 1.0\ncutoff 0.046826534675612264\npower 1.0\ncutoff 0.0451803001711345\npower 1.0\ncutoff 0.04848633285463355\npower 1.0\ncutoff 0.04839953836466382\npower 1.0\n1.0\nuncorrelated_bernoulli 50\ncutoff 0.044407395527043314\npower 1.0\ncutoff 0.04256324586464888\npower 1.0\ncutoff 0.041557788649216665\npower 1.0\ncutoff 0.04520419417748078\npower 1.0\ncutoff 0.044127585073460485\npower 1.0\n1.0\nuncorrelated_bernoulli 55\ncutoff 0.04172350657660007\npower 1.0\ncutoff 0.04042630514267942\npower 1.0\ncutoff 0.04106038474751794\npower 1.0\ncutoff 0.039972588905059725\npower 1.0\ncutoff 0.03809226139879707\npower 1.0\n1.0\nuncorrelated_bernoulli 60\ncutoff 0.03810110209547701\npower 1.0\ncutoff 0.036286793448326415\npower 1.0\ncutoff 0.034116839897411766\npower 1.0\ncutoff 0.03554783329760758\npower 1.0\ncutoff 0.03429547059801619\npower 1.0\n1.0\nuncorrelated_bernoulli 65\ncutoff 0.032203712118296424\npower 1.0\ncutoff 0.03182877691331887\npower 1.0\ncutoff 0.03239143044971737\npower 1.0\ncutoff 0.030541547274574588\npower 1.0\ncutoff 0.03329259084779379\npower 1.0\n1.0\nuncorrelated_bernoulli 70\ncutoff 0.02985182324796376\npower 1.0\ncutoff 0.02965028950901727\npower 1.0\ncutoff 0.03051231612860139\npower 1.0\ncutoff 0.0330143679599576\npower 1.0\ncutoff 0.030835981650612077\npower 1.0\n1.0\nuncorrelated_bernoulli 75\ncutoff 0.030354350560295673\npower 1.0\ncutoff 0.027097810974015868\npower 1.0\ncutoff 0.03034717614325355\npower 1.0\ncutoff 0.030171353849426152\npower 1.0\ncutoff 0.028772026809892437\npower 1.0\n1.0\nuncorrelated_bernoulli 80\ncutoff 0.026595892322450743\npower 1.0\ncutoff 0.02606448820160212\npower 1.0\ncutoff 0.027377134201532316\npower 1.0\ncutoff 0.023654534172504738\npower 1.0\ncutoff 0.025663195430885688\npower 1.0\n1.0\nuncorrelated_bernoulli 85\ncutoff 0.02770360489519763\npower 1.0\ncutoff 0.02440095196758041\npower 1.0\n"
        }
      ],
      "execution_count": 34,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1675551617355
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "POWER = np.load(\"POWER_1D_multi_cutoff_0130exponential.npy\")\n",
        "plt.plot (sample_size,alpha,c = 'r',linestyle='--',label = \"alpha = 0.05\")\n",
        "plt.plot(sample_size,POWER,label = \"power\")\n",
        "plt.yticks(np.arange(0,1.1,0.1))\n",
        "plt.xticks(np.arange(0,110,10))\n",
        "plt.title(\"Statistical Power for Linear Simulation with 100 trees (Incresing Sample Size)\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 640x480 with 1 Axes>",
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAApUAAAGzCAYAAAB+TOwRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABktklEQVR4nO3dd1gU1/s28HtZYBdEQKQp0sSCWEBBCCqCEYOKLcYaExFbiiYafppIjGKJolGjftXEEktiNPYYY41iiQVFsURj7yUCYgFBBWXP+4cvExcWBAdZ2Nyf65pL98yZmWdmpzzMnDmrEEIIEBERERHJYKTvAIiIiIio/GNSSURERESyMakkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZCuXSWVISAhCQkJKbH5ubm7o06dPic0vL4VCgTFjxry2+ZcXW7duhY+PD9RqNRQKBR48eKDXeK5evQqFQoElS5boNY7SoM99sE+fPnBzcyvReS5ZsgQKhQJXr14t0fm+Lrt374ZCocDu3buLXHfNmjWvPzAqshs3bkCtVmP//v36DqXEvY5j9L9An+ehks6DXnT69GkYGxvj1KlTxZ622EnlyZMn0aVLF7i6ukKtVsPJyQmtWrXCrFmztOpNnDgR69evL3ZAuU6fPo0xY8aU2Jd14MABjBkzRu+JTEFyE5zcQalUwsXFBW+//TaOHz+u7/Bku3v3Lrp16wYzMzPMmTMHS5cuRYUKFV7b8nIP9iNHjry2ZZQF+/btQ5s2beDk5AS1Wg0XFxe0b98ey5cv13doJULueaQsW758OWbMmFHi883IyEBMTAxat24NGxubl/7hdObMGbRu3RoWFhawsbHB+++/jzt37uSrp9Fo8M0338Dd3R1qtRoNGjTAL7/8UqSYNm/eXO7/sB43bhwCAgLQtGlTqaxPnz6wsLDQY1Tln0ajwU8//YSAgADY2NigYsWKqFWrFnr37o2DBw/qO7xSd/XqVURGRsLDwwNqtRqOjo5o3rw5YmJiSi0GLy8vhIeHY/To0cWfWBTD/v37hampqahRo4YYP368WLBggRg9erR46623hIeHh1bdChUqiIiIiOLMXsvq1asFALFr165847KyskRWVlax5jdlyhQBQFy5ciXfuCdPnojs7OxXjPTlAIiYmJhC61y5ckUAED179hRLly4VS5YsEV988YWwtLQUKpVKHDt27LXFVxq2bNkiAIjt27eXyvIWL14sAIjDhw8XWEej0YjHjx+LZ8+elUpMJW3VqlVCoVCIhg0bismTJ4v58+eL6Oho0bRpUxESEqJV9/Hjx+Lp06d6iTMiIkK4urq+0rQFnUeePXsmHj9+LDQajbzgSklOTo54/PixyMnJkcrCw8N1bpddu3YJAGL16tWvtKzcc4mLi4sICQkRAMTixYt11r1x44awtbUVHh4eYubMmWLChAmiUqVKwtvbO985dsSIEQKAGDBggJg/f74IDw8XAMQvv/zy0pgGDRokinm5KVNSUlKEiYmJWL58uVZ5RESEqFChgp6iKjnZ2dniyZMnell27r7RsWNHMXPmTDFnzhzx6aefipo1a770uqlvudcZXXnFq7hw4YKwtrYWVapUESNHjhQLFiwQ48aNE506dRIqlUqr7qvkQcWxefNmAUBcvHixWNMZFycBnTBhAqysrHD48GFYW1trjUtJSSl+RvuKTE1NS3R+KpWqROcnR6NGjfDee+9Jn5s2bYoOHTrg+++/x7x58/QY2cs9evQI5ubmOsfl7h959xs5MjMzZd3tVCgUUKvVJRbP61DYNh0zZgy8vLxw8ODBfMdE3uOxrK9ncSmVSiiVSn2HUWRGRkal9h1UqVIFt2/fhqOjI44cOYLGjRsXWHfixInIzMxEYmIiXFxcAAD+/v5o1aoVlixZgoEDBwIAbt26hWnTpmHQoEGYPXs2AKB///4IDg7G8OHD0bVr1xL7Pp49ewaNRlPi53k5fv75ZxgbG6N9+/b6DgVPnjyBqakpjIxKrvWaiYlJic2rOJKTk/Hdd99hwIABmD9/vta4GTNm6LxjbsimT5+OjIwMHD9+HK6urlrj8p7TX/fxERoaikqVKuHHH3/EuHHjijxdsfbKS5cuoW7dujoTA3t7e+n/CoUCmZmZ+PHHH6XHubltFq9du4aPP/4YtWvXhpmZGSpXroyuXbtqPeZesmQJunbtCgBo0aKFNI/c9ki62hLMmjULdevWhbm5OSpVqgQ/Pz/pEeCYMWMwfPhwAIC7u7s0v9xl6mpT+eDBA3z22Wdwc3ODSqVCtWrV0Lt3b6SmpgIAsrOzMXr0aPj6+sLKygoVKlRAUFAQdu3aVZxN+lJvvvkmAODKlStS2erVq+Hr6wszMzPY2trivffew61bt6TxGzZsgEKhwF9//SWVrV27FgqFAp07d9aaf506ddC9e3etsp9//lmav42NDXr06IEbN25o1QkJCUG9evWQmJiI5s2bw9zcHF9++aXOdQgJCUFERAQAoHHjxlr7Q1HWB/j3MdOlS5fQtm1bVKxYEb169XrZ5iuUrjaVucu5desWOnXqBAsLC9jZ2WHYsGHIycnRml6j0WDGjBmoW7cu1Go1HBwc8MEHH+D+/fta9X777TeEh4ejatWqUKlU8PDwwPjx4/PNrzjbFHh+PDZu3FjnyeXF4xHI36ZyzJgxUCgUOH/+PN577z1YWVnBzs4Oo0aNghACN27cQMeOHWFpaQlHR0dMmzZNa34FtSUqatvBqVOnokmTJqhcuTLMzMzg6+ubrw1hYeeRgpb/3XffoW7dulCpVKhatSoGDRqUr8lL7nY+ffo0WrRoAXNzczg5OeGbb74pNGYA6Ny5Mxo1aqRV1r59eygUCmzYsEEqO3ToEBQKBbZs2aJzu4SEhGDTpk24du2atG5527RpNBpMmDAB1apVg1qtRsuWLXHx4sWXxqhSqeDo6PjSesDz80K7du2khBJ4fjGpVasWVq1aJZX99ttvePr0KT7++GOpTKFQ4KOPPsLNmzcRHx9f4DL69OmDOXPmSNPkDsC/x+DUqVMxY8YMeHh4QKVS4fTp0wCAs2fPokuXLrCxsYFarYafn5/Wds714MEDDB06FM7OzlCpVKhRowYmT54MjUajVW/FihXw9fVFxYoVYWlpifr162PmzJkv3U7r169HQEBAkR51u7m5oV27dti3bx/8/f2hVqtRvXp1/PTTTzrjLuw6k7vfrFixAl999RWcnJxgbm6O9PR0AM/3s9atW8PKygrm5uYIDg7O1+bz4cOHGDp0qLQMe3t7tGrVCkePHpXq5G1T+eL3Mn/+fOl7ady4MQ4fPpxvPVavXg0vLy+o1WrUq1cPv/76a5HaaV65cgVCCK0mBbkUCoXWeezevXsYNmwY6tevDwsLC1haWqJNmzY4ceKE1nS522zVqlUYO3YsnJycULFiRXTp0gVpaWnIysrC0KFDYW9vDwsLC0RGRiIrKyvfsgcPHoxly5ahdu3aUKvV8PX1xZ9//lno+uTasmULgoKCUKFCBVSsWBHh4eH4+++/XzrdpUuXUK1atXwJJZD/nJ43D3Jzc9M6vl4cXjwf37p1C3379oWDgwNUKhXq1q2LRYsW5VueiYkJQkJC8NtvvxVpnXMV606lq6sr4uPjcerUKdSrV6/AekuXLkX//v3h7+8v/aXr4eEBADh8+DAOHDiAHj16oFq1arh69Sq+//57hISE4PTp0zA3N0fz5s3x6aef4n//+x++/PJL1KlTBwCkf/NasGABPv30U3Tp0gVDhgzBkydP8Ndff+HQoUN499130blzZ5w/fx6//PILpk+fDltbWwCAnZ2dzvllZGQgKCgIZ86cQd++fdGoUSOkpqZiw4YNuHnzJmxtbZGeno4ffvgBPXv2xIABA/Dw4UMsXLgQYWFhSEhIgI+PT3E2bYEuXboEAKhcuTKA5xfTyMhING7cGLGxsUhOTsbMmTOxf/9+HDt2DNbW1mjWrBkUCgX+/PNPNGjQAACwd+9eGBkZYd++fdK879y5g7Nnz2Lw4MFS2YQJEzBq1Ch069YN/fv3x507dzBr1iw0b95cmn+uu3fvok2bNujRowfee+89ODg46FyHkSNHonbt2pg/fz7GjRsHd3d3aX8oyvrkevbsGcLCwtCsWTNMnTq1wDt4cuXk5CAsLAwBAQGYOnUqduzYgWnTpsHDwwMfffSRVO+DDz6Q4v/0009x5coVzJ49G8eOHcP+/fulv/6XLFkCCwsLREVFwcLCAjt37sTo0aORnp6OKVOmaC27qNsUeH48xsXF4ebNm6hWrdorrWv37t1Rp04dTJo0CZs2bcLXX38NGxsbzJs3D2+++SYmT56MZcuWYdiwYWjcuDGaN2/+SsvJa+bMmejQoQN69eqF7OxsrFixAl27dsXGjRsRHh4OoPDziC5jxozB2LFjERoaio8++gjnzp3D999/j8OHD2t9HwBw//59tG7dGp07d0a3bt2wZs0afPHFF6hfvz7atGlT4DKCgoLw22+/IT09HZaWlhBCYP/+/TAyMsLevXvRoUMHAP8eb7oulsDzYyItLQ03b97E9OnTASBfwjJp0iQYGRlh2LBhSEtLwzfffINevXrh0KFDRdjCL3fr1i2kpKTAz88v3zh/f39s3rxZ+nzs2DFUqFAh3znY399fGt+sWTOdy/nggw/wzz//YPv27Vi6dKnOOosXL8aTJ08wcOBAqFQq2NjY4O+//0bTpk3h5OSEESNGoEKFCli1ahU6deqEtWvX4u233wbw/G5+cHAwbt26hQ8++AAuLi44cOAAoqOjcfv2band6vbt29GzZ0+0bNkSkydPBvC8Pen+/fsxZMiQArfT06dPcfjwYa1j/2UuXryILl26oF+/foiIiMCiRYvQp08f+Pr6om7dugCKdp3JNX78eJiammLYsGHIysqCqakpdu7ciTZt2sDX1xcxMTEwMjLC4sWL8eabb2Lv3r3Sd/Phhx9izZo1GDx4MLy8vHD37l3s27cPZ86cyfcHUl7Lly/Hw4cP8cEHH0ChUOCbb75B586dcfnyZel42rRpE7p374769esjNjYW9+/fR79+/eDk5PTS7ZSbPK1evRpdu3Yt9Jx++fJlrF+/Hl27doW7uzuSk5Mxb948BAcH4/Tp06hatapW/djYWJiZmWHEiBG4ePEiZs2aBRMTExgZGeH+/fsYM2YMDh48iCVLlsDd3T1f+8E9e/Zg5cqV+PTTT6FSqfDdd9+hdevWSEhIeGn+ExERgbCwMEyePBmPHj3C999/j2bNmuHYsWOFJtqurq7YsWMHdu7cKd1QKqoZM2YgIyNDq2z69Ok4fvy4lD8kJyfjjTfekJJmOzs7bNmyBf369UN6ejqGDh2qNb2vr6/W+a5IivOs/I8//hBKpVIolUoRGBgoPv/8c7Ft2zad7RELagv16NGjfGXx8fECgPjpp5+kssLaVAYHB4vg4GDpc8eOHUXdunULjb2wNpWurq5asY4ePVoAEOvWrctXN7cN17Nnz/K1Z7h//75wcHAQffv21SpHMdpUjh07Vty5c0ckJSWJ3bt3i4YNGwoAYu3atSI7O1vY29uLevXqicePH0vTbty4UQAQo0ePlsrq1q0runXrJn1u1KiR6Nq1qwAgzpw5I4QQYt26dQKAOHHihBBCiKtXrwqlUikmTJigFdvJkyeFsbGxVnlwcLAAIObOnVvoeuXS1caxOOsTEREhAIgRI0a88vLyyt3mL7Y3y13OuHHjtOo2bNhQ+Pr6Sp/37t0rAIhly5Zp1du6dWu+cl37/AcffCDMzc212jEVd5suXLhQABCmpqaiRYsWYtSoUWLv3r1a7fZy5d0HY2JiBAAxcOBAqezZs2eiWrVqQqFQiEmTJknl9+/fF2ZmZlrHSEFtiXLbA7543OpqU5l3m2RnZ4t69eqJN998U6u8oPNI3uWnpKQIU1NT8dZbb2mt/+zZswUAsWjRIqksdzu/eL7JysoSjo6O4p133sm3rBcdPnxYABCbN28WQgjx119/CQCia9euIiAgQKrXoUMH0bBhw0K3y8vaVNapU0frHDNz5kwBQJw8ebLQGHXFq6tNZe64F7dDruHDhwsA0v4ZHh4uqlevnq9eZmZmkY7LgtpU5h6DlpaWIiUlRWtcy5YtRf369bWOEY1GI5o0aSJq1qwplY0fP15UqFBBnD9/Xmv6ESNGCKVSKa5fvy6EEGLIkCHC0tKy2G2oL168KACIWbNm5Runq02lq6urACD+/PNPqSwlJUWoVCrxf//3f1JZUa4zuftC9erVtY4ZjUYjatasKcLCwrTaFT969Ei4u7uLVq1aSWVWVlZi0KBBha5j3mM093upXLmyuHfvnlT+22+/CQDi999/l8rq168vqlWrJh4+fCiV7d69WwAoUlvq3r17CwCiUqVK4u233xZTp06VrlEvevLkSb5z25UrV4RKpdI6X+dus3r16mnlJj179hQKhUK0adNGax6BgYH54gQgAIgjR45IZdeuXRNqtVq8/fbbUlne89DDhw+FtbW1GDBggNb8kpKShJWVVb7yvE6dOiXMzMwEAOHj4yOGDBki1q9fLzIzM/PVzZsH5bVq1ap817J+/fqJKlWqiNTUVK26PXr0EFZWVvnOy8uXLxcAxKFDhwqN+0XFevzdqlUrxMfHo0OHDjhx4gS++eYbhIWFwcnJSecjCV3MzMyk/z99+hR3795FjRo1YG1trXU7vjisra1x8+ZNnbflX8XatWvh7e0t/SX8otzHNkqlUnrsqNFocO/ePTx79gx+fn6vvB4AEBMTAzs7Ozg6OiIkJASXLl3C5MmT0blzZxw5cgQpKSn4+OOPtdpnhYeHw9PTE5s2bZLKgoKCsHfvXgDPH3+cOHECAwcOhK2trVS+d+9eWFtbS391rVu3DhqNBt26dUNqaqo0ODo6ombNmvke7atUKkRGRr7yuhZnfXIV526BHB9++KHW56CgIFy+fFn6vHr1alhZWaFVq1Za28rX1xcWFhZa2+rFff7hw4dITU1FUFAQHj16hLNnz2otpzjbtG/fvti6dStCQkKwb98+jB8/HkFBQahZsyYOHDhQpHn0799f+r9SqYSfnx+EEOjXr59Ubm1tjdq1a2utv1wvbpP79+8jLS0NQUFBr3zs7NixA9nZ2Rg6dKhWW7MBAwbA0tIy375kYWGh1XbZ1NQU/v7+L13Hhg0bwsLCQnoMtnfvXumR5dGjR/Ho0SMIIbBv3z4EBQW90rrkioyM1GrakDu/kvoeHj9+DEB3m/Lc4zG3zuPHj4tU71W98847Wk+O7t27h507d6Jbt27SMZOamoq7d+8iLCwMFy5ckJrIrF69GkFBQahUqZLWsRgaGoqcnBzpu7K2tkZmZia2b99erNju3r0LAKhUqVKRp/Hy8tL6/u3s7PIdQ0W5zuSKiIjQOmaOHz+OCxcu4N1338Xdu3eldc7MzETLli3x559/So/+ra2tcejQIfzzzz9Fjj9X9+7dtdY77z74zz//4OTJk+jdu7fWnfbg4GDUr1+/SMtYvHgxZs+eDXd3d/z6668YNmwY6tSpg5YtW2o1g1KpVNKxnZOTg7t378LCwgK1a9fWed7o3bu31tOJgIAACCHQt29frXoBAQG4ceMGnj17plUeGBgIX19f6bOLiws6duyIbdu25Wu6lGv79u148OABevbsqbUvKpVKBAQEvLR5XN26dXH8+HG89957uHr1KmbOnIlOnTrBwcEBCxYsKHTaF50+fRp9+/ZFx44d8dVXXwEAhBBYu3Yt2rdvDyGEVnxhYWFIS0vLtx1zv/vc5hhFUeyWvo0bN8a6detw//59JCQkIDo6Gg8fPkSXLl2kdjCFefz4MUaPHi21fbG1tYWdnR0ePHiAtLS04oYDAPjiiy9gYWEBf39/1KxZE4MGDZLVl9ilS5cKvb2d68cff0SDBg2gVqtRuXJl2NnZYdOmTa+8HgAwcOBAbN++HXFxcUhMTERKSgo+//xzAM/bowJA7dq1803n6ekpjQeeH/y3b9/GxYsXceDAASgUCgQGBmolm3v37kXTpk2lA/XChQsQQqBmzZqws7PTGs6cOZOvobCTk5OsxsLFWR8AMDY2fuXHvMWhVqvzNY2oVKmSVlvJCxcuIC0tDfb29vm2VUZGhta2+vvvv/H222/DysoKlpaWsLOzkxKavPtKcbdpWFgYtm3bhgcPHuDPP//EoEGDcO3aNbRr165IL8+92JYOAKysrKBWq7UeveWW520rKsfGjRvxxhtvQK1Ww8bGBnZ2dvj+++9f+dgpaF8yNTVF9erV8+1L1apVy3fhzvsd66JUKhEYGKh1DAUFBaFZs2bIycnBwYMHcfr0ady7d092Upn3u8k9wZfU95CbpORtTwY8fxnkxTpmZmZFqveq3N3dtT5fvHgRQgiMGjUq3/GV27VK7v594cIFbN26NV+90NBQrXoff/wxatWqhTZt2qBatWrSH2VFJYQoct283x2Qf/8q6nUGyL99Lly4AOB5spl3vX/44QdkZWVJx9I333yDU6dOwdnZGf7+/hgzZkyR/zB52T6Ye1zVqFEj37S6ynQxMjLCoEGDkJiYiNTUVPz2229o06YNdu7ciR49ekj1NBoNpk+fjpo1a2rlDn/99ZfO84aucxsAODs75yvXaDT55lGzZs1886xVqxYePXpU4AtEud/Lm2++me97+eOPP4p0Tq5VqxaWLl2K1NRU/PXXX5g4cSKMjY0xcOBA7Nix46XTp6eno3PnznBycsJPP/0knefu3LmDBw8eYP78+fliy72RkTe+3H0+77myMMVqU/kiU1NTNG7cGI0bN0atWrUQGRmJ1atXv7QvpU8++QSLFy/G0KFDERgYCCsrKygUCvTo0SNfo+qiqlOnDs6dO4eNGzdi69atWLt2Lb777juMHj0aY8eOfaV5vszPP/+MPn36oFOnThg+fDjs7e2hVCoRGxsrtYN8FTVr1pROhnLktm/6888/cfnyZTRq1Eh6meh///sfMjIycOzYMUyYMEGaRqPRSC8X6HqTM2+bL7kXkuJ68S/V16kob7FqNBrY29tj2bJlOsfnJqUPHjxAcHAwLC0tMW7cOKnvsaNHj+KLL77It8+/6jY1NzdHUFAQgoKCYGtri7Fjx2LLli3SC1IF0bWuBa3/ixfVgk4yBf0F/6LctofNmzfHd999hypVqsDExASLFy8utf41i7KOBWnWrBkmTJiAJ0+eYO/evRg5cqR0x3/v3r1SO1i5SaWcGIuiSpUqAIDbt2/nG3f79m3Y2NhIdyerVKmCXbt2QQih9d3nTpu3PVtx5d3vc4+LYcOGISwsTOc0uUmLRqNBq1atpD++86pVqxaA5y86HD9+HNu2bcOWLVuwZcsWLF68GL1798aPP/5YYGy57dGKk8yX9HdX0PaZMmVKge33c8/X3bp1Q1BQEH799Vf88ccfmDJlCiZPnox169YV2n4YeP37YF6VK1dGhw4d0KFDB4SEhGDPnj24du0aXF1dMXHiRIwaNQp9+/bF+PHjYWNjAyMjIwwdOlRn7lBQ7K9znXLjWLp0qc6X5YyNi55yKZVK1K9fH/Xr10dgYCBatGiBZcuWvTQ/6NOnD/755x8kJCRotYPMje29994r8LqQ+w5Grtx9Pu9NhsK8clL5otyG3i+enAq66KxZswYRERFab5M+efIk3xuaxcmMAaBChQro3r07unfvjuzsbHTu3BkTJkxAdHS09AsuReXh4fHSnuTXrFmD6tWrY926dVrzfp0dlOY2aj537ly+Rrznzp3TemPMxcUFLi4u2Lt3Ly5fvixd4Jo3b46oqCisXr0aOTk5Wi9eeHh4QAgBd3d36UT8OhVnfcoaDw8P7NixA02bNi00Edy9ezfu3r2LdevWaW3rF9/mL2m6jseSlnvHIu9xm/eOoC5r166FWq3Gtm3btB6pLl68OF/doh63L+5L1atXl8qzs7Nx5cqVEvlDLVdQUBCys7Pxyy+/4NatW1rHVm5SWatWrUJfsgKKf44raU5OTrCzs9P5AwF5Xzb08fHBDz/8gDNnzsDLy0sqz31p6GUvJhZ3XXO/QxMTk5d+dx4eHsjIyCjSd2xqaor27dujffv20Gg0+PjjjzFv3jyMGjWqwDtrLi4uMDMzK/FjtijXmcKmBQBLS8sirXeVKlXw8ccf4+OPP0ZKSgoaNWqECRMmvDSpfJnc405XrwRF6amgMH5+ftizZw9u374NV1dXrFmzBi1atMDChQu16j148KBYSU9R5d51fNH58+dhbm5e4Eu+ud+Lvb19iZ5zinpOnzRpEtavX49169bB09NTa5ydnR0qVqyInJycIsd25coVGBkZFSsfKNZtn9y/VPPKfUvwxUdPFSpU0PnrNUqlMt88Zs2ale8OR27/g0X5BZzcNi+5TE1N4eXlBSEEnj59Wuz5vfPOOzhx4gR+/fXXfONyY8/9a+fFdTl06FChXWvI5efnB3t7e8ydO1frUdSWLVtw5swZ6a3ZXEFBQdi5cycSEhKkC5+Pjw8qVqyISZMmSV255OrcuTOUSiXGjh2b7zsSQuTbzqW9PmVJt27dkJOTg/Hjx+cb9+zZM2k/07WfZGdn47vvvpMdQ1xcnM5yXcdjScs9eb7YxUZOTk6+vuZ0USqVUCgUWsf81atXdf5yTkHnkbxCQ0NhamqK//3vf1rbeuHChUhLSyvRfSkgIAAmJiaYPHkybGxspLd5g4KCcPDgQezZs6dIdykrVKggq6lMSXjnnXewceNGrS7D4uLicP78ealbNwDo2LEjTExMtPZbIQTmzp0LJycnNGnSpNDlFOf8Czy/KIeEhGDevHk6L6QvPn7s1q0b4uPjsW3btnz1Hjx4ILWVy3v+MjIyku7M6Hq0n8vExAR+fn4l/utcRbnOFMTX1xceHh6YOnVqvjd+gX+3T05OTr59zN7eHlWrVi10nYuqatWqqFevHn766SetOPbs2YOTJ0++dPqkpCSdzeays7MRFxcHIyMjKdnXlTusXr06X/dzJSU+Pl6rjeGNGzfw22+/4a233irwbmdYWBgsLS0xceJEKfd40cv63dy7d6/O6YpyTt+xYwe++uorjBw5Ep06dco3XqlU4p133sHatWt1/jGjK7bExETUrVtXajpQFMW6U/nJJ5/g0aNHePvtt+Hp6Yns7GwcOHAAK1euhJubm9YLBr6+vtixYwe+/fZbVK1aFe7u7ggICEC7du2wdOlSWFlZwcvLC/Hx8dixY4f0iCGXj48PlEolJk+ejLS0NKhUKrz55pv5+moCgLfeeguOjo5o2rQpHBwccObMGcyePRvh4eGoWLGiFA/wvCuPHj16wMTEBO3bt9fZefbw4cOxZs0adO3aFX379oWvry/u3buHDRs2YO7cufD29ka7du2wbt06vP322wgPD8eVK1cwd+5ceHl56TzIS0LuhSwyMhLBwcHo2bOn1AWPm5sbPvvsM636QUFBWLZsGRQKhfQ4XKlUokmTJti2bRtCQkK02u95eHjg66+/RnR0NK5evYpOnTqhYsWKuHLlCn799VcMHDgQw4YN09v6vIpFixbpbDdVWBciRREcHIwPPvgAsbGxOH78ON566y2YmJjgwoULWL16NWbOnIkuXbqgSZMmqFSpEiIiIvDpp59CoVBg6dKlJfKopWPHjnB3d0f79u3h4eGBzMxM7NixA7///jsaN278Wjtqrlu3Lt544w1ER0fj3r17sLGxwYoVK/I1dtclPDwc3377LVq3bo13330XKSkpmDNnDmrUqKHVtypQ8HkkLzs7O0RHR2Ps2LFo3bo1OnTogHPnzuG7775D48aNtV7Kkcvc3By+vr44ePCg1Ecl8PxOZWZmJjIzM4uUVPr6+mLlypWIiopC48aNYWFhUWLf2ezZs/HgwQPp5Yzff/8dN2/eBPD8PJ57kfjyyy+xevVqtGjRAkOGDEFGRgamTJmC+vXra53Pq1WrhqFDh2LKlCl4+vQpGjdujPXr12Pv3r1YtmzZS5uM5J5/P/30U4SFhUGpVGq1l9Nlzpw5aNasGerXr48BAwagevXqSE5ORnx8PG7evCn1Tzh8+HBs2LAB7dq1k7rtyczMxMmTJ7FmzRpcvXoVtra26N+/P+7du4c333wT1apVw7Vr1zBr1iz4+PgU2F1dro4dO2LkyJHF61rlJYpynSmIkZERfvjhB7Rp0wZ169ZFZGQknJyccOvWLezatQuWlpb4/fff8fDhQ1SrVg1dunSBt7c3LCwssGPHDhw+fDhf37OvauLEiejYsSOaNm2KyMhI3L9/H7Nnz0a9evVeei28efMm/P398eabb6Jly5ZwdHRESkoKfvnlF5w4cQJDhw6V7kK2a9cO48aNQ2RkJJo0aYKTJ09i2bJlWk8mSlK9evUQFham1aUQgEKb1FlaWuL777/H+++/j0aNGqFHjx6ws7PD9evXsWnTJjRt2lT68QBdJk+ejMTERHTu3Fn6g+fo0aP46aefYGNjk6/Lnxf17NkTdnZ2qFmzJn7++Wetca1atYKDgwMmTZqEXbt2ISAgAAMGDICXlxfu3buHo0ePYseOHbh37540zdOnT7Fnzx6tvmmLpMjviYvnP7XXt29f4enpKSwsLKSfbPzkk09EcnKyVt2zZ8+K5s2bS6/H53YLcv/+fREZGSlsbW2FhYWFCAsLE2fPns3XrY8QQixYsEBUr15dKJVKre448r5KP2/ePNG8eXNRuXJloVKphIeHhxg+fLhIS0vTmt/48eOFk5OTMDIy0uoGQNey7969KwYPHiycnJyEqampqFatmoiIiJBexddoNGLixInC1dVVqFQq0bBhQ7Fx40ad3aegGF0KTZkypdB6QgixcuVK0bBhQ6FSqYSNjY3o1auXuHnzZr56f//9t9Q1yYu+/vprAUCMGjVK5/zXrl0rmjVrJipUqCAqVKggPD09xaBBg8S5c+ekOsHBwS/txulFhXXxU5T1Ke7PoeUur6Dhxo0bBXYppGs5uV3w5DV//nzh6+srzMzMRMWKFUX9+vXF559/Lv755x+pzv79+8Ubb7whzMzMRNWqVaWuuF7cp4Uo/jb95ZdfRI8ePYSHh4cwMzMTarVaeHl5iZEjR4r09HStunn3wdz1uXPnjla9gtZfV2yXLl0SoaGhQqVSCQcHB/Hll1+K7du3F6lLoYULF4qaNWsKlUolPD09xeLFi3Vu44LOIwV1aTR79mzh6ekpTExMhIODg/joo4/E/fv3X7ouBcVZkNwudyZPnqxVXqNGDQFAXLp0SatcV5dCGRkZ4t133xXW1tZa3a8U9DONuvbXguR2a6NryLvNTp06Jd566y1hbm4urK2tRa9evURSUlK+eebk5EjnPFNTU1G3bl3x888/vzQWIZ53V/XJJ58IOzs7oVAopO/5Zee9S5cuid69ewtHR0dhYmIinJycRLt27cSaNWu06j18+FBER0eLGjVqCFNTU2FrayuaNGkipk6dKnUrs2bNGvHWW28Je3t7YWpqKlxcXMQHH3wgbt++/dL4k5OThbGxsVi6dKlWeUFdCoWHh+ebh64uYF52nXnZT3YeO3ZMdO7cWbr2ubq6im7duom4uDghxPOusoYPHy68vb1FxYoVRYUKFYS3t7f47rvv8q2Hri6FdH0vuq5nK1asEJ6enkKlUol69eqJDRs2iHfeeUd4enrqjDtXenq6mDlzpggLCxPVqlUTJiYmomLFiiIwMFAsWLBAq7ukJ0+eiP/7v/8TVapUEWZmZqJp06YiPj4+33YtaJsVdA3SdS4EIAYNGiR+/vln6TzVsGHDfF0cFta1WlhYmLCyshJqtVp4eHiIPn36aHVRpMv+/fvFoEGDRL169YSVlZUwMTERLi4uok+fPvnOKXnXu7Dr3YtxJycni0GDBglnZ2dhYmIiHB0dRcuWLcX8+fO15p/708oXLlwoNOa8FP8/GCIiIipAv379cP78eenNfyqcj48P7Ozsit2FU1mgUCi0fpL0v6hTp05QKBQ6m2cU5vW/SktERFTOxcTESL/ORP96+vRpvmYvu3fvxokTJ/L9nDKVD2fOnMHGjRt1vjPwMiXy9jcREZEhc3FxkfrlpH/dunULoaGheO+991C1alWcPXsWc+fOhaOjY74fkaDyoU6dOkVqH68Lk0oiIiJ6JZUqVYKvry9++OEH3LlzBxUqVEB4eDgmTZqU7wVcMnxsU0lEREREsrFNJRERERHJxqSSiIiIiGRjm8oSotFo8M8//6BixYp6//k1IiIiKhohBB4+fIiqVavCyIj32uRgUllC/vnnHzg7O+s7DCIiInoFN27cQLVq1fQdRrnGpLKE5P4c5I0bN0rsZ7yIiIjo9UpPT4ezs7N0HadXx6SyhOQ+8ra0tGRSSUREVM6w6Zp8bDxARERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDYmlUREREQkG5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2Qwyqfzzzz/Rvn17VK1aFQqFAuvXr3/pNLt370ajRo2gUqlQo0YNLFmy5LXHSURERGQoDDKpzMzMhLe3N+bMmVOk+leuXEF4eDhatGiB48ePY+jQoejfvz+2bdv2miMlIiIiMgzG+g7gdWjTpg3atGlT5Ppz586Fu7s7pk2bBgCoU6cO9u3bh+nTpyMsLEznNFlZWcjKypI+p6enywtaT4QQ2HIqCXsv3IEQ+o6GiIioYB28q6JJDVt9h0EFMMiksrji4+MRGhqqVRYWFoahQ4cWOE1sbCzGjh37miN7vS7dycDo305h/8W7+g6FiIjopTwdKzKpLMOYVAJISkqCg4ODVpmDgwPS09Px+PFjmJmZ5ZsmOjoaUVFR0uf09HQ4Ozu/9lhLwpOnOZiz6yLm7bmM7BwNTI2N8K6/C2wtTPUdGhERUYEaulTSdwhUCCaVr0ilUkGlUuk7jGLbeTYZMRv+xo17jwEAwbXsMK5jXbhWrqDnyIiIiKg8Y1IJwNHREcnJyVplycnJsLS01HmXsjy69eAxxm74G3+cfr6eVazUiGnvhbC6jlAoFHqOjoiIiMo7JpUAAgMDsXnzZq2y7du3IzAwUE8RlZynORos3HcFM3dcwOOnOTA2UqBfM3d82rImKqj49RMREVHJMMisIiMjAxcvXpQ+X7lyBcePH4eNjQ1cXFwQHR2NW7du4aeffgIAfPjhh5g9ezY+//xz9O3bFzt37sSqVauwadMmfa1CiTh0+S6+Wn8KF1IyAACN3Srh6071Uduxop4jIyIiIkNjkEnlkSNH0KJFC+lz7gs1ERERWLJkCW7fvo3r169L493d3bFp0yZ89tlnmDlzJqpVq4YffvihwO6EyrrUjCxM3HwG647eAgDYVDDFl23r4J1GTnzUTURERK+FQgj2TlgS0tPTYWVlhbS0NFhaWuolhhyNwPKE65iy9SzSnzyDQgH09HfB52G1YW3ON7uJiIjyKgvXb0NhkHcq/4tO3kzDV+tP4sTNNABA3aqW+LpTPXa/QERERKWCSWU5l/b4Kab9cQ5LD16DEEBFlTGGhdXGe2+4QmnER91ERERUOphUllNCCPx2/B98vekMUjOe/1xkR5+qGNm2Duwt1XqOjoiIiP5rmFSWQxdTHuKr9adw8PI9AEB1uwr4umM9/nQVERER6Q2TynLkcXYO/rfzAn7YexlPcwTUJkb45M2a6B/kDpWxUt/hERER0X8Yk8pyYvvpZIzZ8DduPXj+84otPe0xpkNdONuY6zkyIiIiIiaV5cKo9aew9OA1AICTtRnGdKiLVl4Oeo6KiIiI6F9G+g6AXi64lh2MjRT4KMQD26OaM6EkIiKiMod3KsuBUC8H7Pm8BZyszfQdChEREZFOvFNZTjChJCIiorKMSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDYmlUREREQkG5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDaDTSrnzJkDNzc3qNVqBAQEICEhocC6T58+xbhx4+Dh4QG1Wg1vb29s3bq1FKMlIiIiKt8MMqlcuXIloqKiEBMTg6NHj8Lb2xthYWFISUnRWf+rr77CvHnzMGvWLJw+fRoffvgh3n77bRw7dqyUIyciIiIqnxRCCKHvIEpaQEAAGjdujNmzZwMANBoNnJ2d8cknn2DEiBH56letWhUjR47EoEGDpLJ33nkHZmZm+Pnnn4u0zPT0dFhZWSEtLQ2WlpYlsyJERET0WvH6XXIM7k5ldnY2EhMTERoaKpUZGRkhNDQU8fHxOqfJysqCWq3WKjMzM8O+ffsKXE5WVhbS09O1BiIiIqL/KoNLKlNTU5GTkwMHBwetcgcHByQlJemcJiwsDN9++y0uXLgAjUaD7du3Y926dbh9+3aBy4mNjYWVlZU0ODs7l+h6EBEREZUnBpdUvoqZM2eiZs2a8PT0hKmpKQYPHozIyEgYGRW8eaKjo5GWliYNN27cKMWIiYiIiMoWg0sqbW1toVQqkZycrFWenJwMR0dHndPY2dlh/fr1yMzMxLVr13D27FlYWFigevXqBS5HpVLB0tJSayAiIiL6rzK4pNLU1BS+vr6Ii4uTyjQaDeLi4hAYGFjotGq1Gk5OTnj27BnWrl2Ljh07vu5wiYiIiAyCsb4DeB2ioqIQEREBPz8/+Pv7Y8aMGcjMzERkZCQAoHfv3nByckJsbCwA4NChQ7h16xZ8fHxw69YtjBkzBhqNBp9//rk+V4OIiIio3DDIpLJ79+64c+cORo8ejaSkJPj4+GDr1q3SyzvXr1/Xai/55MkTfPXVV7h8+TIsLCzQtm1bLF26FNbW1npaAyIiIqLyxSD7qdQH9nNFRERU/vD6XXIMrk0lEREREZU+JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbAabVM6ZMwdubm5Qq9UICAhAQkJCofVnzJiB2rVrw8zMDM7Ozvjss8/w5MmTUoqWiIiIqHwzyKRy5cqViIqKQkxMDI4ePQpvb2+EhYUhJSVFZ/3ly5djxIgRiImJwZkzZ7Bw4UKsXLkSX375ZSlHTkRERFQ+GWRS+e2332LAgAGIjIyEl5cX5s6dC3NzcyxatEhn/QMHDqBp06Z499134ebmhrfeegs9e/Z86d1NIiIiInrO4JLK7OxsJCYmIjQ0VCozMjJCaGgo4uPjdU7TpEkTJCYmSknk5cuXsXnzZrRt27bA5WRlZSE9PV1rICIiIvqvMtZ3ACUtNTUVOTk5cHBw0Cp3cHDA2bNndU7z7rvvIjU1Fc2aNYMQAs+ePcOHH35Y6OPv2NhYjB07tkRjJyIiIiqvDO5O5avYvXs3Jk6ciO+++w5Hjx7FunXrsGnTJowfP77AaaKjo5GWliYNN27cKMWIiYiIiMoWg7tTaWtrC6VSieTkZK3y5ORkODo66pxm1KhReP/999G/f38AQP369ZGZmYmBAwdi5MiRMDLKn3urVCqoVKqSXwEiIiKicsjg7lSamprC19cXcXFxUplGo0FcXBwCAwN1TvPo0aN8iaNSqQQACCFeX7BEREREBsLg7lQCQFRUFCIiIuDn5wd/f3/MmDEDmZmZiIyMBAD07t0bTk5OiI2NBQC0b98e3377LRo2bIiAgABcvHgRo0aNQvv27aXkkoiIiIgKZpBJZffu3XHnzh2MHj0aSUlJ8PHxwdatW6WXd65fv651Z/Krr76CQqHAV199hVu3bsHOzg7t27fHhAkT9LUKREREROWKQvD5bolIT0+HlZUV0tLSYGlpqe9wiIiIqAh4/S45BtemkoiIiIhKH5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDYmlUREREQkG5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDYmlUREREQkG5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDaDTSrnzJkDNzc3qNVqBAQEICEhocC6ISEhUCgU+Ybw8PBSjJiIiIio/DLIpHLlypWIiopCTEwMjh49Cm9vb4SFhSElJUVn/XXr1uH27dvScOrUKSiVSnTt2rWUIyciIiIqnwwyqfz2228xYMAAREZGwsvLC3PnzoW5uTkWLVqks76NjQ0cHR2lYfv27TA3N2dSSURERFREBpdUZmdnIzExEaGhoVKZkZERQkNDER8fX6R5LFy4ED169ECFChUKrJOVlYX09HStgYiIiOi/yuCSytTUVOTk5MDBwUGr3MHBAUlJSS+dPiEhAadOnUL//v0LrRcbGwsrKytpcHZ2lhU3ERERUXlmcEmlXAsXLkT9+vXh7+9faL3o6GikpaVJw40bN0opQiIiIqKyx1jfAZQ0W1tbKJVKJCcna5UnJyfD0dGx0GkzMzOxYsUKjBs37qXLUalUUKlUsmIlIiIiMhQGd6fS1NQUvr6+iIuLk8o0Gg3i4uIQGBhY6LSrV69GVlYW3nvvvdcdJhEREZFBMbg7lQAQFRWFiIgI+Pn5wd/fHzNmzEBmZiYiIyMBAL1794aTkxNiY2O1plu4cCE6deqEypUr6yNsIiIionLLIJPK7t27486dOxg9ejSSkpLg4+ODrVu3Si/vXL9+HUZG2jdpz507h3379uGPP/7QR8hERERE5ZpCCCH0HYQhSE9Ph5WVFdLS0mBpaanvcIiIiKgIeP0uOQbXppKIiIiISh+TSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJJvBJpVz5syBm5sb1Go1AgICkJCQUGj9Bw8eYNCgQahSpQpUKhVq1aqFzZs3l1K0REREROWbsb4DeB1WrlyJqKgozJ07FwEBAZgxYwbCwsJw7tw52Nvb56ufnZ2NVq1awd7eHmvWrIGTkxOuXbsGa2vr0g+eiIiIqBxSCCGEvoMoaQEBAWjcuDFmz54NANBoNHB2dsYnn3yCESNG5Ks/d+5cTJkyBWfPnoWJickrLTM9PR1WVlZIS0uDpaWlrPiJiIiodPD6XXIM7vF3dnY2EhMTERoaKpUZGRkhNDQU8fHxOqfZsGEDAgMDMWjQIDg4OKBevXqYOHEicnJyClxOVlYW0tPTtQYiIiKi/yqDSypTU1ORk5MDBwcHrXIHBwckJSXpnOby5ctYs2YNcnJysHnzZowaNQrTpk3D119/XeByYmNjYWVlJQ3Ozs4luh5ERERE5YnBJZWvQqPRwN7eHvPnz4evry+6d++OkSNHYu7cuQVOEx0djbS0NGm4ceNGKUZMREREVLYY3Is6tra2UCqVSE5O1ipPTk6Go6OjzmmqVKkCExMTKJVKqaxOnTpISkpCdnY2TE1N802jUqmgUqlKNngiIiq2nJwcPH36VN9hUBmV9/pOr4/BJZWmpqbw9fVFXFwcOnXqBOD5nci4uDgMHjxY5zRNmzbF8uXLodFoYGT0/Obt+fPnUaVKFZ0JJRER6Z8QAklJSXjw4IG+Q6EyztraGo6OjlAoFPoOxaAZXFIJAFFRUYiIiICfnx/8/f0xY8YMZGZmIjIyEgDQu3dvODk5ITY2FgDw0UcfYfbs2RgyZAg++eQTXLhwARMnTsSnn36qz9UgIqJC5CaU9vb2MDc3Z8JA+Qgh8OjRI6SkpAB4/mSSXh+DTCq7d++OO3fuYPTo0UhKSoKPjw+2bt0qvbxz/fp16Y4kADg7O2Pbtm347LPP0KBBAzg5OWHIkCH44osv9LUKRERUiJycHCmhrFy5sr7DoTLMzMwMAJCSkgJ7e3s+Cn+NDLKfSn1gP1dERKXnyZMnuHLlCtzc3KSkgaggjx8/xtWrV+Hu7g61Wq01jtfvksO3v4mIqNziI28qCu4npYNJJRERERHJxqSSiIiIiGRjUklERFSGXL16FQqFAsePHy/yNEuWLIG1tfVri4moKJhUEhER0WuzevVqeHp6Qq1Wo379+ti8efNLp9m9ezcaNWoElUqFGjVqYMmSJVrjx4wZA4VCoTV4enq+pjWgomJSSURERK/FgQMH0LNnT/Tr1w/Hjh1Dp06d0KlTJ5w6darAaa5cuYLw8HC0aNECx48fx9ChQ9G/f39s27ZNq17dunVx+/Ztadi3b9/rXh16CSaVRERkWDIzCx6ePCl63cePi1a3mLZu3YpmzZrB2toalStXRrt27XDp0qUC6+/evRsKhQKbNm1CgwYNoFar8cYbb+hMzLZt24Y6derAwsICrVu3xu3bt6Vxhw8fRqtWrWBrawsrKysEBwfj6NGjxY6/OGbOnInWrVtj+PDhqFOnDsaPH49GjRph9uzZBU4zd+5cuLu7Y9q0aahTpw4GDx6MLl26YPr06Vr1jI2N4ejoKA22travdV3o5ZhUEhGRYbGwKHh45x3tuvb2Bddt00a7rpub7nrFlJmZiaioKBw5cgRxcXEwMjLC22+/DY1GU+h0w4cPx7Rp03D48GHY2dmhffv2Wr95/ujRI0ydOhVLly7Fn3/+ievXr2PYsGHS+IcPHyIiIgL79u3DwYMHUbNmTbRt2xYPHz4scJnLli2DhYVFocPevXsLnD4+Ph6hoaFaZWFhYYiPj5c9zYULF1C1alVUr14dvXr1wvXr1wucJ5UOg/xFHSIiorLqnTyJ7aJFi2BnZ4fTp0+jXr16BU4XExODVq1aAQB+/PFHVKtWDb/++iu6desGAHj69Cnmzp0LDw8PAMDgwYMxbtw4afo333xTa37z58+HtbU19uzZg3bt2ulcZocOHRAQEFDo+jg5ORU4LikpSfo1u1wODg5ISkoq9jTp6el4/PgxzMzMEBAQgCVLlqB27dq4ffs2xo4di6CgIJw6dQoVK1YsNF56fZhUEhGRYcnIKHhc3p/o+/+/Ca2TUZ6HeVevvnJIL7pw4QJGjx6NQ4cOITU1VbpDef369UKTysDAQOn/NjY2qF27Ns6cOSOVmZubSwkl8Px3rlNeWL/k5GR89dVX2L17N1JSUpCTk4NHjx4VeoevYsWKZTJJa/PCXeQGDRogICAArq6uWLVqFfr166fHyP7bmFQSEZFhqVBB/3UL0b59e7i6umLBggWoWrUqNBoN6tWrh+zsbFnzNTEx0fqsUCjw4i8xR0RE4O7du5g5cyZcXV2hUqkQGBhY6HKXLVuGDz74oNDlbtmyBUFBQTrHOTo6Ijk5WassOTkZjo6OBc6voGksLS0L/ElOa2tr1KpVCxcvXiw0Vnq9mFQSERGVkrt37+LcuXNYsGCBlIgV9a3lgwcPwsXFBQBw//59nD9/HnXq1Cnysvfv34/vvvsObdu2BQDcuHEDqamphU4j9/F3YGAg4uLiMHToUKls+/btWndddU2Tt9uhl02TkZGBS5cu4f333y80Vnq9mFQSERGVkkqVKqFy5cqYP38+qlSpguvXr2PEiBFFmnbcuHGoXLkyHBwcMHLkSNja2qJTp05FXnbNmjWxdOlS+Pn5IT09HcOHDy/wzl8uuY+/hwwZguDgYEybNg3h4eFYsWIFjhw5gvnz50t1oqOjcevWLfz0008AgA8//BCzZ8/G559/jr59+2Lnzp1YtWoVNm3aJE0zbNgw6Y7vP//8g5iYGCiVSvTs2fOVYyX5+PY3ERFRKTEyMsKKFSuQmJiIevXq4bPPPsOUKVOKNO2kSZMwZMgQ+Pr6IikpCb///jtMTU2LvOyFCxfi/v37aNSoEd5//318+umnsLe3f9VVKZImTZpg+fLlmD9/Pry9vbFmzRqsX79eq+3o7du3tdp1uru7Y9OmTdi+fTu8vb0xbdo0/PDDDwgLC5Pq3Lx5Ez179kTt2rXRrVs3VK5cGQcPHoSdnd1rXR8qnEK82OCCXll6ejqsrKyQlpYGS0tLfYdDRGTQnjx5gitXrsDd3R1qtVrf4bxWu3fvRosWLXD//n3+FOMrKmx/4fW75PBOJRERERHJxqSSiIiIiGTjizpERERlWEhICNhSjcoD3qkkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREclmsEnlnDlz4ObmBrVajYCAACQkJBRYd8mSJVAoFFqDof9CAxEREVFJMsikcuXKlYiKikJMTAyOHj0Kb29vhIWFISUlpcBpLC0tcfv2bWm4du1aKUZMREREVL4ZZFL57bffYsCAAYiMjISXlxfmzp0Lc3NzLFq0qMBpFAoFHB0dpcHBwaEUIyYiIiobsrOz9R0ClVMGl1RmZ2cjMTERoaGhUpmRkRFCQ0MRHx9f4HQZGRlwdXWFs7MzOnbsiL///rvQ5WRlZSE9PV1rICIi/RFC4FH2M70MxfnFm5CQEAwePBiDBw+GlZUVbG1tMWrUKGke9+/fR+/evVGpUiWYm5ujTZs2uHDhgrSOdnZ2WLNmjTQ/Hx8fVKlSRfq8b98+qFQqPHr0CADw4MED9O/fH3Z2drC0tMSbb76JEydOSPXHjBkDHx8f/PDDD3B3d2fzL3plBvczjampqcjJycl3p9HBwQFnz57VOU3t2rWxaNEiNGjQAGlpaZg6dSqaNGmCv//+G9WqVdM5TWxsLMaOHVvi8RMR0at5/DQHXqO36WXZp8eFwdy06JfUH3/8Ef369UNCQgKOHDmCgQMHwsXFBQMGDECfPn1w4cIFbNiwAZaWlvjiiy/Qtm1bnD59GiYmJmjevDl2796NLl264P79+zhz5gzMzMxw9uxZeHp6Ys+ePWjcuDHMzc0BAF27doWZmRm2bNkCKysrzJs3Dy1btsT58+dhY2MDALh48SLWrl2LdevWQalUvpZtRIbP4JLKVxEYGIjAwEDpc5MmTVCnTh3MmzcP48eP1zlNdHQ0oqKipM/p6elwdnZ+7bESEVH55+zsjOnTp0OhUKB27do4efIkpk+fjpCQEGzYsAH79+9HkyZNAADLli2Ds7Mz1q9fj65duyIkJATz5s0DAPz5559o2LAhHB0dsXv3bnh6emL37t0IDg4G8PyuZUJCAlJSUqBSqQAAU6dOxfr167FmzRoMHDgQwPOnfD/99BPs7Oz0sDXIUBhcUmlrawulUonk5GSt8uTkZDg6OhZpHiYmJmjYsCEuXrxYYB2VSiUdoEREpH9mJkqcHhemt2UXxxtvvAGFQiF9DgwMxLRp03D69GkYGxsjICBAGle5cmXUrl0bZ86cAQAEBwdjyJAhuHPnDvbs2YOQkBApqezXrx8OHDiAzz//HABw4sQJZGRkoHLlylrLf/z4MS5duiR9dnV1ZUJJshlcUmlqagpfX1/ExcWhU6dOAACNRoO4uDgMHjy4SPPIycnByZMn0bZt29cYKRERlSSFQlGsR9DlVf369WFjY4M9e/Zgz549mDBhAhwdHTF58mQcPnwYT58+le5yZmRkoEqVKti9e3e++VhbW0v/r1ChQilFT4bMII++qKgoREREwM/PD/7+/pgxYwYyMzMRGRkJAOjduzecnJwQGxsLABg3bhzeeOMN1KhRAw8ePMCUKVNw7do19O/fX5+rQUREBurQoUNanw8ePIiaNWvCy8sLz549w6FDh6TE8O7duzh37hy8vLwAPE+eg4KC8Ntvv+Hvv/9Gs2bNYG5ujqysLMybNw9+fn5SktioUSMkJSXB2NgYbm5upbqO9N9jcG9/A0D37t0xdepUjB49Gj4+Pjh+/Di2bt0qvbxz/fp13L59W6p///59DBgwAHXq1EHbtm2Rnp6OAwcOSAcwERFRSbp+/TqioqJw7tw5/PLLL5g1axaGDBmCmjVromPHjhgwYAD27duHEydO4L333oOTkxM6duwoTR8SEoJffvkFPj4+sLCwgJGREZo3b45ly5ZJ7SkBIDQ0FIGBgejUqRP++OMPXL16FQcOHMDIkSNx5MgRfaw6GTCDvFMJQOquQZe8jwGmT5+O6dOnl0JUREREz5+YPX78GP7+/lAqlRgyZIj00szixYsxZMgQtGvXDtnZ2WjevDk2b94MExMTafrg4GDk5OQgJCREKgsJCcFvv/2mVaZQKLB582aMHDkSkZGRuHPnDhwdHdG8eXP2x0wlTiGK07kWFSg9PR1WVlZIS0uDpaWlvsMhIjJoT548wZUrV8plv4ohISHw8fHBjBkz9B3Kf0Zh+wuv3yXHIB9/ExEREVHpYlJJRERERLIZbJtKIiKiskhX9z5EhoB3KomIiIhINiaVRERUbvFdUyoK7ielg0klERGVO7nd6zx69EjPkVB5kLufvNgtE5U8tqkkIqJyR6lUwtraGikpKQAAc3Nzrd/SJgKe36F89OgRUlJSYG1tDaWyeL/RTsXDpJKIiMolR0dHAJASS6KCWFtbS/sLvT5MKomIqFxSKBSoUqUK7O3t8fTpU32HQ2WUiYkJ71CWEiaVRERUrimVSiYNRGUAX9QhIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSzWCTyjlz5sDNzQ1qtRoBAQFISEgo0nQrVqyAQqFAp06dXm+ARERERAbEIJPKlStXIioqCjExMTh69Ci8vb0RFhaGlJSUQqe7evUqhg0bhqCgoFKKlIiIiMgwGGRS+e2332LAgAGIjIyEl5cX5s6dC3NzcyxatKjAaXJyctCrVy+MHTsW1atXL8VoiYiIiMo/g0sqs7OzkZiYiNDQUKnMyMgIoaGhiI+PL3C6cePGwd7eHv369SvScrKyspCenq41EBEREf1XGVxSmZqaipycHDg4OGiVOzg4ICkpSec0+/btw8KFC7FgwYIiLyc2NhZWVlbS4OzsLCtuIiIiovLM4JLK4nr48CHef/99LFiwALa2tkWeLjo6GmlpadJw48aN1xglERERUdlmrO8ASpqtrS2USiWSk5O1ypOTk+Ho6Jiv/qVLl3D16lW0b99eKtNoNAAAY2NjnDt3Dh4eHvmmU6lUUKlUJRw9ERERUflkcHcqTU1N4evri7i4OKlMo9EgLi4OgYGB+ep7enri5MmTOH78uDR06NABLVq0wPHjx/lYm4iIiKgIDO5OJQBERUUhIiICfn5+8Pf3x4wZM5CZmYnIyEgAQO/eveHk5ITY2Fio1WrUq1dPa3pra2sAyFdORERERLoZZFLZvXt33LlzB6NHj0ZSUhJ8fHywdetW6eWd69evw8jI4G7SEhEREemNQggh9B2EIUhPT4eVlRXS0tJgaWmp73CIiIioCHj9Ljm8XUdEREREsjGpJCIiIiLZmFQSERERkWxMKomIiIhINiaVRERERCQbk0oiIiIiko1JJRERERHJxqSSiIiIiGRjUklEREREsjGpJCIiIiLZmFQSERERkWxMKomIiIhINiaVRERERCQbk0oiIiIiko1JJRERERHJxqSSiIiIiGRjUklEREREsjGpJCIiIiLZmFQSERERkWxMKomIiIhINiaVRERERCQbk0oiIiIiko1JJRERERHJxqSSiIiIiGRjUklEREREshlsUjlnzhy4ublBrVYjICAACQkJBdZdt24d/Pz8YG1tjQoVKsDHxwdLly4txWiJiIiIyjeDTCpXrlyJqKgoxMTE4OjRo/D29kZYWBhSUlJ01rexscHIkSMRHx+Pv/76C5GRkYiMjMS2bdtKOXIiIiKi8kkhhBD6DqKkBQQEoHHjxpg9ezYAQKPRwNnZGZ988glGjBhRpHk0atQI4eHhGD9+vM7xWVlZyMrKkj6np6fD2dkZaWlpsLS0lL8SRERE9Nqlp6fDysqK1+8SYHB3KrOzs5GYmIjQ0FCpzMjICKGhoYiPj3/p9EIIxMXF4dy5c2jevHmB9WJjY2FlZSUNzs7OJRI/ERERUXlkcEllamoqcnJy4ODgoFXu4OCApKSkAqdLS0uDhYUFTE1NER4ejlmzZqFVq1YF1o+OjkZaWpo03Lhxo8TWgYiIiKi8MdZ3AGVFxYoVcfz4cWRkZCAuLg5RUVGoXr06QkJCdNZXqVRQqVSlGyQRERFRGWVwSaWtrS2USiWSk5O1ypOTk+Ho6FjgdEZGRqhRowYAwMfHB2fOnEFsbGyBSSURERER/cvgHn+bmprC19cXcXFxUplGo0FcXBwCAwOLPB+NRqP1Ig4RERERFczg7lQCQFRUFCIiIuDn5wd/f3/MmDEDmZmZiIyMBAD07t0bTk5OiI2NBfD8pRs/Pz94eHggKysLmzdvxtKlS/H999/rczWIiIiIyg2DTCq7d++OO3fuYPTo0UhKSoKPjw+2bt0qvbxz/fp1GBn9e5M2MzMTH3/8MW7evAkzMzN4enri559/Rvfu3fW1CkRERETlikH2U6kP7OeKiIio/OH1u+QYXJtKIiIiIip9TCqJiIiISDYmlUREREQkG5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDYmlUREREQkG5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDYmlUREREQkG5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2Qw2qZwzZw7c3NygVqsREBCAhISEAusuWLAAQUFBqFSpEipVqoTQ0NBC6xMRERGRNoNMKleuXImoqCjExMTg6NGj8Pb2RlhYGFJSUnTW3717N3r27Ildu3YhPj4ezs7OeOutt3Dr1q1SjpyIiIiofFIIIYS+gyhpAQEBaNy4MWbPng0A0Gg0cHZ2xieffIIRI0a8dPqcnBxUqlQJs2fPRu/evYu0zPT0dFhZWSEtLQ2Wlpay4iciIqLSwet3yTG4O5XZ2dlITExEaGioVGZkZITQ0FDEx8cXaR6PHj3C06dPYWNjU2CdrKwspKenaw1ERERE/1UGl1SmpqYiJycHDg4OWuUODg5ISkoq0jy++OILVK1aVSsxzSs2NhZWVlbS4OzsLCtuIiIiovLM4JJKuSZNmoQVK1bg119/hVqtLrBedHQ00tLSpOHGjRulGCURERFR2WKs7wBKmq2tLZRKJZKTk7XKk5OT4ejoWOi0U6dOxaRJk7Bjxw40aNCg0LoqlQoqlUp2vERERESGwODuVJqamsLX1xdxcXFSmUajQVxcHAIDAwuc7ptvvsH48eOxdetW+Pn5lUaoRERERAbD4O5UAkBUVBQiIiLg5+cHf39/zJgxA5mZmYiMjAQA9O7dG05OToiNjQUATJ48GaNHj8by5cvh5uYmtb20sLCAhYWF3taDiIiIqLwwyKSye/fuuHPnDkaPHo2kpCT4+Phg69at0ss7169fh5HRvzdpv//+e2RnZ6NLly5a84mJicGYMWNKM3QiIiKicskg+6nUB/ZzRUREVP7w+l1yDK5NJRERERGVPiaVRERERCQbk0oiIiIiko1JJRERERHJxqSSiIiIiGRjUklEREREsjGpJCIiIiLZmFQSERERkWxMKomIiIhINiaVRERERCQbk0oiIiIiko1JJRERERHJxqSSiIiIiGRjUklEREREsjGpJCIiIiLZmFQSERERkWxMKomIiIhINiaVRERERCQbk0oiIiIiko1JJRERERHJxqSSiIiIiGRjUklEREREsjGpJCIiIiLZmFQSERERkWwGm1TOmTMHbm5uUKvVCAgIQEJCQoF1//77b7zzzjtwc3ODQqHAjBkzSi9QIiIiIgNgkEnlypUrERUVhZiYGBw9ehTe3t4ICwtDSkqKzvqPHj1C9erVMWnSJDg6OpZytERERETln0Emld9++y0GDBiAyMhIeHl5Ye7cuTA3N8eiRYt01m/cuDGmTJmCHj16QKVSlXK0REREROWfwSWV2dnZSExMRGhoqFRmZGSE0NBQxMfHl9hysrKykJ6erjUQERER/VcZXFKZmpqKnJwcODg4aJU7ODggKSmpxJYTGxsLKysraXB2di6xeRMRERGVNwaXVJaW6OhopKWlScONGzf0HRIRERGR3hjrO4CSZmtrC6VSieTkZK3y5OTkEn0JR6VSsf0lERER0f9ncHcqTU1N4evri7i4OKlMo9EgLi4OgYGBeoyMiIiIyHAZ3J1KAIiKikJERAT8/Pzg7++PGTNmIDMzE5GRkQCA3r17w8nJCbGxsQCev9xz+vRp6f+3bt3C8ePHYWFhgRo1auhtPYiIiIjKC4NMKrt37447d+5g9OjRSEpKgo+PD7Zu3Sq9vHP9+nUYGf17k/aff/5Bw4YNpc9Tp07F1KlTERwcjN27d5d2+ERERETljkIIIfQdhCFIT0+HlZUV0tLSYGlpqe9wiIiIqAh4/S45BtemkoiIiIhKH5NKIiIiIpKNSSURERERycakkoiIiIhkY1JJRERERLIxqSQiIiIi2ZhUEhEREZFsTCqJiIiISDYmlUREREQkm0H+TKPByswseJxSCajVRatrZASYmb1a3UePgIJ+hEmhAMzNX63u48eARlNwHBUqvFrdJ0+AnJySqWtu/jxuAMjKAp49K5m6ZmbPtzMAZGcDT5+WTF21+vl+Udy6T58+r18QlQowNi5+3WfPnm+LgpiaAiYmxa+bk/P8uyuIicnz+sWtq9E839dKoq6x8fNtATw/Jh49Kpm6xTnueY7QXZfniOLX1dc54sXvgsomQSUiLS1NABBpaWmvbyHPT7+6h7ZtteuamxdcNzhYu66tbcF1/fy067q6FlzXy0u7rpdXwXVdXbXr+vkVXNfWVrtucHDBdc3Nteu2bVv4dntRly6F183I+LduREThdVNS/q378ceF171y5d+6w4YVXvfUqX/rxsQUXjch4d+633xTeN1du/6tO3t24XU3bvy37uLFhdddterfuqtWFV538eJ/627cWHjd2bP/rbtrV+F1v/nm37oJCYXXjYn5t+6pU4XXHTbs37pXrhRe9+OP/62bklJ43YiIf+tmZBRet0sXoaWwujxHPB94jvh3KG/niNekVK7f/xF8/E1EREREsimEEELfQRiCUvlBej7aKn5dPtoqfl0+/n7+fz7+frW6PEc8/z/PEcWvq6fH36Vy/f6PYFJZQrhTEhERlT+8fpccPv4mIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbAabVM6ZMwdubm5Qq9UICAhAQkJCofVXr14NT09PqNVq1K9fH5s3by6lSImIiIjKP4NMKleuXImoqCjExMTg6NGj8Pb2RlhYGFJSUnTWP3DgAHr27Il+/frh2LFj6NSpEzp16oRTp06VcuRERERE5ZNCCCH0HURJCwgIQOPGjTF79mwAgEajgbOzMz755BOMGDEiX/3u3bsjMzMTGzdulMreeOMN+Pj4YO7cuUVaJn+QnoiIqPzh9bvkGOs7gJKWnZ2NxMREREdHS2VGRkYIDQ1FfHy8zmni4+MRFRWlVRYWFob169cXuJysrCxkZWVJn9PS0gA83zmJiIiofMi9bhvgPbZSZ3BJZWpqKnJycuDg4KBV7uDggLNnz+qcJikpSWf9pKSkApcTGxuLsWPH5it3dnZ+haiJiIhInx4+fAgrKyt9h1GuGVxSWVqio6O17m4+ePAArq6uuH79ernbKdPT0+Hs7IwbN26Uy1v/5Tl+xq4/5Tl+xq4/5Tl+xq6bEAIPHz5E1apVS3S+/0UGl1Ta2tpCqVQiOTlZqzw5ORmOjo46p3F0dCxWfQBQqVRQqVT5yq2srMrdwZrL0tKy3MYOlO/4Gbv+lOf4Gbv+lOf4GXt+5e1mUFllcG9/m5qawtfXF3FxcVKZRqNBXFwcAgMDdU4TGBioVR8Atm/fXmB9IiIiItJmcHcqASAqKgoRERHw8/ODv78/ZsyYgczMTERGRgIAevfuDScnJ8TGxgIAhgwZguDgYEybNg3h4eFYsWIFjhw5gvnz5+tzNYiIiIjKDYNMKrt37447d+5g9OjRSEpKgo+PD7Zu3Sq9jHP9+nUYGf17k7ZJkyZYvnw5vvrqK3z55ZeoWbMm1q9fj3r16hV5mSqVCjExMTofiZd15Tl2oHzHz9j1pzzHz9j1pzzHz9jpdTPIfiqJiIiIqHQZXJtKIiIiIip9TCqJiIiISDYmlUREREQkG5NKIiIiIpKNSSURERERycaksgTMmTMHbm5uUKvVCAgIQEJCgr5D0unPP/9E+/btUbVqVSgUCqxfv15rvBACo0ePRpUqVWBmZobQ0FBcuHBBP8HmERsbi8aNG6NixYqwt7dHp06dcO7cOa06T548waBBg1C5cmVYWFjgnXfeyfdLSfrw/fffo0GDBtIvQQQGBmLLli3S+LIaty6TJk2CQqHA0KFDpbKyHP+YMWOgUCi0Bk9PT2l8WY4dAG7duoX33nsPlStXhpmZGerXr48jR45I48vyMevm5pZv2ysUCgwaNAhA2d72OTk5GDVqFNzd3WFmZgYPDw+MHz8eL3aWUpa3/cOHDzF06FC4urrCzMwMTZo0weHDh6XxZSn2krgu3bt3D7169YKlpSWsra3Rr18/ZGRklOJakESQLCtWrBCmpqZi0aJF4u+//xYDBgwQ1tbWIjk5Wd+h5bN582YxcuRIsW7dOgFA/Prrr1rjJ02aJKysrMT69evFiRMnRIcOHYS7u7t4/PixfgJ+QVhYmFi8eLE4deqUOH78uGjbtq1wcXERGRkZUp0PP/xQODs7i7i4OHHkyBHxxhtviCZNmugx6uc2bNggNm3aJM6fPy/OnTsnvvzyS2FiYiJOnTolhCi7ceeVkJAg3NzcRIMGDcSQIUOk8rIcf0xMjKhbt664ffu2NNy5c0caX5Zjv3fvnnB1dRV9+vQRhw4dEpcvXxbbtm0TFy9elOqU5WM2JSVFa7tv375dABC7du0SQpTtbT9hwgRRuXJlsXHjRnHlyhWxevVqYWFhIWbOnCnVKcvbvlu3bsLLy0vs2bNHXLhwQcTExAhLS0tx8+ZNIUTZir0krkutW7cW3t7e4uDBg2Lv3r2iRo0aomfPnqW8JiSEEEwqZfL39xeDBg2SPufk5IiqVauK2NhYPUb1cnkPXo1GIxwdHcWUKVOksgcPHgiVSiV++eUXPURYuJSUFAFA7NmzRwjxPFYTExOxevVqqc6ZM2cEABEfH6+vMAtUqVIl8cMPP5SbuB8+fChq1qwptm/fLoKDg6WksqzHHxMTI7y9vXWOK+uxf/HFF6JZs2YFji9vx+yQIUOEh4eH0Gg0ZX7bh4eHi759+2qVde7cWfTq1UsIUba3/aNHj4RSqRQbN27UKm/UqJEYOXJkmY79Va5Lp0+fFgDE4cOHpTpbtmwRCoVC3Lp1q9Rip+f4+FuG7OxsJCYmIjQ0VCozMjJCaGgo4uPj9RhZ8V25cgVJSUla62JlZYWAgIAyuS5paWkAABsbGwBAYmIinj59qhW/p6cnXFxcylT8OTk5WLFiBTIzMxEYGFhu4h40aBDCw8O14gTKx3a/cOECqlatiurVq6NXr164fv06gLIf+4YNG+Dn54euXbvC3t4eDRs2xIIFC6Tx5emYzc7Oxs8//4y+fftCoVCU+W3fpEkTxMXF4fz58wCAEydOYN++fWjTpg2Asr3tnz17hpycHKjVaq1yMzMz7Nu3r0zHnldRYo2Pj4e1tTX8/PykOqGhoTAyMsKhQ4dKPeb/OoP8mcbSkpqaipycHOnnH3M5ODjg7Nmzeorq1SQlJQGAznXJHVdWaDQaDB06FE2bNpV+SjMpKQmmpqawtrbWqltW4j958iQCAwPx5MkTWFhY4Ndff4WXlxeOHz9epuMGgBUrVuDo0aNabbJylfXtHhAQgCVLlqB27dq4ffs2xo4di6CgIJw6darMx3758mV8//33iIqKwpdffonDhw/j008/hampKSIiIsrVMbt+/Xo8ePAAffr0AVD295sRI0YgPT0dnp6eUCqVyMnJwYQJE9CrVy8AZft8WbFiRQQGBmL8+PGoU6cOHBwc8MsvvyA+Ph41atQo07HnVZRYk5KSYG9vrzXe2NgYNjY2ZW59/guYVFK5M2jQIJw6dQr79u3TdyhFVrt2bRw/fhxpaWlYs2YNIiIisGfPHn2H9VI3btzAkCFDsH379nx3PsqD3DtLANCgQQMEBATA1dUVq1atgpmZmR4jezmNRgM/Pz9MnDgRANCwYUOcOnUKc+fORUREhJ6jK56FCxeiTZs2qFq1qr5DKZJVq1Zh2bJlWL58OerWrYvjx49j6NChqFq1arnY9kuXLkXfvn3h5OQEpVKJRo0aoWfPnkhMTNR3aGTg+PhbBltbWyiVynxvLCYnJ8PR0VFPUb2a3HjL+roMHjwYGzduxK5du1CtWjWp3NHREdnZ2Xjw4IFW/bISv6mpKWrUqAFfX1/ExsbC29sbM2fOLPNxJyYmIiUlBY0aNYKxsTGMjY2xZ88e/O9//4OxsTEcHBzKdPx5WVtbo1atWrh48WKZ3/ZVqlSBl5eXVlmdOnWkx/fl5Zi9du0aduzYgf79+0tlZX3bDx8+HCNGjECPHj1Qv359vP/++/jss88QGxsLoOxvew8PD+zZswcZGRm4ceMGEhIS8PTpU1SvXr3Mx/6iosTq6OiIlJQUrfHPnj3DvXv3ytz6/BcwqZTB1NQUvr6+iIuLk8o0Gg3i4uIQGBiox8iKz93dHY6Ojlrrkp6ejkOHDpWJdRFCYPDgwfj111+xc+dOuLu7a4339fWFiYmJVvznzp3D9evXy0T8eWk0GmRlZZX5uFu2bImTJ0/i+PHj0uDn54devXpJ/y/L8eeVkZGBS5cuoUqVKmV+2zdt2jRft1nnz5+Hq6srgLJ/zOZavHgx7O3tER4eLpWV9W3/6NEjGBlpXx6VSiU0Gg2A8rPtK1SogCpVquD+/fvYtm0bOnbsWG5iB4q2nQMDA/HgwQOtu7A7d+6ERqNBQEBAqcf8n6fvN4XKuxUrVgiVSiWWLFkiTp8+LQYOHCisra1FUlKSvkPL5+HDh+LYsWPi2LFjAoD49ttvxbFjx8S1a9eEEM+7brC2tha//fab+Ouvv0THjh3LTBcZH330kbCyshK7d+/W6qbk0aNHUp0PP/xQuLi4iJ07d4ojR46IwMBAERgYqMeonxsxYoTYs2ePuHLlivjrr7/EiBEjhEKhEH/88YcQouzGXZAX3/4WomzH/3//939i9+7d4sqVK2L//v0iNDRU2NraipSUFCFE2Y49ISFBGBsbiwkTJogLFy6IZcuWCXNzc/Hzzz9LdcryMSvE894wXFxcxBdffJFvXFne9hEREcLJyUnqUmjdunXC1tZWfP7551Kdsrztt27dKrZs2SIuX74s/vjjD+Ht7S0CAgJEdna2EKJsxV4S16XWrVuLhg0bikOHDol9+/aJmjVrskshPWFSWQJmzZolXFxchKmpqfD39xcHDx7Ud0g67dq1SwDIN0RERAghnnffMGrUKOHg4CBUKpVo2bKlOHfunH6D/v90xQ1ALF68WKrz+PFj8fHHH4tKlSoJc3Nz8fbbb4vbt2/rL+j/r2/fvsLV1VWYmpoKOzs70bJlSymhFKLsxl2QvEllWY6/e/fuokqVKsLU1FQ4OTmJ7t27a/XzWJZjF0KI33//XdSrV0+oVCrh6ekp5s+frzW+LB+zQgixbds2AUBnTGV526enp4shQ4YIFxcXoVarRfXq1cXIkSNFVlaWVKcsb/uVK1eK6tWrC1NTU+Ho6CgGDRokHjx4II0vS7GXxHXp7t27omfPnsLCwkJYWlqKyMhI8fDhQz2sDSmEeOEnAoiIiIiIXgHbVBIRERGRbEwqiYiIiEg2JpVEREREJBuTSiIiIiKSjUklEREREcnGpJKIiIiIZGNSSURERESyMakkIiIiItmYVBIRERGRbEwqiYiIiEg2JpVEREREJNv/A1r8QLBoXz8LAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 13,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1675273969073
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "SIM_TITLES = [\n",
        "    \"Linear\",\n",
        "    \"Exponential\",\n",
        "    \"Cubic\",\n",
        "    \"Joint Normal\",\n",
        "    \"Step\",\n",
        "    \"Quadratic\",\n",
        "    \"W-Shaped\",\n",
        "    \"Spiral\",\n",
        "    \"Bernoulli\",\n",
        "    \"Logarithmic\",\n",
        "    \"Fourth Root\",\n",
        "    \"Sine 4\\u03C0\",\n",
        "    \"Sine 16\\u03C0\",\n",
        "    \"Square\",\n",
        "    \"Two Parabolas\",\n",
        "    \"Circle\",\n",
        "    \"Ellipse\",\n",
        "    \"Diamond\",\n",
        "    \"Noise\",\n",
        "    \"Independence\",\n",
        "]"
      ],
      "outputs": [],
      "execution_count": 38,
      "metadata": {
        "gather": {
          "logged": 1675966472068
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## PLOT FOR Multivariate Independence Testing (Increasing Sample size)\n",
        "\n",
        "fig, ax = plt.subplots(nrows=4, ncols=5, figsize=(25, 20))\n",
        "plt.suptitle(\n",
        "    \"Multivariate Independence Testing (Increasing Sample size) with Cutoff\",\n",
        "    y=0.93,\n",
        "    va=\"baseline\",\n",
        "    )\n",
        "\n",
        "for i, row in enumerate(ax):\n",
        "    for j, col in enumerate(row):\n",
        "        count = 5 * i + j\n",
        "        sim = list(SIMULATIONS.keys())[count]\n",
        "        \n",
        "        sample_size = range(5,105,5)\n",
        "        #dim = range(1,20,1)\n",
        "        POWER = np.load(\n",
        "                \"POWER_1D_multi_cutoff_0130{}.npy\".format(sim))\n",
        "        \n",
        "        col.set_xticks([])\n",
        "        col.plot(sample_size,POWER)\n",
        "        if i == 3:\n",
        "            col.set_xticks(range(0,120,20))\n",
        "            col.set_ylim(-0.05, 1.05)\n",
        "            col.set_yticks([])\n",
        "            if j == 0:\n",
        "                col.set_yticks([0, 1])\n",
        "            col.set_title(SIM_TITLES[count])\n",
        "        #est_power = np.genfromtxt( \"{}_{}.csv\".format(sim, 'uf'),delimiter=\",\",)\n",
        "        \n",
        "        col.set_yticks(np.arange(0,1.1,0.1))\n",
        "        col.set_xticks([5,50,100])\n",
        "        col.set_title(list(SIMULATIONS.keys())[count])\n",
        "        \n",
        "        #col.show()"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 2500x2000 with 20 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 41,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1675966597572
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python38-jupyter"
    },
    "kernelspec": {
      "name": "python38-jupyter",
      "language": "python",
      "display_name": "Python 3.8 - Jupyter"
    },
    "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"
    },
    "microsoft": {
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      }
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}