From aea0b742776f15b5e6ee5093c7183898a88c05fa Mon Sep 17 00:00:00 2001
From: Jonathan Taylor <jonathan.taylor@stanford.edu>
Date: Tue, 30 Jun 2020 16:25:01 -0700
Subject: [PATCH] added full results notebook

---
 examples/Full_target_results.Rmd       |  638 ++++++++++++++
 examples/Full_target_results.ipynb     | 1073 ++++++++++++++++++++++++
 examples/Selected_target_results.Rmd   |   47 +-
 examples/Selected_target_results.ipynb |  184 ++--
 statistics.py                          |    5 +-
 5 files changed, 1892 insertions(+), 55 deletions(-)
 create mode 100644 examples/Full_target_results.Rmd
 create mode 100644 examples/Full_target_results.ipynb

diff --git a/examples/Full_target_results.Rmd b/examples/Full_target_results.Rmd
new file mode 100644
index 0000000..2120d5a
--- /dev/null
+++ b/examples/Full_target_results.Rmd
@@ -0,0 +1,638 @@
+---
+jupyter:
+  jupytext:
+    formats: ipynb,Rmd
+    text_representation:
+      extension: .Rmd
+      format_name: rmarkdown
+      format_version: '1.2'
+      jupytext_version: 1.3.4
+  kernelspec:
+    display_name: Python 3
+    language: python
+    name: python3
+---
+
+```{python}
+from itertools import product
+import os
+
+import numpy as np, pandas as pd
+from copy import copy
+import seaborn as sns
+import hashlib
+# %load_ext rpy2.ipython
+# %matplotlib inline
+import matplotlib.pyplot as plt
+
+import rpy2.robjects as rpy
+from rpy2.robjects import numpy2ri
+
+from traitlets import (Bool,
+                       Integer,
+                       Unicode,
+                       Float,
+                       Instance)
+
+### selectinf imports
+
+from selectinf.algorithms.lasso import lasso, ROSI as ROSI_lasso
+from selectinf.randomized.lasso import lasso as rand_lasso
+
+### local imports
+
+import sys, os
+srcdir = os.path.abspath(os.path.join(os.curdir, '..'))
+print(srcdir)
+sys.path.insert(0, srcdir)
+from instances import AR_instance
+from utils import (gaussian_setup,
+                   get_method_params)
+                   
+from gaussian_methods import (lasso_theory,
+                              ROSI_theory,
+                              randomized_lasso) # we will explicitly write out the classes
+                                                # here, inheriting from ROSI_theory
+from statistics import interval_statistic, estimator_statistic
+
+```
+
+## Fetch simulation code from `bestsubset`
+
+```{r}
+source("https://raw.githubusercontent.com/ryantibs/best-subset/master/bestsubset/R/common.R")
+source("https://raw.githubusercontent.com/ryantibs/best-subset/master/bestsubset/R/sim.R")
+
+```
+
+```{python}
+
+def simulate(n=500,
+             p=100,
+             nval=500,
+             s=10,
+             rho=0.35,
+             beta_type=1,
+             snr=0.2):
+
+    numpy2ri.activate()
+    r_simulate = rpy.globalenv['sim.xy']
+    sim = r_simulate(n, p, nval, rho, s, beta_type, snr)
+    X = np.array(sim.rx2('x'))
+    y = np.array(sim.rx2('y'))
+    
+    X -= X.mean(0)[None, :]
+    X /= (X.std(0)[None, :] * np.sqrt(n / (n - 1)))
+    y = y - y.mean()
+    
+    X_val = np.array(sim.rx2('xval'))
+    y_val = np.array(sim.rx2('yval'))
+    Sigma = np.array(sim.rx2('Sigma'))
+    beta = np.array(sim.rx2('beta'))
+    noise_sd = np.array(sim.rx2('sigma')).reshape(())
+    numpy2ri.deactivate()
+    return X, y, Sigma, beta, noise_sd
+
+
+```
+
+### Extract $\lambda$ and point estimate from `glmnet`
+
+```{r}
+library(glmnet)
+glmnet_LASSO = function(X, y, lambda){                                            
+    y = as.numeric(y)                                                                 
+    X = as.matrix(X)                                                                 
+    lam = as.matrix(lambda)[1,1]                                                     
+    n = nrow(X)                                                                      
+                                                                                                 
+    fit = glmnet(X, y, standardize=FALSE, intercept=FALSE, thresh=1.e-10)             
+    estimate.theory = coef(fit, s=lam, exact=TRUE, x=X, y=y)[-1]                            
+    fit.cv = cv.glmnet(X, y, standardize=FALSE, intercept=FALSE, thresh=1.e-10)       
+    estimate.1se = coef(fit, s=fit.cv$lambda.1se, exact=TRUE, x=X, y=y)[-1]            
+    estimate.min = coef(fit, s=fit.cv$lambda.min, exact=TRUE, x=X, y=y)[-1]            
+    return(list(estimate.theory=estimate.theory, 
+                estimate.1se=estimate.1se, 
+                estimate.min=estimate.min, 
+                lam.min=fit.cv$lambda.min, 
+                lam.1se=fit.cv$lambda.1se))                            
+}
+    
+```
+
+```{python}
+def glmnet_setup(X, 
+                 y, 
+                 full_dispersion=True):
+
+    n, p = X.shape
+    if full_dispersion:
+        dispersion = np.linalg.norm(y - X.dot(np.linalg.pinv(X).dot(y))) ** 2 / (n - p)
+        sigma_ = np.sqrt(dispersion)
+    else:
+        dispersion = None
+        sigma_ = np.std(y)
+
+    lam_theory = sigma_ * 1. * np.mean(np.fabs(np.dot(X.T,
+                        np.random.standard_normal((n,
+                                                   2000)))).max(0)) / n
+    
+    numpy2ri.activate()
+    lambda_R = rpy.globalenv['glmnet_LASSO']
+    n, p = X.shape
+    r_X = rpy.r.matrix(X, nrow=n, ncol=p)
+    r_y = rpy.r.matrix(y, nrow=n, ncol=1)
+    r_lam = rpy.r.matrix(lam_theory/float(n), nrow=1, ncol=1)
+
+    val = lambda_R(r_X, r_y, r_lam)
+    estimate_theory = np.array(val.rx2('estimate.theory'))
+    estimate_1se = np.array(val.rx2('estimate.1se'))
+    estimate_min = np.array(val.rx2('estimate.min'))
+    lam_min = np.array(val.rx2('lam.min'))[0]
+    lam_1se = np.array(val.rx2('lam.1se'))[0]
+    numpy2ri.deactivate()
+    return estimate_theory, estimate_1se, estimate_min, lam_theory, lam_1se, lam_min
+```
+
+## Make an instance generator from `sim.xy`
+
+```{python}
+
+class best_subset_data(AR_instance):
+    
+    instance_name = Unicode('Best Subset (R)')
+    n = Integer(500)
+    nval = Integer(500)
+    p = Integer(100)
+    s = Integer(20)
+    rho = Float(0.35)
+    l_theory = Float()
+    feature_cov = Instance(np.ndarray)
+    snr = Float(0.2)
+    noise = Float(1.)
+    beta_type = Integer(1)
+
+    def generate_X(self):
+        
+        X = simulate(n=self.n,
+                     p=self.p,
+                     nval=self.nval,
+                     rho=self.rho,
+                     s=self.s,
+                     beta_type=self.beta_type,
+                     snr=self.snr)[0]
+
+        return X
+
+    def generate(self):
+        
+        (X,
+         Y,
+         Sigma,
+         beta,
+         noise_sd) = simulate(n=self.n,
+                              p=self.p,
+                              nval=self.nval,
+                              rho=self.rho,
+                              s=self.s,
+                              beta_type=self.beta_type,
+                              snr=self.snr)
+        self.feature_cov = Sigma 
+        
+        self._beta = beta
+        Y = X.dot(self._beta) + noise_sd * np.random.standard_normal(self.n)
+        return X, Y, self._beta
+
+instance = best_subset_data(n=500, p=100, nval=100, s=5, rho=0.35)
+X, Y = instance.generate()[:2]
+
+
+```
+
+### Implementation of Liu, Markovic and Tibshirani
+
+```{python}
+  
+class ROSI(ROSI_theory):
+    
+    sigma_estimator = Unicode('relaxed')
+    method_name = Unicode("Full (Nonrandom)")
+    lambda_choice = Unicode("CV")
+    model_target = Unicode("full")
+    dispersion = Float(0.)
+    approximate_inverse = Unicode('BN')
+    estimator = Unicode("OLS")
+
+    def __init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid):
+
+        ROSI_theory.__init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid)
+        n, p = X.shape
+        self.lagrange = l_min * np.ones(X.shape[1])
+
+    @property
+    def method_instance(self):
+        if not hasattr(self, "_method_instance"):
+            n, p = self.X.shape
+            self._method_instance = ROSI_lasso.gaussian(self.X,
+                                                        self.Y,
+                                                        self.lagrange * n,
+                                                        approximate_inverse=self.approximate_inverse)
+        return self._method_instance
+    
+```
+
+### Implementation of Lee et al.
+
+```{python}
+class Lee(lasso_theory):
+    
+    sigma_estimator = Unicode('relaxed')
+    method_name = Unicode("Nonrandom")
+    lambda_choice = Unicode("CV")
+    model_target = Unicode("selected")
+    estimator = Unicode("LASSO")
+    
+    def __init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid):
+
+        lasso_theory.__init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid)
+        n, p = X.shape
+        self.lagrange = l_min * np.ones(X.shape[1])
+        self.dispersion = np.linalg.norm(Y - X.dot(np.linalg.pinv(X).dot(Y))) ** 2 / (n - p)
+        
+    @property
+    def method_instance(self):
+        if not hasattr(self, "_method_instance"):
+            n, p = self.X.shape
+            self._method_instance = lasso.gaussian(self.X,
+                                                   self.Y,
+                                                   self.lagrange * n)
+        return self._method_instance
+ 
+```
+
+### Implementation of naive method
+
+```{python}
+class Naive(Lee):
+    
+    method_name = Unicode("Naive")
+    
+    def generate_summary(self, compute_intervals=True):
+        if not self._fit:
+            self.method_instance.fit()
+            self._fit = True
+
+        X, Y, lagrange, L = self.X, self.Y, self.lagrange, self.method_instance
+        n, p = X.shape
+        
+        if len(L.active) > 0:
+            S = L.summary(compute_intervals=False)
+            lower, upper = self.naive_intervals(L.active)[1:3]
+            pvalue = self.naive_pvalues(L.active)[1]
+            return pd.DataFrame({'variable':L.active,
+                                 'upper_confidence':upper,
+                                 'lower_confidence':lower,
+                                 'onestep':S['onestep'],
+                                 'lasso':S['lasso'],
+                                 'pvalue':pvalue})
+    
+    def generate_pvalues(self):
+        S = self.generate_summary()
+        if S is not None:
+            return np.array(S['variable']), np.array(S['pvalue'])
+        else:
+            return [], []
+        
+    def generate_intervals(self):
+        S = self.generate_summary()
+        if S is not None:
+            return (np.array(S['variable']), 
+                    np.array(S['lower_confidence']), 
+                    np.array(S['upper_confidence']), 
+                    np.array(S['pvalue']))
+        else:
+            return [], [], [], []
+```
+
+### Implementation of randomized LASSO
+
+```{python}
+class Randomized(randomized_lasso):
+
+    use_MLE = Bool(False)
+    randomizer_scale = Float(np.sqrt(0.5))
+    method_name = Unicode("Randomized")
+    lambda_choice = Unicode('1se')
+    use_initial_soln = Bool(True)
+    
+    def __init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid):
+
+        randomized_lasso.__init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid)
+        n, p = X.shape
+        self.lagrange = l_1se * np.ones(X.shape[1])
+        self.dispersion = np.linalg.norm(Y - X.dot(np.linalg.pinv(X).dot(Y))) ** 2 / (n - p)
+           
+    @property
+    def method_instance(self):
+        if not hasattr(self, "_method_instance"):
+            n, p = self.X.shape
+            sigma_ = np.sqrt(self.dispersion)
+
+            self._method_instance = rand_lasso.gaussian(self.X,
+                                                        self.Y,
+                                                        self.lagrange * n,
+                                                        randomizer_scale=(
+                                                        np.sqrt(n) * sigma_ * self.randomizer_scale))
+        return self._method_instance
+    
+    def point_estimator(self):
+        active, soln = randomized_lasso.point_estimator(self)
+        if self.use_initial_soln:
+            soln = self.method_instance.initial_soln
+        return active, soln
+```
+
+### Implementation of selective MLE
+
+```{python}
+class MLE(Randomized):
+    method_name = Unicode("MLE")
+    use_MLE = Bool(True)
+    use_initial_soln = Bool(False)
+    model_target = Unicode('full')
+    
+    def __init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid):
+
+        randomized_lasso.__init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid)
+        n, p = X.shape
+        self.lagrange = l_1se * np.ones(X.shape[1])
+        self.dispersion = np.linalg.norm(Y - X.dot(np.linalg.pinv(X).dot(Y))) ** 2 / (n - p)
+
+```
+
+## Run a simulation collecting results
+
+```{python}
+  
+methods = [Lee, Naive, MLE, Randomized]
+for method in methods:
+    method.setup(instance.feature_cov, instance)
+method_params, class_names, method_names = get_method_params(methods)
+
+palette = {'MLE': 'blue',
+           'Naive': 'red',
+           'Nonrandom': 'orange',
+           'Randomized': 'purple'}
+```
+
+```{python}
+nsim = 3
+snrs = [0.15, 0.2, 0.31]
+outfile = 'selected_target_results.csv'
+try:
+    previous = pd.read_csv(outfile)
+except:
+    previous = None
+results = []
+for i, snr in product(range(nsim),
+                      snrs):                                                                            
+
+    instance.snr = snr                                                                                             
+    X, Y, beta = instance.generate()                                                             
+                                                                                                 
+    # make a hash representing same data                                                         
+                                                                                                 
+    instance_hash = hashlib.md5()                                                                
+    instance_hash.update(X.tobytes())                                                            
+    instance_hash.update(Y.tobytes())                                                            
+    instance_hash.update(beta.tobytes())                                                         
+    instance_id = instance_hash.hexdigest()                                                      
+
+    (glm_LASSO_theory,
+     glm_LASSO_1se,
+     glm_LASSO_min,
+     lam_theory,
+     lam_1se,
+     lam_min) = glmnet_setup(X,
+                             Y,
+                             full_dispersion=True)
+
+    for method, method_name, class_name, idx in zip(methods,                                     
+                                                    method_names,                                
+                                                    class_names,                                 
+                                                    range(len(methods))):                        
+        
+        M, result_df = interval_statistic(method,
+                                          instance,
+                                          X.copy(),
+                                          Y.copy(),
+                                          beta.copy(),
+                                          copy(lam_theory),
+                                          copy(lam_min),
+                                          copy(lam_1se),
+                                          None)
+        
+        if result_df is not None:
+            
+            result_df['instance_id'] = copy(instance_id)
+            result_df['method_param'] = str(method_params.loc[idx])
+            result_df['model_target'] = M.model_target
+            result_df['method_name'] = method_name
+            result_df['class_name'] = class_name
+            
+            _, estimator_df = estimator_statistic(method,
+                                                  instance,
+                                                  X.copy(),
+                                                  Y.copy(),
+                                                  beta.copy(),
+                                                  copy(lam_theory),
+                                                  copy(lam_min),
+                                                  copy(lam_1se),
+                                                  None,
+                                                  M=M)
+            for p in instance.params.columns:
+                result_df[p] = instance.params[p][0]
+            result_df['confidence'] = M.confidence
+
+            for col in estimator_df.columns:
+                if col not in result_df.columns:
+                    result_df.insert(1, col, estimator_df[col][0] * np.ones(result_df.shape[0]))
+            results.append(result_df)
+        
+        all_results = pd.concat(results)
+        if previous is not None:
+            final_results = pd.concat([all_results, previous])
+        else:
+            final_results = all_results
+        final_results.to_csv(outfile, index=False)
+```
+
+```{python}
+if previous is not None:
+    final_results = pd.concat([all_results, previous])
+else:
+    final_results = all_results
+final_results.to_csv(outfile, index=False)
+np.unique(final_results['instance_id']).shape[0]
+```
+
+## False Discovery Proportion
+
+```{python}
+fdp_results = []
+for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):
+    fdp_results.append(list(key[1:]) + [df['fdp'].mean()])
+fdp_results = pd.DataFrame(fdp_results, columns=['method_name', 'snr', 'FDP'])
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+sns.pointplot(x='snr',
+              y='FDP',
+              hue='method_name',
+              data=fdp_results,
+              palette=palette)
+```
+
+## Risk
+
+```{python}
+risk_results = []
+risk_names = sorted([n for n in all_results.columns if 'Risk' in n])
+for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):
+    risk_results.append(list(key[1:]) + [df[n].mean() for n in risk_names])
+risk_results = pd.DataFrame(risk_results, columns=['method_name', 'snr'] + risk_names)
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+sns.pointplot(x='snr',
+              y='Full Risk',
+              hue='method_name',
+              data=risk_results,
+              palette=palette)
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+sns.pointplot(x='snr',
+              y='Partial Relative Risk',
+              hue='method_name',
+              data=risk_results,
+              palette=palette)
+```
+
+## Intervals
+
+```{python}
+interval_results = []
+for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):
+    if key[1] != 'Randomized':
+        covered = ((df['lower_confidence'] <= df['target']) & 
+                   (df['upper_confidence'] >= df['target']))
+        length = df['upper_confidence'] - df['lower_confidence']
+        interval_results.append(list(key[1:]) + [np.mean(covered), np.median(length)])
+interval_results = pd.DataFrame(interval_results, columns=['method_name', 'snr'] + ['Coverage', 'Length'])
+
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+ax = sns.barplot(x='snr',
+                 y='Coverage',
+                 hue='method_name',
+                 data=interval_results,
+                 palette=palette)
+xlim = ax.get_xlim()
+ax.plot(xlim, [all_results['confidence'].mean()]*2, 'k--')
+ax.set_xlim(xlim)
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+sns.barplot(x='snr',
+            y='Length',
+            hue='method_name',
+            data=interval_results,
+            palette=palette)
+```
+
+## Power
+
+```{python}
+test_level = 0.1
+power_results = []
+for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):
+    alt_df = df[lambda df: df['target'] != 0]
+    power_results.append(list(key[1:]) + [np.mean(alt_df['pvalue'] < test_level)])
+power_results = pd.DataFrame(power_results, columns=['method_name', 'snr'] + ['Selective Power'])
+
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+ax = sns.barplot(x='snr',
+                 y='Selective Power',
+                 hue='method_name',
+                 data=power_results,
+                 palette=palette)
+ax.set_ylim([0,1.1])
+```
+
+### Power when selecting on `full_target`
+
+```{python}
+test_level = 0.1
+power_results = []
+for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):
+    alt_df = df[lambda df: df['full_target'] != 0]
+    power_results.append(list(key[1:]) + [np.mean(alt_df['pvalue'] < test_level)])
+power_results = pd.DataFrame(power_results, columns=['method_name', 'snr'] + ['Selective Power'])
+
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+ax = sns.barplot(x='snr',
+                 y='Selective Power',
+                 hue='method_name',
+                 data=power_results,
+                 palette=palette)
+ax.set_ylim([0, 1.1])
+```
+
+## Selective Type I Error
+
+```{python}
+size_results = []
+for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):
+    null_df = df[lambda df: df['full_target'] == 0]
+    size_results.append(list(key[1:]) + [np.nanmean(null_df['pvalue'] < test_level)])
+size_results = pd.DataFrame(size_results, columns=['method_name', 'snr'] + ['Selective Type I Error'])
+
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+ax = sns.barplot(x='snr',
+                 y='Selective Type I Error',
+                 hue='method_name',
+                 data=size_results,
+                 palette=palette)
+ax.set_ylim([0, 1.1])
+xlim = ax.get_xlim()
+ax.plot(xlim, [test_level]*2, 'k--')
+ax.set_xlim(xlim)
+```
+
+```{python}
+
+```
+
+```{python}
+
+```
+
+```{python}
+
+```
diff --git a/examples/Full_target_results.ipynb b/examples/Full_target_results.ipynb
new file mode 100644
index 0000000..3e9a96f
--- /dev/null
+++ b/examples/Full_target_results.ipynb
@@ -0,0 +1,1073 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The rpy2.ipython extension is already loaded. To reload it, use:\n",
+      "  %reload_ext rpy2.ipython\n",
+      "/Users/jonathantaylor/git-repos/compare-selection\n"
+     ]
+    }
+   ],
+   "source": [
+    "from itertools import product\n",
+    "import os\n",
+    "\n",
+    "import numpy as np, pandas as pd\n",
+    "from copy import copy\n",
+    "import seaborn as sns\n",
+    "import hashlib\n",
+    "%load_ext rpy2.ipython\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import rpy2.robjects as rpy\n",
+    "from rpy2.robjects import numpy2ri\n",
+    "\n",
+    "from traitlets import (Bool,\n",
+    "                       Integer,\n",
+    "                       Unicode,\n",
+    "                       Float,\n",
+    "                       Instance)\n",
+    "\n",
+    "### selectinf imports\n",
+    "\n",
+    "from selectinf.algorithms.lasso import lasso, ROSI as ROSI_lasso\n",
+    "from selectinf.randomized.lasso import lasso as rand_lasso\n",
+    "\n",
+    "### local imports\n",
+    "\n",
+    "import sys, os\n",
+    "srcdir = os.path.abspath(os.path.join(os.curdir, '..'))\n",
+    "print(srcdir)\n",
+    "sys.path.insert(0, srcdir)\n",
+    "from instances import AR_instance\n",
+    "from utils import (gaussian_setup,\n",
+    "                   get_method_params)\n",
+    "                   \n",
+    "from gaussian_methods import (lasso_theory,\n",
+    "                              ROSI_theory,\n",
+    "                              randomized_lasso) # we will explicitly write out the classes\n",
+    "                                                # here, inheriting from ROSI_theory\n",
+    "from statistics import interval_statistic, estimator_statistic\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fetch simulation code from `bestsubset`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%R\n",
+    "source(\"https://raw.githubusercontent.com/ryantibs/best-subset/master/bestsubset/R/common.R\")\n",
+    "source(\"https://raw.githubusercontent.com/ryantibs/best-subset/master/bestsubset/R/sim.R\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def simulate(n=500,\n",
+    "             p=100,\n",
+    "             nval=500,\n",
+    "             s=10,\n",
+    "             rho=0.35,\n",
+    "             beta_type=1,\n",
+    "             snr=0.2):\n",
+    "\n",
+    "    numpy2ri.activate()\n",
+    "    r_simulate = rpy.globalenv['sim.xy']\n",
+    "    sim = r_simulate(n, p, nval, rho, s, beta_type, snr)\n",
+    "    X = np.array(sim.rx2('x'))\n",
+    "    y = np.array(sim.rx2('y'))\n",
+    "    \n",
+    "    X -= X.mean(0)[None, :]\n",
+    "    X /= (X.std(0)[None, :] * np.sqrt(n / (n - 1)))\n",
+    "    y = y - y.mean()\n",
+    "    \n",
+    "    X_val = np.array(sim.rx2('xval'))\n",
+    "    y_val = np.array(sim.rx2('yval'))\n",
+    "    Sigma = np.array(sim.rx2('Sigma'))\n",
+    "    beta = np.array(sim.rx2('beta'))\n",
+    "    noise_sd = np.array(sim.rx2('sigma')).reshape(())\n",
+    "    numpy2ri.deactivate()\n",
+    "    return X, y, Sigma, beta, noise_sd\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Extract $\\lambda$ and point estimate from `glmnet`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%R\n",
+    "library(glmnet)\n",
+    "glmnet_LASSO = function(X, y, lambda){                                            \n",
+    "    y = as.numeric(y)                                                                 \n",
+    "    X = as.matrix(X)                                                                 \n",
+    "    lam = as.matrix(lambda)[1,1]                                                     \n",
+    "    n = nrow(X)                                                                      \n",
+    "                                                                                                 \n",
+    "    fit = glmnet(X, y, standardize=FALSE, intercept=FALSE, thresh=1.e-10)             \n",
+    "    estimate.theory = coef(fit, s=lam, exact=TRUE, x=X, y=y)[-1]                            \n",
+    "    fit.cv = cv.glmnet(X, y, standardize=FALSE, intercept=FALSE, thresh=1.e-10)       \n",
+    "    estimate.1se = coef(fit, s=fit.cv$lambda.1se, exact=TRUE, x=X, y=y)[-1]            \n",
+    "    estimate.min = coef(fit, s=fit.cv$lambda.min, exact=TRUE, x=X, y=y)[-1]            \n",
+    "    return(list(estimate.theory=estimate.theory, \n",
+    "                estimate.1se=estimate.1se, \n",
+    "                estimate.min=estimate.min, \n",
+    "                lam.min=fit.cv$lambda.min, \n",
+    "                lam.1se=fit.cv$lambda.1se))                            \n",
+    "}\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def glmnet_setup(X, \n",
+    "                 y, \n",
+    "                 full_dispersion=True):\n",
+    "\n",
+    "    n, p = X.shape\n",
+    "    if full_dispersion:\n",
+    "        dispersion = np.linalg.norm(y - X.dot(np.linalg.pinv(X).dot(y))) ** 2 / (n - p)\n",
+    "        sigma_ = np.sqrt(dispersion)\n",
+    "    else:\n",
+    "        dispersion = None\n",
+    "        sigma_ = np.std(y)\n",
+    "\n",
+    "    lam_theory = sigma_ * 1. * np.mean(np.fabs(np.dot(X.T,\n",
+    "                        np.random.standard_normal((n,\n",
+    "                                                   2000)))).max(0)) / n\n",
+    "    \n",
+    "    numpy2ri.activate()\n",
+    "    lambda_R = rpy.globalenv['glmnet_LASSO']\n",
+    "    n, p = X.shape\n",
+    "    r_X = rpy.r.matrix(X, nrow=n, ncol=p)\n",
+    "    r_y = rpy.r.matrix(y, nrow=n, ncol=1)\n",
+    "    r_lam = rpy.r.matrix(lam_theory/float(n), nrow=1, ncol=1)\n",
+    "\n",
+    "    val = lambda_R(r_X, r_y, r_lam)\n",
+    "    estimate_theory = np.array(val.rx2('estimate.theory'))\n",
+    "    estimate_1se = np.array(val.rx2('estimate.1se'))\n",
+    "    estimate_min = np.array(val.rx2('estimate.min'))\n",
+    "    lam_min = np.array(val.rx2('lam.min'))[0]\n",
+    "    lam_1se = np.array(val.rx2('lam.1se'))[0]\n",
+    "    numpy2ri.deactivate()\n",
+    "    return estimate_theory, estimate_1se, estimate_min, lam_theory, lam_1se, lam_min"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Make an instance generator from `sim.xy`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "class best_subset_data(AR_instance):\n",
+    "    \n",
+    "    instance_name = Unicode('Best Subset (R)')\n",
+    "    n = Integer(500)\n",
+    "    nval = Integer(500)\n",
+    "    p = Integer(100)\n",
+    "    s = Integer(20)\n",
+    "    rho = Float(0.35)\n",
+    "    l_theory = Float()\n",
+    "    feature_cov = Instance(np.ndarray)\n",
+    "    snr = Float(0.2)\n",
+    "    noise = Float(1.)\n",
+    "    beta_type = Integer(1)\n",
+    "\n",
+    "    def generate_X(self):\n",
+    "        \n",
+    "        X = simulate(n=self.n,\n",
+    "                     p=self.p,\n",
+    "                     nval=self.nval,\n",
+    "                     rho=self.rho,\n",
+    "                     s=self.s,\n",
+    "                     beta_type=self.beta_type,\n",
+    "                     snr=self.snr)[0]\n",
+    "\n",
+    "        return X\n",
+    "\n",
+    "    def generate(self):\n",
+    "        \n",
+    "        (X,\n",
+    "         Y,\n",
+    "         Sigma,\n",
+    "         beta,\n",
+    "         noise_sd) = simulate(n=self.n,\n",
+    "                              p=self.p,\n",
+    "                              nval=self.nval,\n",
+    "                              rho=self.rho,\n",
+    "                              s=self.s,\n",
+    "                              beta_type=self.beta_type,\n",
+    "                              snr=self.snr)\n",
+    "        self.feature_cov = Sigma \n",
+    "        \n",
+    "        self._beta = beta\n",
+    "        Y = X.dot(self._beta) + noise_sd * np.random.standard_normal(self.n)\n",
+    "        return X, Y, self._beta\n",
+    "\n",
+    "instance = best_subset_data(n=500, p=100, nval=100, s=5, rho=0.35)\n",
+    "X, Y = instance.generate()[:2]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Implementation of Liu, Markovic and Tibshirani"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "  \n",
+    "class ROSI(ROSI_theory):\n",
+    "    \n",
+    "    sigma_estimator = Unicode('relaxed')\n",
+    "    method_name = Unicode(\"Full (Nonrandom)\")\n",
+    "    lambda_choice = Unicode(\"CV\")\n",
+    "    model_target = Unicode(\"full\")\n",
+    "    dispersion = Float(0.)\n",
+    "    approximate_inverse = Unicode('BN')\n",
+    "    estimator = Unicode(\"OLS\")\n",
+    "\n",
+    "    def __init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid):\n",
+    "\n",
+    "        ROSI_theory.__init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid)\n",
+    "        n, p = X.shape\n",
+    "        self.lagrange = l_min * np.ones(X.shape[1])\n",
+    "\n",
+    "    @property\n",
+    "    def method_instance(self):\n",
+    "        if not hasattr(self, \"_method_instance\"):\n",
+    "            n, p = self.X.shape\n",
+    "            self._method_instance = ROSI_lasso.gaussian(self.X,\n",
+    "                                                        self.Y,\n",
+    "                                                        self.lagrange * n,\n",
+    "                                                        approximate_inverse=self.approximate_inverse)\n",
+    "        return self._method_instance\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Implementation of Lee et al."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Lee(lasso_theory):\n",
+    "    \n",
+    "    sigma_estimator = Unicode('relaxed')\n",
+    "    method_name = Unicode(\"Nonrandom\")\n",
+    "    lambda_choice = Unicode(\"CV\")\n",
+    "    model_target = Unicode(\"selected\")\n",
+    "    estimator = Unicode(\"LASSO\")\n",
+    "    \n",
+    "    def __init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid):\n",
+    "\n",
+    "        lasso_theory.__init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid)\n",
+    "        n, p = X.shape\n",
+    "        self.lagrange = l_min * np.ones(X.shape[1])\n",
+    "        self.dispersion = np.linalg.norm(Y - X.dot(np.linalg.pinv(X).dot(Y))) ** 2 / (n - p)\n",
+    "        \n",
+    "    @property\n",
+    "    def method_instance(self):\n",
+    "        if not hasattr(self, \"_method_instance\"):\n",
+    "            n, p = self.X.shape\n",
+    "            self._method_instance = lasso.gaussian(self.X,\n",
+    "                                                   self.Y,\n",
+    "                                                   self.lagrange * n)\n",
+    "        return self._method_instance\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Implementation of naive method"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Naive(Lee):\n",
+    "    \n",
+    "    method_name = Unicode(\"Naive\")\n",
+    "    \n",
+    "    def generate_summary(self, compute_intervals=True):\n",
+    "        if not self._fit:\n",
+    "            self.method_instance.fit()\n",
+    "            self._fit = True\n",
+    "\n",
+    "        X, Y, lagrange, L = self.X, self.Y, self.lagrange, self.method_instance\n",
+    "        n, p = X.shape\n",
+    "        \n",
+    "        if len(L.active) > 0:\n",
+    "            S = L.summary(compute_intervals=False)\n",
+    "            lower, upper = self.naive_intervals(L.active)[1:3]\n",
+    "            pvalue = self.naive_pvalues(L.active)[1]\n",
+    "            return pd.DataFrame({'variable':L.active,\n",
+    "                                 'upper_confidence':upper,\n",
+    "                                 'lower_confidence':lower,\n",
+    "                                 'onestep':S['onestep'],\n",
+    "                                 'lasso':S['lasso'],\n",
+    "                                 'pvalue':pvalue})\n",
+    "    \n",
+    "    def generate_pvalues(self):\n",
+    "        S = self.generate_summary()\n",
+    "        if S is not None:\n",
+    "            return np.array(S['variable']), np.array(S['pvalue'])\n",
+    "        else:\n",
+    "            return [], []\n",
+    "        \n",
+    "    def generate_intervals(self):\n",
+    "        S = self.generate_summary()\n",
+    "        if S is not None:\n",
+    "            return (np.array(S['variable']), \n",
+    "                    np.array(S['lower_confidence']), \n",
+    "                    np.array(S['upper_confidence']), \n",
+    "                    np.array(S['pvalue']))\n",
+    "        else:\n",
+    "            return [], [], [], []"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Implementation of randomized LASSO"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Randomized(randomized_lasso):\n",
+    "\n",
+    "    use_MLE = Bool(False)\n",
+    "    randomizer_scale = Float(np.sqrt(0.5))\n",
+    "    method_name = Unicode(\"Randomized\")\n",
+    "    lambda_choice = Unicode('1se')\n",
+    "    use_initial_soln = Bool(True)\n",
+    "    \n",
+    "    def __init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid):\n",
+    "\n",
+    "        randomized_lasso.__init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid)\n",
+    "        n, p = X.shape\n",
+    "        self.lagrange = l_1se * np.ones(X.shape[1])\n",
+    "        self.dispersion = np.linalg.norm(Y - X.dot(np.linalg.pinv(X).dot(Y))) ** 2 / (n - p)\n",
+    "           \n",
+    "    @property\n",
+    "    def method_instance(self):\n",
+    "        if not hasattr(self, \"_method_instance\"):\n",
+    "            n, p = self.X.shape\n",
+    "            sigma_ = np.sqrt(self.dispersion)\n",
+    "\n",
+    "            self._method_instance = rand_lasso.gaussian(self.X,\n",
+    "                                                        self.Y,\n",
+    "                                                        self.lagrange * n,\n",
+    "                                                        randomizer_scale=(\n",
+    "                                                        np.sqrt(n) * sigma_ * self.randomizer_scale))\n",
+    "        return self._method_instance\n",
+    "    \n",
+    "    def point_estimator(self):\n",
+    "        active, soln = randomized_lasso.point_estimator(self)\n",
+    "        if self.use_initial_soln:\n",
+    "            soln = self.method_instance.initial_soln\n",
+    "        return active, soln"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Implementation of selective MLE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MLE(Randomized):\n",
+    "    method_name = Unicode(\"MLE\")\n",
+    "    use_MLE = Bool(True)\n",
+    "    use_initial_soln = Bool(False)\n",
+    "    model_target = Unicode('selected')\n",
+    "    \n",
+    "    def __init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid):\n",
+    "\n",
+    "        randomized_lasso.__init__(self, X, Y, l_theory, l_min, l_1se, sigma_reid)\n",
+    "        n, p = X.shape\n",
+    "        self.lagrange = l_1se * np.ones(X.shape[1])\n",
+    "        self.dispersion = np.linalg.norm(Y - X.dot(np.linalg.pinv(X).dot(Y))) ** 2 / (n - p)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run a simulation collecting results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "  \n",
+    "methods = [Lee, Naive, MLE, Randomized]\n",
+    "for method in methods:\n",
+    "    method.setup(instance.feature_cov, instance)\n",
+    "method_params, class_names, method_names = get_method_params(methods)\n",
+    "\n",
+    "palette = {'MLE': 'blue',\n",
+    "           'Naive': 'red',\n",
+    "           'Nonrandom': 'orange',\n",
+    "           'Randomized': 'purple'}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nsim = 3\n",
+    "snrs = [0.15, 0.2, 0.31]\n",
+    "outfile = 'selected_target_results.csv'\n",
+    "try:\n",
+    "    previous = pd.read_csv(outfile)\n",
+    "except:\n",
+    "    previous = None\n",
+    "results = []\n",
+    "for i, snr in product(range(nsim),\n",
+    "                      snrs):                                                                            \n",
+    "\n",
+    "    instance.snr = snr                                                                                             \n",
+    "    X, Y, beta = instance.generate()                                                             \n",
+    "                                                                                                 \n",
+    "    # make a hash representing same data                                                         \n",
+    "                                                                                                 \n",
+    "    instance_hash = hashlib.md5()                                                                \n",
+    "    instance_hash.update(X.tobytes())                                                            \n",
+    "    instance_hash.update(Y.tobytes())                                                            \n",
+    "    instance_hash.update(beta.tobytes())                                                         \n",
+    "    instance_id = instance_hash.hexdigest()                                                      \n",
+    "\n",
+    "    (glm_LASSO_theory,\n",
+    "     glm_LASSO_1se,\n",
+    "     glm_LASSO_min,\n",
+    "     lam_theory,\n",
+    "     lam_1se,\n",
+    "     lam_min) = glmnet_setup(X,\n",
+    "                             Y,\n",
+    "                             full_dispersion=True)\n",
+    "\n",
+    "    for method, method_name, class_name, idx in zip(methods,                                     \n",
+    "                                                    method_names,                                \n",
+    "                                                    class_names,                                 \n",
+    "                                                    range(len(methods))):                        \n",
+    "        \n",
+    "        M, result_df = interval_statistic(method,\n",
+    "                                          instance,\n",
+    "                                          X.copy(),\n",
+    "                                          Y.copy(),\n",
+    "                                          beta.copy(),\n",
+    "                                          copy(lam_theory),\n",
+    "                                          copy(lam_min),\n",
+    "                                          copy(lam_1se),\n",
+    "                                          None)\n",
+    "        \n",
+    "        if result_df is not None:\n",
+    "            \n",
+    "            result_df['instance_id'] = copy(instance_id)\n",
+    "            result_df['method_param'] = str(method_params.loc[idx])\n",
+    "            result_df['model_target'] = M.model_target\n",
+    "            result_df['method_name'] = method_name\n",
+    "            result_df['class_name'] = class_name\n",
+    "            \n",
+    "            _, estimator_df = estimator_statistic(method,\n",
+    "                                                  instance,\n",
+    "                                                  X.copy(),\n",
+    "                                                  Y.copy(),\n",
+    "                                                  beta.copy(),\n",
+    "                                                  copy(lam_theory),\n",
+    "                                                  copy(lam_min),\n",
+    "                                                  copy(lam_1se),\n",
+    "                                                  None,\n",
+    "                                                  M=M)\n",
+    "            for p in instance.params.columns:\n",
+    "                result_df[p] = instance.params[p][0]\n",
+    "            result_df['confidence'] = M.confidence\n",
+    "\n",
+    "            for col in estimator_df.columns:\n",
+    "                if col not in result_df.columns:\n",
+    "                    result_df.insert(1, col, estimator_df[col][0] * np.ones(result_df.shape[0]))\n",
+    "            results.append(result_df)\n",
+    "        \n",
+    "        all_results = pd.concat(results)\n",
+    "        if previous is not None:\n",
+    "            final_results = pd.concat([all_results, previous])\n",
+    "        else:\n",
+    "            final_results = all_results\n",
+    "        final_results.to_csv(outfile, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "27"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "if previous is not None:\n",
+    "    final_results = pd.concat([all_results, previous])\n",
+    "else:\n",
+    "    final_results = all_results\n",
+    "final_results.to_csv(outfile, index=False)\n",
+    "np.unique(final_results['instance_id']).shape[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## False Discovery Proportion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fdp_results = []\n",
+    "for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):\n",
+    "    fdp_results.append(list(key[1:]) + [df['fdp'].mean()])\n",
+    "fdp_results = pd.DataFrame(fdp_results, columns=['method_name', 'snr', 'FDP'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a2cbab910>"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "sns.pointplot(x='snr',\n",
+    "              y='FDP',\n",
+    "              hue='method_name',\n",
+    "              data=fdp_results,\n",
+    "              palette=palette)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Risk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "risk_results = []\n",
+    "risk_names = sorted([n for n in all_results.columns if 'Risk' in n])\n",
+    "for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):\n",
+    "    risk_results.append(list(key[1:]) + [df[n].mean() for n in risk_names])\n",
+    "risk_results = pd.DataFrame(risk_results, columns=['method_name', 'snr'] + risk_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a2bf5b3d0>"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "sns.pointplot(x='snr',\n",
+    "              y='Full Risk',\n",
+    "              hue='method_name',\n",
+    "              data=risk_results,\n",
+    "              palette=palette)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a2c3cae50>"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "sns.pointplot(x='snr',\n",
+    "              y='Partial Relative Risk',\n",
+    "              hue='method_name',\n",
+    "              data=risk_results,\n",
+    "              palette=palette)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Intervals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "interval_results = []\n",
+    "for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):\n",
+    "    if key[1] != 'Randomized':\n",
+    "        covered = ((df['lower_confidence'] <= df['target']) & \n",
+    "                   (df['upper_confidence'] >= df['target']))\n",
+    "        length = df['upper_confidence'] - df['lower_confidence']\n",
+    "        interval_results.append(list(key[1:]) + [np.mean(covered), np.median(length)])\n",
+    "interval_results = pd.DataFrame(interval_results, columns=['method_name', 'snr'] + ['Coverage', 'Length'])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.5, 2.5)"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "ax = sns.barplot(x='snr',\n",
+    "                 y='Coverage',\n",
+    "                 hue='method_name',\n",
+    "                 data=interval_results,\n",
+    "                 palette=palette)\n",
+    "xlim = ax.get_xlim()\n",
+    "ax.plot(xlim, [all_results['confidence'].mean()]*2, 'k--')\n",
+    "ax.set_xlim(xlim)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a2d24f0d0>"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "sns.barplot(x='snr',\n",
+    "            y='Length',\n",
+    "            hue='method_name',\n",
+    "            data=interval_results,\n",
+    "            palette=palette)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Power"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_level = 0.1\n",
+    "power_results = []\n",
+    "for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):\n",
+    "    alt_df = df[lambda df: df['target'] != 0]\n",
+    "    power_results.append(list(key[1:]) + [np.mean(alt_df['pvalue'] < test_level)])\n",
+    "power_results = pd.DataFrame(power_results, columns=['method_name', 'snr'] + ['Selective Power'])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0, 1.1)"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "ax = sns.barplot(x='snr',\n",
+    "                 y='Selective Power',\n",
+    "                 hue='method_name',\n",
+    "                 data=power_results,\n",
+    "                 palette=palette)\n",
+    "ax.set_ylim([0,1.1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Power when selecting on `full_target`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_level = 0.1\n",
+    "power_results = []\n",
+    "for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):\n",
+    "    alt_df = df[lambda df: df['full_target'] != 0]\n",
+    "    power_results.append(list(key[1:]) + [np.mean(alt_df['pvalue'] < test_level)])\n",
+    "power_results = pd.DataFrame(power_results, columns=['method_name', 'snr'] + ['Selective Power'])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0, 1.1)"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "ax = sns.barplot(x='snr',\n",
+    "                 y='Selective Power',\n",
+    "                 hue='method_name',\n",
+    "                 data=power_results,\n",
+    "                 palette=palette)\n",
+    "ax.set_ylim([0, 1.1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Selective Type I Error"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/jonathantaylor/opt/anaconda3/lib/python3.7/site-packages/numpy/core/fromnumeric.py:3257: RuntimeWarning: Mean of empty slice.\n",
+      "  out=out, **kwargs)\n",
+      "/Users/jonathantaylor/opt/anaconda3/lib/python3.7/site-packages/numpy/core/_methods.py:161: RuntimeWarning: invalid value encountered in double_scalars\n",
+      "  ret = ret.dtype.type(ret / rcount)\n"
+     ]
+    }
+   ],
+   "source": [
+    "size_results = []\n",
+    "for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):\n",
+    "    null_df = df[lambda df: df['full_target'] == 0]\n",
+    "    size_results.append(list(key[1:]) + [np.nanmean(null_df['pvalue'] < test_level)])\n",
+    "size_results = pd.DataFrame(size_results, columns=['method_name', 'snr'] + ['Selective Type I Error'])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.5, 2.5)"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "ax = sns.barplot(x='snr',\n",
+    "                 y='Selective Type I Error',\n",
+    "                 hue='method_name',\n",
+    "                 data=size_results,\n",
+    "                 palette=palette)\n",
+    "ax.set_ylim([0, 1.1])\n",
+    "xlim = ax.get_xlim()\n",
+    "ax.plot(xlim, [test_level]*2, 'k--')\n",
+    "ax.set_xlim(xlim)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "ipynb,Rmd"
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/Selected_target_results.Rmd b/examples/Selected_target_results.Rmd
index 1b40790..b66c58a 100644
--- a/examples/Selected_target_results.Rmd
+++ b/examples/Selected_target_results.Rmd
@@ -15,6 +15,7 @@ jupyter:
 
 ```{python}
 from itertools import product
+import os
 
 import numpy as np, pandas as pd
 from copy import copy
@@ -95,7 +96,11 @@ def simulate(n=500,
 
 ```
 
+<!-- #region -->
+
+
 ### Extract $\lambda$ and point estimate from `glmnet`
+<!-- #endregion -->
 
 ```{r}
 library(glmnet)
@@ -385,9 +390,13 @@ palette = {'MLE': 'blue',
 ```
 
 ```{python}
-nsim = 30
+nsim = 3
 snrs = [0.15, 0.2, 0.31]
-
+outfile = 'selected_target_results.csv'
+try:
+    previous = pd.read_csv(outfile)
+except:
+    previous = None
 results = []
 for i, snr in product(range(nsim),
                       snrs):                                                                            
@@ -453,12 +462,40 @@ for i, snr in product(range(nsim),
                 if col not in result_df.columns:
                     result_df.insert(1, col, estimator_df[col][0] * np.ones(result_df.shape[0]))
             results.append(result_df)
+        
+        all_results = pd.concat(results)
+        if previous is not None:
+            final_results = pd.concat([all_results, previous])
+        else:
+            final_results = all_results
+        final_results.to_csv(outfile, index=False)
 ```
 
 ```{python}
-all_results = pd.concat(results)
-outfile = 'selected_target_results.csv'
-all_results.to_csv(outfile, index=False)
+if previous is not None:
+    final_results = pd.concat([all_results, previous])
+else:
+    final_results = all_results
+final_results.to_csv(outfile, index=False)
+np.unique(final_results['instance_id']).shape[0]
+```
+
+## False Discovery Proportion
+
+```{python}
+fdp_results = []
+for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):
+    fdp_results.append(list(key[1:]) + [df['fdp'].mean()])
+fdp_results = pd.DataFrame(fdp_results, columns=['method_name', 'snr', 'FDP'])
+```
+
+```{python}
+plt.figure(figsize=(12, 6))
+sns.pointplot(x='snr',
+              y='FDP',
+              hue='method_name',
+              data=fdp_results,
+              palette=palette)
 ```
 
 ## Risk
diff --git a/examples/Selected_target_results.ipynb b/examples/Selected_target_results.ipynb
index 6072b8d..9c34152 100644
--- a/examples/Selected_target_results.ipynb
+++ b/examples/Selected_target_results.ipynb
@@ -2,19 +2,22 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "The rpy2.ipython extension is already loaded. To reload it, use:\n",
+      "  %reload_ext rpy2.ipython\n",
       "/Users/jonathantaylor/git-repos/compare-selection\n"
      ]
     }
    ],
    "source": [
     "from itertools import product\n",
+    "import os\n",
     "\n",
     "import numpy as np, pandas as pd\n",
     "from copy import copy\n",
@@ -64,7 +67,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -75,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -112,12 +115,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "\n",
+    "\n",
     "### Extract $\\lambda$ and point estimate from `glmnet`"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -145,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -191,7 +196,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -255,7 +260,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -297,7 +302,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -336,7 +341,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -390,7 +395,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -438,7 +443,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -465,7 +470,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -483,13 +488,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [],
    "source": [
-    "nsim = 30\n",
+    "nsim = 3\n",
     "snrs = [0.15, 0.2, 0.31]\n",
-    "\n",
+    "outfile = 'selected_target_results.csv'\n",
+    "try:\n",
+    "    previous = pd.read_csv(outfile)\n",
+    "except:\n",
+    "    previous = None\n",
     "results = []\n",
     "for i, snr in product(range(nsim),\n",
     "                      snrs):                                                                            \n",
@@ -554,18 +563,95 @@
     "            for col in estimator_df.columns:\n",
     "                if col not in result_df.columns:\n",
     "                    result_df.insert(1, col, estimator_df[col][0] * np.ones(result_df.shape[0]))\n",
-    "            results.append(result_df)"
+    "            results.append(result_df)\n",
+    "        \n",
+    "        all_results = pd.concat(results)\n",
+    "        if previous is not None:\n",
+    "            final_results = pd.concat([all_results, previous])\n",
+    "        else:\n",
+    "            final_results = all_results\n",
+    "        final_results.to_csv(outfile, index=False)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "27"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "if previous is not None:\n",
+    "    final_results = pd.concat([all_results, previous])\n",
+    "else:\n",
+    "    final_results = all_results\n",
+    "final_results.to_csv(outfile, index=False)\n",
+    "np.unique(final_results['instance_id']).shape[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## False Discovery Proportion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
    "metadata": {},
    "outputs": [],
    "source": [
-    "all_results = pd.concat(results)\n",
-    "outfile = 'selected_target_results.csv'\n",
-    "all_results.to_csv(outfile, index=False)"
+    "fdp_results = []\n",
+    "for key, df in all_results.groupby(['instance_id', 'method_name', 'snr']):\n",
+    "    fdp_results.append(list(key[1:]) + [df['fdp'].mean()])\n",
+    "fdp_results = pd.DataFrame(fdp_results, columns=['method_name', 'snr', 'FDP'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a2cbab910>"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12, 6))\n",
+    "sns.pointplot(x='snr',\n",
+    "              y='FDP',\n",
+    "              hue='method_name',\n",
+    "              data=fdp_results,\n",
+    "              palette=palette)"
    ]
   },
   {
@@ -577,7 +663,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -590,22 +676,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x1a1ddaa690>"
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a2bf5b3d0>"
       ]
      },
-     "execution_count": 28,
+     "execution_count": 40,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x432 with 1 Axes>"
       ]
@@ -627,22 +713,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x1a1e794850>"
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a2c3cae50>"
       ]
      },
-     "execution_count": 27,
+     "execution_count": 41,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x432 with 1 Axes>"
       ]
@@ -671,7 +757,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -687,7 +773,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
@@ -696,13 +782,13 @@
        "(-0.5, 2.5)"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 43,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x432 with 1 Axes>"
       ]
@@ -727,22 +813,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x1a1e3f9c90>"
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a2d24f0d0>"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 44,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs0AAAFzCAYAAADFZzQZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de7ReZWEm8OdNQhLulUsNJtZEliCQBHIFRcK1SJVG0cpFawaVlVUhEkcUYTooM12ucSJLINRpxYkKmAFGRMRaO1NmSAsK4okk0EkUhyZiIqEhOoFEIpzknT9yOA0Q2F9CzvednPP7rXXW+fb9Od9yw+Pm3XuXWmsAAICXN6TTAQAAoL9TmgEAoIHSDAAADZRmAABooDQDAEADpRkAABoM66sdl1K+muTMJP9Sax3fM++AJLcmGZtkZZKza62/adrXQQcdVMeOHdtXUQEAIIsXL36y1nrw9paVvnpOcyllRpINSW7cpjTPS/LrWuvnSymXJXlNrfXTTfuaOnVq7erq6pOcAACQJKWUxbXWqdtb1mfDM2qt/5jk1y+a/a4kN/R8viHJu/vq+AAAsKu0e0zza2utjydJz+/ff7kVSymzSyldpZSutWvXti0gAAC8WL+9EbDWen2tdWqtderBB293aAkAALRFn90I+DKeKKUcUmt9vJRySJJ/afPxAQD6leeeey6rVq3Kpk2bOh1l0Bg5cmTGjBmTPfbYo+Vt2l2a70zyb5J8vuf3d9p8fACAfmXVqlXZd999M3bs2JRSOh1nwKu1Zt26dVm1alXGjRvX8nZ9NjyjlHJzkvuSHF5KWVVK+Ui2luU/LKX8PMkf9kwDAAxamzZtyoEHHqgwt0kpJQceeOAOX9nvsyvNtdbzXmbRqX11TACA3ZHC3F4783332xsBAQCgv1CaAQAGiSVLluRv//Zve6evvPLKXHXVVTu9v1e7/e5EaQYAGCReXJppndIMALAbWblyZd785jfnggsuyPjx4/OBD3wgd911V44//vi86U1vygMPPJCNGzfmwx/+cKZNm5ZJkyblO9/5Tp599tl85jOfya233ppjjjkmt956a5Jk2bJlOemkk/LGN74x8+fP7z3OF7/4xYwfPz7jx4/PNddc0zv/c5/7XA4//PCcdtpp+dnPfvaKWU866aR8+tOfzvTp03PYYYflnnvu6f0bTjjhhEyePDmTJ0/OD3/4wyTJokWLcuKJJ+bss8/OYYcdlssuuywLFy7M9OnTM2HChDz66KNJkrVr1+a9731vpk2blmnTpuUHP/jBLv2Ot6vW2u9/pkyZUgEABqJly5bt0PorVqyoQ4cOrQ899FDdvHlznTx5cv3Qhz5Ut2zZUu+44476rne9q15++eX1pptuqrXW+pvf/Ka+6U1vqhs2bKhf+9rX6kUXXdS7r89+9rP1LW95S920aVNdu3ZtPeCAA+qzzz5bu7q66vjx4+uGDRvq008/XY888sj6k5/8pHf+xo0b6/r16+uhhx5av/CFL7xs1hNPPLF+4hOfqLXW+r3vfa+eeuqptdZaN27cWJ955plaa62PPPJIfb7r3X333XX//fevv/rVr+qmTZvq6173uvqZz3ym1lrrNddcU+fOnVtrrfW8886r99xzT6211l/84hf1zW9+8w59h7Vu/3tP0lVfpo+2+znNALBLXXrppVmzZk1GjRqVefPmdToOtMW4ceMyYcKEJMlRRx2VU089NaWUTJgwIStXrsyqVaty55139o433rRpUx577LHt7uud73xnRowYkREjRuT3f//388QTT+Tee+/NWWedlb333jtJ8p73vCf33HNPtmzZkrPOOit77bVXkmTmzJmNWd/znvckSaZMmZKVK1cm2fpClzlz5mTJkiUZOnRoHnnkkd71p02blkMOOSRJcuihh+b0009PkkyYMCF33313kuSuu+7KsmXLerd56qmn8vTTT2ffffdt7QvcCUozALu1NWvWZPXq1Z2OAW01YsSI3s9DhgzpnR4yZEi6u7szdOjQfOtb38rhhx/+gu1+9KMfveK+hg4dmu7u7my96Lp9O/q4tuf3//y+k+Tqq6/Oa1/72ixdujRbtmzJyJEjW/7bkmTLli257777sueee+5QllfDmGYAgAHm7W9/e6677rre8vvggw8mSfbdd988/fTTjdvPmDEjd9xxR377299m48aN+fa3v50TTjghM2bMyLe//e0888wzefrpp/Pd7353p/KtX78+hxxySIYMGZKbbropmzdv3qHtTz/99PzlX/5l7/SSJUt2KseOUJoBAAaYK664Is8991wmTpyY8ePH54orrkiSnHzyyVm2bNkLbgTcnsmTJ+f888/P9OnTc+yxx+aCCy7IpEmTMnny5Jxzzjk55phj8t73vjcnnHDCTuW78MILc8MNN+S4447LI4880jsMpFXz589PV1dXJk6cmCOPPDJ//dd/vVM5dkR5pcvv/cXUqVNrV1dXp2MA0A/NmjUrq1evzujRo3PjjTd2Og7ssOXLl+eII47odIxBZ3vfeyllca116vbWd6UZAAAauBEQAIBX5aKLLnrJs5Lnzp2bD33oQx1KtOspzQAAvCpf+tKXOh2hzxmeAQAADZRmAABooDQDAEADpRkAYJArpeSDH/xg73R3d3cOPvjgnHnmmUmSr3/965kzZ85Lths7dmwmTJiQY445Jsccc0wuvvjitmVuNzcCAgD0I+PGrdyl+1uxYmzjOnvvvXf+6Z/+Kc8880z23HPP/P3f/31Gjx7d0v7vvvvuHHTQQa8yZf/nSjMAAPmjP/qjfO9730uS3HzzzTnvvPM6nKh/UZoBAMi5556bW265JZs2bcpDDz2UY489tqXtTj755N7hGVdffXUfp+wcwzMAAMjEiROzcuXK3HzzzXnHO97R8naDZXiG0gwAQJJk5syZ+eQnP5lFixZl3bp1nY7TryjNAAAkST784Q9n//33z4QJE7Jo0aJOx+lXlGYAAJIkY8aMydy5c7e77Otf/3ruuOOO3un7778/ydYxzUOHDk2ydYjHjTfe2PdBO0BpBgDoR1p5RNyutmHDhpfMO+mkk3LSSSclSc4///ycf/75L1ln5cqVfRusH/H0DAAAaKA0AwBAA6UZAAAaKM0AANBAaQYAgAZKMwAANFCaAQAGuVJKLrnkkt7pq666KldeeeUrbnPnnXfm85//fB8n6z88pxkAoB9ZOW7cLt3f2BUrGtcZMWJEbr/99lx++eU56KCDWtrvzJkzM3PmzFcbb7fhSjMAwCA3bNiwzJ49O1dfffVLln33u9/Nsccem0mTJuW0007LE088kWTrGwLnzJmT9evXZ+zYsdmyZUuS5Le//W1e//rX57nnnsujjz6aM844I1OmTMkJJ5yQn/70p239u3YlpRkAgFx00UVZuHBh1q9f/4L5b3vb23L//ffnwQcfzLnnnpt58+a9YPn++++fo48+Ov/wD/+QZGvJfvvb35499tgjs2fPznXXXZfFixfnqquuyoUXXti2v2dXMzwDAIDst99+mTVrVubPn58999yzd/6qVatyzjnn5PHHH8+zzz6bcdsZPnLOOefk1ltvzcknn5xbbrklF154YTZs2JAf/vCHed/73te73u9+97u2/C19wZVmAACSJB//+MezYMGCbNy4sXfexz72scyZMycPP/xwvvzlL2fTpk0v2W7mzJn5/ve/n1//+tdZvHhxTjnllGzZsiW/93u/lyVLlvT+LF++vJ1/zi6lNAMAkCQ54IADcvbZZ2fBggW989avX5/Ro0cnSW644YbtbrfPPvtk+vTpmTt3bs4888wMHTo0++23X8aNG5dvfvObSZJaa5YuXdr3f0QfUZoBAOh1ySWX5Mknn+ydvvLKK/O+970vJ5xwwis+WeOcc87JN77xjZxzzjm98xYuXJgFCxbk6KOPzlFHHZXvfOc7fZq9L5Vaa6czNJo6dWrt6urqdAwA+qFZs2Zl9erVGT16dG688cZOx4Edtnz58hxxxBGdjjHobO97L6UsrrVO3d76rjQDAEADpRkAABoozQAA0EBpBgCABkozAAA0UJoBAKCB0gwAMMiVUnLJJZf0Tl911VW58sorOxfoRfbZZ59OR8iwTgcAAOBfrVwwbpfub+xHVjSuM2LEiNx+++25/PLLX/EFJjtq8+bNGTp06C7bXye50gwAMMgNGzYss2fPztVXX/2SZb/4xS9y6qmnZuLEiTn11FPz2GOPJUnOP//8XHzxxXnrW9+aN77xjbntttuSJIsWLcrJJ5+c97///ZkwYUKS5N3vfnemTJmSo446Ktdff33vvvfZZ5/8+Z//eY4++ugcd9xxeeKJJ5IkK1asyFve8pZMmzYtV1xxRe/6tdZ86lOfyvjx4zNhwoTceuutvcc88cQTc/bZZ+ewww7LZZddloULF2b69OmZMGFCHn300Vf9HSnNAADkoosuysKFC7N+/foXzJ8zZ05mzZqVhx56KB/4wAdy8cUX9y57/PHHc++99+Zv/uZvctlll/XOf+CBB/K5z30uy5YtS5J89atfzeLFi9PV1ZX58+dn3bp1SZKNGzfmuOOOy9KlSzNjxox85StfSZLMnTs3H/3oR/PjH/84o0aN6t3v7bffniVLlmTp0qW566678qlPfSqPP/54kmTp0qW59tpr8/DDD+emm27KI488kgceeCAXXHBBrrvuulf9/SjNAABkv/32y6xZszJ//vwXzL/vvvvy/ve/P0nywQ9+MPfee2/vsne/+90ZMmRIjjzyyN6rxEkyffr0jBv3r8NM5s+f33s1+Ze//GV+/vOfJ0mGDx+eM888M0kyZcqUrFy5Mknygx/8IOedd17vMZ9377335rzzzsvQoUPz2te+NieeeGJ+/OMfJ0mmTZuWQw45JCNGjMihhx6a008/PUkyYcKE3v2+GkozAABJko9//ONZsGBBNm7c+LLrlFJ6P48YMaL3c6219/Pee+/d+3nRokW56667ct9992Xp0qWZNGlSNm3alCTZY489evc3dOjQdHd3b/c42zvGi22bZciQIb3TQ4YMecF+d5bSDABAkuSAAw7I2WefnQULFvTOe+tb35pbbrklSbJw4cK87W1v26F9rl+/Pq95zWuy11575ac//Wnuv//+xm2OP/74FxzzeTNmzMitt96azZs3Z+3atfnHf/zHTJ8+fYfy7CylGQCAXpdcckmefPLJ3un58+fna1/7WiZOnJibbrop11577Q7t74wzzkh3d3cmTpyYK664Iscdd1zjNtdee22+9KUvZdq0aS8YY33WWWdl4sSJOfroo3PKKadk3rx5Lxjz3JfKK13m7i+mTp1au7q6Oh0DgH5o1qxZWb16dUaPHp0bb7yx03Fghy1fvjxHHHFEp2MMOtv73kspi2utU7e3vivNAADQoCOluZTyb0sp/6eU8k+llJtLKSM7kQMAAFrR9tJcShmd5OIkU2ut45MMTXJuu3MAAECrOjU8Y1iSPUspw5LsleRXHcoBANBxu8M9ZgPJznzfbS/NtdbVSa5K8liSx5Osr7X+zxevV0qZXUrpKqV0rV27tt0xAQDaYuTIkVm3bp3i3Ca11qxbty4jR+7Y6OBhfZTnZZVSXpPkXUnGJfl/Sb5ZSvnTWus3tl2v1np9kuuTrU/PaHdOAIB2GDNmTFatWhUXCdtn5MiRGTNmzA5t0/bSnOS0JCtqrWuTpJRye5K3JvnGK24FADAA7bHHHi945TT9UyfGND+W5LhSyl5l6/sRT02yvAM5AACgJZ0Y0/yjJLcl+UmSh3syXN/uHAAA0KpODM9IrfWzST7biWMDAMCO8kZAAABooDQDAEADpRkAABoozQAA0EBpBgCABkozAAA0UJoBAKCB0gwAAA2UZgAAaKA0AwBAA6UZAAAaKM0AANBAaQYAgAZKMwAANFCaAQCggdIMAAANlGYAAGigNAMAQAOlGQAAGijNAADQQGkGAIAGSjMAADQY1ukAMFBceumlWbNmTUaNGpV58+Z1Og4AsAspzbCLrFmzJqtXr+50DACgDxieAQAADZRmAABooDQDAEADpRkAABoozQAA0EBpBgCABkozAAA0UJoBAKCB0gwAAA2UZgAAaKA0AwBAA6UZAAAaKM0AANBAaQYAgAZKMwAANFCaAQCggdIMAAANlGYAAGigNAMAQAOlGQAAGijNAADQQGkGAIAGSjMAADRQmgEAoIHSDAAADZRmAABooDQDAEADpRkAABoozQAA0EBpBgCABkozAAA06EhpLqX8XinltlLKT0spy0spb+lEDgAAaMWwDh332iR/V2v9k1LK8CR7dSgHAAA0antpLqXsl2RGkvOTpNb6bJJn250DAABa1YnhGW9MsjbJ10opD5ZS/mspZe8Xr1RKmV1K6SqldK1du7b9KQEAoEcnSvOwJJOT/FWtdVKSjUkue/FKtdbra61Ta61TDz744HZnBACAXp0ozauSrKq1/qhn+rZsLdEAANAvtX1Mc611TSnll6WUw2utP0tyapJl7c4BwK63csG4th+z+6kxSYan+6kVbT/+2I+saOvxgM7p1NMzPpZkYc+TM/45yYc6lAMAABp1pDTXWpckmdqJYwMAwI7yRkAAAGigNAMAQAOlGQAAGijNAADQQGkGAIAGSjMAADRQmgEAoIHSDAAADZRmAABooDQDAEADpRkAABoMa2WlUsphST6V5A3bblNrPaWPcgEAQL/RUmlO8s0kf53kK0k2910cAADof1otzd211r/q0yQAANBPvWJpLqUc0PPxu6WUC5N8O8nvnl9ea/11H2YDAIB+oelK8+IkNUnpmf7UNstqkjf2RSgAAOhPXrE011rHJUkpZWStddO2y0opI/syGAAA9BetPnLuhy3OAwCAAadpTPOoJKOT7FlKmZR/HaaxX5K9+jgbAAD0C01jmt+e5PwkY5J8cZv5Tyf5d32UCQAA+pWmMc03JLmhlPLeWuu32pQJAAD6lVaf0/yGUsonXjRvfZLFtdYluzgTAAD0K63eCDg1yZ9l6/jm0UlmJzkpyVdKKZf2TTQAAOgfWr3SfGCSybXWDUlSSvlsktuSzMjWZznP65t4AADQea1eaf6DJM9uM/1ckjfUWp/JNm8IBACAgajVK83/Lcn9pZTv9Ez/cZKbSyl7J1nWJ8kAAKCfaKk011r/opTy/STHZ+uzmv+s1trVs/gDfRUOAAD6g1avNCfJg0l+9fw2pZQ/qLU+1iepAACgH2mpNJdSPpbks0meSLI5W6821yQT+y4aAAD0D61eaZ6b5PBa67q+DAMAAP1Rq0/P+GW2vswEAAAGnVavNP9zkkWllO9lm0fM1Vq/2CepAACgH2m1ND/W8zO85wcAAAaNVh859x+SpJSyd611Y99GAgCA/qWlMc2llLeUUpYlWd4zfXQp5b/0aTIAAOgnWr0R8Jokb0+yLklqrUuTzOirUAAA0J+0WppTa/3li2Zt3sVZAACgX2r1RsBfllLemqSWUoYnuTg9QzUAAGCga/VK858luSjJ6CSrkhyT5MK+CgUAAP1Jq0/PeDLJB7adV0r5eLaOdQYAgAGt5THN2/GJXZYCAAD6sVdTmssuSwEAAP3YqynNdZelAACAfuwVxzSXUp7O9stxSbJnnyQCAIB+5hVLc61133YFAQCA/qrV5zQDAECvSy+9NGvWrMmoUaMyb968Tsfpc0ozAAA7bM2aNVm9enWnY7TNq7kREAAABgWlGQAAGhiewYC0csG4th+z+6kxSYan+6kVbT/+2I+saOvxAGCwcaUZAAAaKM0AANBAaQYAgAZKMwAANFCaAQCggdIMAAANOlaaSylDSykPllL+plMZAACgFZ280jw3yfIOHh8AAFrSkdJcShmT5J1J/msnjg8AADuiU1ear0lyaZItL7dCKWV2KaWrlNK1du3a9iUDAIAXaXtpLqWcmeRfaq2LX2m9Wuv1tdaptdapBx98cJvSAQDAS3XiSvPxSWaWUlYmuSXJKaWUb3QgBwAAtKTtpbnWenmtdUytdWySc5P871rrn7Y7BwAAtMpzmgEAoMGwTh681rooyaJOZgAAgCauNAMAQAOlGQAAGijNAADQQGkGAIAGSjMAADRQmgEAoIHSDAAADZRmAABooDQDAEADpRkAABoozQAA0EBpBgCABkozAAA0UJoBAKCB0gwAAA2UZgAAaKA0AwBAA6UZAAAaKM0AANBAaQYAgAZKMwAANFCaAQCggdIMAAANhnU6AAAAr97KBePaerzup8YkGZ7up1a0/dhjP7KircdLXGkGAIBGSjMAADRQmgEAoIHSDAAADZRmAABooDQDAEADpRkAABoozQAA0EBpBgCABkozAAA0UJoBAKCB0gwAAA2UZgAAaKA0AwBAA6UZAAAaKM0AANBAaQYAgAZKMwAANFCaAQCggdIMAAANlGYAAGigNAMAQAOlGQAAGijNAADQQGkGAIAGSjMAADRQmgEAoIHSDAAADZRmAABooDQDAECDYZ0OAAPFgXt3v+A3ADBwtL00l1Jen+TGJKOSbElyfa312nbngF3tklPWdDoCANBHOnGluTvJJbXWn5RS9k2yuJTy97XWZR3IAgAAjdo+prnW+nit9Sc9n59OsjzJ6HbnAACAVnX0RsBSytgkk5L8aDvLZpdSukopXWvXrm13NAAA6NWx0lxK2SfJt5J8vNb61IuX11qvr7VOrbVOPfjgg9sfEAAAenTk6RmllD2ytTAvrLXe3okMAAwMnlwDtEMnnp5RkixIsrzW+sV2Hx+AgcWTa4B26MTwjOOTfDDJKaWUJT0/7+hADgAAaEnbrzTXWu9NUtp9XAAA2Fleow0AAA2UZgAAaKA0AwBAg448cg4AgN3bYHvco9IMAMAOG2yPezQ8AwAAGijNAADQQGkGAIAGSjMAADRQmgEAoIHSDAAADZRmAABooDQDAEADpRkAABoozQAA0EBpBgCABkozAAA0UJoBAKCB0gwAAA2GdTrAYHPppZdmzZo1GTVqVObNm9fpOAAAtEBpbrM1a9Zk9erVnY4BAMAOMDwDAAAaKM0AANBAaQYAgAZKMwAANBjUNwKOG7ey7cccM6Y7w4cnK1Z0t/34K1aMbevxAAAGCleaAQCggdIMAAANBvXwjE7o7j7wBb8BAOj/lOY2W7Pmkk5HaBtvP6Q/8b9HAF4NpZk+4+2HvJzO3IS7KsOHP+EmXAB2itI8iKwcN66tx+seMyYZPjzdK1a0/dj59+09HAAwsCnNwKDgfgIAXg2lmT5zYHf3C35DJw2m+wkSY7gBdjWlmT5zyZo1nY4Ag5Z7CgB2Lc9pBgCABq40A/Sxtt8Imw7eiOsmXF7EUCEGCqUZAOgzhgoxUCjNAAOQG3F5Oe1+TvmYMd0ZPjyD5hnprqwPXEozwADkRlzoDFfWBy6lGQAYkAbV/QSJewr6mNIMAPQZLxZioFCaAYA+M9heLOR+goFLaQYA2EXcTzBwebkJAAA0UJoBAKCB0gwAAA2UZgAAaKA0AwBAA6UZAAAaKM0AANBAaQYAgAZKMwAANFCaAQCggdIMAAANlGYAAGjQkdJcSjmjlPKzUsr/LaVc1okMAADQqraX5lLK0CRfSvJHSY5Mcl4p5ch25wAAgFZ14krz9CT/t9b6z7XWZ5PckuRdHcgBAAAtKbXW9h6wlD9Jckat9YKe6Q8mObbWOudF681OMrtn8vAkP2trUHaVg5I82ekQMEg5/6AznHu7rzfUWg/e3oJh7U6SpGxn3kuae631+iTX930c+lIppavWOrXTOWAwcv5BZzj3BqZODM9YleT120yPSfKrDuQAAICWdKI0/zjJm0op40opw5Ocm+TODuQAAICWtH14Rq21u5QyJ8n/SDI0yVdrrf+n3TloG0NsoHOcf9AZzr0BqO03AgIAwO7GGwEBAKCB0gwAAA2UZnZa0+vQSykzSik/KaV09zyfe9tlm0spS3p+3AgKO6mF8/ATpZRlpZSHSin/q5Tyhk7khIGghfPtz0opD/f8u+3e5994XEo5sJRydyllQynlL9ufnF3BmGZ2Ss/r0B9J8ofZ+hjBHyc5r9a6bJt1xibZL8knk9xZa71tm2Ubaq37tDMzDDQtnocnJ/lRrfW3pZSPJjmp1npORwLDbqzF822/WutTPZ9nJrmw1npGKWXvJJOSjE8y/sUvdGP34EozO6vxdei11pW11oeSbOlEQBgEWjkP7661/rZn8v5sfTY+sONaOd+e2mZy7/S8vK3WurHWem+STe0Ky66nNLOzRif55TbTq3rmtWpkKaWrlHJ/KeXduzYaDBo7eh5+JMn3+zQRDFwtnW+llItKKY8mmZfk4jZlow2UZnZWS69DfwV/0POK0fcnuaaUcuiuiQWDSsvnYSnlT5NMTfKFPk0EA1dL51ut9Uu11kOTfDrJv+/zVLSN0szOelWvQ6+1/qrn9z8nWZStY72AHdPSeVhKOS3JnyeZWWv9XZuywUCzo//euyWJ/5I6gCjN7Kydfh16KeU1pZQRPZ8PSnJ8kmWvvBWwHY3nYSllUpIvZ2th/pcOZISBopXz7U3bTL4zyc/bmI8+1vbXaDMwvNzr0Esp/zFJV631zlLKtCTfTvKaJH9cSvkPtdajkhyR5MullC3Z+n/cPr/t3cdAa1o5D7N1OMY+Sb5ZSkmSx2qtMzsWGnZTLZ5vc3r+y85zSX6T5N88v30pZWW2PlFqeM+9PKf7d9/uxSPnAACggeEZAADQQGkGAIAGSjMAADRQmgEAoIHSDAAADZRmAABooDQDDDKlFM/oB9hB/sEJsJsqpeyd5L9n6+t8hyb5iyT/OckNSf44yR5J3ldr/Wkp5cokr0syNsmTSd7fgcgAuy1XmgF2X2ck+VWt9eha6/gkf9cz/8la6+Qkf5Xkk9usPyXJu2qtCjPADlKaAXZfDyc5rZTyn0spJ9Ra1/fMv73n9+JsvbL8vDtrrc+0MyDAQGF4BsBuqtb6SCllSpJ3JPlPpZT/2bPodz2/N+eF/5zf2M58AAOJ0gywmyqlvC7Jr2ut3yilbEhyfocjAQxYSjPA7mtCki+UUrYkeS7JR5Pc1tlIAANTqbV2OgMAAPRrbgQEAF5bKoUAAAAoSURBVIAGSjMAADRQmgEAoIHSDAAADZRmAABooDQDAEADpRkAABr8f++npRoZa1m4AAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 864x432 with 1 Axes>"
       ]
@@ -771,7 +857,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -785,7 +871,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
@@ -794,13 +880,13 @@
        "(0, 1.1)"
       ]
      },
-     "execution_count": 22,
+     "execution_count": 46,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtAAAAFzCAYAAAAXNz5BAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de5jWdb3v/+ebkYN5wFRKE4vR7QFkOA4oGR7SjEpRaymiy1MZ10pIK6x0uTR3++raLWNHYqy9sh+pGUs8pEalu5ZtTPGQDgqaoKSBiooLtSZFCQfevz9mmA3jMNxfmXvuOTwf1zXX3N/v93N/7vfMXDfz4jPv7/cbmYkkSZKk0vSqdAGSJElSV2KAliRJkgowQEuSJEkFGKAlSZKkAgzQkiRJUgEGaEmSJKmAHSpdQFF77rlnDho0qNJlSJIkqZtbtGjRq5k5oOX+LhegBw0aRF1dXaXLkCRJUjcXEc+1tt8WDkmSJKkAA7QkSZJUgAFakiRJKqDL9UBLkiR1J++88w6rVq1i3bp1lS6lx+rXrx8DBw6kd+/eJY03QEuSJFXQqlWr2GWXXRg0aBARUelyepzM5LXXXmPVqlVUV1eX9BxbOCRJkipo3bp17LHHHobnCokI9thjj0J/ATBAS5IkVZjhubKKfv8N0JIkSVIBBmhJkqQeZvHixdx5553N21dccQUzZsx4z/Nt7/O7GgO0JElSD9MyQKsYA7QkSVIXtHLlSg4++GDOO+88hg4dyhlnnMHdd9/N4YcfzgEHHMDDDz/M2rVr+fznP8+YMWMYOXIkv/jFL1i/fj2XX345N910EyNGjOCmm24CYOnSpRx11FHst99+zJo1q/l1vv/97zN06FCGDh3KD37wg+b93/nOdzjooIM49thjefrpp9us9aijjuKb3/wmY8eO5cADD+S+++5r/hrGjx/PqFGjGDVqFA888AAA99xzD0ceeSSnnnoqBx54IBdffDFz585l7Nix1NTU8OyzzwKwZs0aPve5zzFmzBjGjBnD/fff367f463KzC71MXr06JQkSeouli5d+p6et2LFiqyqqsrHH388N2zYkKNGjcpzzz03N27cmHfccUeeeOKJeckll+QNN9yQmZl/+ctf8oADDsg333wzr7322pw6dWrzXN/61rdy3LhxuW7dulyzZk3uvvvuuX79+qyrq8uhQ4fmm2++mW+88UYOGTIkH3300eb9a9euzfr6+tx///3ze9/73lZrPfLII/NrX/taZmb++te/zmOOOSYzM9euXZtvv/12ZmYuX748N+W8BQsWZP/+/fOll17KdevW5Yc+9KG8/PLLMzPzBz/4QV544YWZmTl58uS87777MjPzueeey4MPPvg9fS8zW/85AHXZSh71OtCSJEldVHV1NTU1NQAccsghHHPMMUQENTU1rFy5klWrVjF//vzm/uR169bx/PPPtzrXZz7zGfr27Uvfvn35wAc+wCuvvMLChQs5+eST2WmnnQD47Gc/y3333cfGjRs5+eSTed/73gfAxIkTt1nrZz/7WQBGjx7NypUrgcabyEybNo3FixdTVVXF8uXLm8ePGTOGvffeG4D999+f4447DoCamhoWLFgAwN13383SpUubn/O3v/2NN954g1122aW0b+B7ZICWJEnqovr27dv8uFevXs3bvXr1oqGhgaqqKn7+859z0EEHbfG8P/zhD23OVVVVRUNDA42LsK0reum3TfNvmhtg5syZfPCDH2TJkiVs3LiRfv36lfy1AWzcuJEHH3yQHXfcsVAt28seaEmSpG7qk5/8JFdffXVzEH7ssccA2GWXXXjjjTe2+fwjjjiCO+64g7feeou1a9dy++23M378eI444ghuv/123n77bd544w1++ctfvqf66uvr2XvvvenVqxc33HADGzZsKPT84447jh/+8IfN24sXL35PdRRlgJYkSeqmLrvsMt555x2GDRvG0KFDueyyywA4+uijWbp06RYnEbZm1KhRnHPOOYwdO5ZDDz2U8847j5EjRzJq1CgmTZrEiBEj+NznPsf48ePfU33nn38+119/PYcddhjLly9vbhUp1axZs6irq2PYsGEMGTKEf//3f39PdRQVbS3Nd0a1tbVZV1dX6TIkSZLaxbJlyxg8eHCly+jxWvs5RMSizKxtOdYVaEmSJKkATyKUJElSu5g6deq7rsV84YUXcu6551aoovIwQEuSJKldzJ49u9IldAhbOCRJkqQCDNCSJElSAQZoSZIkqQADtCRJUg8XEZx55pnN2w0NDQwYMIDjjz8egOuuu45p06a963mDBg2ipqaGESNGMGLECC644IIOq7mSynYSYUT8BDge+K/MHNrK8QCuAj4NvAWck5mPlqseSZKkrqC6emW7zrdixaBtjtlpp5344x//yNtvv82OO+7If/7nf7LPPvuUNP+CBQvYc889t7PKrqWcK9DXARPaOP4p4ICmjynA/y5jLZIkSWrDpz71KX79618DcOONNzJ58uQKV9R5lS1AZ+a9wOttDDkR+Gk2egjYLSL2Llc9kiRJ2rrTTjuNefPmsW7dOh5//HEOPfTQkp539NFHN7dwzJw5s8xVdg6VvA70PsALm22vatr3csuBETGFxlVqPvzhD3dIcZIkST3JsGHDWLlyJTfeeCOf/vSnS36eLRwdK1rZl60NzMxrMrM2M2sHDBhQ5rIkSZJ6pokTJ3LRRRfZvrENlVyBXgXsu9n2QOClCtUiSZLU433+85+nf//+1NTUcM8991S6nE6rkivQ84GzotFhQH1mvqt9Q5IkSR1j4MCBXHjhha0eu+666xg4cGDzx6pVq4Ate6DPOuusjiy3YiKz1a6J7Z844kbgKGBP4BXgW0BvgMz896bL2P2Qxit1vAWcm5l125q3trY26+q2OUySJKlLWLZsGYMHD650GT1eaz+HiFiUmbUtx5athSMz22yeycbkPrVcry9JkiSVg3cilCRJkgowQEuSJEkFGKAlSZKkAgzQkiRJUgEGaEmSJKkAA7QkSVIPFxFMnz69eXvGjBlcccUVbT5n/vz5fPe73y1zZZ1TJe9EKEmSpBZWVle363yDVqzY5pi+ffty2223cckll7DnnnuWNO/EiROZOHHi9pbXJbkCLUmS1MPtsMMOTJkyhZkzZ77r2C9/+UsOPfRQRo4cybHHHssrr7wCNN6ZcNq0adTX1zNo0CA2btwIwFtvvcW+++7LO++8w7PPPsuECRMYPXo048eP56mnnurQr6tcDNCSJEli6tSpzJ07l/r6+i32f+xjH+Ohhx7iscce47TTTuPKK6/c4nj//v0ZPnw4v//974HGwP3JT36S3r17M2XKFK6++moWLVrEjBkzOP/88zvs6yknWzgkSZLErrvuyllnncWsWbPYcccdm/evWrWKSZMm8fLLL7N+/XqqW2kxmTRpEjfddBNHH3008+bN4/zzz+fNN9/kgQce4JRTTmke9/e//71DvpZycwVakiRJAHzlK19hzpw5rF27tnnfl7/8ZaZNm8YTTzzBj370I9atW/eu502cOJG77rqL119/nUWLFvHxj3+cjRs3sttuu7F48eLmj2XLlnXkl1M2BmhJkiQBsPvuu3PqqacyZ86c5n319fXss88+AFx//fWtPm/nnXdm7NixXHjhhRx//PFUVVWx6667Ul1dzS233AJAZrJkyZLyfxEdwAAtSZKkZtOnT+fVV19t3r7iiis45ZRTGD9+fJtX6Jg0aRI/+9nPmDRpUvO+uXPnMmfOHIYPH84hhxzCL37xi7LW3lEiMytdQyG1tbVZV1dX6TIkSZLaxbJlyxg8eHCly+jxWvs5RMSizKxtOdYVaEmSJKkAA7QkSZJUgAFakiRJKsAALUmSJBVggJYkSZIKMEBLkiRJBRigJUmSeriIYPr06c3bM2bM4IorrqhcQS3svPPOlS5hCztUugBJkiT9PyvnVLfrfIO+sGKbY/r27cttt93GJZdc0ubNUorasGEDVVVV7TZfZ+EKtCRJUg+3ww47MGXKFGbOnPmuY8899xzHHHMMw4YN45hjjuH5558H4JxzzuGCCy7gox/9KPvttx+33norAPfccw9HH300p59+OjU1NQCcdNJJjB49mkMOOYRrrrmmee6dd96ZSy+9lOHDh3PYYYfxyiuvALBixQrGjRvHmDFjuOyyy5rHZyZf//rXGTp0KDU1Ndx0003Nr3nkkUdy6qmncuCBB3LxxRczd+5cxo4dS01NDc8++2y7fr8M0JIkSWLq1KnMnTuX+vr6LfZPmzaNs846i8cff5wzzjiDCy64oPnYyy+/zMKFC/nVr37FxRdf3Lz/4Ycf5jvf+Q5Lly4F4Cc/+QmLFi2irq6OWbNm8dprrwGwdu1aDjvsMJYsWcIRRxzBj3/8YwAuvPBCvvSlL/HII4+w1157Nc972223sXjxYpYsWcLdd9/N17/+dV5++WUAlixZwlVXXcUTTzzBDTfcwPLly3n44Yc577zzuPrqq9v1e2WAliRJErvuuitnnXUWs2bN2mL/gw8+yOmnnw7AmWeeycKFC5uPnXTSSfTq1YshQ4Y0rx4DjB07lurq/9eKMmvWrOZV5hdeeIE//elPAPTp04fjjz8egNGjR7Ny5UoA7r//fiZPntz8mpssXLiQyZMnU1VVxQc/+EGOPPJIHnnkEQDGjBnD3nvvTd++fdl///057rjjAKipqWmet70YoCVJkgTAV77yFebMmcPatWu3OiYimh/37du3+XFmNj/eaaedmh/fc8893H333Tz44IMsWbKEkSNHsm7dOgB69+7dPF9VVRUNDQ2tvk5rr9HS5rX06tWrebtXr15bzNseDNCSJEkCYPfdd+fUU09lzpw5zfs++tGPMm/ePADmzp3Lxz72sUJz1tfX8/73v5/3ve99PPXUUzz00EPbfM7hhx++xWtucsQRR3DTTTexYcMG1qxZw7333svYsWML1dMeDNCSJElqNn36dF599dXm7VmzZnHttdcybNgwbrjhBq666qpC802YMIGGhgaGDRvGZZddxmGHHbbN51x11VXMnj2bMWPGbNGTffLJJzNs2DCGDx/Oxz/+ca688soteqQ7SrS1FN4Z1dbWZl1dXaXLkCRJahfLli1j8ODBlS6jx2vt5xARizKztuVYV6AlSZKkAgzQkiRJUgEGaEmSJKkAA7QkSZJUgAFakiRJKsAALUmSJBVggJYkSerhqqqqGDFiBEOHDuWEE07gr3/9a7vMu3LlSoYOHdouc11++eXcfffd2z3PzjvvvN1z7LDdM0iSJKndfPX9X23X+Wb+ZeY2x+y4444sXrwYgLPPPpvZs2dz6aWXtmsd2+vb3/52pUto5gq0JEmSmo0bN44XX3wRgDfffJNjjjmGUaNGUVNTwy9+8QugcWV58ODBfPGLX+SQQw7huOOO4+233wZg0aJFDB8+nHHjxjF79uzmedetW8e5555LTU0NI0eOZMGCBQBcd911nHTSSZxwwglUV1fzwx/+kO9///uMHDmSww47jNdffx2Ac845h1tvvZW6ujpGjBjBiBEjqKmpISIAePbZZ5kwYQKjR49m/PjxPPXUUwCsWLGCcePGMWbMGC677LJ2+R4ZoCVJkgTAhg0b+N3vfsfEiRMB6NevH7fffjuPPvooCxYsYPr06Wy6i/Wf/vQnpk6dypNPPsluu+3Gz3/+cwDOPfdcZs2axYMPPrjF3JvC9BNPPMGNN97I2Wefzbp16wD44x//yH/8x3/w8MMPc+mll/K+972Pxx57jHHjxvHTn/50i3lqa2tZvHgxixcvZsKECVx00UUATJkyhauvvppFixYxY8YMzj//fAAuvPBCvvSlL/HII4+0222/beGQJEnq4d5++21GjBjBypUrGT16NJ/4xCcAyEz++Z//mXvvvZdevXrx4osv8sorrwBQXV3NiBEjABg9ejQrV66kvr6ev/71rxx55JEAnHnmmdx1110ALFy4kC9/+csAHHzwwXzkIx9h+fLlABx99NHssssu7LLLLvTv358TTjgBgJqaGh5//PFWa7755pt59NFH+e1vf8ubb77JAw88wCmnnNJ8/O9//zsA999/f3O4P/PMM/nmN7+53d8vA7QkSVIPt6kHur6+nuOPP57Zs2dzwQUXMHfuXNasWcOiRYvo3bs3gwYNal417tu3b/Pzq6qqePvtt8nM5paKljatXLdm87l69erVvN2rVy8aGhreNf7JJ5/kW9/6Fvfeey9VVVVs3LiR3XbbrbmPu6Wt1fRe2cIhSZIkAPr378+sWbOYMWMG77zzDvX19XzgAx+gd+/eLFiwgOeee67N5++2227079+fhQsXAjB37tzmY0cccUTz9vLly3n++ec56KCDCtdYX1/Paaedxk9/+lMGDBgAwK677kp1dTW33HIL0BjWlyxZAsDhhx/OvHnz3lXP9jBAS5IkqdnIkSMZPnw48+bN44wzzqCuro7a2lrmzp3LwQcfvM3nX3vttUydOpVx48ax4447Nu8///zz2bBhAzU1NUyaNInrrrtui5XnUt1xxx0899xzfPGLX2w+mRAaw/GcOXMYPnw4hxxySPMJj1dddRWzZ89mzJgx1NfXF3691kRby+mdUW1tbdbV1VW6DEmSpHaxbNkyBg8eXOkyerzWfg4RsSgza1uOdQVakiRJKsAALUmSJBVggJYkSZIKMEBLkiRVWFc7J627Kfr9N0BLkiRVUL9+/XjttdcM0RWSmbz22mv069ev5Od4IxVJkqQKGjhwIKtWrWLNmjWVLqXH6tevHwMHDix5fFkDdERMAK4CqoD/LzO/2+L4h4Hrgd2axlycmXeWsyZJkqTOpHfv3lRXV1e6DBVQthaOiKgCZgOfAoYAkyNiSIth/wLcnJkjgdOAfytXPZIkSVJ7KGcP9Fjgmcz8c2auB+YBJ7YYk8CuTY/7Ay+VsR5JkiRpu5WzhWMf4IXNtlcBh7YYcwXw24j4MrATcGwZ65Ek9XDf+MY3WL16NXvttRdXXnllpcuR1EWVcwU6WtnX8vTSycB1mTkQ+DRwQ0S8q6aImBIRdRFRZ4O9JOm9Wr16NS+++CKrV6+udCmSurByBuhVwL6bbQ/k3S0aXwBuBsjMB4F+wJ4tJ8rMazKzNjNrBwwYUKZyJUmSpG0rZ4B+BDggIqojog+NJwnObzHmeeAYgIgYTGOAdolZkiRJnVbZAnRmNgDTgN8Ay2i82saTEfHtiJjYNGw68MWIWALcCJyTXkVckiRJnVhZrwPddE3nO1vsu3yzx0uBw8tZgyRJktSevJW3JEmSVIABWpIkSSrAAC1JkiQVUNYeaEmSJKm73cTIAC1JkqSy2nQTo+7CFg5JkiSpAFegpQrobn/KkiSpJzFASxXQ3f6UJUlST2ILhyRJklSAAVqSJEkqwBYObcHeXEmSpLYZoLUFe3MlSZLaZguHJEmSVIABWpIkSSrAAC1JkiQVYA+0JElqN56Mrp7AAC1JktqNJ6OrJzBAS5I6pa++/6vtPueaIWugH6x5dk27zz/zLzPbdT5JnZc90JIkSVIBrkBLkqQezb5tFWWAltQt+QtRUqns21ZRBmhJ3ZK/ECXpvfH8g22zB1qSJEkqwBVoSeokbDuRpK7BAF1m/kKUVCrbTiSpazBAl5m/ECVJkroXe6AlSZKkAgzQkiRJUgG2cHRhK6ur233OhoEDoU8fGlasKMv8g1asaPc5JUmSOpIr0JIkSVIBbQboaLRvRxUjSZIkdXZtBujMTOCODqpFkiRJ6vRKaeF4KCLGlL0SSZIkqQso5STCo4F/ioiVwFogaFycHlbOwiRJkjZXjpPbobwn0HvyfPdUSoD+VNmrkCRJkrqIbQbozHwuIj4GHJCZ10bEAGDn8pcmSZLKqbp6ZbvPOXBgA336wIoVDe0+/4J2nU1677bZAx0R3wK+CVzStKs38LNyFiVJkiR1VqWcRHgyMJHG/mcy8yVgl3IWJUmSJHVWpfRAr8/MjIgEiIidylyT1Gl89f1fLcu8a4asgX6w5tk17f4aM/8ys13nkyRJWyolQN8cET8CdouILwKfB35c3rIkqfPySgCS1LOVchLhjIj4BPA34CDg8sz8z7JXJkmSpG6hz/o+W3zu6rYZoCPi88B9mfn1DqhHUg/klQAkqXvb75n9Kl1CuyqlhWMQ8I8R8RFgEXAfjYF6cTkLkyRJkjqjbV6FIzMvz8yPA0OBhcDXaQzSkiRJUo9TSgvHvwCH03jzlMeAi2hchZYkqUvpbn2YkiqjlBaOzwINwK+B3wMPZea6slYlSVIZdLc+TEmVUUoLxyjgGOBh4BPAExGxsNyFSZIkdYQ9Ghr44Pr17NHQUOlS1EWU0sIxFBgPHAnUAi9gC0e3tekfD/8RkST1FNNXr650CepiSmnh+FfgXmAW8EhmvlPeklRJ/iMiSZLUtlJupPKZiOgDHAgcFBFPG6IlSZLUU22zBzoijgT+BMwG/g1YHhFHlDJ5REyIiKcj4pmIuHgrY06NiKUR8WRE/EeR4iVJkqSOVkoLx/eB4zLzaYCIOBC4ERjd1pMioorG0P0JYBXwSETMz8ylm405ALgEODwz/xIRH3hvX4YkSZLUMba5Ag303hSeATJzOdC7hOeNBZ7JzD9n5npgHnBiizFfBGZn5l+a5v6v0sqWJEmSKqOUAF0XEXMi4qimjx9T2p0I96Hxih2brGrat7kDgQMj4v6IeCgiJpRWtiRJklQZpbRwfAmYClwABI1X5Pi3Ep4XrezLVl7/AOAoYCBwX0QMzcy/bjFRxBRgCsCHP/zhEl5akiRVQkPDHlt8lrqjNgN0RIwE9gfuyszvF5x7FbDvZtsDgZdaGfNQ01U9VkTE0zQG6kc2H5SZ1wDXANTW1rYM4ZIkqZNYvXp6pUuQym6rAToiLgf+kcZ2jSsj4n9m5o8LzP0IcEBEVAMvAqcBp7cYcwcwGbguIvaksaXjzwVeo91UV68sy7wDBzbQpw+sWNHQ7q+xoF1nk1Rp3shIkrqGtlagJwEjMvOtiNgD+D9AyQE6MxsiYhrwG6AK+ElmPhkR3wbqMnN+07HjImIpsAH4ema+9l6/GEnqyryRkSR1DW0F6HWZ+RZAZr4WEaWccLiFzLwTuLPFvss3e5zA15o+JEmSpE6vrQC9f0TMb3ocLbbJzIllrUyStoMnMkmSyqWtAN3yms0zylmIJLUnT2SSJJXLVgN0Zv6+IwuRJEmSuoLCfc2SJElST2aAliRJkgooOUBHxE7lLESSJEnqCrYZoCPio03XaV7WtD08Ikq5lbckSZLU7ZSyAj0T+CTwGkBmLgGOKGdRkiRJUmdVUgtHZr7QYteGMtQiSZIkdXptXQd6kxci4qNARkQf4AKa2jkkSZKknqaUFeh/AqYC+wCrgBFN25Leoz7r+9BnXR/6rO9T6VIkSVJBpaxAR2aeUfZKpB5kv2f2q3QJkiTpPSplBfqBiPhtRHwhInYre0WSJElSJ7bNAJ2ZBwD/AhwCPBoRv4qIfyx7ZZIkSVInVOpVOB7OzK8BY4HXgevLWpUkSZLUSZVyI5VdI+LsiLgLeAB4mcYgLUmSJPU4pZxEuAS4A/h2Zj5Y5nokSZKkTq2UAL1fZmbZK5EkSZK6gK0G6Ij4QWZ+BZgfEe8K0Jk5sayVSZIkSZ1QWyvQNzR9ntERhUiSJEldwVYDdGYuano4IjOv2vxYRFwI/L6chUmSJEmdUSmXsTu7lX3ntHMdkiRJUpfQVg/0ZOB0oDoi5m92aBfgtXIXJkmSJHVGbfVAb7rm857A/9ps/xvA4+UsSpIkSeqs2uqBfg54LiLOAF7KzHUAEbEjMBBY2SEVSpIkSZ1IKT3QNwMbN9veANxSnnIkSZKkzq2UAL1DZq7ftNH0uE/5SpIkSZI6r1IC9JqIaL5pSkScCLxavpIkSZKkzquUW3n/EzA3ImYDCawCziprVZIkSVIntc0AnZnPAodFxM5AZOYb5S9LkiRJ6py22cIRER+MiDnALZn5RkQMiYgvdEBtkiRJUqdTSg/0dcBvgA81bS8HvlKugiRJkqTOrJQAvWdmNl/KLjMbaLyUnUrQ0LAH69d/kIaGPSpdiiRJktpBKScRro2IPWg8gZCIOAyoL2tV3cjq1dMrXYIkSZLaUSkB+mvAfGD/iLgfGAD8Q1mrkiRJkjqpUq7C8WhEHAkcBATwdGa+U/bKJEmSpE5oqwE6Ij67lUMHRgSZeVuZapIkSZI6rbZWoE9o41gCBmhJkiT1OFsN0Jl5bkcWIkmSJHUFJd9IJSLuatr2RiqSJEnqsbyRiiRJklSAN1KRJEmSCiglQHsjFUmSJKmJN1KRJEmSCvBGKpIkSVIBW23hiIgxEbEXNPc9jwa+A/yviNi9g+qTJEmSOpW2eqB/BKwHiIgjgO8CP6Wx//ma8pcmSZIkdT5ttXBUZebrTY8nAddk5s+Bn0fE4vKXJkmSJHU+ba1AV0XEpoB9DPB/NztWysmHkiRJUrfTVhC+Efh9RLwKvA3cBxAR/w0vYydJkqQeaqsBOjO/ExG/A/YGfpuZ2XSoF/DljihOkiRJ6mzavJFKZj6Umbdn5trN9i3PzEdLmTwiJkTE0xHxTERc3Ma4f4iIjIja0kuXJEmSOl4pdyJ8TyKiCpgNfAoYAkyOiCGtjNsFuAD4Q7lqkSRJktpL2QI0MBZ4JjP/nJnrgXnAia2M+x/AlcC6MtYiSZIktYtyBuh9gBc2217VtK9ZRIwE9s3MX7U1UURMiYi6iKhbs2ZN+1cqSZIklaicATpa2ZfNByN6ATOB6duaKDOvyczazKwdMGBAO5YoSZIkFVPO6zmvAvbdbHsg8NJm27sAQ4F7IgJgL2B+REzMzLoy1qVu5hvf+AarV69mr7324sorr6x0OZIkqZsrZ4B+BDggIqqBF4HTgNM3HczMemDPTdsRcQ9wkeFZRa1evZoXX3yx0mVIkqQeomwtHJnZAEwDfgMsA27OzCcj4tsRMbFcrytJkiSVU1lvyZ2ZdwJ3tth3+VbGHlXOWiRJ7cv2KUk9VVkDtCSp+7J9SlJPVc6rcEiSJEndjgFakiRJKsAALUmSJBVggJYkSZIKMEBLkqcI230AAAkPSURBVCRJBRigJUmSpAK8jJ0kSVIX4jXYK88ALUmS1IV4DfbKs4VDkiRJKsAALUmSJBVgC4ck9QAr51S3+5wNfxsI9KHhbyvKMj+cVIY5JWn7GaDVobreL3F/gUuSpC3ZwiFJkiQVYICWJEmSCjBAS5IkSQUYoCVJkqQCDNCSJElSAQZoSZIkqQADtCRJklSAAVqSJEkqwBupSJIklUnXu4EYeBOxbXMFWpIkSSrAAC1JkiQVYAuHJOk92WOnhi0+S1JPYYCWJL0n0z++utIlSFJF2MIhSZIkFeAKtLo8/4wsSZI6kgFaXZ5/RpYkSR3JFg5JkiSpAAO0JEmSVIABWpIkSSrAAC1JkiQVYICWJEmSCvAqHJIkSV2Il2+tPAO0JElSF+LlWyvPFg5JkiSpAAO0JEmSVIABWpIkSSrAAC1JkiQVYICWJEmSCjBAS5IkSQUYoCVJkqQCDNCSJElSAQZoSZIkqQADtCRJklSAAVqSJEkqwAAtSZIkFWCAliRJkgowQEuSJEkFlDVAR8SEiHg6Ip6JiItbOf61iFgaEY9HxO8i4iPlrEeSJEnaXmUL0BFRBcwGPgUMASZHxJAWwx4DajNzGHArcGW56pEkSZLaQzlXoMcCz2TmnzNzPTAPOHHzAZm5IDPfatp8CBhYxnokSZKk7VbOAL0P8MJm26ua9m3NF4C7WjsQEVMioi4i6tasWdOOJUqSJEnFlDNARyv7stWBEf8I1ALfa+14Zl6TmbWZWTtgwIB2LFGSJEkqZocyzr0K2Hez7YHASy0HRcSxwKXAkZn59zLWI0mSJG23cq5APwIcEBHVEdEHOA2Yv/mAiBgJ/AiYmJn/VcZaJEmSpHZRtgCdmQ3ANOA3wDLg5sx8MiK+HRETm4Z9D9gZuCUiFkfE/K1MJ0mSJHUK5WzhIDPvBO5sse/yzR4fW87XlyRJktqbdyKUJEmSCjBAS5IkSQUYoCVJkqQCDNCSJElSAQZoSZIkqQADtCRJklSAAVqSJEkqwAAtSZIkFWCAliRJkgowQEuSJEkFGKAlSZKkAgzQkiRJUgEGaEmSJKkAA7QkSZJUgAFakiRJKsAALUmSJBVggJYkSZIKMEBLkiRJBRigJUmSpAIM0JIkSVIBBmhJkiSpAAO0JEmSVIABWpIkSSrAAC1JkiQVYICWJEmSCjBAS5IkSQUYoCVJkqQCDNCSJElSAQZoSZIkqQADtCRJklSAAVqSJEkqwAAtSZIkFWCAliRJkgowQEuSJEkFGKAlSZKkAgzQkiRJUgEGaEmSJKkAA7QkSZJUgAFakiRJKsAALUmSJBVggJYkSZIKMEBLkiRJBRigJUmSpAIM0JIkSVIBBmhJkiSpAAO0JEmSVIABWpIkSSrAAC1JkiQVYICWJEmSCjBAS5IkSQWUNUBHxISIeDoinomIi1s53jcibmo6/oeIGFTOeiRJkqTtVbYAHRFVwGzgU8AQYHJEDGkx7AvAXzLzvwEzgX8tVz2SJElSeyjnCvRY4JnM/HNmrgfmASe2GHMicH3T41uBYyIiyliTJEmStF3KGaD3AV7YbHtV075Wx2RmA1AP7FHGmiRJkqTtEplZnokjTgE+mZnnNW2fCYzNzC9vNubJpjGrmrafbRrzWou5pgBTmjYPAp4uS9HqCHsCr1a6CKkH8r0nVYbvva7tI5k5oOXOHcr4gquAfTfbHgi8tJUxqyJiB6A/8HrLiTLzGuCaMtWpDhQRdZlZW+k6pJ7G955UGb73uqdytnA8AhwQEdUR0Qc4DZjfYsx84Oymx/8A/N8s15K4JEmS1A7KtgKdmQ0RMQ34DVAF/CQzn4yIbwN1mTkfmAPcEBHP0LjyfFq56pEkSZLaQ9l6oKXWRMSUppYcSR3I955UGb73uicDtCRJklSAt/KWJEmSCjBAq12UcNv2IyLi0YhoiIh/aHFsQ0QsbvpoeaKppAJKeC9+LSKWRsTjEfG7iPhIJeqUuoMS3m//FBFPNP1+W7jpjswRsUdELIiINyPihx1fubaXLRzabk23bV8OfILGSxM+AkzOzKWbjRkE7ApcBMzPzFs3O/ZmZu7ckTVL3VGJ78WjgT9k5lsR8SXgqMycVJGCpS6sxPfbrpn5t6bHE4HzM3NCROwEjASGAkMzc1qHfwHaLq5Aqz1s87btmbkyMx8HNlaiQKmHKOW9uCAz32rafIjGa/RLKq6U99vfNtvcCcim/WszcyGwrqOKVfsyQKs9lHLb9rb0i4i6iHgoIk5q39KkHqXoe/ELwF1lrUjqvkp6v0XE1KY7LV8JXNBBtanMDNBqD9HKviK9QR9uukvT6cAPImL/9ilL6nFKfi9GxD8CtcD3ylqR1H2V9H7LzNmZuT/wTeBfyl6VOoQBWu2hlNu2b1VmvtT0+c/APTT2hUkqrqT3YkQcC1wKTMzMv3dQbVJ3U/R33zzAv7J2EwZotYdSbtveqoh4f0T0bXq8J3A4sLTtZ0naim2+FyNiJPAjGsPzf1WgRqm7KOX9dsBmm58B/tSB9amMynYrb/Ucpdy2PSLGALcD7wdOiIj/npmHAIOBH0XERhr/Q/fdzc9gllS6Ut6LNLZs7AzcEhEAz2fmxIoVLXVRJb7fpjX9xecd4C/A2ZueHxErabw6VZ+m83+O8/df1+Fl7CRJkqQCbOGQJEmSCjBAS5IkSQUYoCVJkqQCDNCSJElSAQZoSZIkqQADtCRJklSAAVqSeriI8J4AklSA/2hKUjcRETsBN9N4S+Eq4H8A/wpcD5wA9AZOycynIuIK4EPAIOBV4PQKlCxJXZIr0JLUfUwAXsrM4Zk5FPg/TftfzcxRwP8GLtps/GjgxMw0PEtSAQZoSeo+ngCOjYh/jYjxmVnftP+2ps+LaFxx3mR+Zr7dkQVKUndgC4ckdROZuTwiRgOfBv5nRPy26dDfmz5vYMt/99d2ZH2S1F0YoCWpm4iIDwGvZ+bPIuJN4JwKlyRJ3ZIBWpK6jxrgexGxEXgH+BJwa2VLkqTuJzKz0jVIkiRJXYYnEUqSJEkFGKAlSZKkAgzQkiRJUgEGaEmSJKkAA7QkSZJUgAFakiRJKsAALUmSJBVggJYkSZIK+P8BLMgsN0vuCvoAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x432 with 1 Axes>"
       ]
@@ -830,7 +916,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -844,7 +930,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [
     {
@@ -853,13 +939,13 @@
        "(0, 1.1)"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtAAAAFzCAYAAAAXNz5BAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3df9zX893//9ujQ0e1xEibTZwds7L8GCn5OcIQJ7KWUGY2P845sfkZNuPUxui0hZ0tP2YnjaT4REj2PS3GpimhjURTUe2Y0BT90FHP7x/H4VhH6uj9qvfreB8/btfLpcv7/fr1fN+PLl7cvY7n+/WKlBKSJEmSCtOq1AEkSZKkpsQCLUmSJGVggZYkSZIysEBLkiRJGVigJUmSpAws0JIkSVIGW5Q6QFbbbbdd6tKlS6ljSJIkqZl74YUX3k0pdVp3fZMr0F26dGHatGmljiFJkqRmLiLmrW+9UzgkSZKkDCzQkiRJUgYWaEmSJCkDC7QkSZKUgQVakiRJysACLUmSJGVggZYkSZIysEBLkiRJGVigJUmSpAws0JIkSVIGFmhJkiQpAwu0JEmSlIEFWpIkScrAAi1JkiRlYIGWJEmSMrBAS5IkSRlYoCVJkqQMLNCSJElSBhZoSZIkKQMLtCRJkpSBBVqSJEnKwAItSZIkZWCBliRJkjKwQEuSJEkZ5FagI+I3EfFORPx1A9sjIm6JiNkRMSMi9s4riyRJklQseV6BvgvoW8/2o4GuNX/OBkbmmEWSJEkqii3yGjil9IeI6FLPLv2AUSmlBEyJiM9GxBdSSn/PK5MkNWZDhgyhsrKS7bffnmHDhpU6jrRJ/OdY69Pc/rnIrUAXYAfg7bWW59es+1SBjoizqb5KzU477dQg4SSpoVVWVrJgwYJSx5A2S57/HM+tqMhl3Dx1mTOn1BEaheb277dSfokw1rMurW/HlNLtKaVeKaVenTp1yjmWJEmStGGlvAI9H9hxreXOwMISZZGkguV1Fayqc2coL6dqzpyif4ZXwSSpeEpZoCcA50XEGGBf4APnP5dec5ujJEmSVGy5FeiIuA/oA2wXEfOBq4HWACmlW4GJwDHAbGAZ8J28sqhwzW2OkiRpwyoq5hZ9zM6dqygvhzlzqoo+/uSijiZtujzvwnHKRrYn4Ny8Pl+SpHX5WzZJxVDKKRySJDUof8smbdyF21xY9DEX7boI2sKivy0q+vjDFw8v6niFsEBLUiPRsaqqzqskqXGyQEtqlprir+ovrqwsdQRJUgEs0JKaJX9VL0nKSykfpCJJkiQ1OV6BliRJRVNV1bHOq9QcWaAlSVLRVFZeXOoIUu4s0E1YHo8TzvNRwuDjhCVJUtPnHGhJkiQpA69AS5IkKVflH5fXeW3qLNCSJEnK1Zdmf6nUEYrKKRySJElSBhZoSZIkKQOncEiSGqULt7mw6GMu2nURtIVFf1tU9PGHLx5e1PEkNV5egZYkSZIy8Aq0pJKrqJhb9DE7d66ivBzmzKkq+viTizpa0zVkyBAqKyvZfvvtGTZsWKnjSFKDsUBLJWDxUHNQWVnJggULSh1DkhqcBVp1dKyqqvOqfFg8JElquizQquPiyspSR5AkSWrULNA581f1kiRJzYsFOmf+ql6SJKl58TZ2kiRJUgYWaEmSJCkDC7QkSZKUgQVakiRJysACLUmSJGVggZYkSZIysEBLkiRJGXgfaElSi1H+cXmdV0naFBZoSVKL8aXZXyp1BEnNgFM4JEmSpAy8Ai2pWaqq6ljnVZKkYrFAS2qWKisvLnWERmXunRVFH7NqSWegnKolc3IZH07IYUxJ2nwWaEmSpCZkyJAhVFZWsv322zNs2LBSx2mRLNCSJElNSGVlJQsWLCh1jBbNLxFKkiRJGVigJUmSpAws0JIkSVIGFmhJkiQpAwu0JEmSlIEFWpIkScrA29hJ9bhwmwtzGXfRrougLSz626Kif8bwxcOLOp4kSarLK9CSJElSBhZoSZIkKQMLtCRJkpSBBVqSJEnKwAItSZIkZWCBliRJkjKwQEuSJEkZeB9oSdIm6di+qs6rJLUUuRboiOgL3AyUAb9OKV2/zvadgLuBz9bsc3lKaWKemSRJxXHxYZWljiBJJZFbgY6IMmAEcAQwH5gaERNSSq+utduVwNiU0siI2BWYCHTJK1N9Kirm5jJu585VlJfDnDlVRf+MyUUdrekaMmQIlZWVbL/99gwbNqzUcSRJUjOX5xXo3sDslNKbABExBugHrF2gE7BVzfutgYU55lEzVVlZyYIFC0odQ5IktRB5FugdgLfXWp4P7LvOPv8F/C4izgfaA1/PMY8kSZK02fK8C0esZ11aZ/kU4K6UUmfgGOC3EfGpTBFxdkRMi4hpixYtyiGqJEmSVJg8C/R8YMe1ljvz6SkaZwBjAVJKzwFtge3WHSildHtKqVdKqVenTp1yiitJkiRtXJ5TOKYCXSOiAlgAnAwMWmeft4DDgbsiojvVBdpLzJIkqVmYe2dF0cesWtIZKKdqyZxcxocTchizecntCnRKqQo4D3gCmEn13TZeiYihEXF8zW4XA2dFxMvAfcDpKaV1p3lIkiRJjUau94GuuafzxHXWXbXW+1eBA/PMIEmSJBWTj/KWJEmSMrBAS5IkSRlYoCVJkqQMLNCSJElSBhZoSZIkKQMLtCRJkpSBBVqSJEnKwAItSZIkZWCBliRJkjKwQEuSJEkZWKAlSZKkDCzQkiRJUgYWaEmSJCkDC7QkSZKUgQVakiRJymCLUgdQyzL3zoqij1m1pDNQTtWSOTmMf0KRx5MkSU2dBVoqgfKPy+u8SpKkpsMCLZXAl2Z/qdQRJEnSJnIOtCRJkpSBBVqSJEnKwAItSZIkZeAcaEmSpCakY/uqOq9qeBZoSZKkJuTiwypLHaHFcwqHJEmSlIEFWpIkScrAAi1JkiRlYIGWJEmSMrBAS5IkSRl4F46cVVV1rPMqSZKkps0CnbPKyotLHUGSJElFVO8Ujqi2Y0OFkSRJkhq7egt0SikBDzVQFkmSJKnRK+RLhFMiYp/ck0iSJElNQCFzoA8FvhcRc4GPgKD64vRX8wwmSZIkNUaFFOijc08hSZIkNREbncKRUpoH7AgcVvN+WSHHSZIkSc3RRotwRFwNXAZcUbOqNXBPnqEkSZKkxqqQK8nfAI6nev4zKaWFQIc8Q0mSJEmNVSFzoD9OKaWISAAR0T7nTFImHdtX1XmVJEnKUyEFemxE3AZ8NiLOAr4L3JFvLKlwFx9WWeoIkiSpBdlogU4p3RgRRwBLgF2Aq1JK/1/uySRJkqRGaKMFOiK+CzyTUrq0AfJIkiRJjVohUzi6AKdGxL8BLwDPUF2oX8ozmCRJktQYFXIf6KtSSocBuwPPApdSXaQlSZKkFqeQKRxXAgcCWwIvApdQfRVakiRJanEKmcLRH6gCHgOeBqaklFbkmkqSJElqpAqZwrE3cDjwPHAE8JeIeDbvYJIkSVJjVMgUjt2BrwGHAL2At3EKhyRJklqoQqZw3AD8AbgFmJpSWpVvJEmSJKnxKuRBKv8eEeVAN2CXiJhliZYkSVJLtdE50BFxCPAGMAL4FfB6RBxcyOAR0TciZkXE7Ii4fAP7DIyIVyPilYgYnSW8JEmS1NAKmcLxC+DIlNIsgIjoBtwH9KzvoIgoo7p0HwHMB6ZGxISU0qtr7dMVuAI4MKW0OCI+t2k/hiRJktQwNnoFGmj9SXkGSCm9DrQu4LjewOyU0psppY+BMUC/dfY5CxiRUlpcM/Y7hcWWJEmSSqOQAj0tIu6MiD41f+6gsCcR7kD1HTs+Mb9m3dq6Ad0i4o8RMSUi+hYWW5IkSSqNQqZwnAOcC3wfCKrvyPGrAo6L9axL6/n8rkAfoDPwTETsnlL6Z52BIs4GzgbYaaedCvhoSZIkKR/1FuiI6AHsDDyeUvpFxrHnAzuutdwZWLiefabU3NVjTkTMorpQT117p5TS7cDtAL169Vq3hEuSJEkNZoNTOCLiKuB+4JvAYxFxVsaxpwJdI6Ki5jZ4JwMT1tnnIeDQms/bjuopHW9m/BxJkiSpwdR3BfokYK+U0rKI6AhMAu4odOCUUlVEnAc8AZQBv0kpvRIRQ4FpKaUJNduOjIhXgdXApSml9zb1h5EkSZLyVl+BXpFSWgaQUnovIgr5wmEdKaWJwMR11l211vsEXFTzR5IkSWr06ivQO0fEJ1MuYp1lUkrH55pMkiRJaoTqK9Dr3rP5xjyDSJIkSU3BBgt0SunphgwiSZIkNQWZ5zVLkiRJLZkFWpIkScqg4AIdEe3zDCJJkiQ1BRst0BFxQM19mmfWLO8ZEYU8yluSJElqdgq5Aj0cOAp4DyCl9DJwcJ6hJEmSpMaqoCkcKaW311m1OocskiRJUqNX332gP/F2RBwApIgoB75PzXQOSZIkqaUp5Ar094BzgR2A+cBeNcuSJElSi1PIFehIKQ3OPYkkSZLUBBRyBfpPEfG7iDgjIj6beyJJkiSpEdtogU4pdQWuBHYDpkfEoxFxau7JJEmSpEao0LtwPJ9SugjoDbwP3J1rKkmSJKmRKuRBKltFxLcj4nHgT8DfqS7SkiRJUotTyJcIXwYeAoamlJ7LOY8kSZLUqBVSoL+UUkq5J5EkSZKagA0W6Ii4KaV0ATAhIj5VoFNKx+eaTJIkSWqE6rsC/dua1xsbIogkSZLUFGywQKeUXqh5u1dK6ea1t0XED4Cn8wwmSZIkNUaF3Mbu2+tZd3qRc0iSJElNQn1zoE8BBgEVETFhrU0dgPfyDiZJkiQ1RvXNgf7kns/bAT9fa/1SYEaeoSRJkqTGqr450POAeRExGFiYUloBEBHtgM7A3AZJKEmSJDUihcyBHgusWWt5NTAunziSJElS41ZIgd4ipfTxJws178vziyRJkiQ1XoUU6EURUfvQlIjoB7ybXyRJkiSp8SrkUd7fA+6NiBFAAuYDp+WaSpIkSWqkNlqgU0p/A/aLiC2BSCktzT+WJEmS1DhtdApHRHw+Iu4ExqWUlkbErhFxRgNkkyRJkhqdQuZA3wU8AXyxZvl14IK8AkmSJEmNWSEFeruUUu2t7FJKVVTfyk6SJElqcQop0B9FREeqv0BIROwHfJBrKkmSJKmRKuQuHBcBE4CdI+KPQCdgQK6pJEmSpEaqkLtwTI+IQ4BdgABmpZRW5Z5MkiRJaoQ2WKAjov8GNnWLCFJK/y+nTJIkSVKjVd8V6OPq2ZYAC7QkSZJanA0W6JTSdxoyiCRJktQUFPwglYh4vGbZB6lIkiSpxfJBKpIkSVIGPkhFkiRJysAHqUiSJEkZ+CAVSZIkKQMfpCJJkiRlsMEpHBGxT0RsD7XznnsC1wI/j4htGyifJEmS1KjUNwf6NuBjgIg4GLgeGEX1/Ofb848mSZIkNT71TeEoSym9X/P+JOD2lNKDwIMR8VL+0SRJkqTGp74r0GUR8UnBPhz4/VrbCvnyoSRJktTs1FeE7wOejoh3geXAMwAR8WW8jZ0kSZJaqA0W6JTStRHxJPAF4HcppVSzqRVwfkOEkyRJkhqbeh+kklKaklIan1L6aK11r6eUphcyeET0jYhZETE7Ii6vZ78BEZEiolfh0SVJkqSGV8iTCDdJRJQBI4CjgV2BUyJi1/Xs1wH4PvDnvLJIkiRJxZJbgQZ6A7NTSm+mlD4GxgD91rPfT4BhwIocs0iSJElFkWeB3gF4e63l+TXrakVED2DHlNKj9Q0UEWdHxLSImLZo0aLiJ5UkSZIKlGeBjvWsS7UbI1oBw4GLNzZQSun2lFKvlFKvTp06FTGiJEmSlE2eBXo+sONay52BhWstdwB2B56KiLnAfsAEv0goSZKkxizPAj0V6BoRFRFRDpwMTPhkY0rpg5TSdimlLimlLsAU4PiU0rQcM0mSJEmbJbcCnVKqAs4DngBmAmNTSq9ExNCIOD6vz5UkSZLylOsjuVNKE4GJ66y7agP79skziyRJklQMeU7hkCRJkpodC7QkSZKUgQVakiRJysACLUmSJGVggZYkSZIysEBLkiRJGVigJUmSpAws0JIkSVIGFmhJkiQpAwu0JEmSlIEFWpIkScrAAi1JkiRlYIGWJEmSMrBAS5IkSRlYoCVJkqQMLNCSJElSBhZoSZIkKQMLtCRJkpSBBVqSJEnKwAItSZIkZWCBliRJkjKwQEuSJEkZWKAlSZKkDCzQkiRJUgYWaEmSJCkDC7QkSZKUgQVakiRJysACLUmSJGVggZYkSZIy2KLUAYph1apVzJ8/nxUrVmzyGHfcUVXERA1jKXeUOkK1NWto9dZbtPvlL2m1ZEmp00iSJOWqWRTo+fPn06FDB7p06UJEbNIYq1atLHKq/HUjlToCACklFnfsyPvnn0/7a68tdRxJkqRcNYspHCtWrKBjx46bXJ61eSKCbbbYgjU77VTqKJIkSblrFgUasDyXWERAq2bzj5MkSdIG2XgkSZKkDCzQm+i1117mmWcm1S6PHPkT7r57+CaPt7nHS5IkqWFYoDfRrFl1C7QkSZJahmZxF45NNXfuXPr27ctBBx3EU089xy677EG/fqcxcuRPeP/9RVx33V3svPOuXH/9hcye/QpVVVWcc86VHHTQUfzqV0NZuXIFL730J7773UsB+NvfZnLGGUfw97+/zeDB5zN48LkAjBp1Mw89dDcA/ft/h1NPPR+AO+64nkceuZftt+/MNttsx6677r3BrGeccQS7796bqVOfZunSf3LNNbeyy96dmLtgAd/90Y9Ytnw5AMOvuIL999qLp6dO5ScjR/L5jh15+bXXOOHww9mta1dG3Hsvy1euZOxNN7Hzjjuy6P33Of+nP+XtykoA/vvSSzmgR4/c/s4lSZKauhZdoAFmz57NuHHjOO+8XzJo0IFMnHg/d901maeeepQ77xzGl770FXr37sPQobezZMk/GTz4IPbd9zD+8z+v4pVXpvPDH94EVE/BmDv3dX796yf46KOl9Ov3VQYOPJs33vgLDz88invueQZIDB78NXr2/BoprWHSpHHcf/+fWb26ipNP3q/eAg2wenUVo0c/yzPPTOLWW6/llNtv4nPbbsvE226jbZs2zJ43j9Muv5w/3XcfAH95/XV+O3482269Nd2POYbT+/fn2dGj+Z9772Xkffdx45AhXDxsGOefeioH7r03b/397xx3zjm8/NBDef+1S5IkNVktvkBXVFSwxx57MGPGSnbeuTv77nsoEUHXrruxcOE8/vGPBTz11GOMGlVdlD/+eAWVlW+vd6yvfa0v5eVtKC9vw7bbduL99//Biy/+icMOO57PfKY9AIcf3o/p0/9ISms47LDjadfuMwAccsixG816+OH9ANh11x4sXDgPgFVVVVzws58xY9YsysrKeGPevNr9e+62G1/o1Kn659xxR76+//4A7PblL/P01KkATJ4yhdfefLP2mKUffsjSjz6iQ/v2hf8lSpIktSAtvkC3adOm9n2rVq0oL69ejmhFVVUVrVqV8YtfjKFLl251jvvLX57/1FifHFs9VhlVVVWktOGHnWS99d4n47dqVcbq1dVPTrzlnnv4fMeOTB03jjVr1rB1797/+tlat67zs7UpL699X1VVffyalHh61CjatW2bKYskSVJL5ZcIN+KAA77O6NG/qi3CM2e+BED79h1YtmzpRo/v2fMgJk9+hOXLl7Fs2Uf8/vcT2HvvA+nZ8yB+//sJrFixnI8+Wsof/vDYJuVb8uGHbL/ddrRq1Yp7H32U1atXZzr+8P33Z+SYMbXLL7/22iblkCRJaiks0Btx9tk/pKpqFQMG9KJ//70ZMeIaAPbZ5xDefPM1Bg7szaRJ4zZ4fPfuPTj++G8xePBBnHrq1+jf/zt0774X3bv34KijBjBwYG8uuuhkevQ4cJPy/cfAgdzzyCMcfOqpvDFvHu3btct0/C8uu4zpr7xCrwED2Osb3+COcRv+WSRJkgRR3xSDxqhXr15p2rRpddbNnDmT7t27b9a4M2as3KzjS2EXZpU6Qh2vv/MOHc46q/6drmyYLMVy8yUnlDpCZsMXN737iVdUzC11hEwmc2ipI2TXxM49aHrnn+de/jz3Gobn3r9ExAsppV7rrvcKtCRJkpRBi/8SYWNz3XU/4KWXnquzbtCgcznhhG+XKJEkSZLWZoFuZH74w5tLHUGSJEn1cAqHJEmSlIEFWpIkScrAAi1JkiRlYIEukj33bMsPf/id2uWqqir69OnMeed9A4CHHx7Fdddd8Knjjj66G9/8Zk8GDuzNwIG9uf76ixossyRJkrLL9UuEEdEXuBkoA36dUrp+ne0XAWcCVcAi4LsppXmb+7nFvq/lww9/YaP7tGvXntmzX2XFiuW0bduOKVOe5HOf+2JB4//610+wzTbbbW5MSZIkNYDcrkBHRBkwAjga2BU4JSJ2XWe3F4FeKaWvAg8Aw/LK0xAOOuhInnnmcQAef/x++vYdWOJEkiRJKrY8p3D0BmanlN5MKX0MjAH6rb1DSmlySmlZzeIUoHOOeXLXt+9AJk0ax8qVK3jjjb+yxx77FHTcmWceVTuF47e/vSXnlJIkSdoceU7h2AF4e63l+cC+9ex/BvD4+jZExNnA2QA77bRTsfIVXbdue7Bw4Twef/x+DjroqIKPcwqHJElS05HnFehYz7q03h0jTgV6Af+9vu0ppdtTSr1SSr06depUxIjFd8gh/84vfnEFRx99UqmjSJIkKQd5XoGeD+y41nJnYOG6O0XE14EfAYeklFbmmKdBfOMb36ZDh63p2nV3pk59utRxJEmSVGR5FuipQNeIqAAWACcDg9beISJ6ALcBfVNK7+SYpcF8/vOdGTz4vPVumzDht0ye/Ejt8j33VBfsM888irKyMgC6dt2da6/9Tf5BJUmStElyK9AppaqIOA94gurb2P0mpfRKRAwFpqWUJlA9ZWNLYFxEALyVUjp+cz97zpwumY+ZMWPzLn5PmfLep9bts88h7LPPIQD063ca/fqd9ql9Hn/89c36XEmSJDWsXO8DnVKaCExcZ91Va73/ep6fL0mSJBWbTyKUJEmSMrBAS5IkSRlYoCVJkqQMLNCSJElSBhZoSZIkKQMLdJHsuWdbbrzxstrlu+8ezsiRP6n3mKeeepQ771zvwxclSZLUSOV6G7tSmVtRkfmYrerZtuTh1zZ6fHl5G5588iHOOONSttlmu4I+s0+fY+nT59gCE0qSJKkx8Ap0kZSVbcGAAWdwzz23fGrbU089xuDBX2PgwH05++yjee+9fwDw8MOjuO66C1i69AOOProba9asAWD58mUceeTOrFq1irff/hvnnHMcJ5+8P6effhhz5sxq0J9LkiRJdVmgi+ikk77HxIljWLr0gzrr9977AO655w+MHftn+vY9kf/931/U2d6hw9Z06/ZVpk37AwBPP/0YBxxwBK1bt2bo0HO5/PLhjBnzHBdddD3XXvv9Bvt5JEmS9GnNcgpHqWy55VYce+xgRo8eQdu27WrX/+MfC7j00lN5991KVq36mB126PKpY486agBPPPEAvXv3YdKkcZx00tksW/YhL788hUsvHVS738cfb94jxyVJkrR5LNBFduqp53PyyfvRr99pteuuv/5CvvWtH9Cnz7FMnfo0t976008d16fPsdxyy4/54IP3mTlzOr17H8ry5R/RocNnGTv2+Yb8ESRJklQPp3AU2dZbb8uRRw5g/Pi7atctXbqEz33uiwBMmHDPeo/7zGe2ZPfd9+GGGy7m4IOPoaysjC233IoddujC7373IAApJWbNmpH7zyBJkqQNs0Dn4LTTfsA///le7fI551zJJZcM4vTTD6v3Dh1HHTWAxx67j6OOGlC77rrr/pfx4+/ixBP3oX//Hkye/Eiu2SVJklS/ZjmFo8ucOZmPmTFj8+YWT5nyr8LcsePn+fOfF9cuH3rocRx66HGfOqZfv9PqTPU44oj+vPzyijr7dO5cwciRlmZJkqTGwivQkiRJUgYWaEmSJCkDC7QkSZKUgQVakiRJysACLUmSJGVggZYkSZIysEAXyZ57tuXGGy+rXb777uGMHPmTEiaqq+N++5U6giRJUrPQLO8DPffOiszHbFXPtiX7vLbR48vL2/Dkkw9xxhmX1vuwlKxWr15NWVlZ0caTJEnS5mmWBboUysq2YMCAM7jnnls4//yhdbYtXDiPq6/+DxYvfpdtttmOoUNv5wtf2Ikf//hM2rffildfnc6771Zy4YXXccQR/Zk69WluvfVaOnXanlmzZjB+/EtccMGJVFbOZ+XKFQwefC4DBpwJVF9ZPnfwYB7/wx9o16YN426+mc937Mic+fM5/YorqFq9miMOOKA2S0qJHw4fzhPPPktEcPlZZ3Fi3748PXUqPxk5ks937MjLr73GCYcfzm5duzLi3ntZvnIlY2+6iZ133LFB/04lSZIaI6dwFNFJJ32PiRPHsHTpB3XW/+xnF3LccYN54IFpHHPMydxww8W12959t5K77vo9v/zleG6++cra9X/96zTOO+8axo9/CYBrrrmNMWOe4777/sTo0b+qfVT4R8uXs+8eezB13DgO6tmT3zz4IACXDBvGWQMH8sfRo9l+u39dEX/oySd5edYspo4bx8Tbb+eK4cP5+6JFAPzl9de5ccgQXnjwQUY/+ihvzJvHs6NH853+/Rl53335/KVJkiQ1MRboItpyy6049tjBjB49os76GTP+zNFHnwzAsccO5sUX/1S77dBDj6NVq1bsvHN33nvvndr1u+/ei86d/zUVZfToEZx44j5861sH849/zOett2YDUN66NccccggAPbp3Z97ChQA899JLnNS3LwCDjj22dpw/vfgiA/v2paysjM937MjXevbkhVdeAaDnbrvxhU6daFNeTsWOO/L1/fcHYLcvf7l2XEmSpJbOAl1kp556Pg89dBfLl3+0wX0iovZ9eXmb2vcppdr37dq1r30/derTTJnye0aNeppx46byla/sycqVKwBovcUWteOVlZVRtXr1ej9nfZ+xrjatW9e+b9WqFW3Ky2vfV1VVbfA4SZKklsQCXWRbb70tRx45gPHj76pdt+ee+zFp0lgAJk68j732OmADR6/fhx8uYauttqFdu88wZ+J9FJkAAAt5SURBVM4sZsx4fqPH7L/XXoydNAmAMRMn1q4/aO+9eeCJJ1i9ejWL3n+fZ6dPp9fuu2fKI0mS1JJZoHNw2mk/qJ2jDHDZZT/n4YdHMWBALx59dDSXXXZjpvEOPPBIVq+uYsCAXowYcQ1f/WrvjR5z45Ah3Hb//Rw4aBAfLF1au77f4YezR7du7HPiifQ96yyuu+CCOnOkJUmSVL+o71f6jVGvXr3StGnT6qybOXMm3bt336xxZ8xYuVnHl8IuzCp1hDpef+cdOpx1Vv07XVn/5sbm5ktOKHWEzIYvHl7qCJlVVMwtdYRMJnNoqSNk18TOPWh655/nXv489xqG596/RMQLKaVe6673CrQkSZKUgQVakiRJysACLUmSJGVggZYkSZIysEBLkiRJGVigJUmSpAws0EXSo8dnGDiwN/3778355/dnyZJ/FmXcBQvm0r//3kUZ65oRI3hyypTNHqfjfvsVIY0kSVLTtEWpA+Thwm0uLOp433n6+o3u06ZNO8aOrX5C4JVXnsH999/KWWddXtQcm+vqc88tdQRJkqQmr1kW6FL76lf34403/gLAsmUf8oMfDGDJkn9SVbWK8877Lw499DgWLJjLuef2o0ePA3jppSl87nNf5OabH6Bt23a8+up0rr76P2jb9jP06PGvx36vXLmCn/70fF59dTplZVtw8yXn0ad3b0Y9/DCPTJ7M6tWreWX2bC447TQ+XrWK0Y8+Spvych4aMYJtt96aM3/8Y445+GD+7Ytf5JxrrgGoPWbFyy/zt7ff5oLrruPdxYtp17YtI6++ml0qKpgzfz6nX3EFVatXc8QB2R5DLkmS1Nw4haPIVq9ezfPPT6ZPn2MBKC9vy/DhY7n//in8+tdP8POfX8YnT398663ZnHTS9xg//kW22uqz/N//jQfgqqvO5rLLfs5vf/t0nbHHjLkVgAcffIEbbhjFmT/+MStWVj9B8ZXZs7n7+ut59t57ufp//ofPtG3Ln8eOZd899+TeRx6pM07P3Xbj+bFjeX7sWI488EAu/Pa3ATh36FCGX345z40Zw/UXXcT3r70WgEuGDeOsgQP54+jRPvZbkiS1eF6BLpKVK5czcGBvFi6cR/fuPdhvv8MBSClxyy1XMX36s7Rq1Yp33lnIe+/9A4AddujCV76yJwDdu/dg4cJ5LF36AUuX/pNevQ4G4NhjB/Hss08A8OKLf+KUU84BoKJiF3b6whd4Y948AA7ZZx86tG9Ph/bt2WrLLTnmkEMA2O3LX+avb7yx3swPPPEEL86cyWO33sqHy5Yx5eWXGXTppf/6mT7+GIDnXnqJMT//OQCDjj2WH910U/H+4iRJkpoYC3SRfDIHeunSDzj//G8wZsytDB58LhMn3sfixe9y333P0bp1a44+uhsrV64AoHXrNrXHl5WVsXLlclJKRMQGPiVt+PNbt65936pVK9qUl9e+r6qq+tT+r86ezU9GjuT/fvMbysrKWLNmDZ/t0IHnx45d7/gbziRJktSyOIWjyDp02JrLLvsFo0YNZ9WqVXz44RK23bYTrVu35vnnn2LhwrfqPX6rrT7LlltuzfTpfwTgscfG1G7be++DmDixennu3Dd4u7KSbl26ZM74wdKlfOuyy7jzpz+l07bbVn/ullvSZYcdePB3vwOqr5zPmDULgP332ouxkyYBMGbixMyfJ0mS1JxYoHPQvftedOv2VSZNGssxx5zMq69O55RTDmDixDFUVOyy0eOHDr2dn/3sAr71rUNo27Zt7fqTTvoP1qxZzTe/2ZMhQ07ljqFDa680ZzFh8mTe+vvf+c+hQ+k9cCC9Bw4E4H+vu467xo9nnxNPpEf//jwyeTIANw4Zwm3338+BgwbxwdKlmT9PkiSpOYlPvtDWVPTq1StNmzatzrqZM2fSvXv3zRp3xoyVm3V8KezCrFJHqOP1d96hw1ln1b/TlQ2TpVhuvuSEUkfIbPji4aWOkFlFxdxSR8hkMoeWOkJ2Tezcg6Z3/nnu5c9zr2F47v1LRLyQUuq17nqvQEuSJEkZWKAlSZKkDCzQkiRJUgbNpkA3tbnczU1KCdasKXUMSZKk3DWLAt22bVvee+89S3SJpJRYXFVFq7fqv0WfJElSc9AsHqTSuXNn5s+fz6JFizZ5jHfe+fTDRhq74J1SR6i2Zg2t3nqLdr/8ZamTSJIk5S7XAh0RfYGbgTLg1yml69fZ3gYYBfQE3gNOSinNzfo5rVu3pqKiYrOyHnNM5o8tuckcX+oIkiRJLU5uUzgiogwYARwN7AqcEhG7rrPbGcDilNKXgeHADXnlkSRJkoohzznQvYHZKaU3U0ofA2OAfuvs0w+4u+b9A8DhERE5ZpIkSZI2S54Fegfg7bWW59esW+8+KaUq4AOgY46ZJEmSpM2S26O8I+JE4KiU0pk1y98CeqeUzl9rn1dq9plfs/y3mn3eW2ess4GzaxZ3gUb2DGtlsR3wbqlDSC2Q555UGp57Tdu/pZQ6rbsyzy8Rzgd2XGu5M7BwA/vMj4gtgK2B99cdKKV0O3B7TjnVgCJi2vqeKS8pX557Uml47jVPeU7hmAp0jYiKiCgHTgYmrLPPBODbNe8HAL9P3sxZkiRJjVhuV6BTSlURcR7wBNW3sftNSumViBgKTEspTQDuBH4bEbOpvvJ8cl55JEmSpGLIbQ60tD4RcXbNlBxJDchzTyoNz73myQItSZIkZZDnHGhJkiSp2bFAqygiom9EzIqI2RFx+Xq2HxwR0yOiKiIGrLNtdUS8VPNn3S+aSsqggHPxooh4NSJmRMSTEfFvpcgpNQcFnG/fi4i/1Pz37dlPnsgcER0jYnJEfBgR/9PwybW5nMKhzVbz2PbXgSOovjXhVOCUlNKra+3TBdgKuASYkFJ6YK1tH6aUtmzIzFJzVOC5eCjw55TSsog4B+iTUjqpJIGlJqzA822rlNKSmvfHA/+ZUuobEe2BHsDuwO4ppfMa/AfQZvEKtIpho49tTynNTSnNANaUIqDUQhRyLk5OKS2rWZxC9T36JWVXyPm2ZK3F9kCqWf9RSulZYEVDhVVxWaBVDIU8tr0+bSNiWkRMiYgTihtNalGynotnAI/nmkhqvgo63yLi3JonLQ8Dvt9A2ZQzC7SKIdazLsvcoJ1qntI0CLgpInYuTiypxSn4XIyIU4FewH/nmkhqvgo631JKI1JKOwOXAVfmnkoNwgKtYijkse0blFJaWPP6JvAU1fPCJGVX0LkYEV8HfgQcn1Ja2UDZpOYm63/7xgD+lrWZsECrGAp5bPt6RcQ2EdGm5v12wIHAq/UfJWkDNnouRkQP4Daqy/M7JcgoNReFnG9d11r8d+CNBsynHOX2KG+1HIU8tj0i9gHGA9sAx0XENSml3YDuwG0RsYbq/6G7fu1vMEsqXCHnItVTNrYExkUEwFsppeNLFlpqogo8386r+Y3PKmAx8O1Pjo+IuVTfnaq85vs/R/rfv6bD29hJkiRJGTiFQ5IkScrAAi1JkiRlYIGWJEmSMrBAS5IkSRlYoCVJkqQMLNCSJElSBhZoSWrhIsJnAkhSBv5LU5KaiYhoD4yl+pHCZcBPgBuAu4HjgNbAiSml1yLiv4AvAl2Ad4FBJYgsSU2SV6AlqfnoCyxMKe2ZUtodmFSz/t2U0t7ASOCStfbvCfRLKVmeJSkDC7QkNR9/Ab4eETdExNdSSh/UrP9/Na8vUH3F+RMTUkrLGzKgJDUHTuGQpGYipfR6RPQEjgF+FhG/q9m0suZ1NXX/vf9RQ+aTpObCAi1JzUREfBF4P6V0T0R8CJxe4kiS1CxZoCWp+dgD+O+IWAOsAs4BHihtJElqfiKlVOoMkiRJUpPhlwglSZKkDCzQkiRJUgYWaEmSJCkDC7QkSZKUgQVakiRJysACLUmSJGVggZYkSZIysEBLkiRJGfz/toFYBnqXBZMAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x432 with 1 Axes>"
       ]
@@ -889,7 +975,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [
     {
@@ -913,7 +999,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
@@ -922,13 +1008,13 @@
        "(-0.5, 2.5)"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 50,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x432 with 1 Axes>"
       ]
diff --git a/statistics.py b/statistics.py
index 62e47db..3a8b3de 100644
--- a/statistics.py
+++ b/statistics.py
@@ -34,11 +34,14 @@ def interval_statistic(method,
     tic = time.time()
 
     if len(active) > 0:
+        alpha = 1 - M.confidence
+        fdp = (pvalues[full_target == 0] < alpha).sum() / pvalues.shape[0]
         value = pd.DataFrame({'active_variable':active,
                               'lower_confidence':lower,
                               'upper_confidence':upper,
                               'target':target,
-                              'full_target':full_target})
+                              'full_target':full_target,
+                              'fdp':fdp * np.ones_like(pvalues)})
         if naive_lower is not None:
             value['naive_lower_confidence'] = naive_lower
             value['naive_upper_confidence'] = naive_upper