From c088e0bb7e0a9ca311b93cf4d8fa956dd0b03667 Mon Sep 17 00:00:00 2001 From: rchan Date: Wed, 18 Oct 2023 10:02:31 +0100 Subject: [PATCH 01/22] transformation first attempt --- .../sig_mahal_knn.py | 110 +++++++++++------- 1 file changed, 69 insertions(+), 41 deletions(-) diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index 9a2a98f..2f070dd 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -33,8 +33,8 @@ def __init__( def fit( self, knn_library: str = "sklearn", - X: np.ndarray | None = None, - signatures: np.ndarray | None = None, + X_train: np.ndarray | None = None, + signatures_train: np.ndarray | None = None, knn_algorithm: str = "auto", signature_kwargs: dict | None = None, **kwargs, @@ -47,11 +47,11 @@ def fit( Parameters ---------- - X : np.ndarray | None, optional + X_train : np.ndarray | None, optional Data points, by default None. Must support index operation X[i] where each X[i] returns a data point in the corpus. - signatures : np.ndarray | None, optional + signatures_train : np.ndarray | None, optional Signatures of the data points, by default None. Must support index operation X[i] where each X[i] returns a data point in the corpus. @@ -97,8 +97,8 @@ def fit( See scikit-learn documentation for `sklearn.neighbors.NearestNeighbors` and pynndescent documentation for `pynndescent.NNDescent`. """ - if signatures is None: - if X is None: + if signatures_train is None: + if X_train is None: raise ValueError(X_OR_SIGNATURE_ERROR_MSG) from sktime.transformations.panel.signature_based import ( @@ -124,42 +124,32 @@ def fit( # compute signatures sigs = Parallel(n_jobs=self.n_jobs)( - delayed(self.signature_transform.fit_transform)(X[i]) - for i in range(len(X)) + delayed(self.signature_transform.fit_transform)(X_train[i]) + for i in range(len(X_train)) ) - self.signatures = pd.concat(sigs) + self.signatures_train = pd.concat(sigs) else: - self.signatures = signatures + self.signatures_train = signatures_train - # fit mahalanobis distance for the signatures + # fit mahalanobis distance for the signatures_train self.mahal_distance = Mahalanobis() - self.mahal_distance.fit(self.signatures) - - # set metric parameters for NearestNeighbors and NNDescent - metric_params = { - "Vt": self.mahal_distance.Vt, - "S": self.mahal_distance.S, - "subspace_thres": self.mahal_distance.subspace_thres, - "zero_thres": self.mahal_distance.zero_thres, - } + self.mahal_distance.fit(self.signatures_train) if knn_library == "sklearn": # fit knn for the mahalanobis distance knn = NearestNeighbors( - metric=self.mahal_distance.calc_distance, - metric_params=metric_params, + metric="euclidean", n_jobs=self.n_jobs, algorithm=knn_algorithm, **kwargs, ) - knn.fit(self.signatures) + knn.fit(self.mahal_distance.U) self.knn = knn elif knn_library == "pynndescent": # fit pynndescent for the mahalanobis distance knn = NNDescent( - data=self.signatures, - metric=self.mahal_distance.calc_distance, - metric_kwds=metric_params, + data=self.mahal_distance.U, + metric="euclidean", n_jobs=self.n_jobs, **kwargs, ) @@ -167,8 +157,8 @@ def fit( def conformance( self, - X: np.ndarray | None = None, - signatures: np.ndarray | None = None, + X_test: np.ndarray | None = None, + signatures_test: np.ndarray | None = None, ) -> np.ndarray: """ Compute the conformance scores for the data points either passed in @@ -198,28 +188,66 @@ def conformance( if self.knn is None: raise ValueError(MODEL_NOT_FITTED_ERROR_MSG) - if signatures is None: - if X is None: + if signatures_test is None: + if X_test is None: raise ValueError(X_OR_SIGNATURE_ERROR_MSG) if self.signature_transform is None: raise ValueError(MODEL_NOT_FITTED_ERROR_MSG) # compute signatures sigs = Parallel(n_jobs=self.n_jobs)( - delayed(self.signature_transform.fit_transform)(X[i]) - for i in range(len(X)) + delayed(self.signature_transform.fit_transform)(X_test[i]) + for i in range(len(X_test)) ) - signatures = pd.concat(sigs) + signatures_test = pd.concat(sigs) + # pre-process the signatures + sig_dim = signatures_test.shape[1] + modified_signatures = ( + signatures_test + @ self.mahal_distance.Vt.T + @ np.diag(self.mahal_distance.S ** (-1)) + ) + + # compute Euclidean NNs if isinstance(self.knn, NearestNeighbors): - # compute KNN distances for the signatures of the data points - # against the signatures of the corpus - distances, _ = self.knn.kneighbors( - signatures, n_neighbors=1, return_distance=True + # compute KNN distances for the modified_signatures of the data points + # against the modified_signatures of the corpus + candidate_distances, train_indices = self.knn.kneighbors( + modified_signatures, n_neighbors=1, return_distance=True ) elif isinstance(self.knn, NNDescent): - # compute KNN distances for the signatures of the data points - # against the signatures of the corpus - _, distances = self.knn.query(signatures, k=1) + # compute KNN distances for the modified_signatures of the data points + # against the modified_signatures of the corpus + train_indices, candidate_distances = self.knn.query( + modified_signatures, k=1 + ) - return distances[:, 0] + candidate_distances = candidate_distances[:, 0] + + # post-process the candidate distances + test_indices = np.tile( + np.arange(train_indices.shape[0]), (train_indices.shape[1], 1) + ).T + # differences has shape (n_test x n_neighbors x sig_dim) + differences = ( + self.sigatures_train[train_indices] - signatures_test[test_indices] + ) + + denominator = np.linalg.norm(differences, axis=-1) + numerator = np.linalg.norm( + differences + @ ( + np.identity(sig_dim) - self.mahal_distance.Vt.T @ self.mahal_distance.Vt + ), + axis=-1, + ) + + rho = numerator / denominator + # get rid of nans from zero denominator + rho[denominator == 0] = 0 + + candidate_distances[denominator < self.mahal_distance.zero_thres] = 0 + candidate_distances[rho > self.mahal_distance.subspace_thres] = np.inf + + return candidate_distances From 3ba007770773a4963475d9fa8c63dab4ba140878 Mon Sep 17 00:00:00 2001 From: rchan Date: Wed, 18 Oct 2023 10:11:13 +0100 Subject: [PATCH 02/22] update docs for _train and _test --- .../sig_mahal_knn.py | 42 ++++++++++--------- 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index 2f070dd..e168891 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -27,7 +27,7 @@ def __init__( self.signature_transform = None self.n_jobs = n_jobs self.mahal_distance = None - self.signatures = None + self.signatures_train = None self.knn = None def fit( @@ -40,28 +40,29 @@ def fit( **kwargs, ) -> None: """ - Fit the KNN model with the corpus of signatures. - If signatures is not provided, then X must be provided - to compute the signatures. - If signatures is provided, then X is ignored. + Fit the KNN model with the corpus of signatures_train. + If signatures_train is not provided, then X_train must be provided + to compute the signatures_train. + If signatures_train is provided, then X_train is ignored. Parameters ---------- X_train : np.ndarray | None, optional Data points, by default None. - Must support index operation X[i] where - each X[i] returns a data point in the corpus. + Must support index operation X_train[i] where + each X_train[i] returns a data point in the corpus. + Typically a three-dimensional array of shape + (batch, length, channels). signatures_train : np.ndarray | None, optional Signatures of the data points, by default None. - Must support index operation X[i] where - each X[i] returns a data point in the corpus. + Two dimensional array of shape (n_samples, sig_dim). knn_algorithm : str, optional Algorithm used to compute the nearest neighbors (see scikit-learn documentation for `sklearn.neighbors.NearestNeighbors`), by default "auto". signature_kwargs : dict | None, optional Keyword arguments passed to the signature transformer if - signatures are not provided and X is provided. + signatures_train are not provided and X_train is provided. See sktime documentation for `sktime.transformations.panel.signature_based.SignatureTransformer` for more details on what arguments are available. @@ -162,23 +163,24 @@ def conformance( ) -> np.ndarray: """ Compute the conformance scores for the data points either passed in - directly as X or the signatures of the data points in signatures. - If signatures is not provided, then X must be provided - to compute the signatures. - If signatures is provided, then X is ignored. + directly as X_test or the signatures_test of the data points in signatures_test. + If signatures_test is not provided, then X_test must be provided + to compute the signatures_test. + If signatures_test is provided, then X_test is ignored. Must call fit() method first. Parameters ---------- - X : np.ndarray | None, optional + X_test : np.ndarray | None, optional Data points, by default None. - Must support index operation X[i] where - each X[i] returns a data point in the corpus. - signatures : np.ndarray | None, optional + Must support index operation X_test[i] where + each X_test[i] returns a data point in the corpus. + Typically a three-dimensional array of shape + (batch, length, channels). + signatures_test : np.ndarray | None, optional Signatures of the data points, by default None. - Must support index operation X[i] where - each X[i] returns a data point in the corpus. + Two dimensional array of shape (n_samples, sig_dim). Returns ------- From 5256ccc1632f4c8dbe3d2359657f162c6e5bb600 Mon Sep 17 00:00:00 2001 From: rchan Date: Thu, 19 Oct 2023 16:03:26 +0100 Subject: [PATCH 03/22] take min distance after subspace threshold computations --- src/signature_mahalanobis_knn/sig_mahal_knn.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index e168891..8df6f7c 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -216,17 +216,15 @@ def conformance( # compute KNN distances for the modified_signatures of the data points # against the modified_signatures of the corpus candidate_distances, train_indices = self.knn.kneighbors( - modified_signatures, n_neighbors=1, return_distance=True + modified_signatures, n_neighbors=30, return_distance=True ) elif isinstance(self.knn, NNDescent): # compute KNN distances for the modified_signatures of the data points # against the modified_signatures of the corpus train_indices, candidate_distances = self.knn.query( - modified_signatures, k=1 + modified_signatures, k=30 ) - candidate_distances = candidate_distances[:, 0] - # post-process the candidate distances test_indices = np.tile( np.arange(train_indices.shape[0]), (train_indices.shape[1], 1) @@ -252,4 +250,5 @@ def conformance( candidate_distances[denominator < self.mahal_distance.zero_thres] = 0 candidate_distances[rho > self.mahal_distance.subspace_thres] = np.inf - return candidate_distances + # compute the minimum of the candidate distances for each data point + return np.min(candidate_distances, axis=-1) From 2eebbf661a85e3faeb486cbdf6e2987c2e99a253 Mon Sep 17 00:00:00 2001 From: rchan Date: Thu, 19 Oct 2023 18:02:17 +0100 Subject: [PATCH 04/22] store U from sdv calculation in Mahalanobis --- src/signature_mahalanobis_knn/mahal_distance.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/signature_mahalanobis_knn/mahal_distance.py b/src/signature_mahalanobis_knn/mahal_distance.py index a4edd58..6c9efe7 100644 --- a/src/signature_mahalanobis_knn/mahal_distance.py +++ b/src/signature_mahalanobis_knn/mahal_distance.py @@ -57,9 +57,10 @@ def fit(self, X: np.ndarray, y: None = None, **kwargs) -> None: # noqa: ARG002 self.mu = np.mean(X, axis=0) X = X - self.mu - _, S, Vt = np.linalg.svd(X) + U, S, Vt = np.linalg.svd(X) k = np.sum(self.svd_thres <= S) # detected numerical rank self.numerical_rank = k + self.U = U[:, :k].astype(self.default_dtype) self.Vt = Vt[:k].astype(self.default_dtype) self.S = S[:k].astype(self.default_dtype) From f06ce7275bba70d37b06764ff9839e736c3e3b83 Mon Sep 17 00:00:00 2001 From: rchan Date: Tue, 24 Oct 2023 08:19:10 +0100 Subject: [PATCH 05/22] subtract signatures by mean in modified signature comp --- src/signature_mahalanobis_knn/sig_mahal_knn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index 8df6f7c..fb83c19 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -206,7 +206,7 @@ def conformance( # pre-process the signatures sig_dim = signatures_test.shape[1] modified_signatures = ( - signatures_test + (signatures_test - self.mahal_distance.mu) @ self.mahal_distance.Vt.T @ np.diag(self.mahal_distance.S ** (-1)) ) From e2e0dac979032b1a6a50ebb9f2a11436aaf41832 Mon Sep 17 00:00:00 2001 From: rchan Date: Tue, 24 Oct 2023 16:33:03 +0100 Subject: [PATCH 06/22] fix some errors and convert signatures to numpy arrays --- .../sig_mahal_knn.py | 21 ++++++++++--------- src/signature_mahalanobis_knn/utils.py | 5 +++-- 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index fb83c19..ca1b57f 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -24,11 +24,11 @@ def __init__( Parameter for joblib, number of parallel processors to use, by default 1. -1 means using all processors, -2 means using all processors but one. """ - self.signature_transform = None - self.n_jobs = n_jobs - self.mahal_distance = None - self.signatures_train = None - self.knn = None + self.signature_transform: object | None = None + self.n_jobs: int = n_jobs + self.mahal_distance: Mahalanobis | None = None + self.signatures_train: np.array | None = None + self.knn: NearestNeighbors | NNDescent | None = None def fit( self, @@ -128,7 +128,7 @@ def fit( delayed(self.signature_transform.fit_transform)(X_train[i]) for i in range(len(X_train)) ) - self.signatures_train = pd.concat(sigs) + self.signatures_train = np.array(pd.concat(sigs)) else: self.signatures_train = signatures_train @@ -160,6 +160,7 @@ def conformance( self, X_test: np.ndarray | None = None, signatures_test: np.ndarray | None = None, + n_neighbors: int = 20, ) -> np.ndarray: """ Compute the conformance scores for the data points either passed in @@ -201,7 +202,7 @@ def conformance( delayed(self.signature_transform.fit_transform)(X_test[i]) for i in range(len(X_test)) ) - signatures_test = pd.concat(sigs) + signatures_test = np.array(pd.concat(sigs)) # pre-process the signatures sig_dim = signatures_test.shape[1] @@ -216,13 +217,13 @@ def conformance( # compute KNN distances for the modified_signatures of the data points # against the modified_signatures of the corpus candidate_distances, train_indices = self.knn.kneighbors( - modified_signatures, n_neighbors=30, return_distance=True + modified_signatures, n_neighbors=n_neighbors, return_distance=True ) elif isinstance(self.knn, NNDescent): # compute KNN distances for the modified_signatures of the data points # against the modified_signatures of the corpus train_indices, candidate_distances = self.knn.query( - modified_signatures, k=30 + modified_signatures, k=n_neighbors ) # post-process the candidate distances @@ -231,7 +232,7 @@ def conformance( ).T # differences has shape (n_test x n_neighbors x sig_dim) differences = ( - self.sigatures_train[train_indices] - signatures_test[test_indices] + self.signatures_train[train_indices] - signatures_test[test_indices] ) denominator = np.linalg.norm(differences, axis=-1) diff --git a/src/signature_mahalanobis_knn/utils.py b/src/signature_mahalanobis_knn/utils.py index 5542ba7..a12de4a 100644 --- a/src/signature_mahalanobis_knn/utils.py +++ b/src/signature_mahalanobis_knn/utils.py @@ -82,8 +82,9 @@ def compute_auc_given_dists( distances_in[distances_in == np.inf] = np.nan distances_out[distances_out == np.inf] = np.nan max_val = max(np.nanmax(distances_in), np.nanmax(distances_out)) - distances_in = np.nan_to_num(distances_in, max_val * 2) - distances_out = np.nan_to_num(distances_out, max_val * 2) + two_times_max = 2 * max_val + distances_in = np.nan_to_num(distances_in, two_times_max) + distances_out = np.nan_to_num(distances_out, two_times_max) y_true = [0] * len(distances_in) + [1] * len(distances_out) y_score = np.concatenate([distances_in, distances_out]) From d11083b3d8e0290df9a6b090593e69e196feb588 Mon Sep 17 00:00:00 2001 From: rchan Date: Tue, 24 Oct 2023 17:59:20 +0100 Subject: [PATCH 07/22] add examples in repo --- paper-examples/Data.py | 230 ++++++++ paper-examples/UCR_data_support.py | 164 ++++++ paper-examples/examples.ipynb | 813 +++++++++++++++++++++++++++++ 3 files changed, 1207 insertions(+) create mode 100644 paper-examples/Data.py create mode 100644 paper-examples/UCR_data_support.py create mode 100644 paper-examples/examples.ipynb diff --git a/paper-examples/Data.py b/paper-examples/Data.py new file mode 100644 index 0000000..335df89 --- /dev/null +++ b/paper-examples/Data.py @@ -0,0 +1,230 @@ +from __future__ import annotations + +import os +import pickle +import random + +import numpy as np +import pandas as pd +import sklearn +from scipy.io import arff +from sklearn.model_selection import train_test_split + +DATA_DIR = "data/" + + +def get_corpus_and_outlier_paths(df, desired_class): + corpus_paths = [] + outlier_paths = [] + + for i in range(df.shape[0]): + if df.iloc[i]["target"] == desired_class: + corpus_paths.append( + np.column_stack([list(range(df.shape[1] - 1)), df.iloc[i][:-1]]) + ) + else: + outlier_paths.append( + np.column_stack([list(range(df.shape[1] - 1)), df.iloc[i][:-1]]) + ) + + return corpus_paths, outlier_paths + + +def normalise(streams): + return [ + sklearn.preprocessing.MinMaxScaler().fit_transform(stream) for stream in streams + ] + + +class Data: + """ + Hold time-series data and allow augmentations + """ + + def __init__(self, if_sample=True, n_samples=(800, 10, 10), random_seed=1): + self.corpus = ( + None # unlabelled corpus consists of streams, numpy.array(numpy.array) + ) + self.test_inlier = None # test set consists of numpy.array of inliers, + self.test_outlier = None # test set consists of numpy.array of outliers + self.if_sample = if_sample + self.n_samples = n_samples + self.random_seed = random_seed + + def sample(self): + random.seed(self.random_seed) + self.corpus = random.choices(list(self.corpus), k=self.n_samples[0]) + self.test_inlier = random.choices(list(self.test_inlier), k=self.n_samples[1]) + self.test_outlier = random.choices(list(self.test_outlier), k=self.n_samples[2]) + + def load_pen_digit(self, digit: int = 1): + """ + Load pen digit dataset with a specific digit as training set + :param digit: 0-9, use as "normality" training corpus + :return: None + """ + train_df = pd.read_pickle(DATA_DIR + "pen_digit_train.pkl") + test_df = pd.read_pickle(DATA_DIR + "pen_digit_test.pkl") + self.corpus = train_df[train_df["Digit"] == digit]["Stream"].values + self.test_inlier = test_df[test_df["Digit"] == digit]["Stream"].values + self.test_outlier = test_df[test_df["Digit"] != digit]["Stream"].values + + if self.if_sample: + self.sample() + self.corpus, self.test_inlier, self.test_outlier = map( + normalise, (self.corpus, self.test_inlier, self.test_outlier) + ) + + def load_language_data(self): + """ + Load language data set with English and German words. + :return: None + """ + paths = np.load(DATA_DIR + "paths_en_de.npy") + labels = np.load(DATA_DIR + "labels_en_de.npy") + (paths_train, paths_test, labels_train, labels_test) = train_test_split( + paths, labels, random_state=1, test_size=0.2 + ) + paths_train = paths_train[labels_train == 0] + + self.corpus = paths_train + self.test_inlier = paths_test[labels_test == 0] + self.test_outlier = paths_test[labels_test == 1] + if self.if_sample: + self.sample() + self.corpus, self.test_inlier, self.test_outlier = map( + normalise, (self.corpus, self.test_inlier, self.test_outlier) + ) + + def load_ship_movements(self, thres_distance=32000, n_samples=5000): + """ + + :param thres_distance: Must be one of [4000, 8000, 16000, 32000] + :param n_samples: samples taken for each of the train, test_in and test_out + :return: + """ + + # process data in a format where it could be indexed. + def process_data(data_frame): + data_frame["TimeDiff"] = data_frame["BaseDateTime"].apply( + lambda x: np.append(0, np.diff(x)) + ) + data_frame = data_frame[["LAT", "LON", "TimeDiff"]] + res = [] + for i in range(len(data_frame)): + res.append( + np.array( + list( + zip( + data_frame.iloc[i].values[0], + data_frame.iloc[i].values[1], + data_frame.iloc[i].values[2], + ) + ) + ) + ) + return res + + # subsample data + def sample_data(ais_by_vessel_split, random_state): + return ais_by_vessel_split.sample( + n=n_samples, + weights="SUBSTREAM_WEIGHT", + replace=True, + random_state=random_state, + ) + + with open(DATA_DIR + "inlier_mmsis_train.pkl", "rb") as f: + inlier_mmsis_train = pickle.load(f) + with open(DATA_DIR + "inlier_mmsis_test.pkl", "rb") as f: + inlier_mmsis_test = pickle.load(f) + with open(DATA_DIR + "outlier_mmsis.pkl", "rb") as f: + outlier_mmsis = pickle.load(f) + + if thres_distance not in [4000, 8000, 16000, 32000]: + msg = "thres_distance needs to be in [4000, 8000, 16000, 32000]" + raise ValueError(msg) + ais_by_vessel_split_local = pd.read_pickle( + DATA_DIR + "substreams_" + str(thres_distance) + ".pkl" + ) + + self.corpus = process_data( + sample_data( + ais_by_vessel_split_local.loc[inlier_mmsis_train], random_state=1 + ) + ) + self.test_inlier = process_data( + sample_data( + ais_by_vessel_split_local.loc[inlier_mmsis_test], random_state=2 + ) + ) + self.test_outlier = process_data( + sample_data(ais_by_vessel_split_local.loc[outlier_mmsis], random_state=3) + ) + if self.if_sample: + self.sample() + self.corpus, self.test_inlier, self.test_outlier = map( + normalise, (self.corpus, self.test_inlier, self.test_outlier) + ) + + def load_ucr_dataset( + self, data_set_name="Adiac", anomaly_level=0.001, random_state=1 + ): + """ + + :param data_set_name: Must be one of ['Adiac', 'ArrowHead', 'Beef', 'BeetleFly', 'BirdChicken', 'CBF', + 'ChlorineConcentration', 'Coffee', 'ECG200', 'ECGFiveDays', 'FaceFour', + 'GunPoint', 'Ham', 'Herring', 'Lightning2', 'Lightning7', 'Meat', + 'MedicalImages', 'MoteStrain', 'Plane', 'Strawberry', 'Symbols', + 'ToeSegmentation1', 'ToeSegmentation2', 'Trace', 'TwoLeadECG', 'Wafer', + 'Wine'] + :param anomaly_level: Must be one of [0.001, 0.05] + :param random_state: + :return: + """ + Level_To_COLUMN = {0.001: "Atra", 0.05: "A5tra"} + comparisons = pd.read_csv( + DATA_DIR + "results_beggel_et_al_2019_tables_2_and_4.csv" + ) + comparisons = comparisons.set_index("Dataset") + if data_set_name not in comparisons.index: + msg = "data_set_name must be in " + raise ValueError(msg, comparisons.index) + DATASET_PATH = DATA_DIR + "Univariate_arff" + datatrain = arff.loadarff( + os.path.join(DATASET_PATH, data_set_name, data_set_name + "_TRAIN.arff") + ) + datatest = arff.loadarff( + os.path.join(DATASET_PATH, data_set_name, data_set_name + "_TEST.arff") + ) + alldata = pd.concat( + [pd.DataFrame(datatrain[0]), pd.DataFrame(datatest[0])], ignore_index=True + ) + alldata["target"] = pd.to_numeric(alldata["target"]) + corpus_paths, outlier_paths = get_corpus_and_outlier_paths( + alldata, comparisons.loc[data_set_name].normal + ) + corpus_train, corpus_test = train_test_split( + corpus_paths, + test_size=comparisons.loc[data_set_name].Ntes.astype("int"), + random_state=random_state, + ) + outliers_injection = comparisons.loc[data_set_name][ + Level_To_COLUMN[anomaly_level] + ].astype("int") + if outliers_injection != 0: + outlier_paths, outlier_paths_to_train = train_test_split( + outlier_paths, test_size=outliers_injection, random_state=random_state + ) + corpus_train = ( + corpus_train + outlier_paths_to_train + ) # injecting anomaly into the corpus + + self.corpus = corpus_train + self.test_inlier = corpus_test + self.test_outlier = outlier_paths + if self.if_sample: + self.sample() + self.corpus, self.test_inlier, self.test_outlier = map( + normalise, (self.corpus, self.test_inlier, self.test_outlier) + ) diff --git a/paper-examples/UCR_data_support.py b/paper-examples/UCR_data_support.py new file mode 100644 index 0000000..be56e48 --- /dev/null +++ b/paper-examples/UCR_data_support.py @@ -0,0 +1,164 @@ +from __future__ import annotations + +import matplotlib.lines as mlines +import numpy as np +import pandas as pd + +DATA_DIR = "/Users/zoos/PycharmProjects/Anomaly_detection/data/" + + +def compute_best_and_std(data_set, iter, data, signature_maha_knn, anomaly_level=0.001): + tnfn = {} + for d in data_set: + tnfn[d] = [] + for random_state in range(iter): + # data loading + data.load_ucr_dataset( + data_set_name=d, random_state=random_state, anomaly_level=anomaly_level + ) + # anomaly detection + signature_maha_knn.fit(data.corpus) + inlier_dists = signature_maha_knn.conformance(data.test_inlier) + outlier_dists = signature_maha_knn.conformance(data.test_outlier) + + tnfn[d].append(compute_tn_fn_for_all_thres(inlier_dists, outlier_dists)) + + roughpathsbest = [] + roughpathserror = [] + for d in data_set: + balanced_accuracies = [] + for tn, fn in tnfn[d]: + balanced_accuracies.append(compute_balanced_accuracy(tn, fn)) + roughpathsbest.append(max(np.median(balanced_accuracies, axis=0))) + bestthreshold = np.argmax(np.median(balanced_accuracies, axis=0)) + roughpathserror.append( + np.std(balanced_accuracies, axis=0, ddof=1)[bestthreshold] + ) + + return roughpathsbest, roughpathserror + + +def plot_ucr_result(roughpathsbest, roughpathserror, anomaly_level, ax_num, axs): + # result from beggels 2019 + comparisons = pd.read_csv(DATA_DIR + "results_beggel_et_al_2019_tables_2_and_4.csv") + adslbest = np.maximum(comparisons.ADSL, comparisons.ADSLbest) + adslerror = comparisons["ADSL sd"] * ( + comparisons.ADSLbest < comparisons.ADSL + ) + comparisons["ADSLbest sd"] * (comparisons.ADSLbest >= comparisons.ADSL) + + # table + comparison_table = pd.DataFrame( + np.column_stack( + [comparisons.Dataset, roughpathsbest, roughpathserror, adslbest, adslerror] + ) + ) + + # plotting + fontsize = 15 + ax = axs.flatten()[ax_num] + + ax.scatter(adslbest, roughpathsbest) + ax.set_xlim(0.45, 1.01) + ax.set_ylim(0.45, 1.01) + + line = mlines.Line2D([0, 1.01], [0, 1.01], color="black", ls=":") + ax.add_line(line) + ax.set_xlabel("ADSL: median balanced accuracy", fontsize=fontsize) + ax.set_ylabel("Signature variance: best achievable median BA", fontsize=fontsize) + ax.set_title(str(anomaly_level) + " training anomaly rate", fontsize=fontsize) + ax.tick_params(axis="both", which="major", labelsize=fontsize) + ax.tick_params(axis="both", which="minor", labelsize=fontsize) + for i in range(len(adslbest)): + if comparisons.Dataset[i] in [ + "Wafer", + "ChlorineConcentration", + "BeetleFly", + "Wine", + ]: + ax.text( + adslbest[i] + 0.01, + roughpathsbest[i], + comparisons.Dataset[i], + fontsize=fontsize, + ) + if comparisons.Dataset[i] in ["FaceFour"]: + ax.text( + adslbest[i], + roughpathsbest[i] + 0.01, + comparisons.Dataset[i], + fontsize=fontsize, + ) + if comparisons.Dataset[i] in ["ECG200", "BirdChicken"]: + ax.text( + adslbest[i], + roughpathsbest[i] - 0.025, + comparisons.Dataset[i], + fontsize=fontsize, + ) + if comparisons.Dataset[i] in ["ToeSegmentation1", "ToeSegmentation2"]: + ax.text( + adslbest[i] + 0.01, + roughpathsbest[i] - 0.005, + comparisons.Dataset[i][:3] + comparisons.Dataset[i][-1], + fontsize=fontsize, + ) + + return comparison_table + + +def compute_tn_fn_for_all_thres(inlier_dists, outlier_dists): + # The below two lines compute the true negatives and false negatives for all possible threshold + corpus_variances = list(inlier_dists) + outlier_variances = list(outlier_dists) + tn = np.concatenate( + [ + [0], + np.cumsum( + np.array( + [ + y + for _, y in sorted( + zip( + corpus_variances + outlier_variances, + [0] * len(corpus_variances) + + [1] * len(outlier_variances), + ) + ) + ] + ) + == 0 + ), + ] + ) + fn = np.concatenate( + [ + [0], + np.cumsum( + np.array( + [ + y + for _, y in sorted( + zip( + corpus_variances + outlier_variances, + [0] * len(corpus_variances) + + [1] * len(outlier_variances), + ) + ) + ] + ) + == 1 + ), + ] + ) + return (tn, fn) + + +def compute_balanced_accuracy(tn, fn): + # compute balanced accuracy as the average between sensitivity and specificity + false_pos = np.flip(max(tn) - tn) + true_pos = np.flip(max(fn) - fn) + true_neg = max(false_pos) - false_pos + false_neg = max(true_pos) - true_pos + sens = true_pos / (true_pos + false_neg) + spec = true_neg / (true_neg + false_pos) + return (sens + spec) / 2 diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb new file mode 100644 index 0000000..b747f10 --- /dev/null +++ b/paper-examples/examples.ipynb @@ -0,0 +1,813 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b430e261-33b2-4878-94d6-46e5dbb18c72", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.join(\"..\", \"..\"))\n", + "import random\n", + "import time\n", + "\n", + "import sklearn\n", + "import numpy as np\n", + "import matplotlib.lines as mlines\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "import Data\n", + "from signature_mahalanobis_knn import SignatureMahalanobisKNN\n", + "from signature_mahalanobis_knn.utils import compute_auc_given_dists\n", + "import UCR_data_support" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "34fc097e-0eb5-4c0d-9973-4dc8810ec398", + "metadata": {}, + "outputs": [], + "source": [ + "# DATA_DIR = '/Users/zoos/PycharmProjects/Anomaly_detection/data/'\n", + "# importlib.reload(Data)\n", + "# importlib.reload(SigMahaKNN)" + ] + }, + { + "cell_type": "markdown", + "id": "46aff929-3380-43d7-8949-2df9564af3dc", + "metadata": {}, + "source": [ + "### Pen digit data example; Reproduce the result." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9", + "metadata": {}, + "outputs": [], + "source": [ + "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n", + "data.load_pen_digit()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a9b82cb0-4754-409c-891b-b19ec7e9b1a3", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 0 doing signature level 1\n", + "fit_time: 2.644990921020508\n", + "compute_auc_time: 0.21709394454956055\n", + "depth: 1 , Auc of digit: 0 is 0.9755555555555556\n", + "doing digit 1 doing signature level 1\n", + "fit_time: 2.1924781799316406\n", + "compute_auc_time: 0.2025890350341797\n", + "depth: 1 , Auc of digit: 1 is 0.9122222222222223\n", + "doing digit 2 doing signature level 1\n", + "fit_time: 2.158695936203003\n", + "compute_auc_time: 0.19025826454162598\n", + "depth: 1 , Auc of digit: 2 is 0.9877777777777779\n", + "doing digit 3 doing signature level 1\n", + "fit_time: 2.232917070388794\n", + "compute_auc_time: 0.3566279411315918\n", + "depth: 1 , Auc of digit: 3 is 0.99\n", + "doing digit 4 doing signature level 1\n", + "fit_time: 2.1989760398864746\n", + "compute_auc_time: 0.21189594268798828\n", + "depth: 1 , Auc of digit: 4 is 0.9888888888888889\n", + "doing digit 5 doing signature level 1\n", + "fit_time: 2.210461139678955\n", + "compute_auc_time: 0.2282869815826416\n", + "depth: 1 , Auc of digit: 5 is 0.9633333333333334\n", + "doing digit 6 doing signature level 1\n", + "fit_time: 2.190329074859619\n", + "compute_auc_time: 0.19521689414978027\n", + "depth: 1 , Auc of digit: 6 is 0.9611111111111111\n", + "doing digit 7 doing signature level 1\n", + "fit_time: 2.173105001449585\n", + "compute_auc_time: 0.2118082046508789\n", + "depth: 1 , Auc of digit: 7 is 0.8911111111111112\n", + "doing digit 8 doing signature level 1\n", + "fit_time: 2.1880011558532715\n", + "compute_auc_time: 0.22732305526733398\n", + "depth: 1 , Auc of digit: 8 is 0.9822222222222222\n", + "doing digit 9 doing signature level 1\n", + "fit_time: 2.1670219898223877\n", + "compute_auc_time: 0.2432420253753662\n", + "depth: 1 , Auc of digit: 9 is 0.9877777777777778\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall, depth: 1 AUC: 0.9615111111111112\n", + "doing digit 0 doing signature level 2\n", + "fit_time: 2.3718907833099365\n", + "compute_auc_time: 0.23317909240722656\n", + "depth: 2 , Auc of digit: 0 is 0.9955555555555555\n", + "doing digit 1 doing signature level 2\n", + "fit_time: 2.3590400218963623\n", + "compute_auc_time: 0.26011013984680176\n", + "depth: 2 , Auc of digit: 1 is 0.9177777777777778\n", + "doing digit 2 doing signature level 2\n", + "fit_time: 2.3768370151519775\n", + "compute_auc_time: 0.23803067207336426\n", + "depth: 2 , Auc of digit: 2 is 0.9622222222222223\n", + "doing digit 3 doing signature level 2\n", + "fit_time: 2.4472439289093018\n", + "compute_auc_time: 0.2737162113189697\n", + "depth: 2 , Auc of digit: 3 is 0.9644444444444444\n", + "doing digit 4 doing signature level 2\n", + "fit_time: 2.3566629886627197\n", + "compute_auc_time: 0.28398585319519043\n", + "depth: 2 , Auc of digit: 4 is 0.9944444444444445\n", + "doing digit 5 doing signature level 2\n", + "fit_time: 2.3845980167388916\n", + "compute_auc_time: 0.25104784965515137\n", + "depth: 2 , Auc of digit: 5 is 0.9644444444444444\n", + "doing digit 6 doing signature level 2\n", + "fit_time: 2.3544719219207764\n", + "compute_auc_time: 0.2796359062194824\n", + "depth: 2 , Auc of digit: 6 is 0.9644444444444444\n", + "doing digit 7 doing signature level 2\n", + "fit_time: 2.498778820037842\n", + "compute_auc_time: 0.3044109344482422\n", + "depth: 2 , Auc of digit: 7 is 0.8755555555555556\n", + "doing digit 8 doing signature level 2\n", + "fit_time: 2.350219964981079\n", + "compute_auc_time: 0.20730185508728027\n", + "depth: 2 , Auc of digit: 8 is 0.96\n", + "doing digit 9 doing signature level 2\n", + "fit_time: 2.3618369102478027\n", + "compute_auc_time: 0.2354259490966797\n", + "depth: 2 , Auc of digit: 9 is 0.9966666666666667\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall, depth: 2 AUC: 0.9580777777777778\n", + "doing digit 0 doing signature level 3\n", + "fit_time: 2.6937179565429688\n", + "compute_auc_time: 0.3327350616455078\n", + "depth: 3 , Auc of digit: 0 is 0.9933333333333333\n", + "doing digit 1 doing signature level 3\n", + "fit_time: 2.7239160537719727\n", + "compute_auc_time: 0.3238558769226074\n", + "depth: 3 , Auc of digit: 1 is 0.41333333333333333\n", + "doing digit 2 doing signature level 3\n", + "fit_time: 2.763735055923462\n", + "compute_auc_time: 0.32450103759765625\n", + "depth: 3 , Auc of digit: 2 is 0.43333333333333335\n", + "doing digit 3 doing signature level 3\n", + "fit_time: 2.742331027984619\n", + "compute_auc_time: 0.30933403968811035\n", + "depth: 3 , Auc of digit: 3 is 0.3333333333333333\n", + "doing digit 4 doing signature level 3\n", + "fit_time: 3.260939836502075\n", + "compute_auc_time: 0.44203734397888184\n", + "depth: 3 , Auc of digit: 4 is 0.5233333333333333\n", + "doing digit 5 doing signature level 3\n", + "fit_time: 2.9551239013671875\n", + "compute_auc_time: 0.41173672676086426\n", + "depth: 3 , Auc of digit: 5 is 0.6822222222222223\n", + "doing digit 6 doing signature level 3\n", + "fit_time: 2.7711238861083984\n", + "compute_auc_time: 0.37404584884643555\n", + "depth: 3 , Auc of digit: 6 is 0.6983333333333334\n", + "doing digit 7 doing signature level 3\n", + "fit_time: 2.858855962753296\n", + "compute_auc_time: 0.3353588581085205\n", + "depth: 3 , Auc of digit: 7 is 0.7666666666666667\n", + "doing digit 8 doing signature level 3\n", + "fit_time: 2.706423044204712\n", + "compute_auc_time: 0.325808048248291\n", + "depth: 3 , Auc of digit: 8 is 0.9644444444444444\n", + "doing digit 9 doing signature level 3\n", + "fit_time: 2.665424108505249\n", + "compute_auc_time: 0.3166041374206543\n", + "depth: 3 , Auc of digit: 9 is 0.6855555555555556\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall, depth: 3 AUC: 0.6477277777777778\n", + "doing digit 0 doing signature level 4\n", + "fit_time: 4.051016092300415\n", + "compute_auc_time: 0.7964949607849121\n", + "depth: 4 , Auc of digit: 0 is 0.2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 1 doing signature level 4\n", + "fit_time: 4.131290674209595\n", + "compute_auc_time: 0.7271778583526611\n", + "depth: 4 , Auc of digit: 1 is 0.3061111111111111\n", + "doing digit 2 doing signature level 4\n", + "fit_time: 4.490506887435913\n", + "compute_auc_time: 0.6685390472412109\n", + "depth: 4 , Auc of digit: 2 is 0.11666666666666664\n", + "doing digit 3 doing signature level 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fit_time: 4.055716037750244\n", + "compute_auc_time: 0.6969881057739258\n", + "depth: 4 , Auc of digit: 3 is 0.15000000000000002\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 4 doing signature level 4\n", + "fit_time: 4.0092620849609375\n", + "compute_auc_time: 0.7524690628051758\n", + "depth: 4 , Auc of digit: 4 is 0.31666666666666665\n", + "doing digit 5 doing signature level 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fit_time: 4.062707901000977\n", + "compute_auc_time: 0.7112889289855957\n", + "depth: 4 , Auc of digit: 5 is 0.3833333333333333\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 6 doing signature level 4\n", + "fit_time: 4.065374135971069\n", + "compute_auc_time: 0.9478049278259277\n", + "depth: 4 , Auc of digit: 6 is 0.18333333333333335\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 7 doing signature level 4\n", + "fit_time: 4.136836051940918\n", + "compute_auc_time: 0.7570099830627441\n", + "depth: 4 , Auc of digit: 7 is 0.3666666666666667\n", + "doing digit 8 doing signature level 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fit_time: 4.506422996520996\n", + "compute_auc_time: 1.7055130004882812\n", + "depth: 4 , Auc of digit: 8 is 0.3833333333333333\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 9 doing signature level 4\n", + "fit_time: 4.593477010726929\n", + "compute_auc_time: 1.2677769660949707\n", + "depth: 4 , Auc of digit: 9 is 0.4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall, depth: 4 AUC: 0.28071666666666667\n", + "doing digit 0 doing signature level 5\n", + "fit_time: 10.585472106933594\n", + "compute_auc_time: 5.377856969833374\n", + "depth: 5 , Auc of digit: 0 is 0.2833333333333333\n", + "doing digit 1 doing signature level 5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + ] + }, + { + "ename": "LinAlgError", + "evalue": "SVD did not converge", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m:13\u001b[0m\n", + "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:137\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[39m# fit mahalanobis distance for the signatures_train\u001b[39;00m\n\u001b[1;32m 136\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmahal_distance \u001b[39m=\u001b[39m Mahalanobis()\n\u001b[0;32m--> 137\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mmahal_distance\u001b[39m.\u001b[39;49mfit(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignatures_train)\n\u001b[1;32m 139\u001b[0m \u001b[39mif\u001b[39;00m knn_library \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39msklearn\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m 140\u001b[0m \u001b[39m# fit knn for the mahalanobis distance\u001b[39;00m\n\u001b[1;32m 141\u001b[0m knn \u001b[39m=\u001b[39m NearestNeighbors(\n\u001b[1;32m 142\u001b[0m metric\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39meuclidean\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 143\u001b[0m n_jobs\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_jobs,\n\u001b[1;32m 144\u001b[0m algorithm\u001b[39m=\u001b[39mknn_algorithm,\n\u001b[1;32m 145\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs,\n\u001b[1;32m 146\u001b[0m )\n", + "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/mahal_distance.py:60\u001b[0m, in \u001b[0;36mMahalanobis.fit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmu \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mmean(X, axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)\n\u001b[1;32m 58\u001b[0m X \u001b[39m=\u001b[39m X \u001b[39m-\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmu\n\u001b[0;32m---> 60\u001b[0m U, S, Vt \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49msvd(X)\n\u001b[1;32m 61\u001b[0m k \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39msum(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msvd_thres \u001b[39m<\u001b[39m\u001b[39m=\u001b[39m S) \u001b[39m# detected numerical rank\u001b[39;00m\n\u001b[1;32m 62\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnumerical_rank \u001b[39m=\u001b[39m k\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/numpy/linalg/linalg.py:1681\u001b[0m, in \u001b[0;36msvd\u001b[0;34m(a, full_matrices, compute_uv, hermitian)\u001b[0m\n\u001b[1;32m 1678\u001b[0m gufunc \u001b[39m=\u001b[39m _umath_linalg\u001b[39m.\u001b[39msvd_n_s\n\u001b[1;32m 1680\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->DdD\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->ddd\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m-> 1681\u001b[0m u, s, vh \u001b[39m=\u001b[39m gufunc(a, signature\u001b[39m=\u001b[39;49msignature, extobj\u001b[39m=\u001b[39;49mextobj)\n\u001b[1;32m 1682\u001b[0m u \u001b[39m=\u001b[39m u\u001b[39m.\u001b[39mastype(result_t, copy\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m 1683\u001b[0m s \u001b[39m=\u001b[39m s\u001b[39m.\u001b[39mastype(_realType(result_t), copy\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/numpy/linalg/linalg.py:121\u001b[0m, in \u001b[0;36m_raise_linalgerror_svd_nonconvergence\u001b[0;34m(err, flag)\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_raise_linalgerror_svd_nonconvergence\u001b[39m(err, flag):\n\u001b[0;32m--> 121\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m\"\u001b[39m\u001b[39mSVD did not converge\u001b[39m\u001b[39m\"\u001b[39m)\n", + "\u001b[0;31mLinAlgError\u001b[0m: SVD did not converge" + ] + } + ], + "source": [ + "%%time\n", + "depth_to_auc = {}\n", + "n_neighbours = 50\n", + "for depth in [1, 2, 3, 4, 5]:\n", + " digit_to_inlier_dists = {}\n", + " digit_to_outlier_dists = {}\n", + "\n", + " for digit in range(10):\n", + " data.load_pen_digit(digit=digit)\n", + " print(\"doing digit\", digit, \"doing signature level \", depth)\n", + " signature_maha_knn = SignatureMahalanobisKNN()\n", + " # Measure the time spent on fit\n", + " start_time = time.time()\n", + " signature_maha_knn.fit(\n", + " knn_library=\"sklearn\",\n", + " X_train=data.corpus,\n", + " signature_kwargs={\n", + " \"depth\": depth,\n", + " },\n", + " )\n", + " fit_time = time.time() - start_time\n", + " print(\"fit_time: \", fit_time)\n", + "\n", + " # Measure the time spent on conformance\n", + " start_time = time.time()\n", + " inlier_dists = signature_maha_knn.conformance(\n", + " data.test_inlier, n_neighbors=n_neighbours\n", + " )\n", + " outlier_dists = signature_maha_knn.conformance(\n", + " data.test_outlier, n_neighbors=n_neighbours\n", + " )\n", + " compute_auc_time = time.time() - start_time\n", + " print(\"compute_auc_time: \", compute_auc_time)\n", + "\n", + " digit_to_inlier_dists[digit] = inlier_dists\n", + " digit_to_outlier_dists[digit] = outlier_dists\n", + "\n", + " auc = compute_auc_given_dists(inlier_dists, outlier_dists)\n", + " print(\"depth: \", depth, \", Auc of\", \" digit: \", digit, \" is \", auc)\n", + "\n", + " all_inlier_dists = np.concatenate(list(digit_to_inlier_dists.values()))\n", + " all_outlier_dists = np.concatenate(list(digit_to_outlier_dists.values()))\n", + " auc = compute_auc_given_dists(\n", + " all_inlier_dists,\n", + " all_outlier_dists,\n", + " plot=True,\n", + " title=f\"Pen Digit (depth={depth})\",\n", + " )\n", + " print(\"Overall, \", \"depth: \", depth, \"AUC: \", auc)\n", + " depth_to_auc[depth] = auc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0724f2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(30, 20, 45)" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array(signature_maha_knn.signatures_train)[signature_maha_knn.train_indices].shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34198fd3-3b8c-46ec-8484-bcbb1510a257", + "metadata": {}, + "outputs": [], + "source": [ + "print(depth_to_auc)" + ] + }, + { + "cell_type": "markdown", + "id": "535655b1-d733-47b0-b471-f25a6fd11593", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### Ship movement data example" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f49674f-86c7-4d6e-88f9-98218ab69be3", + "metadata": {}, + "outputs": [], + "source": [ + "data = Data.Data(\n", + " n_samples=(800, 30, 30),\n", + " if_sample=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60165b32-c950-4b0c-9526-3edcb7674e62", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "lead_lag_and_inv_rest_and_thres_distance_to_auc = {}\n", + "for lead_lag in [True, False]:\n", + " augmentation_list1 = []\n", + " lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag] = {}\n", + " if lead_lag:\n", + " augmentation_list1.append(\"leadlag\")\n", + " for inv_reset in [True, False]:\n", + " lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag][inv_reset] = {}\n", + " if inv_reset:\n", + " augmentation_list = augmentation_list1 + [\"ir\"]\n", + " else:\n", + " augmentation_list = augmentation_list1\n", + "\n", + " if (not inv_reset) and (not lead_lag):\n", + " augmentation_list = None\n", + "\n", + " for thres_distance in [4000, 8000, 16000, 32000]:\n", + " signature_maha_knn = SignatureMahalanobisKNN()\n", + " data.load_ship_movements(\n", + " thres_distance=thres_distance,\n", + " )\n", + " # Measure the time spent on fit\n", + " start_time = time.time()\n", + " signature_maha_knn.fit(\n", + " knn_library=\"sklearn\",\n", + " X=data.corpus,\n", + " signature_kwargs={\n", + " \"augmentation_list\": augmentation_list,\n", + " \"depth\": 3,\n", + " },\n", + " )\n", + " fit_time = time.time() - start_time\n", + " print(\"fit_time: \", fit_time)\n", + "\n", + " # Measure the time spent on compute_auc\n", + " start_time = time.time()\n", + " auc = signature_maha_knn.compute_auc(data.test_inlier, data.test_outlier)\n", + " compute_auc_time = time.time() - start_time\n", + " print(\"compute_auc_time: \", compute_auc_time)\n", + "\n", + " print(\n", + " \"lead_lag: \",\n", + " lead_lag,\n", + " \"inv_rest: \",\n", + " inv_reset,\n", + " \"thres_distance: \",\n", + " thres_distance,\n", + " \"auc: \",\n", + " auc,\n", + " )\n", + " lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag][inv_reset][\n", + " thres_distance\n", + " ] = auc" + ] + }, + { + "cell_type": "markdown", + "id": "12e4c956-0b49-4d06-9ff0-201cd1f3a27e", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### UCR data example" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a22e802a-c924-4ead-9c8d-0fb3c262e84d", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "data = Data.Data(if_sample=True, n_samples=[100, 10, 10])\n", + "data_full_names = [\n", + " \"Adiac\",\n", + " \"ArrowHead\",\n", + " \"Beef\",\n", + " \"BeetleFly\",\n", + " \"BirdChicken\",\n", + " \"CBF\",\n", + " \"ChlorineConcentration\",\n", + " \"Coffee\",\n", + " \"ECG200\",\n", + " \"ECGFiveDays\",\n", + " \"FaceFour\",\n", + " \"GunPoint\",\n", + " \"Ham\",\n", + " \"Herring\",\n", + " \"Lightning2\",\n", + " \"Lightning7\",\n", + " \"Meat\",\n", + " \"MedicalImages\",\n", + " \"MoteStrain\",\n", + " \"Plane\",\n", + " \"Strawberry\",\n", + " \"Symbols\",\n", + " \"ToeSegmentation1\",\n", + " \"ToeSegmentation2\",\n", + " \"Trace\",\n", + " \"TwoLeadECG\",\n", + " \"Wafer\",\n", + " \"Wine\",\n", + "]\n", + "\n", + "signature_maha_knn = SignatureMahalanobisKNN(\n", + " augmentation_list=(\"addtime\",),\n", + " depth=5,\n", + ")\n", + "anomaly_level = 0.001\n", + "iter = 10\n", + "data_names = data_full_names\n", + "\n", + "roughpathsbest, roughpathserror = UCR_data_support.compute_best_and_std(\n", + " data_names, iter, data, signature_maha_knn, anomaly_level\n", + ")\n", + "\n", + "anomaly_level = 0.05\n", + "roughpathsbest, roughpathserror = UCR_data_support.compute_best_and_std(\n", + " data_names, iter, data, signature_maha_knn, anomaly_level\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6043a4d-1ba9-4e77-acbb-5a758d9c1693", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n", + "comparison_table_1 = UCR_data_support.plot_ucr_result(\n", + " roughpathsbest, roughpathserror, anomaly_level=0.001, ax_num=0, axs=axs\n", + ")\n", + "comparison_table_2 = UCR_data_support.plot_ucr_result(\n", + " roughpathsbest, roughpathserror, anomaly_level=0.05, ax_num=1, axs=axs\n", + ")\n", + "fig.savefig(\"benchmark.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c52ba35-77cf-45e4-bc24-b8084a0a6583", + "metadata": {}, + "outputs": [], + "source": [ + "comparison_table_1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "168f43f7-d6a7-49de-b95a-336ac6b2cb1c", + "metadata": {}, + "outputs": [], + "source": [ + "comparison_table_2" + ] + }, + { + "cell_type": "markdown", + "id": "847fb50d-44b1-42fc-84e5-f5088493a60b", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### Language dataset example" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "887c4530-28dd-4df7-b1f5-58c74e40f0eb", + "metadata": {}, + "outputs": [], + "source": [ + "data.load_language_data()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cf434a5d-68dc-46f4-9a69-a8a1cff32d5d", + "metadata": {}, + "outputs": [], + "source": [ + "random.seed(1)\n", + "data.corpus = random.sample(list(data.corpus), 800)\n", + "data.test_inlier = random.sample(list(data.test_inlier), 10)\n", + "data.test_outlier = random.sample(list(data.test_outlier), 10)" + ] + }, + { + "cell_type": "markdown", + "id": "fb0e4bf6-b7eb-4c9b-a4bf-63cd343b4378", + "metadata": {}, + "source": [ + "##### Takes a while as signature dimension very large" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a25e03a-1c77-414d-a576-22232871b6d9", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "%%time\n", + "signature_maha_knn = SignatureMahalanobisKNN()\n", + "signature_maha_knn.fit(data.corpus)\n", + "signature_maha_knn.compute_auc(data.test_inlier, data.test_outlier)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87ec6dc8-75f7-436b-8528-00093a576ba7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a943e07a5f3a4789421edf6a2ab31c36821cfaad Mon Sep 17 00:00:00 2001 From: shaoz Date: Wed, 25 Oct 2023 10:10:30 +0100 Subject: [PATCH 08/22] fix a bug where nans are set to zeros instead of the desired value --- src/signature_mahalanobis_knn/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/signature_mahalanobis_knn/utils.py b/src/signature_mahalanobis_knn/utils.py index a12de4a..dc154de 100644 --- a/src/signature_mahalanobis_knn/utils.py +++ b/src/signature_mahalanobis_knn/utils.py @@ -83,8 +83,8 @@ def compute_auc_given_dists( distances_out[distances_out == np.inf] = np.nan max_val = max(np.nanmax(distances_in), np.nanmax(distances_out)) two_times_max = 2 * max_val - distances_in = np.nan_to_num(distances_in, two_times_max) - distances_out = np.nan_to_num(distances_out, two_times_max) + distances_in = np.nan_to_num(distances_in, nan=two_times_max) + distances_out = np.nan_to_num(distances_out, nan=two_times_max) y_true = [0] * len(distances_in) + [1] * len(distances_out) y_score = np.concatenate([distances_in, distances_out]) From 3c5283223b1cfab893a567e80eabb1e0393bb1a9 Mon Sep 17 00:00:00 2001 From: shaoz Date: Wed, 25 Oct 2023 10:12:00 +0100 Subject: [PATCH 09/22] added some diagosis information --- paper-examples/examples.ipynb | 521 ++++++++++------------------------ 1 file changed, 146 insertions(+), 375 deletions(-) diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index b747f10..804e38b 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 12, "id": "b430e261-33b2-4878-94d6-46e5dbb18c72", "metadata": {}, "outputs": [], @@ -28,12 +28,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 13, "id": "34fc097e-0eb5-4c0d-9973-4dc8810ec398", "metadata": {}, "outputs": [], "source": [ - "# DATA_DIR = '/Users/zoos/PycharmProjects/Anomaly_detection/data/'\n", + "DATA_DIR = '/Users/zoos/PycharmProjects/Anomaly_detection/data/'\n", "# importlib.reload(Data)\n", "# importlib.reload(SigMahaKNN)" ] @@ -48,363 +48,49 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 21, "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9", "metadata": {}, "outputs": [], "source": [ "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n", - "data.load_pen_digit()" + "data.load_pen_digit()\n", + "\n", + "depths = [4]\n", + "digits = range(1)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 22, "id": "a9b82cb0-4754-409c-891b-b19ec7e9b1a3", - "metadata": { - "scrolled": true - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "doing digit 0 doing signature level 1\n", - "fit_time: 2.644990921020508\n", - "compute_auc_time: 0.21709394454956055\n", - "depth: 1 , Auc of digit: 0 is 0.9755555555555556\n", - "doing digit 1 doing signature level 1\n", - "fit_time: 2.1924781799316406\n", - "compute_auc_time: 0.2025890350341797\n", - "depth: 1 , Auc of digit: 1 is 0.9122222222222223\n", - "doing digit 2 doing signature level 1\n", - "fit_time: 2.158695936203003\n", - "compute_auc_time: 0.19025826454162598\n", - "depth: 1 , Auc of digit: 2 is 0.9877777777777779\n", - "doing digit 3 doing signature level 1\n", - "fit_time: 2.232917070388794\n", - "compute_auc_time: 0.3566279411315918\n", - "depth: 1 , Auc of digit: 3 is 0.99\n", - "doing digit 4 doing signature level 1\n", - "fit_time: 2.1989760398864746\n", - "compute_auc_time: 0.21189594268798828\n", - "depth: 1 , Auc of digit: 4 is 0.9888888888888889\n", - "doing digit 5 doing signature level 1\n", - "fit_time: 2.210461139678955\n", - "compute_auc_time: 0.2282869815826416\n", - "depth: 1 , Auc of digit: 5 is 0.9633333333333334\n", - "doing digit 6 doing signature level 1\n", - "fit_time: 2.190329074859619\n", - "compute_auc_time: 0.19521689414978027\n", - "depth: 1 , Auc of digit: 6 is 0.9611111111111111\n", - "doing digit 7 doing signature level 1\n", - "fit_time: 2.173105001449585\n", - "compute_auc_time: 0.2118082046508789\n", - "depth: 1 , Auc of digit: 7 is 0.8911111111111112\n", - "doing digit 8 doing signature level 1\n", - "fit_time: 2.1880011558532715\n", - "compute_auc_time: 0.22732305526733398\n", - "depth: 1 , Auc of digit: 8 is 0.9822222222222222\n", - "doing digit 9 doing signature level 1\n", - "fit_time: 2.1670219898223877\n", - "compute_auc_time: 0.2432420253753662\n", - "depth: 1 , Auc of digit: 9 is 0.9877777777777778\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Overall, depth: 1 AUC: 0.9615111111111112\n", - "doing digit 0 doing signature level 2\n", - "fit_time: 2.3718907833099365\n", - "compute_auc_time: 0.23317909240722656\n", - "depth: 2 , Auc of digit: 0 is 0.9955555555555555\n", - "doing digit 1 doing signature level 2\n", - "fit_time: 2.3590400218963623\n", - "compute_auc_time: 0.26011013984680176\n", - "depth: 2 , Auc of digit: 1 is 0.9177777777777778\n", - "doing digit 2 doing signature level 2\n", - "fit_time: 2.3768370151519775\n", - "compute_auc_time: 0.23803067207336426\n", - "depth: 2 , Auc of digit: 2 is 0.9622222222222223\n", - "doing digit 3 doing signature level 2\n", - "fit_time: 2.4472439289093018\n", - "compute_auc_time: 0.2737162113189697\n", - "depth: 2 , Auc of digit: 3 is 0.9644444444444444\n", - "doing digit 4 doing signature level 2\n", - "fit_time: 2.3566629886627197\n", - "compute_auc_time: 0.28398585319519043\n", - "depth: 2 , Auc of digit: 4 is 0.9944444444444445\n", - "doing digit 5 doing signature level 2\n", - "fit_time: 2.3845980167388916\n", - "compute_auc_time: 0.25104784965515137\n", - "depth: 2 , Auc of digit: 5 is 0.9644444444444444\n", - "doing digit 6 doing signature level 2\n", - "fit_time: 2.3544719219207764\n", - "compute_auc_time: 0.2796359062194824\n", - "depth: 2 , Auc of digit: 6 is 0.9644444444444444\n", - "doing digit 7 doing signature level 2\n", - "fit_time: 2.498778820037842\n", - "compute_auc_time: 0.3044109344482422\n", - "depth: 2 , Auc of digit: 7 is 0.8755555555555556\n", - "doing digit 8 doing signature level 2\n", - "fit_time: 2.350219964981079\n", - "compute_auc_time: 0.20730185508728027\n", - "depth: 2 , Auc of digit: 8 is 0.96\n", - "doing digit 9 doing signature level 2\n", - "fit_time: 2.3618369102478027\n", - "compute_auc_time: 0.2354259490966797\n", - "depth: 2 , Auc of digit: 9 is 0.9966666666666667\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Overall, depth: 2 AUC: 0.9580777777777778\n", - "doing digit 0 doing signature level 3\n", - "fit_time: 2.6937179565429688\n", - "compute_auc_time: 0.3327350616455078\n", - "depth: 3 , Auc of digit: 0 is 0.9933333333333333\n", - "doing digit 1 doing signature level 3\n", - "fit_time: 2.7239160537719727\n", - "compute_auc_time: 0.3238558769226074\n", - "depth: 3 , Auc of digit: 1 is 0.41333333333333333\n", - "doing digit 2 doing signature level 3\n", - "fit_time: 2.763735055923462\n", - "compute_auc_time: 0.32450103759765625\n", - "depth: 3 , Auc of digit: 2 is 0.43333333333333335\n", - "doing digit 3 doing signature level 3\n", - "fit_time: 2.742331027984619\n", - "compute_auc_time: 0.30933403968811035\n", - "depth: 3 , Auc of digit: 3 is 0.3333333333333333\n", - "doing digit 4 doing signature level 3\n", - "fit_time: 3.260939836502075\n", - "compute_auc_time: 0.44203734397888184\n", - "depth: 3 , Auc of digit: 4 is 0.5233333333333333\n", - "doing digit 5 doing signature level 3\n", - "fit_time: 2.9551239013671875\n", - "compute_auc_time: 0.41173672676086426\n", - "depth: 3 , Auc of digit: 5 is 0.6822222222222223\n", - "doing digit 6 doing signature level 3\n", - "fit_time: 2.7711238861083984\n", - "compute_auc_time: 0.37404584884643555\n", - "depth: 3 , Auc of digit: 6 is 0.6983333333333334\n", - "doing digit 7 doing signature level 3\n", - "fit_time: 2.858855962753296\n", - "compute_auc_time: 0.3353588581085205\n", - "depth: 3 , Auc of digit: 7 is 0.7666666666666667\n", - "doing digit 8 doing signature level 3\n", - "fit_time: 2.706423044204712\n", - "compute_auc_time: 0.325808048248291\n", - "depth: 3 , Auc of digit: 8 is 0.9644444444444444\n", - "doing digit 9 doing signature level 3\n", - "fit_time: 2.665424108505249\n", - "compute_auc_time: 0.3166041374206543\n", - "depth: 3 , Auc of digit: 9 is 0.6855555555555556\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Overall, depth: 3 AUC: 0.6477277777777778\n", "doing digit 0 doing signature level 4\n", - "fit_time: 4.051016092300415\n", - "compute_auc_time: 0.7964949607849121\n", - "depth: 4 , Auc of digit: 0 is 0.2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "doing digit 1 doing signature level 4\n", - "fit_time: 4.131290674209595\n", - "compute_auc_time: 0.7271778583526611\n", - "depth: 4 , Auc of digit: 1 is 0.3061111111111111\n", - "doing digit 2 doing signature level 4\n", - "fit_time: 4.490506887435913\n", - "compute_auc_time: 0.6685390472412109\n", - "depth: 4 , Auc of digit: 2 is 0.11666666666666664\n", - "doing digit 3 doing signature level 4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fit_time: 4.055716037750244\n", - "compute_auc_time: 0.6969881057739258\n", - "depth: 4 , Auc of digit: 3 is 0.15000000000000002\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "doing digit 4 doing signature level 4\n", - "fit_time: 4.0092620849609375\n", - "compute_auc_time: 0.7524690628051758\n", - "depth: 4 , Auc of digit: 4 is 0.31666666666666665\n", - "doing digit 5 doing signature level 4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fit_time: 4.062707901000977\n", - "compute_auc_time: 0.7112889289855957\n", - "depth: 4 , Auc of digit: 5 is 0.3833333333333333\n" + "fit_time: 3.6063642501831055\n", + "compute_auc_time: 0.830460786819458\n", + "there is the change\n", + "depth: 4 , Auc of digit: 0 is 0.8\n", + "there is the change\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "doing digit 6 doing signature level 4\n", - "fit_time: 4.065374135971069\n", - "compute_auc_time: 0.9478049278259277\n", - "depth: 4 , Auc of digit: 6 is 0.18333333333333335\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "doing digit 7 doing signature level 4\n", - "fit_time: 4.136836051940918\n", - "compute_auc_time: 0.7570099830627441\n", - "depth: 4 , Auc of digit: 7 is 0.3666666666666667\n", - "doing digit 8 doing signature level 4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fit_time: 4.506422996520996\n", - "compute_auc_time: 1.7055130004882812\n", - "depth: 4 , Auc of digit: 8 is 0.3833333333333333\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "doing digit 9 doing signature level 4\n", - "fit_time: 4.593477010726929\n", - "compute_auc_time: 1.2677769660949707\n", - "depth: 4 , Auc of digit: 9 is 0.4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + "/Users/zoos/PycharmProjects/Anomaly_detection/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", + " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n", + "/Users/zoos/PycharmProjects/Anomaly_detection/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -416,35 +102,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 4 AUC: 0.28071666666666667\n", - "doing digit 0 doing signature level 5\n", - "fit_time: 10.585472106933594\n", - "compute_auc_time: 5.377856969833374\n", - "depth: 5 , Auc of digit: 0 is 0.2833333333333333\n", - "doing digit 1 doing signature level 5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" - ] - }, - { - "ename": "LinAlgError", - "evalue": "SVD did not converge", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mLinAlgError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m:13\u001b[0m\n", - "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:137\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[39m# fit mahalanobis distance for the signatures_train\u001b[39;00m\n\u001b[1;32m 136\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmahal_distance \u001b[39m=\u001b[39m Mahalanobis()\n\u001b[0;32m--> 137\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mmahal_distance\u001b[39m.\u001b[39;49mfit(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignatures_train)\n\u001b[1;32m 139\u001b[0m \u001b[39mif\u001b[39;00m knn_library \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39msklearn\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m 140\u001b[0m \u001b[39m# fit knn for the mahalanobis distance\u001b[39;00m\n\u001b[1;32m 141\u001b[0m knn \u001b[39m=\u001b[39m NearestNeighbors(\n\u001b[1;32m 142\u001b[0m metric\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39meuclidean\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 143\u001b[0m n_jobs\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_jobs,\n\u001b[1;32m 144\u001b[0m algorithm\u001b[39m=\u001b[39mknn_algorithm,\n\u001b[1;32m 145\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs,\n\u001b[1;32m 146\u001b[0m )\n", - "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/mahal_distance.py:60\u001b[0m, in \u001b[0;36mMahalanobis.fit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmu \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mmean(X, axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)\n\u001b[1;32m 58\u001b[0m X \u001b[39m=\u001b[39m X \u001b[39m-\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmu\n\u001b[0;32m---> 60\u001b[0m U, S, Vt \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mlinalg\u001b[39m.\u001b[39;49msvd(X)\n\u001b[1;32m 61\u001b[0m k \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39msum(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msvd_thres \u001b[39m<\u001b[39m\u001b[39m=\u001b[39m S) \u001b[39m# detected numerical rank\u001b[39;00m\n\u001b[1;32m 62\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnumerical_rank \u001b[39m=\u001b[39m k\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/numpy/linalg/linalg.py:1681\u001b[0m, in \u001b[0;36msvd\u001b[0;34m(a, full_matrices, compute_uv, hermitian)\u001b[0m\n\u001b[1;32m 1678\u001b[0m gufunc \u001b[39m=\u001b[39m _umath_linalg\u001b[39m.\u001b[39msvd_n_s\n\u001b[1;32m 1680\u001b[0m signature \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mD->DdD\u001b[39m\u001b[39m'\u001b[39m \u001b[39mif\u001b[39;00m isComplexType(t) \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39md->ddd\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m-> 1681\u001b[0m u, s, vh \u001b[39m=\u001b[39m gufunc(a, signature\u001b[39m=\u001b[39;49msignature, extobj\u001b[39m=\u001b[39;49mextobj)\n\u001b[1;32m 1682\u001b[0m u \u001b[39m=\u001b[39m u\u001b[39m.\u001b[39mastype(result_t, copy\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m 1683\u001b[0m s \u001b[39m=\u001b[39m s\u001b[39m.\u001b[39mastype(_realType(result_t), copy\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/numpy/linalg/linalg.py:121\u001b[0m, in \u001b[0;36m_raise_linalgerror_svd_nonconvergence\u001b[0;34m(err, flag)\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_raise_linalgerror_svd_nonconvergence\u001b[39m(err, flag):\n\u001b[0;32m--> 121\u001b[0m \u001b[39mraise\u001b[39;00m LinAlgError(\u001b[39m\"\u001b[39m\u001b[39mSVD did not converge\u001b[39m\u001b[39m\"\u001b[39m)\n", - "\u001b[0;31mLinAlgError\u001b[0m: SVD did not converge" + "Overall, depth: 4 AUC: 0.8\n", + "CPU times: user 13.2 s, sys: 4.04 s, total: 17.2 s\n", + "Wall time: 4.64 s\n" ] } ], @@ -452,14 +112,14 @@ "%%time\n", "depth_to_auc = {}\n", "n_neighbours = 50\n", - "for depth in [1, 2, 3, 4, 5]:\n", + "for depth in depths:\n", " digit_to_inlier_dists = {}\n", " digit_to_outlier_dists = {}\n", "\n", - " for digit in range(10):\n", + " for digit in digits:\n", " data.load_pen_digit(digit=digit)\n", " print(\"doing digit\", digit, \"doing signature level \", depth)\n", - " signature_maha_knn = SignatureMahalanobisKNN()\n", + " signature_maha_knn = signature_mahalanobis_knn.SignatureMahalanobisKNN()\n", " # Measure the time spent on fit\n", " start_time = time.time()\n", " signature_maha_knn.fit(\n", @@ -503,35 +163,146 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "a0724f2b", + "execution_count": 25, + "id": "fa3d0039-5d50-4aa8-ac91-f76a83513315", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(30, 20, 45)" + "array([3.17808345, 2.90903013, 2.64864169, nan, nan,\n", + " 2.94073725, 2.09585869, nan, 2.76321417, 3.25512904,\n", + " nan, 4.00545501, 3.96774404, nan, 3.70931255,\n", + " nan, nan, nan, 4.15736527, nan,\n", + " 4.07228945, nan, 2.41246371, 2.0039075 , 1.94522639,\n", + " 1.73669995, 3.33430435, nan, nan, 5.30823054])" ] }, - "execution_count": 61, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "np.array(signature_maha_knn.signatures_train)[signature_maha_knn.train_indices].shape" + "inlier_dists" + ] + }, + { + "cell_type": "markdown", + "id": "798d4c01-0fb8-4e38-a5b1-2f2fe8d1a749", + "metadata": {}, + "source": [ + "#### Should be \n", + "[13]:\t\n", + "array([[0.00048547],\n", + " [0.00069512],\n", + " [0.00026231],\n", + " [0.00024205],\n", + " [0.01478617],\n", + " [0.00101271],\n", + " [0.00063996],\n", + " [0.01085489],\n", + " [0.00031296],\n", + " [0.0003389 ],\n", + " [0.0009286 ],\n", + " [0.0001704 ],\n", + " [0.00065423],\n", + " [0.0053868 ],\n", + " [0.00033216],\n", + " [0.00559567],\n", + " [0.00057974],\n", + " [0.03442473],\n", + " [0.00139299],\n", + " [0.01456522],\n", + " [0.00034281],\n", + " [0.00019561],\n", + " [0.00018355],\n", + " [0.00015556],\n", + " [0.0005628 ],\n", + " [0.00013005],\n", + " [0.00049769],\n", + " [0.00200352],\n", + " [0.00387577],\n", + " [0.00061396]])" ] }, { "cell_type": "code", - "execution_count": null, - "id": "34198fd3-3b8c-46ec-8484-bcbb1510a257", + "execution_count": 26, + "id": "7b24a162-ab61-42ec-92d0-31067441e1ea", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "print(depth_to_auc)" + "outlier_dists" ] }, + { + "cell_type": "markdown", + "id": "ec6bff3a-f221-4332-bee7-00eac140a9a3", + "metadata": {}, + "source": [ + "#### Should be\n", + "array([[0.51469102],\n", + " [0.05943012],\n", + " [0.01498096],\n", + " [0.06730538],\n", + " [0.06133516],\n", + " [0.01573002],\n", + " [0.04566752],\n", + " [0.04301818],\n", + " [0.5029002 ],\n", + " [0.56088974],\n", + " [0.05448295],\n", + " [0.39831413],\n", + " [0.03359998],\n", + " [0.08014344],\n", + " [0.05892539],\n", + " [0.07691271],\n", + " [0.67933435],\n", + " [0.20881273],\n", + " [0.42321369],\n", + " [0.07168717],\n", + " [0.05208077],\n", + " [0.51004513],\n", + " [0.29315337],\n", + " [0.21727576],\n", + " [0.00884847],\n", + " [0.02950856],\n", + " [0.04087942],\n", + " [0.33563053],\n", + " [0.26939553],\n", + " [0.07901108]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f265a90a-0e6a-47b3-9cf2-8942e8bcd63e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "30c04c72-edb2-4ed7-9f16-2fc27ca864ad", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "535655b1-d733-47b0-b471-f25a6fd11593", @@ -805,7 +576,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.8.17" } }, "nbformat": 4, From 5114b49f6b0596352b7160e4a5e95ab041e6a066 Mon Sep 17 00:00:00 2001 From: rchan Date: Thu, 2 Nov 2023 09:55:16 +0000 Subject: [PATCH 10/22] fix #12: signature default args --- .../sig_mahal_knn.py | 30 ++++++++++++------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index ca1b57f..f112a8e 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -107,17 +107,25 @@ def fit( ) # set default kwargs for signature transformer if not provided - if signature_kwargs is None or signature_kwargs == {}: - signature_kwargs = { - "augmentation_list": ("addtime",), - "window_name": "global", - "window_depth": None, - "window_length": None, - "window_step": None, - "rescaling": None, - "sig_tfm": "signature", - "depth": 2, - } + sig_defaults = { + "augmentation_list": ("addtime",), + "window_name": "global", + "window_depth": None, + "window_length": None, + "window_step": None, + "rescaling": None, + "sig_tfm": "signature", + "depth": 2, + } + + if signature_kwargs is None: + # set all defaults + signature_kwargs = sig_defaults + else: + # set defaults for any missing kwargs + for key, value in sig_defaults.items(): + if key not in signature_kwargs: + signature_kwargs[key] = value self.signature_transform = SignatureTransformer( **signature_kwargs, From 816558bf49ad6e606b4ff2f23c67960bfe85fbd0 Mon Sep 17 00:00:00 2001 From: rchan Date: Thu, 2 Nov 2023 11:20:28 +0000 Subject: [PATCH 11/22] update paper examples using signature args fix --- .pre-commit-config.yaml | 5 - paper-examples/examples.ipynb | 10529 +++++++++++++++++++++++++++++++- 2 files changed, 10481 insertions(+), 53 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 99c0269..6e4e178 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -50,11 +50,6 @@ repos: - id: ruff args: ["--fix", "--show-fixes"] - - repo: https://github.com/codespell-project/codespell - rev: "v2.2.6" - hooks: - - id: codespell - - repo: https://github.com/shellcheck-py/shellcheck-py rev: "v0.9.0.6" hooks: diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index 804e38b..de9b124 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 12, + "execution_count": 1, "id": "b430e261-33b2-4878-94d6-46e5dbb18c72", "metadata": {}, "outputs": [], @@ -33,7 +33,7 @@ "metadata": {}, "outputs": [], "source": [ - "DATA_DIR = '/Users/zoos/PycharmProjects/Anomaly_detection/data/'\n", + "DATA_DIR = \"/Users/zoos/PycharmProjects/Anomaly_detection/data/\"\n", "# importlib.reload(Data)\n", "# importlib.reload(SigMahaKNN)" ] @@ -48,7 +48,17 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, + "id": "b7a56abc", + "metadata": {}, + "outputs": [], + "source": [ + "n_neighbours = 50" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9", "metadata": {}, "outputs": [], @@ -56,13 +66,13 @@ "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n", "data.load_pen_digit()\n", "\n", - "depths = [4]\n", - "digits = range(1)" + "depths = [1, 2, 3, 4, 5]\n", + "digits = range(10)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 19, "id": "a9b82cb0-4754-409c-891b-b19ec7e9b1a3", "metadata": {}, "outputs": [ @@ -70,27 +80,279 @@ "name": "stdout", "output_type": "stream", "text": [ + "doing digit 0 doing signature level 1\n", + "fit_time: 1.8175599575042725\n", + "compute_auc_time: 0.2454509735107422\n", + "depth: 1 , Auc of digit: 0 is 0.9522222222222222\n", + "doing digit 1 doing signature level 1\n", + "fit_time: 1.7983481884002686\n", + "compute_auc_time: 0.22825384140014648\n", + "depth: 1 , Auc of digit: 1 is 0.8288888888888888\n", + "doing digit 2 doing signature level 1\n", + "fit_time: 1.7937610149383545\n", + "compute_auc_time: 0.1955101490020752\n", + "depth: 1 , Auc of digit: 2 is 0.9388888888888889\n", + "doing digit 3 doing signature level 1\n", + "fit_time: 1.775019884109497\n", + "compute_auc_time: 0.24438023567199707\n", + "depth: 1 , Auc of digit: 3 is 0.9644444444444444\n", + "doing digit 4 doing signature level 1\n", + "fit_time: 1.7686738967895508\n", + "compute_auc_time: 0.2114849090576172\n", + "depth: 1 , Auc of digit: 4 is 0.9311111111111111\n", + "doing digit 5 doing signature level 1\n", + "fit_time: 1.7760677337646484\n", + "compute_auc_time: 0.19081592559814453\n", + "depth: 1 , Auc of digit: 5 is 0.9377777777777778\n", + "doing digit 6 doing signature level 1\n", + "fit_time: 1.862623929977417\n", + "compute_auc_time: 0.14302921295166016\n", + "depth: 1 , Auc of digit: 6 is 0.8455555555555556\n", + "doing digit 7 doing signature level 1\n", + "fit_time: 1.7721309661865234\n", + "compute_auc_time: 0.20407915115356445\n", + "depth: 1 , Auc of digit: 7 is 0.8955555555555557\n", + "doing digit 8 doing signature level 1\n", + "fit_time: 1.8542490005493164\n", + "compute_auc_time: 0.21956300735473633\n", + "depth: 1 , Auc of digit: 8 is 0.9555555555555556\n", + "doing digit 9 doing signature level 1\n", + "fit_time: 1.773684024810791\n", + "compute_auc_time: 0.21489596366882324\n", + "depth: 1 , Auc of digit: 9 is 0.818888888888889\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall, depth: 1 AUC: 0.9025000000000001\n", + "doing digit 0 doing signature level 2\n", + "fit_time: 1.782930850982666\n", + "compute_auc_time: 0.17782831192016602\n", + "depth: 2 , Auc of digit: 0 is 0.9922222222222222\n", + "doing digit 1 doing signature level 2\n", + "fit_time: 1.8092701435089111\n", + "compute_auc_time: 0.19916629791259766\n", + "depth: 2 , Auc of digit: 1 is 0.9488888888888888\n", + "doing digit 2 doing signature level 2\n", + "fit_time: 1.8085293769836426\n", + "compute_auc_time: 0.24826908111572266\n", + "depth: 2 , Auc of digit: 2 is 0.9933333333333334\n", + "doing digit 3 doing signature level 2\n", + "fit_time: 1.828705072402954\n", + "compute_auc_time: 0.22558903694152832\n", + "depth: 2 , Auc of digit: 3 is 1.0\n", + "doing digit 4 doing signature level 2\n", + "fit_time: 1.816422939300537\n", + "compute_auc_time: 0.2291879653930664\n", + "depth: 2 , Auc of digit: 4 is 0.9866666666666667\n", + "doing digit 5 doing signature level 2\n", + "fit_time: 1.9208240509033203\n", + "compute_auc_time: 0.26401209831237793\n", + "depth: 2 , Auc of digit: 5 is 0.9855555555555555\n", + "doing digit 6 doing signature level 2\n", + "fit_time: 1.8196361064910889\n", + "compute_auc_time: 0.19854211807250977\n", + "depth: 2 , Auc of digit: 6 is 1.0\n", + "doing digit 7 doing signature level 2\n", + "fit_time: 1.822005033493042\n", + "compute_auc_time: 0.31998777389526367\n", + "depth: 2 , Auc of digit: 7 is 0.9777777777777777\n", + "doing digit 8 doing signature level 2\n", + "fit_time: 1.8831498622894287\n", + "compute_auc_time: 0.1961832046508789\n", + "depth: 2 , Auc of digit: 8 is 0.9977777777777778\n", + "doing digit 9 doing signature level 2\n", + "fit_time: 1.846689224243164\n", + "compute_auc_time: 0.18111586570739746\n", + "depth: 2 , Auc of digit: 9 is 0.9677777777777778\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall, depth: 2 AUC: 0.9826555555555556\n", + "doing digit 0 doing signature level 3\n", + "fit_time: 1.8771882057189941\n", + "compute_auc_time: 0.2520630359649658\n", + "depth: 3 , Auc of digit: 0 is 0.9933333333333334\n", + "doing digit 1 doing signature level 3\n", + "fit_time: 1.902285099029541\n", + "compute_auc_time: 0.21264314651489258\n", + "depth: 3 , Auc of digit: 1 is 0.9866666666666666\n", + "doing digit 2 doing signature level 3\n", + "fit_time: 1.9661970138549805\n", + "compute_auc_time: 0.2668132781982422\n", + "depth: 3 , Auc of digit: 2 is 0.9977777777777778\n", + "doing digit 3 doing signature level 3\n", + "fit_time: 1.9230389595031738\n", + "compute_auc_time: 0.16147518157958984\n", + "depth: 3 , Auc of digit: 3 is 0.9955555555555555\n", + "doing digit 4 doing signature level 3\n", + "fit_time: 1.9575071334838867\n", + "compute_auc_time: 0.26868581771850586\n", + "depth: 3 , Auc of digit: 4 is 0.9988888888888889\n", + "doing digit 5 doing signature level 3\n", + "fit_time: 1.891937017440796\n", + "compute_auc_time: 0.20909786224365234\n", + "depth: 3 , Auc of digit: 5 is 0.9888888888888889\n", + "doing digit 6 doing signature level 3\n", + "fit_time: 1.8992087841033936\n", + "compute_auc_time: 0.23921418190002441\n", + "depth: 3 , Auc of digit: 6 is 0.9944444444444445\n", + "doing digit 7 doing signature level 3\n", + "fit_time: 1.845163106918335\n", + "compute_auc_time: 0.24655508995056152\n", + "depth: 3 , Auc of digit: 7 is 0.9755555555555555\n", + "doing digit 8 doing signature level 3\n", + "fit_time: 1.8408448696136475\n", + "compute_auc_time: 0.23415112495422363\n", + "depth: 3 , Auc of digit: 8 is 1.0\n", + "doing digit 9 doing signature level 3\n", + "fit_time: 1.869530200958252\n", + "compute_auc_time: 0.24516701698303223\n", + "depth: 3 , Auc of digit: 9 is 0.9800000000000001\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overall, depth: 3 AUC: 0.9858111111111111\n", "doing digit 0 doing signature level 4\n", - "fit_time: 3.6063642501831055\n", - "compute_auc_time: 0.830460786819458\n", - "there is the change\n", - "depth: 4 , Auc of digit: 0 is 0.8\n", - "there is the change\n" + "fit_time: 1.9820890426635742\n", + "compute_auc_time: 0.20805883407592773\n", + "depth: 4 , Auc of digit: 0 is 0.9922222222222222\n", + "doing digit 1 doing signature level 4\n", + "fit_time: 1.9823508262634277\n", + "compute_auc_time: 0.19276905059814453\n", + "depth: 4 , Auc of digit: 1 is 0.9888888888888889\n", + "doing digit 2 doing signature level 4\n", + "fit_time: 1.9892983436584473\n", + "compute_auc_time: 0.2388601303100586\n", + "depth: 4 , Auc of digit: 2 is 0.9966666666666667\n", + "doing digit 3 doing signature level 4\n", + "fit_time: 2.15161395072937\n", + "compute_auc_time: 0.32798099517822266\n", + "depth: 4 , Auc of digit: 3 is 1.0\n", + "doing digit 4 doing signature level 4\n", + "fit_time: 1.9887158870697021\n", + "compute_auc_time: 0.2344069480895996\n", + "depth: 4 , Auc of digit: 4 is 1.0\n", + "doing digit 5 doing signature level 4\n", + "fit_time: 2.098742961883545\n", + "compute_auc_time: 0.2179582118988037\n", + "depth: 4 , Auc of digit: 5 is 0.9922222222222222\n", + "doing digit 6 doing signature level 4\n", + "fit_time: 2.0192692279815674\n", + "compute_auc_time: 0.29630589485168457\n", + "depth: 4 , Auc of digit: 6 is 0.9955555555555555\n", + "doing digit 7 doing signature level 4\n", + "fit_time: 2.035627841949463\n", + "compute_auc_time: 0.34957003593444824\n", + "depth: 4 , Auc of digit: 7 is 0.9800000000000001\n", + "doing digit 8 doing signature level 4\n", + "fit_time: 1.9556260108947754\n", + "compute_auc_time: 0.21259498596191406\n", + "depth: 4 , Auc of digit: 8 is 1.0\n", + "doing digit 9 doing signature level 4\n", + "fit_time: 1.9622900485992432\n", + "compute_auc_time: 0.1990797519683838\n", + "depth: 4 , Auc of digit: 9 is 0.9911111111111112\n" ] }, { - "name": "stderr", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByXElEQVR4nO3dd1hTZxsG8Dsge6qAIKK4d0Vx1L1QHLV146iide9RrVscVbTuqq1btLVurdaBddZdrYgTN7jBHWRL8n5/nI9oZEgwcIDcv+vKpefNOSdPckLy5J0KIYQAERERkQEykjsAIiIiIrkwESIiIiKDxUSIiIiIDBYTISIiIjJYTISIiIjIYDERIiIiIoPFRIiIiIgMFhMhIiIiMlhMhIiIiMhgMREyQO7u7ujRo4fcYRicBg0aoEGDBnKH8UlTpkyBQqHAixcv5A4l21EoFJgyZYpezhUWFgaFQoGAgAC9nC+n+5y/jx49esDd3f2zY9iyZQvy5cuHqKioT+6rz/eCro4dOwaFQoFt27bJ8vgfCgwMhLW1NZ4/fy53KBnGREjPAgICoFAoNLc8efLA1dUVPXr0wOPHj+UOL1uLjo7G9OnT8cUXX8DS0hJ2dnaoW7cu1q9fj5yyEsz169cxZcoUhIWFyR1KMiqVCmvXrkWDBg2QL18+mJmZwd3dHT179sR///0nd3h68ccff2DhwoVyh6ElK2JKSqqSbsbGxihcuDDatGmD4ODgTH3slPTo0UMrHmtraxQrVgzt27fH9u3boVarM/XxY2JiMGXKFBw7dizdx6hUKvj5+WHIkCGwtrbOvOB0kF3ez+/evUO5cuWgUCgwd+5crfuaNWuGEiVKwN/fX6boPl8euQPIraZNm4aiRYsiLi4OZ8+eRUBAAE6ePImrV6/C3Nxc1thu3rwJI6PslQNHRESgcePGCAkJQadOnTB48GDExcVh+/bt8PX1xb59+7BhwwYYGxvLHWqarl+/jqlTp6JBgwbJfqH+/fff8gQFIDY2Fm3btkVgYCDq1auH8ePHI1++fAgLC8OWLVuwbt06PHjwAIUKFZItRn34448/cPXqVQwfPjxTzh8bG4s8eXT72EwtpiJFiiA2NhYmJiZ6i69z585o0aIFVCoVQkJC8Ouvv2L//v04e/YsPDw89PY46WFmZoZVq1YBkF63+/fv46+//kL79u3RoEED7Nq1C7a2tpr9P+fvY+XKlVrJVUxMDKZOnQoA6a5l+uuvv3Dz5k307ds3w3HoW2a/n9Nr8eLFePDgQar39+vXD6NGjcLUqVNhY2OThZHpiSC9Wrt2rQAgzp8/r1U+ZswYAUBs3rxZpsjkFRsbK1QqVar3e3t7CyMjI7Fr165k940aNUoAELNmzcrMEFMUFRWl0/5bt24VAMTRo0czJ6AMGjRokAAgFixYkOy+xMREMWfOHPHw4UMhhBB+fn4CgHj+/HmmxaNWq0VMTIzez9uyZUtRpEgRvZ5TpVKJ2NjYDB+fGTF9LDQ0VAAQc+bM0SrfvXu3ACD69u2bqY//MV9fX2FlZZXiff7+/gKA6NixY6Y9/vPnzwUA4efnl+5jvv76a1GnTp1076/r+TMitffO0aNHBQCxdevWTH18IYSIiIgQdnZ2Ytq0aSm+x5L2MTY2FqtXr870eDIDEyE9Sy0R2rNnjwAgZs6cqVUeEhIi2rVrJ/LmzSvMzMyEp6dnisnA69evxfDhw0WRIkWEqampcHV1Fd26ddP6soqLixOTJ08WxYsXF6ampqJQoUJi9OjRIi4uTutcRYoUEb6+vkIIIc6fPy8AiICAgGSPGRgYKACIv/76S1P26NEj0bNnT+Hk5CRMTU1FuXLlkr35k/5IN27cKCZMmCAKFiwoFAqFeP36dYqv2ZkzZwQA8d1336V4/7t370TJkiVF3rx5NV+eH37wz58/XxQuXFiYm5uLevXqiStXriQ7R3pe56Rrd+zYMTFgwADh6Ogo7O3thRBChIWFiQEDBohSpUoJc3NzkS9fPtG+fXsRGhqa7PiPb0lJUf369UX9+vWTvU6bN28WP/74o3B1dRVmZmaiUaNG4vbt28mew5IlS0TRokWFubm5qFatmjh+/Hiyc6bk4cOHIk+ePKJJkyZp7pckKRG6ffu28PX1FXZ2dsLW1lb06NFDREdHa+27Zs0a0bBhQ+Ho6ChMTU1F2bJlxS+//JLsnEWKFBEtW7YUgYGBwtPTU5iZmWmSsvSeQwgh9u3bJ+rVqyesra2FjY2NqFq1qtiwYYMQQnp9P37tP/wSSe/fBwAxaNAg8fvvv4ty5cqJPHnyiJ07d2ru+/DLLzIyUgwbNkzzd+no6Ci8vLzEhQsXPhlT0nt47dq1Wo8fEhIiOnToIBwcHIS5ubkoVaqUGD9+fFqXLNVEKCoqSgDQuvZnz54V3t7ewtbWVlhYWIh69eqJkydPah2ny3sgJWklQkII0bRpU6FQKMTNmzc1ZSm9l8PCwkSrVq2EpaWlcHR0FMOHD9d8Ln34Y8PX1zfZ6/rxLa2kJTY2VpiamoopU6Ykuy8uLk4MHz5cODg4CGtra9GqVSvx8OHDFM+py+fjpk2bxLhx40SBAgWEpaWlaNWqlXjw4IHW65Hae0fXz47P0bNnT1G9enVx7969VBMhIYSoXLmy+Prrr/X62FmFTWNZJKnPSN68eTVl165dQ+3ateHq6oqxY8fCysoKW7ZsQevWrbF9+3a0adMGABAVFYW6desiJCQE3333HapUqYIXL15g9+7dePToERwcHKBWq/H111/j5MmT6Nu3L8qWLYsrV65gwYIFuHXrFv78888U46patSqKFSuGLVu2wNfXV+u+zZs3I2/evPD29gYgNV99+eWXUCgUGDx4MBwdHbF//3706tULkZGRyapvp0+fDlNTU4waNQrx8fEwNTVNMYa//voLANC9e/cU78+TJw+6dOmCqVOn4tSpU/Dy8tLct379erx9+xaDBg1CXFwcFi1ahEaNGuHKlSsoUKCATq9zkoEDB8LR0RGTJ09GdHQ0AOD8+fM4ffo0OnXqhEKFCiEsLAy//vorGjRogOvXr8PS0hL16tXD0KFD8fPPP2P8+PEoW7YsAGj+Tc2sWbNgZGSEUaNGQalU4qeffkLXrl3x77//avb59ddfMXjwYNStWxcjRoxAWFgYWrdujbx5836yOWv//v1ITExEt27d0tzvYx07dkTRokXh7++PoKAgrFq1Ck5OTpg9e7ZWXOXLl8fXX3+NPHny4K+//sLAgQOhVqsxaNAgrfPdvHkTnTt3Rr9+/dCnTx+ULl1ap3MEBATgu+++Q/ny5TFu3DjY29vj4sWLCAwMRJcuXTBhwgQolUo8evQICxYsAABNXw9d/z6OHDmCLVu2YPDgwXBwcEi1I27//v2xbds2DB48GOXKlcPLly9x8uRJhISEoEqVKmnGlJLLly+jbt26MDExQd++feHu7o67d+/ir7/+wowZM9J34T5w9+5dAED+/Pk1z6t58+bw9PSEn58fjIyMsHbtWjRq1AgnTpxA9erVtY5Pz3sgI7p164a///4bBw8eRKlSpVLcJzo6Go0aNcLTp08xbNgwODs7448//sDRo0fTPLejoyN+/fVXDBgwAG3atEHbtm0BAF988UWqx1y4cAEJCQmoUqVKsvt69+6N33//HV26dEGtWrVw5MgRtGzZMtl+un4+zpgxAwqFAmPGjMGzZ8+wcOFCeHl5ITg4GBYWFul676TnsyMmJgYxMTFpvmYAYGxsrPX9BADnzp3DunXrcPLkSSgUijSP9/T0TPV7JtuTOxPLbZJqBQ4dOiSeP38uHj58KLZt2yYcHR2FmZmZpvlBCCEaN24sKlasqPWLVK1Wi1q1aomSJUtqyiZPniwAiB07diR7PLVaLYQQ4rfffhNGRkbixIkTWvcvW7ZMABCnTp3SlH1YIySEEOPGjRMmJibi1atXmrL4+Hhhb2+vVUvTq1cv4eLiIl68eKH1GJ06dRJ2dnaa2pqkXyvFihVLV/NH69atBYBUa4yEEGLHjh0CgPj555+FEO9/9VlYWIhHjx5p9vv3338FADFixAhNWXpf56RrV6dOHZGYmKj1+Ck9j6SarPXr12vK0moaS61GqGzZsiI+Pl5TvmjRIgFAU7MVHx8v8ufPL6pVqybevXun2S8gIEAA+GSN0IgRIwQAcfHixTT3S5JUG/BxDV2bNm1E/vz5tcpSel28vb1FsWLFtMqKFCkiAIjAwMBk+6fnHG/evBE2NjaiRo0ayZqpkv4GhEi9KUGXvw8AwsjISFy7di3ZefBRLYCdnZ0YNGhQsv0+lFpMKdUI1atXT9jY2Ij79++n+hxTknSuqVOniufPn4vw8HBx7NgxUblyZQFAbN++XajValGyZEnh7e2tdb6YmBhRtGhRrVojXd4DKflUjdDFixeT/Z1+/Pcxb948AUD8+eefmrLY2FhRpkyZNGuEhNC9aWzVqlVaf3NJgoODBQAxcOBArfIuXbokO7+un4+urq4iMjJSs9+WLVsEALFo0SJN2aeaxj712SHE+2v5qdvHj6NWq0X16tVF586dhRCp1zommTlzpgAgIiIiUrw/O8tePWZzES8vLzg6OsLNzQ3t27eHlZUVdu/erfn1/urVKxw5cgQdO3bE27dv8eLFC7x48QIvX76Et7c3bt++rRlltn37dlSqVClZzQUATZa+detWlC1bFmXKlNGc68WLF2jUqBEApPkrysfHB+/evcOOHTs0ZX///TfevHkDHx8fAIAQAtu3b0erVq0ghNB6DG9vbyiVSgQFBWmd19fXFxYWFp98rd6+fQsAaXayS7ovMjJSq7x169ZwdXXVbFevXh01atTAvn37AOj2Oifp06dPsk7ZHz6Pd+/e4eXLlyhRogTs7e2TPW9d9ezZU6u2rG7dugCAe/fuAQD+++8/vHz5En369NHqqNu1a9dkv+BSkvSa6dqJsX///lrbdevWxcuXL7WuwYevi1KpxIsXL1C/fn3cu3cPSqVS6/iiRYtqahc/lJ5zHDx4EG/fvsXYsWOTDTb41C9VQPe/j/r166NcuXKfPK+9vT3+/fdfPHny5JP7fsrz589x/PhxfPfddyhcuLDWfel5jgDg5+cHR0dHODs7o0GDBrh79y5mz56Ntm3bIjg4GLdv30aXLl3w8uVLzWsQHR2Nxo0b4/jx48lGc6XnPZARSTUbSX/7KQkMDISrqyu+/vprTZm5uTn69OnzWY+dkpcvXwJAsr+npM+RoUOHapV/XLuTkc/H7t27a/1Ntm/fHi4uLprHTI9PfXYkPc7Bgwc/eduwYYPWuQMCAnDlypV01/4lvXY5cdoNNo1lkqVLl6JUqVJQKpVYs2YNjh8/DjMzM839d+7cgRACkyZNwqRJk1I8x7Nnz+Dq6oq7d++iXbt2aT7e7du3ERISAkdHx1TPlZpKlSqhTJky2Lx5M3r16gVAahZzcHDQfFE8f/4cb968wYoVK7BixYp0PUbRokXTjDlJ0ofB27dvYW9vn+I+qSVLJUuWTLZvqVKlsGXLFgC6vc5pxR0bGwt/f3+sXbsWjx8/1hrO//EXvq4+/tJL+kB5/fo1AOD+/fsAgBIlSmjtlydPnnTNnZI0MietLx1d40o656lTp+Dn54czZ84kq35XKpWws7PTbKf2fkjPOZKaeCpUqKDTc0ii699Het+7P/30E3x9feHm5gZPT0+0aNEC3bt3R7FixXSOMenLK6PPEQD69u2LDh06wMjICPb29ihfvrzmc+f27dsAkKwJ/ENKpVIrGUjPeyAjkubpSSs5v3//PooXL54sCfz470CfPvy7TorByMgIxYsX1ypPatZNkpHPx48/uxQKBUqUKKHT1Buf+uwAgGLFiun8foyMjMS4ceMwevRouLm5peuYpNcuvUl7dsJEKJNUr14dVatWBSDVWtSpUwddunTBzZs3YW1trfnlNWrUqBR/JQO6/cGr1WpUrFgR8+fPT/H+T72ZfXx8MGPGDLx48QI2NjbYvXs3OnfurKmBSIr322+/TfWD9OM2+PTUBgFSH5o///wTly9fRr169VLc5/LlywCQrl/pH8rI65xS3EOGDMHatWsxfPhw1KxZE3Z2dlAoFOjUqdNnz4mS2pQAH38oZ1SZMmUAAFeuXNFpCPWn4rp79y4aN26MMmXKYP78+XBzc4OpqSn27duHBQsWJHtdUnpddT1HRun695He927Hjh1Rt25d7Ny5E3///TfmzJmD2bNnY8eOHWjevPlnx62rkiVLavWh+1DSazlnzpxU3wcf90HJrPfm1atXAWRuUqOLpD5Ur1+/ztAUEhn5fNSH9FyfqKiodE0QaWxsrPmhMHfuXCQkJMDHx0eTmD169AiA9BqFhYWhYMGCWrVRScmXg4NDhp6LnJgIZQFjY2P4+/ujYcOGWLJkCcaOHavJ0E1MTFL94EpSvHhxzQdHWvtcunQJjRs3zlBG7uPjg6lTp2L79u0oUKAAIiMj0alTJ839jo6OsLGxgUql+mS8uvrqq6/g7++P9evXp5gIqVQq/PHHH8ibNy9q166tdV/Sr9wP3bp1S1NTosvrnJZt27bB19cX8+bN05TFxcXhzZs3Wvtlxq+hIkWKAJBqtxo2bKgpT0xMRFhY2Cc/YJs3bw5jY2P8/vvvOneYTstff/2F+Ph47N69W+uX6ac6s2bkHEm/yK9evZrml2dqr//n/n2kxcXFBQMHDsTAgQPx7NkzVKlSBTNmzNAkQul9vKT36qf+1jMq6TW0tbXV+9+wrn777TcoFAo0adIk1X2KFCmC69evQwih9RreuXPnk+fX9Ron/VgIDQ1FxYoVtWJQq9W4e/euVi3QzZs3tY7PyOfjx59dQgjcuXNH6+9ZH+/VuXPnauZUSkuRIkU0Sc+DBw/w+vVrlC9fPtl+M2fOxMyZM3Hx4kWthDo0NBQODg6p1rpmZ+wjlEUaNGiA6tWrY+HChYiLi4OTkxMaNGiA5cuX4+nTp8n2/3C68nbt2uHSpUvYuXNnsv2SMv+OHTvi8ePHWLlyZbJ9YmNjNaOfUlO2bFlUrFgRmzdvxubNm+Hi4qKVlBgbG6Ndu3bYvn17ih/UnzO9eq1ateDl5YW1a9diz549ye6fMGECbt26hR9++CHZL/U///xTq4/PuXPn8O+//2q+hHR5ndNibGyc7Ffw4sWLoVKptMqsrKwAIFmC9DmqVq2K/PnzY+XKlUhMTNSUb9iwQasKPDVubm7o06cP/v77byxevDjZ/Wq1GvPmzdP84kuvpF+jHzcTrl27Vu/naNq0KWxsbODv74+4uDit+z481srKKsWmys/9+0iJSqVK9lhOTk4oWLAg4uPjPxnTxxwdHVGvXj2sWbMm2eR1+qgd9PT0RPHixTF37twUawiyaomEWbNm4e+//4aPj0+KTdtJvL298fjxY+zevVtTFhcXl+I1/JilpSWA9P8denp6wtTUNNkM60mfIz///LNW+cezPWfk8zFpxGuSbdu24enTp1o1iel976QlI32Ehg4dip07d2rdli9fDkCaNXznzp3Jmo8vXLiAmjVrflascmGNUBYaPXo0OnTogICAAPTv3x9Lly5FnTp1ULFiRfTp0wfFihVDREQEzpw5g0ePHuHSpUua47Zt24YOHTrgu+++g6enJ169eoXdu3dj2bJlqFSpErp164YtW7agf//+OHr0KGrXrg2VSoUbN25gy5YtOHDggKapLjU+Pj6YPHkyzM3N0atXr2SzT8+aNQtHjx5FjRo10KdPH5QrVw6vXr1CUFAQDh06hFevXmX4tVm/fj0aN26Mb775Bl26dEHdunURHx+PHTt24NixY/Dx8cHo0aOTHVeiRAnUqVMHAwYMQHx8PBYuXIj8+fPjhx9+0OyT3tc5LV999RV+++032NnZoVy5cjhz5gwOHTqkqVJP4uHhAWNjY8yePRtKpRJmZmZo1KgRnJycMvzamJqaYsqUKRgyZAgaNWqEjh07IiwsDAEBASn2oUjJvHnzcPfuXQwdOhQ7duzAV199hbx58+LBgwfYunUrbty4oVUDmB5NmzaFqakpWrVqhX79+iEqKgorV66Ek5NTiknn55zD1tYWCxYsQO/evVGtWjV06dIFefPmxaVLlxATE4N169YBkL7QNm/ejJEjR6JatWqwtrZGq1at9PL38bG3b9+iUKFCaN++PSpVqgRra2scOnQI58+f16o5TC2mlPz888+oU6cOqlSpgr59+6Jo0aIICwvD3r17P3upDCMjI6xatQrNmzdH+fLl0bNnT7i6uuLx48c4evQobG1tNVNZ6ENiYiJ+//13AFICc//+fezevRuXL19Gw4YNU+1Lk6Rfv35YsmQJOnfujGHDhsHFxQUbNmzQdJZP631vYWGBcuXKYfPmzShVqhTy5cuHChUqpNr/ytzcHE2bNsWhQ4cwbdo0TbmHhwc6d+6MX375BUqlErVq1cLhw4dTrJXS9fMxX758qFOnDnr27ImIiAgsXLgQJUqU0OoMrst7JzUZ6SNUpUqVZFMJJNUWlS9fHq1bt9a679mzZ7h8+XKyKTNyjCwdo2YAUptQUQhphtrixYuL4sWLa4Zn3717V3Tv3l04OzsLExMT4erqKr766iuxbds2rWNfvnwpBg8eLFxdXTWTwfn6+moN1UxISBCzZ88W5cuXF2ZmZiJv3rzC09NTTJ06VSiVSs1+Hw+fT3L79m3NUMqPJ1hLEhERIQYNGiTc3NyEiYmJcHZ2Fo0bNxYrVqzQ7JPRWU/fvn0rpkyZIsqXLy8sLCyEjY2NqF27tggICEg2fPjDoZzz5s0Tbm5uwszMTNStW1dcunQp2bnT8zqnde1ev34tevbsqZlUzdvbW9y4cSPF13LlypWiWLFiwtjYOF0TKn78OqU20d7PP/8sihQpIszMzET16tXFqVOnhKenp2jWrFk6Xl1pBulVq1aJunXrCjs7O2FiYiKKFCkievbsqTW0PrWZpZNenw8nkdy9e7f44osvhLm5uXB3dxezZ88Wa9asSbZf0oSKKUnvOZL2rVWrlrCwsBC2traievXqYuPGjZr7o6KiRJcuXYS9vX2yIcHp/fvA/ydUTAk+GDIdHx8vRo8eLSpVqiRsbGyElZWVqFSpUrLJIFOLKbXrfPXqVdGmTRthb28vzM3NRenSpcWkSZNSjCfJp4Y2f+jixYuibdu2In/+/MLMzEwUKVJEdOzYURw+fFizjy7vgZT4+vpqDc22tLQU7u7uol27dmLbtm0pzjKf0oSK9+7dEy1bthQWFhbC0dFRfP/992L79u0CgDh79qzW4308/Pv06dPC09NTmJqapmso/Y4dO4RCodCa1FAIacj+0KFDRf78+YWVlVWaEyrq8vm4ceNGMW7cOOHk5CQsLCxEy5Ytk02bkNp7R9fPDn1I6z3266+/CktLS63pAHIShRA5ZDVLog+EhYWhaNGimDNnDkaNGiV3OLJQq9VwdHRE27Zt09VcQJQbLFy4ECNGjMCjR4+0Rnt+LpVKhXLlyqFjx46YPn263s77sWPHjqFhw4bYunUr2rdvn2mPk5UqV66MBg0aaCZ+zGnYR4goB4iLi0vWT2T9+vV49epVuheVJMppYmNjtbbj4uKwfPlylCxZUq9JECD185k2bRqWLl2arlFWJAkMDMTt27cxbtw4uUPJMPYRIsoBzp49ixEjRqBDhw7Inz8/goKCsHr1alSoUAEdOnSQOzyiTNG2bVsULlwYHh4eUCqV+P3333Hjxo1kk//pi4+Pj2YSWUqfZs2a5fjEkYkQUQ7g7u4ONzc3/Pzzz3j16hXy5cuH7t27Y9asWamu4UaU03l7e2PVqlXYsGGDpulq06ZNTFZIr2TtI3T8+HHMmTMHFy5cwNOnT7Fz585kvdE/duzYMYwcORLXrl2Dm5sbJk6ciB49emRJvERERJS7yNpHKDo6GpUqVcLSpUvTtX9oaChatmyJhg0bIjg4GMOHD0fv3r1x4MCBTI6UiIiIcqNsM2pMoVB8skZozJgx2Lt3r9aEVZ06dcKbN28QGBiYBVESERFRbpKj+gidOXMm2fTl3t7eyVYC/lB8fLzWLK9qtRqvXr1C/vz5c+TicERERIZICIG3b9+iYMGCySb8/Rw5KhEKDw9HgQIFtMqS1sWKjY1NcaFEf3//dK2zQkRERNnfw4cPM7Q4bmpyVCKUEePGjcPIkSM120qlEoULF8bDhw9ha2srY2TyEQKIicncx4iJAbLJwtI6q1gRCAwEWGFIRCQv4z27oGrcBLCwxNu3kShd2g02NjZ6fYwclQg5OzsjIiJCqywiIgK2trYp1gYBgJmZGczMzJKV29raGkwi9GHiIwRQty7wmcsW6SQiAvj/WqQ5gqUlkyAiIllFRwODBgHr1gG9ewMrV2q+R/TdrSVHJUI1a9bEvn37tMoOHjyYY1e81Ze0anjkSHw+VLs24OjIxIKIiNLp6lWgY0cgJAQwMgIKF5a+zDKJrIlQVFSU1iq+oaGhCA4ORr58+VC4cGGMGzcOjx8/xvr16wEA/fv3x5IlS/DDDz/gu+++w5EjR7Blyxbs3btXrqcgO7Ua8PTUPdHx8ABOnMj8BIW1K0RElC5CAGvWAEOGALGxgIsL8McfQCYvIyRrIvTff/+hYcOGmu2kvjy+vr4ICAjA06dP8eDBA839RYsWxd69ezFixAgsWrQIhQoVwqpVq+Dt7Z3lsWcHQqQ/Cfo48WGCQkRE2UZUFNC/P5C0fErTpsBvvwFOTpn+0NlmHqGsEhkZCTs7OyiVyhzZR+jDZrDoaCBpEF3JkkBQUOrJDRMfIiLKth49kn6xv3kD/Pgj8MMPUrPYBzLr+ztH9REydGk1gwUFAdbWWR4SERHR5ytUCNi4EbCwAOrUydKHlnWJDUqbEFKtT3S0VGtYpkzKSVDt2jlrVBYRERm4yEigUyfgzz/flzVpkuVJEMAaoWxLCOn9cPp08vs+bgZjsxcREeUYFy4APj7A3bvA0aNSfyBLS9nCYY1QNhUTk3IS5OEB3LghNYNZWUk3JkFERJTtCQEsXgzUqiUlQUWKALt2yZoEAawRyhE+nJCQtT9ERJTjvHkD9OoF7NghbbduLQ2Vz5tXzqgAMBHKEZJqfoiIiHKcN2+AypWBsDDAxASYO1eaKyib/Kpn0xgRERFlHnt7oHlzoFgxqc/H0KHZJgkCWCOU7STNExQdLXckREREGfTyJZCY+H6yu/nzgfh4wM5O3rhSwBqhbEIIaYh8lSpSR+ik9w4REVGOcvq01BTWuTOgUkll5ubZMgkCmAhlC0lD5W1sks8TVLu27B3qiYiIPk2tBmbPBurVAx4+lG5Pn8od1SexaSwb+Hio/IfrgnGUGBERZXvPnwO+vsD+/dJ2587A8uXSL/xsjolQNvDham8REYCjI5MfIiLKIU6ckGaJfvJEagL7+Wegd+8c80XGRCiLfbhoatJ2lSrvtzlBIhER5RgqFTBwoJQElSkDbNkCVKwod1Q6YSKUCT5Odj4sr1s35fXCAKlJjP2BiIgoxzA2lhZLXbQIWLAgR67+zURIz9JaIywtHh7S8iusDSIiomztyBHg9m2gXz9pu0IFYOVKeWP6DEyE9Cy1NcI+9GFn6CTsFE1ERNmaSgVMmwZMny7VBHl6AlWryh3VZ2MipEdCaE+E+OEaYR9i0kNERDnKkydA167AsWPSdo8eQLlyckakN0yEMiilTs8f9//hGmFERJTjHTgAdOsmDZG3tpaGxXfpIndUesNEKAPUaqlGMLVOzwAnQiQiolxgyhRg6lTp/5UqSaPCSpWSNSR948zSOhIi7STIwwN4+zZ5HyAiIqIcx95e+rd/f+Ds2VyXBAGsEdJZTMz7JKhkSSAoiJ2eiYgoF4mOft+vY9gwad2w+vXljSkTsUZIBx93hg4KkppLk/oCcTJEIiLKsd69A0aPlmb5fftWKlMocnUSBDARSrek+YE+XBWeSQ8REeUK9+9Li6XOnQvcugX8+afcEWUZJkLp9PH8QOwMTUREucKuXVIH17NnATs7YPt2aZSYgWAfoQzgwqhERJTjJSQAP/wgLY8BANWrA5s2AUWLyhtXFmONUAawLxAREeV4Y8a8T4K+/14a7mxgSRDARIiIiMgwjR0LlC8P7N4t9Q0yNZU7IlkwESIiIjIEcXHSSvFJChQALl8GWrWSL6ZsgH2EiIiIcrvbt4GOHd9PhNe5s/SvEetD+AoQERHlZhs3SnMDBQcDDg5AvnxyR5StMBEiIiLKjWJjgb59pQVSo6KkeYKCgwFvb7kjy1aYCBEREeU2N24ANWoAK1dKw5wnTgQOHwZcXeWOLNthHyEiIqLc5u5d4MoVwMkJ2LAB8PKSO6Jsi4lQOgkhdwRERETp1LKlVBvUsiXg4iJ3NNkam8bSQQigbl25oyAiIkrFtWvSF9X9++/LevdmEpQOTITSISbm/YhDDw+uMUZERNmEEMCaNUC1asDJk8Dw4XJHlOOwaUxHJ05weQ0iIsoGoqKA/v2lPkAA0LQpsHy5vDHlQKwR0hGTICIikt2lS4Cnp5QEGRsDM2cC+/dLnaNJJ6wRIiIiyklOnACaNAHi46Xh8Js2AXXqyB1VjsVEiIiIKCepVg0oU0ZKgtatk2aLpgxjIkRERJTdhYQApUpJzWDm5sChQ9JSGVwr7LPxFSQiIsquhACWLJGGLM+Y8b7cwYFJkJ6wRoiIiCg7evMG6NUL2LFD2r50CVCrmQDpGV9NIiKi7ObcOaByZSkJMjEBFi4Etm1jEpQJ+IoSERFlF0IACxZIo8DCwoCiRYFTp4Bhwzh/SyZhIvQJQgDR0XJHQUREBiE0FBg/Hnj3DmjXDggKkkaJUaZhH6E0CCEl5adPyx0JEREZhGLFgKVLgdhYYOBA1gJlASZCaYiJ0U6CatfmOmNERKRHajUwb560YOqXX0pl330nb0wGholQOkVEAI6OTM6JiEhPnj8HfH2lpTGKFAGuXgWsreWOyuAwEUonKysmQUREpCfHjwOdOwNPnkgTJE6YIH3RUJZjZ2kiIqKsolZLEyM2bCglQaVLA//+C/Tpw1/bMmGNEBERUVaIigLatgUOHpS2u3UDfvmFzWEyYyJERESUFaysAAsL6fbLL0CPHnJHRGAiRERElHlUKiAhQUp+FApg7VogPBwoV07uyOj/2EcoBUmTKHIiRSIiyrCnTwEvL6n/jxBSWb58TIKyGdYIfYSTKBIR0Wf7+2/g22+lIfJWVsC9e0Dx4nJHRSlgjdAHhJDesx8nQZxIkYiI0iUxURoK36yZ9IXyxRfAf/8xCcrGWCP0fynVBEVESIm8pSVHNRIR0Sc8egR06QKcOCFt9+snLaBqYSFvXJQmJkJIuSaodm3OJE1EROmkVgPNm0uzQ9vYACtXAj4+ckdF6WDwTWNJNUEFCrwvi4iQEnomQURElC5GRsDChUDVqtKK8UyCcgyDT4RSWliVNUFERPRJDx5InaKTNG4szRJdooR8MZHODL5pLGlEI8CFVYmIKJ1275YmRExMlGqAkpIfI4OvX8hxDPqKCQHUrft+mwurEhFRmhISgBEjgG++AV6/BsqUAfIYfJ1CjiZ7IrR06VK4u7vD3NwcNWrUwLlz59Lcf+HChShdujQsLCzg5uaGESNGIC4uLkOPHRMDBAdL//fw4BB5IiJKQ2io1Kl04UJpe8QI4ORJwN1dzqjoM8maCG3evBkjR46En58fgoKCUKlSJXh7e+PZs2cp7v/HH39g7Nix8PPzQ0hICFavXo3Nmzdj/Pjxnx0LO0cTEVGqtm8HKlcGzp8H8uYFdu0C5s8HTE3ljow+k6yJ0Pz589GnTx/07NkT5cqVw7Jly2BpaYk1a9akuP/p06dRu3ZtdOnSBe7u7mjatCk6d+78yVqk9GASREREqTp9GlAqgZo1paaEr7+WOyLSE9kSoYSEBFy4cAFeXl7vgzEygpeXF86cOZPiMbVq1cKFCxc0ic+9e/ewb98+tGjRItXHiY+PR2RkpNaNiIjokz4cTePvDyxaBPzzD1C4sHwxkd7Jlgi9ePECKpUKBT6cwAdAgQIFEB4enuIxXbp0wbRp01CnTh2YmJigePHiaNCgQZpNY/7+/rCzs9Pc3Nzc9Po8iIgoF9q0CWjRAnj3Tto2NQWGDgVMTOSNi/RO9s7Sujh27BhmzpyJX375BUFBQdixYwf27t2L6dOnp3rMuHHjoFQqNbeHDx9mYcRERJSjxMZKS2N07gwEBkozRFOuJtuYPwcHBxgbGyMiIkKrPCIiAs7OzikeM2nSJHTr1g29e/cGAFSsWBHR0dHo27cvJkyYAKMU5m8wMzODmZmZ/p8AERHlLjdvAh07ApcvSx1Hx48H+vaVOyrKZLLVCJmamsLT0xOHDx/WlKnVahw+fBg1a9ZM8ZiYmJhkyY6xsTEAQHzYlktERKSL338HPD2lJMjJCThwAPjxR84RZABkvcIjR46Er68vqlatiurVq2PhwoWIjo5Gz549AQDdu3eHq6sr/P39AQCtWrXC/PnzUblyZdSoUQN37tzBpEmT0KpVK01CREREpJMZM4CJE6X/N2wIbNgAuLjIGxNlGVkTIR8fHzx//hyTJ09GeHg4PDw8EBgYqOlA/eDBA60aoIkTJ0KhUGDixIl4/PgxHB0d0apVK8yYMUOup0BERDld+/bATz8BI0dKCRF/WBsUhTCwNqXIyEjY2dlBqVTC2NgW1tZSeVSUtMQGERHlckJITWCVKr0ve/kSyJ9fvpjokz78/ra1tdXbeXPUqDEiIqLPEhUFdO8OVKkizQmUhEmQwWIiREREhuHyZaBqValjNABcvSpvPJQtMBEiIqLcTQhgxQqgenVpiLyrK3DsGDBokNyRUTbAcYFERJR7RUZKEyRu2iRtN28OrF8PODjIGxdlG6wRIiKi3GvXLikJMjaWRobt2cMkiLSwRoiIiHKvb78FLl4EOnSQVo4n+ghrhIiIKPd48wYYPBh4/VraViiA+fOZBFGqWCNERES5w/nzgI8PEBoKvHjxvl8QURpYI0RERDmbEMDChUDt2lISVLQo8P33ckdFOQRrhIiIKOd69Qro2RPYvVvabtcOWLUKsLeXNSzKOZgIERFRznTlCvDVV8CDB4CpqdQXaOBAqV8QUToxESIiopypYEGpWax4cWDLFmnZDCIdMREiIqKc4+1bwNpaqvXJnx/Yvx9wcwP0uAgnGRZ2liYiopzhxAmgbFkgIOB9WfnyTILoszARIiKi7E2tBmbOBBo2BB4/BhYvBlQquaOiXIKJEBERZV/PngHNmgETJkjJz7ffAsePS0tmEOkB+wgREVH2dPQo0KULEB4OWFgAS5ZIQ+U5Koz0yGATISGA6Gi5oyAiohTdvw80bQokJgLlykmjwsqXlzsqyoUMNhFq2hQ4d07uKIiIKEVFigDjxgGPHkl9gqys5I6IcimDTYQ+TIJq1wYsLeWLhYiIABw6BLi7AyVKSNtTp7IZjDKdwXeWjoiQRmTyb42ISCaJicDEiVJVvY8PEB8vlfODmbKAwdYIJbGy4t8aEZFsHj8GOneWfpECQLVqUidOoixi8IkQERHJZP9+oHt34MULwMYGWLEC6NRJ7qjIwBh80xgREWWxd++AMWOAFi2kJKhyZeDCBSZBJAsmQkRElLWEkOYIAoBBg4DTp4GSJeWNiQwWm8aIiChrCCF1yjQ1BTZvBoKCgHbt5I6KDBwTISIiylwJCcDYsYC5ubRmGAAULSrdiGTGRIiIiDJPaKjU9+fcOak2qHt3oEwZuaMi0mAfISIiyhw7dkgdoc+dA+ztgZ07mQRRtsNEiIiI9Cs+HhgyROr/o1QCX34JBAcD33wjd2REybBpjIiI9EcIaYbo48el7R9+AH78ETAxkTcuolQwESIiIv1RKIDevYFr14D166W5goiyMTaNERHR54mNBUJC3m936wbcusUkiHIEJkJERJRxN29KfYC8vIDnz9+X58snX0xEOmAiREREGfP774CnJ3D5srRsRmio3BER6YyJEBER6SYmBujVS2oCi44GGjSQRoVVry53ZEQ6YyJERETpd/26lPCsWSN1jPbzAw4dAgoWlDsyogzhqDEiIkq/2bOlEWHOzsCGDUCjRnJHRPRZmAgREVH6/fwzkCePtGZYgQJyR0P02dg0RkREqbtyBRg9WpooEQDs7IDVq5kEUa7BGiEiIkpOCGDVKmDoUCAuDihdWpookSiXYSJERETaIiOBfv2ATZuk7ebNuU4Y5VpsGiMiovcuXpTmBtq0CTA2ljpH79kDODrKHRlRpvisGqG4uDiYm5vrKxYiIpLTb79JzV8JCYCbm5QM1aold1REmUrnGiG1Wo3p06fD1dUV1tbWuHfvHgBg0qRJWL16td4DJCKiLFK0KKBSAa1aSRMkMgkiA6BzIvTjjz8iICAAP/30E0xNTTXlFSpUwKpVq/QaHBERZTKl8v3/69QBzpwBdu3iWmFkMHROhNavX48VK1aga9euMDY21pRXqlQJN27c0GtwRESUSYQAFi0C3N2l2aKTVKsmzRhNZCB0ToQeP36MEiVKJCtXq9V49+6dXoIiIqJM9OoV0KYNMHw48OYNEBAgc0BE8tE5ESpXrhxOnDiRrHzbtm2oXLmyXoIiIqJMcvYsULmy1PxlagosXiyNDCMyUDqPGps8eTJ8fX3x+PFjqNVq7NixAzdv3sT69euxZ8+ezIiRiIg+l1oNzJ8PjBsHJCYCxYsDmzdLQ+WJDJjONULffPMN/vrrLxw6dAhWVlaYPHkyQkJC8Ndff6FJkyaZESMREX2u33+XlspITAQ6dgQuXGASRARAIUTSAjKGITIyEnZ2dgCUAGwRFQVYWckdFRFRJktMBFq2lPoG9evHDtGU4yR9fyuVStja2urtvDrXCBUrVgwvX75MVv7mzRsUK1ZML0EREdFnUqultcLi46XtPHmAwECgf38mQUQf0DkRCgsLg0qlSlYeHx+Px48f6yUoIiL6DM+eSeuD9ekDjBnzvpwJEFEy6e4svXv3bs3/Dxw48P/mJYlKpcLhw4fh7u6u1+CIiEhHx44BXboAT58CFhbAF1/IHRFRtpbuRKh169YAAIVCAV9fX637TExM4O7ujnnz5uk1OCIiSieVCpgxA5g6VWoWK1sW2LoVKF9e7siIsrV0J0JqtRoAULRoUZw/fx4ODg6ZFhQREekgPBzo2hU4ckTa7tlTmh+II0GIPknneYRCQ0MzIw4iIsqomBjgv/8AS0tg2TKgWze5IyLKMXROhAAgOjoa//zzDx48eICEhASt+4YOHaqXwLJC7drS5wYRUY4jxPvOz8WKAVu2AEWKAGXKyBsXUQ6j8zxCFy9eRIsWLRATE4Po6Gjky5cPL168gKWlJZycnHDv3r3MilUvkuYhuHNHiWLFbDmIgohynsePgW+/lWaJbtpU7miIskS2mUdoxIgRaNWqFV6/fg0LCwucPXsW9+/fh6enJ+bOnau3wDKbpSVHkhJRDhQYCHh4SKPDBg6UJkokogzTOREKDg7G999/DyMjIxgbGyM+Ph5ubm746aefMH78+MyIkYiI3r0Dxo6V5gd68UJKhvbtkyZKJKIM0zkRMjExgZGRdJiTkxMePHgAALCzs8PDhw/1Gx0REQEPHwINGrxfJX7gQODMGaBUKVnDIsoNdE6EKleujPPnzwMA6tevj8mTJ2PDhg0YPnw4KlSooHMAS5cuhbu7O8zNzVGjRg2cO3cuzf3fvHmDQYMGwcXFBWZmZihVqhT27dun8+MSEeUIjx9LtT+nTwO2ttLcQEuXAubmckdGlCvonAjNnDkTLi4uAIAZM2Ygb968GDBgAJ4/f47ly5frdK7Nmzdj5MiR8PPzQ1BQECpVqgRvb288e/Ysxf0TEhLQpEkThIWFYdu2bbh58yZWrlwJV1dXXZ8GEVHO4OoKtGoFVK0KXLwItG8vd0REuYqsq8/XqFED1apVw5IlSwBIkza6ublhyJAhGDt2bLL9ly1bhjlz5uDGjRswMTHJ0GMm9Tp/8kQJFxf99TonItKbsDDA2hpImrg2JgYwNgbMzGQNi0hO2WbUWGqCgoLw1VdfpXv/hIQEXLhwAV5eXu+DMTKCl5cXzpw5k+Ixu3fvRs2aNTFo0CAUKFAAFSpUwMyZM1NcBDZJfHw8IiMjtW5ERNnWzp1SU5ivr7RUBiANc2USRJQpdEqEDhw4gFGjRmH8+PGa+YJu3LiB1q1bo1q1applONLjxYsXUKlUKFCggFZ5gQIFEB4enuIx9+7dw7Zt26BSqbBv3z5MmjQJ8+bNw48//pjq4/j7+8POzk5zc3NzS3eMRERZJj4eGDoUaNsWUCqBly+lf4koU6U7EVq9ejWaN2+OgIAAzJ49G19++SV+//131KxZE87Ozrh69Wqmd1pWq9VwcnLCihUr4OnpCR8fH0yYMAHLli1L9Zhx48ZBqVRqbhzZRkTZzt270lT3ixdL26NGASdOAHnzyhsXkQFI9wQUixYtwuzZszF69Ghs374dHTp0wC+//IIrV66gUKFCOj+wg4MDjI2NERERoVUeEREBZ2fnFI9xcXGBiYkJjI2NNWVly5ZFeHg4EhISYGpqmuwYMzMzmLFKmYiyqy1bgN69gbdvgfz5gXXrgJYt5Y6KyGCku0bo7t276NChAwCgbdu2yJMnD+bMmZOhJAgATE1N4enpicOHD2vK1Go1Dh8+jJo1a6Z4TO3atXHnzh2tJrhbt27BxcUlxSSIiChbi4uTlsl4+1aqEQoOZhJElMXSnQjFxsbC8v8rlCoUCpiZmWmG0WfUyJEjsXLlSqxbtw4hISEYMGAAoqOj0bNnTwBA9+7dMW7cOM3+AwYMwKtXrzBs2DDcunULe/fuxcyZMzFo0KDPioOISBbm5sDmzcD48dKSGRn8YUlEGafT3OyrVq2CtbU1ACAxMREBAQFwSBre+X+6rD7v4+OD58+fY/LkyQgPD4eHhwcCAwM1HagfPHigmcUaANzc3HDgwAGMGDECX3zxBVxdXTFs2DCMGTNGl6dBRCSfP/6QhsP37i1tV60q3YhIFumeR8jd3R2KT6xSqlAocszq85xHiIiyVEwMMGwYsGoVYGoqNYOVLSt3VEQ5RmbNI5TuGqGwsDC9PSgRkUEJCQE6dgSuXgUUCqlfENcJI8oWuGwxEVFmWrdOWiQ1JgYoUEBqGmvUSO6oiOj/mAgREWUGIYA+fYDVq6VtLy/g99+lZIiIsg29LbFBREQfUCiAYsUAIyNg+nQgMJBJEFE2xBohIiJ9EUJaFsPeXtoeOxZo1gyoUkXWsIgodawRIiLSh7dvga5dgbp1pf5AgFQbxCSIKFvLUCJ09+5dTJw4EZ07d8azZ88AAPv378e1a9f0GhwRUY4QHAx4egIbN0ojxI4flzsiIkonnROhf/75BxUrVsS///6LHTt2ICoqCgBw6dIl+Pn56T1AIqJsSwjg11+BL78Ebt8G3NykJKhZM7kjI6J00jkRGjt2LH788UccPHhQa32vRo0a4ezZs3oNjogo21IqAR8faWh8fDzQqhVw8SJQq5bckRGRDnROhK5cuYI2bdokK3dycsKLFy/0EhQRUbY3eDCwdSuQJw8wbx6wa5e0ejwR5Sg6J0L29vZ4+vRpsvKLFy/C1dVVL0EREWV7/v5Sv6CTJ4GRI6Xh8kSU4+icCHXq1AljxoxBeHg4FAoF1Go1Tp06hVGjRqF79+6ZESMRkfxev5ZmiU5SqBBw/jxQo4Z8MRHRZ9M5EZo5cybKlCkDNzc3REVFoVy5cqhXrx5q1aqFiRMnZkaMRETy+vdfoHJloEcPqQksCWuBiHI8nSdUNDU1xcqVKzFp0iRcvXoVUVFRqFy5MkqWLJkZ8RERyUcIYP58aWLExESgeHGpJoiIcg2dE6GTJ0+iTp06KFy4MAoXLpwZMRERye/lS6kGaM8eabtjR2DlSsDWVtawiEi/dG4aa9SoEYoWLYrx48fj+vXrmRETEZG8Tp0CPDykJMjMTJoraNMmJkFEuZDOidCTJ0/w/fff459//kGFChXg4eGBOXPm4NGjR5kRHxFR1nvyBHj0CChZEjh7Fujfn/2BiHIphRBCZPTg0NBQ/PHHH9i4cSNu3LiBevXq4ciRI/qMT+8iIyNhZ2eHJ0+UcHHhrzsi+j8htJOddeuAtm0BGxv5YiIijaTvb6VSCVs91s5+1qKrRYsWxdixYzFr1ixUrFgR//zzj77iIiLKOv/8I80J9OEcab6+TIKIDECGE6FTp05h4MCBcHFxQZcuXVChQgXs3btXn7EREWUulQqYPh1o1EhaHmPyZLkjIqIspvOosXHjxmHTpk148uQJmjRpgkWLFuGbb76BpaVlZsRHRJQ5wsOBb78FDh+Wtnv0ABYulDMiIpKBzonQ8ePHMXr0aHTs2BEODg6ZERMRUeY6fBjo2hWIiAAsLaVRYZwZn8gg6ZwInTp1KjPiICLKGjt3Au3aSZ2jK1QAtmwBypaVOyoikkm6EqHdu3ejefPmMDExwe7du9Pc9+uvv9ZLYEREmaJJE6B0aaBuXWDRIsDCQu6IiEhG6Ro+b2RkhPDwcDg5OcHIKPX+1QqFAiqVSq8B6huHzxMZoPPnpVFhSZ9fSiVgZydvTESkE1mHz6vVajg5OWn+n9otuydBRGRgEhOBceOA6tWlNcOSMAkiov/Tefj8+vXrER8fn6w8ISEB69ev10tQRESf7eFDoEEDYNYsaZuz3xNRCnSeWdrY2BhPnz7V1BAlefnyJZycnLJ9rRCbxogMwN690iiwV6+k9cFWrwbat5c7KiL6DNlmZmkhBBQprLnz6NEj2LG6mYjklJAAjBoFfPWVlARVrSpNlMgkiIhSke7h85UrV4ZCoYBCoUDjxo2RJ8/7Q1UqFUJDQ9GsWbNMCZKIKF1CQoCff5b+P2wYMHu2tHo8EVEq0p0ItW7dGgAQHBwMb29vWFtba+4zNTWFu7s72rVrp/cAiYjSrVIlYMkSwMkJ+P9nFhFRWnTuI7Ru3Tr4+PjA3Nw8s2LKVOwjRJSLxMcD48cD3boBHh5yR0NEmSiz+gjpPLO0r6+v3h6ciCjD7t4FfHyACxeAPXuAq1cBExO5oyKiHCZdiVC+fPlw69YtODg4IG/evCl2lk7y6tUrvQVHRJSirVuB3r2ByEggXz5pjiAmQUSUAelKhBYsWAAbGxvN/9NKhIiIMk1cHDBypLRIKgDUrg1s3Ai4uckbFxHlWDr3Ecrp2EeIKId6/hxo2hQIDpa2x40Dpk0D8ujcwk9EOVC2mUcoKCgIV65c0Wzv2rULrVu3xvjx45GQkKC3wIiItOTLBzg4AI6OQGAgMHMmkyAi+mw6J0L9+vXDrVu3AAD37t2Dj48PLC0tsXXrVvzwww96D5CIDFhMDBAbK/3f2BjYsEGqEfL2ljUsIso9dE6Ebt26BY//D1PdunUr6tevjz/++AMBAQHYvn27vuMjIkMVEgLUqAEMH/6+zMkJKFhQtpCIKPfJ0BIbarUaAHDo0CG0aNECAODm5oYXL17oNzoiMkzr1knLY1y9CuzaJfUPIiLKBDonQlWrVsWPP/6I3377Df/88w9atmwJAAgNDUWBAgX0HiARGZDoaKBHD+kWEwM0biw1hTk6yhwYEeVWOidCCxcuRFBQEAYPHowJEyagRIkSAIBt27ahVq1aeg+QiAzE1atAtWpSbZCRETB9OnDgAODsLHdkRJSL6W34fFxcHIyNjWGSzSc14/B5omwoIQEoXhx49EjqA/THH0D9+nJHRUTZSLZZYiPJhQsXEBISAgAoV64cqlSporegiMjAmJoCy5YBS5dKNUJsCiOiLKJzIvTs2TP4+Pjgn3/+gb29PQDgzZs3aNiwITZt2gRHfoARUXpcugQ8ewY0aSJtt2wJtGgBcOZ6IspCOvcRGjJkCKKionDt2jW8evUKr169wtWrVxEZGYmhQ4dmRoxElJsIIdX+1KghLZr64MH7+5gEEVEW07lGKDAwEIcOHULZsmU1ZeXKlcPSpUvRtGlTvQZHRLmMUgn07Qts2SJtN2kCWFnJGxMRGTSda4TUanWKHaJNTEw08wsRESVz4QJQpYqUBOXJA8ybB+zeDeTPL3dkRGTAdE6EGjVqhGHDhuHJkyeassePH2PEiBFo3LixXoMjolxi8WKgVi3g3j2gSBHg5ElpFXk2hRGRzHROhJYsWYLIyEi4u7ujePHiKF68OIoWLYrIyEgsXrw4M2Ikopzu2jVpiHzr1sDFi1L/ICKibEDnPkJubm4ICgrC4cOHNcPny5YtCy8vL70HR0Q5mBDva3wWLJBqhLp1Yy0QEWUrOiVCmzdvxu7du5GQkIDGjRtjyJAhmRUXEeVUQkiJz8GDwJ490qrxFhZA9+5yR0ZElEy6E6Fff/0VgwYNQsmSJWFhYYEdO3bg7t27mDNnTmbGR0Q5ycuX0jphe/ZI2zt2AB06yBoSEVFa0t1HaMmSJfDz88PNmzcRHByMdevW4ZdffsnM2IgoJzl9GqhcWUqCzMyAX38F2reXOyoiojSlOxG6d+8efH19NdtdunRBYmIinj59mimBEVEOoVYDs2cD9eoBDx8CJUsCZ88C/fuzPxARZXvpToTi4+Nh9cHEZ0ZGRjA1NUVsbGymBEZEOcTQocDYsYBKBXTpIs0X5OEhd1REROmiU2fpSZMmwdLSUrOdkJCAGTNmwM7OTlM2f/58/UVHRNlf377Axo3ATz8B333HWiAiylHSnQjVq1cPN2/e1CqrVasW7t27p9lW8AOQKPdTqYD//ns/F9AXXwBhYYCNjaxhERFlRLoToWPHjmViGESUI0REAN9+Cxw7Js0OnZQMMQkiohxK55mlichAHTkCVKoEHDoEmJoCjx7JHRER0WdjIkREaVOpAD8/wMtLqhGqUEFqGmvXTu7IiIg+m85LbBCRAXnyBOjaVWoKA4DevYFFi4APBk0QEeVkTISIKHU7dkhJkLU1sHy5NDyeiCgXyRZNY0uXLoW7uzvMzc1Ro0YNnDt3Ll3Hbdq0CQqFAq1bt87cAIkM1aBBwKhR0txATIKIKBfKUCJ04sQJfPvtt6hZsyYeP34MAPjtt99w8uRJnc+1efNmjBw5En5+fggKCkKlSpXg7e2NZ8+epXlcWFgYRo0ahbp162bkKRBRSh49ktYKe/tW2lYogDlzgFKlZA2LiCiz6JwIbd++Hd7e3rCwsMDFixcRHx8PAFAqlZg5c6bOAcyfPx99+vRBz549Ua5cOSxbtgyWlpZYs2ZNqseoVCp07doVU6dORbFixXR+TCJKwd690ozQ69YB338vdzRERFlC50Toxx9/xLJly7By5UqYmJhoymvXro2goCCdzpWQkIALFy7Ay8vrfUBGRvDy8sKZM2dSPW7atGlwcnJCr169PvkY8fHxiIyM1LoR0QfevQNGjwa++kpaPd7TExgzRu6oiIiyhM6J0M2bN1GvXr1k5XZ2dnjz5o1O53rx4gVUKhUKFCigVV6gQAGEh4eneMzJkyexevVqrFy5Ml2P4e/vDzs7O83Nzc1NpxiJcrX796XFUufOlbaHDgVOnQKKF5c3LiKiLKJzIuTs7Iw7d+4kKz958mSmN1O9ffsW3bp1w8qVK+Hg4JCuY8aNGwelUqm5PXz4MFNjJMoxTpyQmsLOngXs7YGdO6Wh8WZmckdGRJRldB4+36dPHwwbNgxr1qyBQqHAkydPcObMGYwaNQqTJk3S6VwODg4wNjZGRESEVnlERAScnZ2T7X/37l2EhYWhVatWmjK1Wi09kTx5cPPmTRT/6JesmZkZzPjBTpRcyZJS0lOjBrBpE+DuLndERERZTudEaOzYsVCr1WjcuDFiYmJQr149mJmZYdSoURgyZIhO5zI1NYWnpycOHz6sGQKvVqtx+PBhDB48ONn+ZcqUwZUrV7TKJk6ciLdv32LRokVs9iL6lJcvgfz5pf87O0tzBBUrJi2ZQURkgHROhBQKBSZMmIDRo0fjzp07iIqKQrly5WBtbZ2hAEaOHAlfX19UrVoV1atXx8KFCxEdHY2ePXsCALp37w5XV1f4+/vD3NwcFSpU0Dre3t4eAJKVE9FHtm0DevUCVqwAfHyksjJl5I2JiEhmGZ5Z2tTUFOXKlfvsAHx8fPD8+XNMnjwZ4eHh8PDwQGBgoKYD9YMHD2BklC3mfSTKmeLipOHwv/wiba9bB3TsKM0RRERk4BRCCKHLAQ0bNoQijQ/QI0eOfHZQmSkyMhJ2dnZ48kQJFxdbucMhyly3b0tJT3CwtD12LDBtGvDB1BdERDlB0ve3UqmEra3+vr91rhHy8PDQ2n737h2Cg4Nx9epV+Pr66isuIvpcGzcCffsCUVGAgwPw229As2ZyR0VElK3onAgtWLAgxfIpU6YgKirqswMiIj24fPn92mD16gF//AG4usobExFRNqRz01hq7ty5g+rVq+PVq1f6OF2mYdMYGYzRowELC2DyZCBPhrsDEhFlC9mmaSw1Z86cgbm5ub5OR0S62rABqFsXKFxY2v7pJ3aIJiL6BJ0TobZt22ptCyHw9OlT/PfffzpPqEhEehAdDQwZAqxdC9SqJc0NZGLCJIiIKB10ToTs7Oy0to2MjFC6dGlMmzYNTZs21VtgRJQO165Jo8KuXweMjABvb+lfIiJKF50SIZVKhZ49e6JixYrImzdvZsVERJ8ihFQDNHgwEBsLuLhIHaIbNJA7MiKiHEWnn47GxsZo2rSpzqvME5EeRUcD3btLs0THxkq1QMHBTIKIiDJA5zr0ChUq4N69e5kRCxGlh5GRNDze2Bjw9wf27QOcnOSOiogoR9K5j9CPP/6IUaNGYfr06fD09ISVlZXW/foc0kZE/yeEdDMykobEb9kCPH8O1Kkjd2RERDlauucRmjZtGr7//nvY2Ni8P/iDUSlCCCgUCqhUKv1HqUecR4hyHKVSmiG6YkVg4kS5oyEikkVmzSOU7kTI2NgYT58+RUhISJr71a9fXy+BZRYmQpSjXLggrRR/9y5gbg7cuyd1jCYiMjCyT6iYlC9l90SHKFcQAliyBBg1CkhIAIoUATZtYhJERKRnOvURSmvVeSLSkzdvpBFhO3ZI261bA2vWAJyygohI73RKhEqVKvXJZCi7rzVGlK0lJkqzQ4eESLNDz50rzRrNHyFERJlCp0Ro6tSpyWaWJiI9ypMHGDZMWids82agalW5IyIiytXS3VnayMgI4eHhcMrh85WwszRlO69eAU+fAuXLS9tCADExwEdTUxARGbLM6iyd7gkV2T+IKBOcPg14eABffSX1DQKkZjAmQUREWSLdiVA6K46IKD3UamD2bKBePeDhQ6k/0LNnckdFRGRw0t1HSK1WZ2YcRIbj+XPA1xfYv1/a7twZWL4c+GCyUiIiyho6L7FBRJ/h+HEp8XnyRJogcfFiaag8m56JiGTBRIgoK82fLyVBZcpI64VVrCh3REREBo2JEFFWWr0aKFYMmDYNsLaWOxoiIoOX7s7SRJQBR44A338vDYkHgPz5pVohJkFERNkCa4SIMoNKJdX6TJ8uJUE1agAdO8odFRERfYSJEJG+PXkCdO0KHDsmbffqJc0TRERE2Q4TISJ9+vtv4NtvpSHyVlbSsPiuXeWOioiIUsE+QkT6MmcO0KyZlARVqgQEBTEJIiLK5pgIEelL5crSvwMGAGfPAqVKyRsPERF9EpvGiD7Hs2dA0kLEXl7AlSvvF08lIqJsjzVCRBnx7h0werRU63P37vtyJkFERDkKEyEiXd2/D9StC8ydCyiVwF9/yR0RERFlEJvGiHTx559Az57AmzeAnR2wZg3Qtq3cURERUQaxRogoPRISgOHDgTZtpCSoenXg4kUmQUREORwTIaL0WLIEWLRI+v/IkcCJE0DRovLGREREn41NY0TpMXgwcPAgMHAg0KqV3NEQEZGesEaIKCVxcdLiqO/eSdumpsD+/UyCiIhyGdYIEX3s9m3Ax0fqA/T8OeDvL3dERESUSVgjRPShTZuAKlWkJMjBAahXT+6IiIgoEzERIgKA2FigXz+gc2cgKkqaJyg4GGjeXO7IiIgoEzERIrp1C6hRA1ixAlAogIkTgSNHAFdXuSMjIqJMxj5CRGo1cO+etGbYhg3SmmFERGQQmAiRYVKrAaP/V4iWKQPs2AFUrAi4uMgbFxERZSk2jZHhuXYN8PAAjh9/X9a0KZMgIiIDxESIDIcQwOrVQLVqwJUrwPffS2VERGSwmAiRYXj7FujWDejdWxoh1rQpsHev1DmaiIgMFhMhyv0uXQKqVpU6QhsbAzNnSrNEOznJHRkREcmMnaUpdwsJkYbGx8dLw+E3bQLq1JE7KiIiyiaYCFHuVqYM8PXXQHQ0sG6dNFs0ERHR/zERotzn4kWgaFHA3l7qA7RuHWBm9n64PBER0f/xm4FyDyGAJUuAL7+UOkUnjQizsGASREREKWKNEOUOb94AvXpJEyMCQGIiEBcnJUFERESp4M9kyvnOnQMqV5aSIBMTYOFCYOdOJkFERPRJTIQo5xICWLBAGgUWFib1Czp1Chg2jPMDERFRujARopxLqQTmzwfevQPatQOCgqRZo4mIiNKJfYQo57K3BzZulCZMHDiQtUBERKQzJkKUc6jVwNy5gLMz0L27VFanDidIJCKiDGMiRDnD8+eAr6+0NIalJdCwIeDmJndURESUwzERouzvxAmgUyfgyRPA3FwaFVaokNxRERFRLsDO0pR9qdXAjBlAgwZSElS6NPDvv0CfPuwPREREesEaIcqeVCqgZUvgwAFpu1s34JdfAGtreeMiIqJchTVClD0ZGwNVq0r9gdauBdavZxJERER6x0SIsg+VSuoUnWTKFCA4GOjRQ6aAiIgot8sWidDSpUvh7u4Oc3Nz1KhRA+fOnUt135UrV6Ju3brImzcv8ubNCy8vrzT3pxzi6VOgSROgeXMgPl4qy5MHKFlS3riIiChXkz0R2rx5M0aOHAk/Pz8EBQWhUqVK8Pb2xrNnz1Lc/9ixY+jcuTOOHj2KM2fOwM3NDU2bNsXjx4+zOHLSm7//BipVAo4eBW7ckCZIJCIiygIKIYSQM4AaNWqgWrVqWLJkCQBArVbDzc0NQ4YMwdixYz95vEqlQt68ebFkyRJ0T5pkLw2RkZGws7PDkydKuLjYfnb89BkSEwE/P8DfX1o37IsvgC1bpNFhREREH0j6/lYqlbC11d/3t6w1QgkJCbhw4QK8vLw0ZUZGRvDy8sKZM2fSdY6YmBi8e/cO+fLlS/H++Ph4REZGat0oG3j0CGjUCJg5U0qC+vUDzp5lEkRERFlK1kToxYsXUKlUKFCggFZ5gQIFEB4enq5zjBkzBgULFtRKpj7k7+8POzs7zc2NsxFnD336SBMl2tgAmzYBy5YBFhZyR0VERAZG9j5Cn2PWrFnYtGkTdu7cCXNz8xT3GTduHJRKpeb28OHDLI6SUrR0qbRMRlAQ4OMjdzRERGSgZJ1Q0cHBAcbGxoiIiNAqj4iIgLOzc5rHzp07F7NmzcKhQ4fwxRdfpLqfmZkZzMzM9BIvfYYHD6RO0b17S9vFigFHjsgbExERGTxZa4RMTU3h6emJw4cPa8rUajUOHz6MmjVrpnrcTz/9hOnTpyMwMBBVq1bNilDpc+zeDXh4AH37SskQERFRNiH7EhsjR46Er68vqlatiurVq2PhwoWIjo5Gz549AQDdu3eHq6sr/P39AQCzZ8/G5MmT8ccff8Dd3V3Tl8ja2hrWnHk4e0lIAMaMkRZJBYBq1TgvEBERZSuyJ0I+Pj54/vw5Jk+ejPDwcHh4eCAwMFDTgfrBgwcwMnpfcfXrr78iISEB7du31zqPn58fpkyZkpWhU1pCQ6W+P+fPS9sjRgCzZgGmpvLGRURE9AHZ5xHKapxHKAv8+ae0LIZSCeTNCwQEAF9/LXNQRESUk2XWPEKy1whRLhQZKSVBNWtKQ+MLF5Y7IiIiohQxESL9UKmkFeMBoHt3wNwcaNMGMDGRNy4iIqI05Oh5hCib2LQJqFgRePHifVnHjkyCiIgo22MiRBkXGystjdG5MxASAsyfL3dEREREOmHTGGXMjRtSrc+VK4BCAYwfD3DUHhER5TBMhEh3v/0GDBgAREcDTk7A778DTZrIHRUREZHOmAiRbpYvB/r3l/7fsCGwYQPg4iJvTERERBnEPkKkm06dgBIlpGawgweZBBERUY7GGiFKmxDS4qiNGkl9gezsgMuXAQsLuSMjIiL6bKwRotRFRQG+voCXF7Bs2ftyJkFERJRLsEaIUnb5sjQq7OZNwMhI6hhNRESUyzARIm1CACtWAMOGAfHxgKsrsHEjULeu3JERERHpHRMhei8yEujbF9i8Wdpu3hxYvx5wcJA3LiIiokzCPkL03tWrwNat0pphP/0E7NnDJIiIiHI11gjRe7VqAUuWAB4e0srxREREuRxrhAzZmzdAt27SOmFJBgxgEkRERAaDNUKG6vx5wMcHCA0Frl8H/vtPmieIiIjIgLBGyNAIASxcCNSuLSVB7u7SHEFMgoiIyACxRsiQvHoF9OwJ7N4tbbdtC6xeDdjbyxoWERGRXJgIGYrQUKBBA+DBA8DUFJg/Hxg4kDVBRERk0JgIGQo3N6BwYcDEBNiyBahSRe6IiIiIZMdEKDd7+RKwsZFqgPLkkeYIsrQEbG3ljoyIiChbYGfp3OrECaBSJWDMmPdlzs5MgoiIiD7ARCi3UauBmTOBhg2Bx4+BwEAumEpERJQKJkK5ybNnQLNmwIQJgEoFfPutNF+QlZXckREREWVL7COUWxw9CnTpAoSHAxYWwNKlQI8eHBVGRESUBiZCuUFkJNCuHfD6NVCunDQqrHx5uaMiIiLK9pgI5Qa2tsDy5cD+/cDixWwKIyIiSicmQjnVoUOAkRHQqJG03aGDdCMiIqJ0Y2fpnCYxEZg4EWjaFOjcGXj6VO6IiIiIcizWCOUkjx9Lyc+JE9J269ZcJ4yIiOgzMBHKKfbvB7p3B168AKytgZUrgU6d5I6KiIgoR2PTWHanVkuzQ7doISVBlSsDQUFMgoiIiPSAiVB2Z2QkzQ0EAIMGAadPAyVLyhsTERFRLsGmsewqMVFaKBWQJkfs0AH46it5YyIiymQqlQrv3r2TOwySiYmJCYyNjbP0MZkIZTcJCcDYscCdO8CuXdLM0NbWTIKIKNeLiorCo0ePIISQOxSSiUKhQKFChWBtbZ1lj8lEKDsJDQV8fKT1wQDg2DFp8VQiolxOpVLh0aNHsLS0hKOjIxRcHsjgCCHw/PlzPHr0CCVLlsyymiEmQtnFjh3Ad98BSqU0JD4ggEkQERmMd+/eQQgBR0dHWFhYyB0OycTR0RFhYWF49+5dliVC7Cwtt/h4YMgQaa0wpRL48ksgOBj45hu5IyMiynKsCTJsclx/JkJy69oVWLJE+v/o0cDx40CRIvLGREREZCCYCMltzBjAxQXYswf46SfAxETuiIiIiAwGE6GsFhsL/PPP++1q1YB794CWLeWLiYiIPsuZM2dgbGyMlil8lh87dgwKhQJv3rxJdp+7uzsWLlyoVXb06FG0aNEC+fPnh6WlJcqVK4fvv/8ejx8/zqTogbi4OAwaNAj58+eHtbU12rVrh4iIiDSPiYiIQI8ePVCwYEFYWlqiWbNmuH37ttY+d+/eRZs2beDo6AhbW1t07Njxk+fNakyEstLNm1IfIG9vqR9QEnNz2UIiIqLPt3r1agwZMgTHjx/HkydPMnye5cuXw8vLC87Ozti+fTuuX7+OZcuWQalUYt68eXqMWNuIESPw119/YevWrfjnn3/w5MkTtG3bNtX9hRBo3bo17t27h127duHixYsoUqQIvLy8EB0dDQCIjo5G06ZNoVAocOTIEZw6dQoJCQlo1aoV1Gp1pj0XnQkDo1QqBQDx5Ikyax/499+FsLISAhDC0VGIo0ez9vGJiLKx2NhYcf36dREbGyt3KDp7+/atsLa2Fjdu3BA+Pj5ixowZWvcfPXpUABCvX79OdmyRIkXEggULhBBCPHz4UJiamorhw4en+DgpHa8Pb968ESYmJmLr1q2aspCQEAFAnDlzJsVjbt68KQCIq1evaspUKpVwdHQUK1euFEIIceDAAWFkZCSUyvfft2/evBEKhUIcPHgwxfOm9T5I+v7+8Hz6wBqhzBYTA/TuDXz7LRAdDTRoINUGNWggc2BERNmXENJHphw3Xedz3LJlC8qUKYPSpUvj22+/xZo1azI0KeTWrVuRkJCAH374IcX77e3tUz22efPmsLa2TvVWvnz5VI+9cOEC3r17By8vL01ZmTJlULhwYZw5cybFY+Lj4wEA5h+0aBgZGcHMzAwnT57U7KNQKGBmZqbZx9zcHEZGRpp9sgPOI5SZrl8HOnYErl2TZoiePBmYNAnI4unDiYhympgYaVJ9OURFAVZW6d9/9erV+PbbbwEAzZo1g1KpxD///IMGOv7gvX37NmxtbeHi4qLTcQCwatUqxMbGpnq/SRoDccLDw2Fqapos0SpQoADCk9a6/EhSojRu3DgsX74cVlZWWLBgAR49eoSnT58CAL788ktYWVlhzJgxmDlzJoQQGDt2LFQqlWaf7ICJUGbatUtKgpydgQ0bgEaN5I6IiIj06ObNmzh37hx27twJAMiTJw98fHywevVqnRMhIUSG59FxdXXN0HEZZWJigh07dqBXr17Ily8fjI2N4eXlhebNm2tqwxwdHbF161YMGDAAP//8M4yMjNC5c2dUqVIFRkbZp0GKiVBm+uEHqZ51yBCgQAG5oyEiyjEsLaWaGbkeO71Wr16NxMREFCxYUFMmhICZmRmWLFkCOzs72NraAgCUSmWyWpc3b97Azs4OAFCqVCkolUo8ffpU51qh5s2b48SJE6neX6RIEVy7di3F+5ydnZGQkIA3b95oxRcREQFnZ+dUz+np6Yng4GAolUokJCTA0dERNWrUQNWqVTX7NG3aFHfv3sWLFy+QJ08e2Nvbw9nZGcWKFdPp+WUmJkL6dOUKMG0asH49YGEhNYH9+KPcURER5TgKhW7NU3JITEzE+vXrMW/ePDRt2lTrvtatW2Pjxo3o378/SpYsCSMjI1y4cAFFPpgw9969e1AqlShVqhQAoH379hg7dix++uknLFiwINnjfZyofOhzmsY8PT1hYmKCw4cPo127dgCkmq4HDx6gZs2aqR6XJCmRu337Nv777z9Mnz492T4ODg4AgCNHjuDZs2f4+uuvP3nerMJESB+EAFatAoYOBeLigGLFgNmz5Y6KiIgy0Z49e/D69Wv06tVLkwwkadeuHVavXo3+/fvDxsYGvXv3xvfff488efKgYsWKePjwIcaMGYMvv/wStWrVAgC4ublhwYIFGDx4MCIjI9G9e3e4u7vj0aNHWL9+PaytrVMdQv85TWN2dnbo1asXRo4ciXz58sHW1hZDhgxBzZo18eWXX2r2K1OmDPz9/dGmTRsAUuduR0dHFC5cGFeuXMGwYcPQunVrraRw7dq1KFu2LBwdHXHmzBkMGzYMI0aMQOnSpTMcr97pdQxaDqD34fNKpRCdOknD4gEhmjUT4tkz/ZybiMhA5MTh81999ZVo0aJFivf9+++/AoC4dOmSEEJ6fn5+fqJMmTLCwsJCFC1aVPTt21c8f/482bEHDx4U3t7eIm/evMLc3FyUKVNGjBo1Sjx58iTTnktsbKwYOHCgyJs3r7C0tBRt2rQRT58+1doHgFi7dq1me9GiRaJQoULCxMREFC5cWEycOFHEx8drHTNmzBhRoEABYWJiIkqWLCnmzZsn1Gp1mnFk9fB5hRAZGOOXg0VGRsLOzg5Pnijh4mL7eSe7eFEaFXbnjtQMNnMmMGoUkI06gRER5QRxcXEIDQ1F0aJFtYZkk2FJ632Q9P2tVCo1/a70gU1jGbVzJ9CpE5CQALi5AZs2Af+v3iQiIqKcgYlQRlWtKk1yUbs2sHYtkD+/3BERERGRjpgI6eLxYyCpQ5qbG3DunNQxOoPzPhAREZG82JklPYQAFi2Skp7du9+XFy/OJIiIiCgHYyL0Ka9eAW3aAMOHS/2BPkyEiIiIKEdjIpSWs2eBypWlpTJMTYHFi4GVK+WOiogo1zKwgcz0ETmuPxOhlKjVwNy5QN26wIMHUhPY6dPA4MFsCiMiygTG/1+MOiEhQeZISE5J1984CxcnZ2fplBw/DoweLf2/Y0epFkiPcxYQEZG2PHnywNLSEs+fP4eJiUm2WpSTsoZarcbz589haWmJPHmyLj1hIpSSBg2AYcOAMmWAfv1YC0RElMkUCgVcXFwQGhqK+/fvyx0OycTIyAiFCxeGIgu/d5kIAVJT2KJFQOfOQNJKuwsXyhoSEZGhMTU1RcmSJdk8ZsBMTU2zvDYwWyRCS5cuxZw5cxAeHo5KlSph8eLFqF69eqr7b926FZMmTUJYWBhKliyJ2bNno0WLFhl78GfPgG7dgL//BvbsAQ4e5BIZREQyMTIy4hIblKVk/8bfvHkzRo4cCT8/PwQFBaFSpUrw9vbGs2fPUtz/9OnT6Ny5M3r16oWLFy+idevWaN26Na5evar7gx87Bnh4SEmQhQXQtSubwYiIiAyI7Iuu1qhRA9WqVcOSJUsASJ2l3NzcMGTIEIwdOzbZ/j4+PoiOjsaePXs0ZV9++SU8PDywbNmyTz5e0qJtz0eNg8P82VKzWNmywJYtQIUK+ntiREREpDeZteiqrDVCCQkJuHDhAry8vDRlRkZG8PLywpkzZ1I85syZM1r7A4C3t3eq+6fGdK6/lAT17AmcP88kiIiIyADJ2kfoxYsXUKlUKFCggFZ5gQIFcOPGjRSPCQ8PT3H/8PDwFPePj49HfHy8ZlupVEr/mptLHaQ7dQJUKiAy8nOeChEREWWiyP9/T+u7IStbdJbOTP7+/pg6dWqy8sJxcdLQ+H79ZIiKiIiIMuLly5ews7PT2/lkTYQcHBxgbGyMiIgIrfKIiAg4Jw1j/4izs7NO+48bNw4jR47UbL958wZFihTBgwcP9PpCku4iIyPh5uaGhw8f6rW9lzKG1yP74LXIPngtsg+lUonChQsjX758ej2vrImQqakpPD09cfjwYbRu3RqA1Fn68OHDGDx4cIrH1KxZE4cPH8bw4cM1ZQcPHkTNmjVT3N/MzAxmZmbJyu3s7PimziZsbW15LbIRXo/sg9ci++C1yD70Pc+Q7E1jI0eOhK+vL6pWrYrq1atj4cKFiI6ORs+ePQEA3bt3h6urK/z9/QEAw4YNQ/369TFv3jy0bNkSmzZtwn///YcVK1bI+TSIiIgoB5I9EfLx8cHz588xefJkhIeHw8PDA4GBgZoO0Q8ePNDK/mrVqoU//vgDEydOxPjx41GyZEn8+eefqMBRX0RERKQj2RMhABg8eHCqTWHHjh1LVtahQwd06NAhQ49lZmYGPz+/FJvLKGvxWmQvvB7ZB69F9sFrkX1k1rWQfUJFIiIiIrnIvsQGERERkVyYCBEREZHBYiJEREREBouJEBERERmsXJkILV26FO7u7jA3N0eNGjVw7ty5NPffunUrypQpA3Nzc1SsWBH79u3LokhzP12uxcqVK1G3bl3kzZsXefPmhZeX1yevHelG17+NJJs2bYJCodBMfEqfT9dr8ebNGwwaNAguLi4wMzNDqVKl+FmlJ7pei4ULF6J06dKwsLCAm5sbRowYgbi4uCyKNvc6fvw4WrVqhYIFC0KhUODPP//85DHHjh1DlSpVYGZmhhIlSiAgIED3Bxa5zKZNm4SpqalYs2aNuHbtmujTp4+wt7cXERERKe5/6tQpYWxsLH766Sdx/fp1MXHiRGFiYiKuXLmSxZHnPrpeiy5duoilS5eKixcvipCQENGjRw9hZ2cnHj16lMWR5066Xo8koaGhwtXVVdStW1d88803WRNsLqfrtYiPjxdVq1YVLVq0ECdPnhShoaHi2LFjIjg4OIsjz310vRYbNmwQZmZmYsOGDSI0NFQcOHBAuLi4iBEjRmRx5LnPvn37xIQJE8SOHTsEALFz58409793756wtLQUI0eOFNevXxeLFy8WxsbGIjAwUKfHzXWJUPXq1cWgQYM02yqVShQsWFD4+/unuH/Hjh1Fy5Yttcpq1Kgh+vXrl6lxGgJdr8XHEhMThY2NjVi3bl1mhWhQMnI9EhMTRa1atcSqVauEr68vEyE90fVa/Prrr6JYsWIiISEhq0I0GLpei0GDBolGjRpplY0cOVLUrl07U+M0NOlJhH744QdRvnx5rTIfHx/h7e2t02PlqqaxhIQEXLhwAV5eXpoyIyMjeHl54cyZMykec+bMGa39AcDb2zvV/Sl9MnItPhYTE4N3797pfYE9Q5TR6zFt2jQ4OTmhV69eWRGmQcjItdi9ezdq1qyJQYMGoUCBAqhQoQJmzpwJlUqVVWHnShm5FrVq1cKFCxc0zWf37t3Dvn370KJFiyyJmd7T1/d3tphZWl9evHgBlUqlWZ4jSYECBXDjxo0UjwkPD09x//Dw8EyL0xBk5Fp8bMyYMShYsGCyNzrpLiPX4+TJk1i9ejWCg4OzIELDkZFrce/ePRw5cgRdu3bFvn37cOfOHQwcOBDv3r2Dn59fVoSdK2XkWnTp0gUvXrxAnTp1IIRAYmIi+vfvj/Hjx2dFyPSB1L6/IyMjERsbCwsLi3SdJ1fVCFHuMWvWLGzatAk7d+6Eubm53OEYnLdv36Jbt25YuXIlHBwc5A7H4KnVajg5OWHFihXw9PSEj48PJkyYgGXLlskdmsE5duwYZs6ciV9++QVBQUHYsWMH9u7di+nTp8sdGmVQrqoRcnBwgLGxMSIiIrTKIyIi4OzsnOIxzs7OOu1P6ZORa5Fk7ty5mDVrFg4dOoQvvvgiM8M0GLpej7t37yIsLAytWrXSlKnVagBAnjx5cPPmTRQvXjxzg86lMvK34eLiAhMTExgbG2vKypYti/DwcCQkJMDU1DRTY86tMnItJk2ahG7duqF3794AgIoVKyI6Ohp9+/bFhAkTtBYJp8yV2ve3ra1tumuDgFxWI2RqagpPT08cPnxYU6ZWq3H48GHUrFkzxWNq1qyptT8AHDx4MNX9KX0yci0A4KeffsL06dMRGBiIqlWrZkWoBkHX61GmTBlcuXIFwcHBmtvXX3+Nhg0bIjg4GG5ublkZfq6Skb+N2rVr486dO5pkFABu3boFFxcXJkGfISPXIiYmJlmyk5SgCi7dmaX09v2tWz/u7G/Tpk3CzMxMBAQEiOvXr4u+ffsKe3t7ER4eLoQQolu3bmLs2LGa/U+dOiXy5Mkj5s6dK0JCQoSfnx+Hz+uJrtdi1qxZwtTUVGzbtk08ffpUc3v79q1cTyFX0fV6fIyjxvRH12vx4MEDYWNjIwYPHixu3rwp9uzZI5ycnMSPP/4o11PINXS9Fn5+fsLGxkZs3LhR3Lt3T/z999+iePHiomPHjnI9hVzj7du34uLFi+LixYsCgJg/f764ePGiuH//vhBCiLFjx4pu3bpp9k8aPj969GgREhIili5dyuHzSRYvXiwKFy4sTE1NRfXq1cXZs2c199WvX1/4+vpq7b9lyxZRqlQpYWpqKsqXLy/27t2bxRHnXrpciyJFiggAyW5+fn5ZH3gupevfxoeYCOmXrtfi9OnTokaNGsLMzEwUK1ZMzJgxQyQmJmZx1LmTLtfi3bt3YsqUKaJ48eLC3NxcuLm5iYEDB4rXr19nfeC5zNGjR1P8Dkh6/X19fUX9+vWTHePh4SFMTU1FsWLFxNq1a3V+XIUQrMsjIiIiw5Sr+ggRERER6YKJEBERERksJkJERERksJgIERERkcFiIkREREQGi4kQERERGSwmQkRERGSwmAgRkZaAgADY29vLHUaGKRQK/Pnnn2nu06NHD7Ru3TpL4iGi7I2JEFEu1KNHDygUimS3O3fuyB0aAgICNPEYGRmhUKFC6NmzJ549e6aX8z99+hTNmzcHAISFhUGhUCA4OFhrn0WLFiEgIEAvj5eaKVOmaJ6nsbEx3Nzc0LdvX7x69Uqn8zBpI8pcuWr1eSJ6r1mzZli7dq1WmaOjo0zRaLO1tcXNmzehVqtx6dIl9OzZE0+ePMGBAwc++9yprRr+ITs7u89+nPQoX748Dh06BJVKhZCQEHz33XdQKpXYvHlzljw+EX0aa4SIcikzMzM4Oztr3YyNjTF//nxUrFgRVlZWcHNzw8CBAxEVFZXqeS5duoSGDRvCxsYGtra28PT0xH///ae5/+TJk6hbty4sLCzg5uaGoUOHIjo6Os3YFAoFnJ2dUbBgQTRv3hxDhw7FoUOHEBsbC7VajWnTpqFQoUIwMzODh4cHAgMDNccmJCRg8ODBcHFxgbm5OYoUKQJ/f3+tcyc1jRUtWhQAULlyZSgUCjRo0ACAdi3LihUrULBgQa2V3QHgm2++wXfffafZ3rVrF6pUqQJzc3MUK1YMU6dORWJiYprPM0+ePHB2doarqyu8vLzQoUMHHDx4UHO/SqVCr169ULRoUVhYWKB06dJYtGiR5v4pU6Zg3bp12LVrl6Z26dixYwCAhw8fomPHjrC3t0e+fPnwzTffICwsLM14iCg5JkJEBsbIyAg///wzrl27hnXr1uHIkSP44YcfUt2/a9euKFSoEM6fP48LFy5g7NixMDExAQDcvXsXzZo1Q7t27XD58mVs3rwZJ0+exODBg3WKycLCAmq1GomJiVi0aBHmzZuHuXPn4vLly/D29sbXX3+N27dvAwB+/vln7N69G1u2bMHNmzexYcMGuLu7p3jec+fOAQAOHTqEp0+fYseOHcn26dChA16+fImjR49qyl69eoXAwEB07doVAHDixAl0794dw4YNw/Xr17F8+XIEBARgxowZ6X6OYWFhOHDgAExNTTVlarUahQoVwtatW3H9+nVMnjwZ48ePx5YtWwAAo0aNQseOHdGsWTM8ffoUT58+Ra1atfDu3Tt4e3vDxsYGJ06cwKlTp2BtbY1mzZohISEh3TEREZArV58nMnS+vr7C2NhYWFlZaW7t27dPcd+tW7eK/Pnza7bXrl0r7OzsNNs2NjYiICAgxWN79eol+vbtq1V24sQJYWRkJGJjY1M85uPz37p1S5QqVUpUrVpVCCFEwYIFxYwZM7SOqVatmhg4cKAQQoghQ4aIRo0aCbVaneL5AYidO3cKIYQIDQ0VAMTFixe19vH19RXffPONZvubb74R3333nWZ7+fLlomDBgkKlUgkhhGjcuLGYOXOm1jl+++034eLikmIMQgjh5+cnjIyMhJWVlTA3N9espD1//vxUjxFCiEGDBol27dqlGmvSY5cuXVrrNYiPjxcWFhbiwIEDaZ6fiLSxjxBRLtWwYUP8+uuvmm0rKysAUu2Iv78/bty4gcjISCQmJiIuLg4xMTGwtLRMdp6RI0eid+/e+O233zTNO8WLFwcgNZtdvnwZGzZs0OwvhIBarUZoaCjKli2bYmxKpRLW1tZQq9WIi4tDnTp1sGrVKkRGRuLJkyeoXbu21v61a9fGpUuXAEjNWk2aNEHp0qXRrFkzfPXVV2jatOlnvVZdu3ZFnz598Msvv8DMzAwbNmxAp06dYGRkpHmep06d0qoBUqlUab5uAFC6dGns3r0bcXFx+P333xEcHIwhQ4Zo7bN06VKsWbMGDx48QGxsLBISEuDh4ZFmvJcuXcKdO3dgY2OjVR4XF4e7d+9m4BUgMlxMhIhyKSsrK5QoUUKrLCwsDF999RUGDBiAGTNmIF++fDh58iR69eqFhISEFL/Qp0yZgi5dumDv3r3Yv38//Pz8sGnTJrRp0wZRUVHo168fhg4dmuy4woULpxqbjY0NgoKCYGRkBBcXF1hYWAAAIiMjP/m8qlSpgtDQUOzfvx+HDh1Cx44d4eXlhW3btn3y2NS0atUKQgjs3bsX1apVw4kTJ7BgwQLN/VFRUZg6dSratm2b7Fhzc/NUz2tqaqq5BrNmzULLli0xdepUTJ8+HQCwadMmjBo1CvPmzUPNmjVhY2ODOXPm4N9//00z3qioKHh6emoloEmyS4d4opyCiRCRAblw4QLUajXmzZunqe1I6o+SllKlSqFUqVIYMWIEOnfujLVr16JNmzaoUqUKrl+/nizh+hQjI6MUj7G1tUXBggVx6tQp1K9fX1N+6tQpVK9eXWs/Hx8f+Pj4oH379mjWrBlevXqFfPnyaZ0vqT+OSqVKMx5zc3O0bdsWGzZswJ07d1C6dGlUqVJFc3+VKlVw8+ZNnZ/nxyZOnIhGjRphwIABmudZq1YtDBw4ULPPxzU6pqamyeKvUqUKNm/eDCcnJ9ja2n5WTESGjp2liQxIiRIl8O7dOyxevBj37t3Db7/9hmXLlqW6f2xsLAYPHoxjx47h/v37OHXqFM6fP69p8hozZgxOnz6NwYMHIzg4GLdv38auXbt07iz9odGjR2P27NnYvHkzbt68ibFjxyI4OBjDhg0DAMyfPx8bN27EjRs3cOvWLWzduhXOzs4pTgLp5OQECwsLBAYGIiIiAkqlMtXH7dq1K/bu3Ys1a9ZoOkknmTx5MtavX4+pU6fi2rVrCAkJwaZNmzBx4kSdnlvNmjXxxRdfYObMmQCAkiVL4r///sOBAwdw69YtTJo0CefPn9c6xt3dHZcvX8bNmzfx4sULvHv3Dl27doWDgwO++eYbnDhxAqGhoTh27BiGDh2KR48e6RQTkcGTu5MSEelfSh1sk8yfP1+4uLgICwsL4e3tLdavXy8AiNevXwshtDszx8fHi06dOgk3NzdhamoqChYsKAYPHqzVEfrcuXOiSZMmwtraWlhZWYkvvvgiWWfnD33cWfpjKpVKTJkyRbi6ugoTExNRqVIlsX//fs39K1asEB4eHsLKykrY2tqKxo0bi6CgIM39+KCztBBCrFy5Uri5uQkjIyNRv379VF8flUolXFxcBABx9+7dZHEFBgaKWrVqCQsLC2FrayuqV68uVqxYkerz8PPzE5UqVUpWvnHjRmFmZiYePHgg4uLiRI8ePYSdnZ2wt7cXAwYMEGPHjtU67tmzZ5rXF4A4evSoEEKIp0+fiu7duwsHBwdhZmYmihUrJvr06SOUSmWqMRFRcgohhJA3FSMiIiKSB5vGiIiIyGAxESIiIiKDxUSIiIiIDBYTISIiIjJYTISIiIjIYDERIiIiIoPFRIiIiIgMFhMhIiIiMlhMhIiIiMhgMREiIiIig8VEiIiIiAwWEyEiIiIyWP8DOpsxg2c/V0sAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", "output_type": "stream", "text": [ - "/Users/zoos/PycharmProjects/Anomaly_detection/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n", - "/Users/zoos/PycharmProjects/Anomaly_detection/signature_mahalanobis_knn/src/signature_mahalanobis_knn/utils.py:84: RuntimeWarning: All-NaN slice encountered\n", - " max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))\n" + "Overall, depth: 4 AUC: 0.9892111111111112\n", + "doing digit 0 doing signature level 5\n", + "fit_time: 2.3774771690368652\n", + "compute_auc_time: 0.32339024543762207\n", + "depth: 5 , Auc of digit: 0 is 0.9933333333333334\n", + "doing digit 1 doing signature level 5\n", + "fit_time: 2.3257060050964355\n", + "compute_auc_time: 0.4489150047302246\n", + "depth: 5 , Auc of digit: 1 is 0.9911111111111112\n", + "doing digit 2 doing signature level 5\n", + "fit_time: 2.6403658390045166\n", + "compute_auc_time: 0.3673131465911865\n", + "depth: 5 , Auc of digit: 2 is 0.9966666666666667\n", + "doing digit 3 doing signature level 5\n", + "fit_time: 2.5935380458831787\n", + "compute_auc_time: 0.5372729301452637\n", + "depth: 5 , Auc of digit: 3 is 1.0\n", + "doing digit 4 doing signature level 5\n", + "fit_time: 2.544213056564331\n", + "compute_auc_time: 0.4548349380493164\n", + "depth: 5 , Auc of digit: 4 is 0.9977777777777778\n", + "doing digit 5 doing signature level 5\n", + "fit_time: 2.757185935974121\n", + "compute_auc_time: 0.566464900970459\n", + "depth: 5 , Auc of digit: 5 is 0.9933333333333333\n", + "doing digit 6 doing signature level 5\n", + "fit_time: 2.504159927368164\n", + "compute_auc_time: 0.41169309616088867\n", + "depth: 5 , Auc of digit: 6 is 0.9855555555555555\n", + "doing digit 7 doing signature level 5\n", + "fit_time: 2.4034860134124756\n", + "compute_auc_time: 0.4391207695007324\n", + "depth: 5 , Auc of digit: 7 is 0.9833333333333334\n", + "doing digit 8 doing signature level 5\n", + "fit_time: 2.4482288360595703\n", + "compute_auc_time: 0.43535900115966797\n", + "depth: 5 , Auc of digit: 8 is 1.0\n", + "doing digit 9 doing signature level 5\n", + "fit_time: 2.3607637882232666\n", + "compute_auc_time: 0.35583996772766113\n", + "depth: 5 , Auc of digit: 9 is 0.9944444444444445\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -102,16 +364,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 4 AUC: 0.8\n", - "CPU times: user 13.2 s, sys: 4.04 s, total: 17.2 s\n", - "Wall time: 4.64 s\n" + "Overall, depth: 5 AUC: 0.9895333333333334\n", + "CPU times: user 2min 57s, sys: 2min 20s, total: 5min 17s\n", + "Wall time: 2min 8s\n" ] } ], "source": [ "%%time\n", "depth_to_auc = {}\n", - "n_neighbours = 50\n", + "\n", "for depth in depths:\n", " digit_to_inlier_dists = {}\n", " digit_to_outlier_dists = {}\n", @@ -119,7 +381,7 @@ " for digit in digits:\n", " data.load_pen_digit(digit=digit)\n", " print(\"doing digit\", digit, \"doing signature level \", depth)\n", - " signature_maha_knn = signature_mahalanobis_knn.SignatureMahalanobisKNN()\n", + " signature_maha_knn = SignatureMahalanobisKNN()\n", " # Measure the time spent on fit\n", " start_time = time.time()\n", " signature_maha_knn.fit(\n", @@ -163,22 +425,23 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 15, "id": "fa3d0039-5d50-4aa8-ac91-f76a83513315", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([3.17808345, 2.90903013, 2.64864169, nan, nan,\n", - " 2.94073725, 2.09585869, nan, 2.76321417, 3.25512904,\n", - " nan, 4.00545501, 3.96774404, nan, 3.70931255,\n", - " nan, nan, nan, 4.15736527, nan,\n", - " 4.07228945, nan, 2.41246371, 2.0039075 , 1.94522639,\n", - " 1.73669995, 3.33430435, nan, nan, 5.30823054])" + "array([ 0.37542346, 0.6084737 , 0.5330198 , 2.0521839 , 18.178993 ,\n", + " 0.9051934 , 0.66631705, 11.695885 , 0.7718717 , 0.6693719 ,\n", + " 1.4397979 , 0.6041697 , 0.6704992 , 5.289418 , 0.52658904,\n", + " 6.532274 , 1.2970588 , 27.432434 , 1.2141329 , 15.89954 ,\n", + " 0.6093601 , 1.6905133 , 0.64199626, 0.49906355, 0.42805055,\n", + " 0.36041334, 0.41619825, 4.1343365 , 3.3879225 , 0.92946756],\n", + " dtype=float32)" ] }, - "execution_count": 25, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -228,19 +491,23 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 16, "id": "7b24a162-ab61-42ec-92d0-31067441e1ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", - " nan, nan, nan, nan])" + "array([246.81157 , 45.91195 , 23.841997, 101.71473 , 32.23767 ,\n", + " 23.344664, 61.933914, 88.72693 , 274.00122 , 229.67078 ,\n", + " 55.578976, 194.31023 , 124.48786 , 128.36687 , 96.641365,\n", + " 66.92221 , 240.74686 , 238.1418 , 198.62576 , 65.794754,\n", + " 51.987164, 281.74393 , 194.5858 , 243.91685 , 10.673991,\n", + " 34.443893, 125.14485 , 132.93954 , 159.01588 , 112.86924 ],\n", + " dtype=float32)" ] }, - "execution_count": 26, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -315,7 +582,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "9f49674f-86c7-4d6e-88f9-98218ab69be3", "metadata": {}, "outputs": [], @@ -328,10 +595,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "60165b32-c950-4b0c-9526-3edcb7674e62", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ValueError", + "evalue": "Either X or signatures must be provided", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m:24\u001b[0m\n", + "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:103\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[39mif\u001b[39;00m signatures_train \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 102\u001b[0m \u001b[39mif\u001b[39;00m X_train \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 103\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(X_OR_SIGNATURE_ERROR_MSG)\n\u001b[1;32m 105\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msktime\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mtransformations\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpanel\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39msignature_based\u001b[39;00m \u001b[39mimport\u001b[39;00m (\n\u001b[1;32m 106\u001b[0m SignatureTransformer,\n\u001b[1;32m 107\u001b[0m )\n\u001b[1;32m 109\u001b[0m \u001b[39m# set default kwargs for signature transformer if not provided\u001b[39;00m\n", + "\u001b[0;31mValueError\u001b[0m: Either X or signatures must be provided" + ] + } + ], "source": [ "%%time\n", "lead_lag_and_inv_rest_and_thres_distance_to_auc = {}\n", @@ -370,25 +650,10178 @@ "\n", " # Measure the time spent on compute_auc\n", " start_time = time.time()\n", - " auc = signature_maha_knn.compute_auc(data.test_inlier, data.test_outlier)\n", + " inlier_dists = signature_maha_knn.conformance(\n", + " data.test_inlier, n_neighbors=n_neighbours\n", + " )\n", + " outlier_dists = signature_maha_knn.conformance(\n", + " data.test_outlier, n_neighbors=n_neighbours\n", + " )\n", + " auc = compute_auc_given_dists(\n", + " inlier_dists,\n", + " outlier_dists,\n", + " plot=True,\n", + " title=f\"Threshold distance: {thres_distance} (depth={depth})\",\n", + " )\n", + " auc = compute_auc_given_dists(inlier_dists, outlier_dists)\n", " compute_auc_time = time.time() - start_time\n", " print(\"compute_auc_time: \", compute_auc_time)\n", "\n", " print(\n", - " \"lead_lag: \",\n", - " lead_lag,\n", - " \"inv_rest: \",\n", - " inv_reset,\n", - " \"thres_distance: \",\n", - " thres_distance,\n", - " \"auc: \",\n", - " auc,\n", + " f\"lead_lag: {lead_lag}\",\n", + " f\"inv_rest: {inv_reset}\",\n", + " f\"thres_distance: {thres_distance}\",\n", + " f\"auc: {auc}\",\n", + " )\n", + " auc = compute_auc_given_dists(\n", + " all_inlier_dists,\n", + " all_outlier_dists,\n", + " plot=True,\n", + " title=f\"Pen Digit (depth={depth})\",\n", " )\n", " lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag][inv_reset][\n", " thres_distance\n", " ] = auc" ] }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8b2f56b6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[array([[0. , 0. , 0. ],\n", + " [0.12361251, 0.1265174 , 0.98484848],\n", + " [0.25176589, 0.25492312, 1. ],\n", + " [0.37083754, 0.37361748, 0.92424242],\n", + " [0.49646821, 0.49986512, 0.96969697],\n", + " [0.6160444 , 0.61586188, 0.92424242],\n", + " [0.74470232, 0.74372808, 1. ],\n", + " [0.87487386, 0.87321284, 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.01311249, 0.97699594, 0.31386861],\n", + " [0.03588682, 0.95453315, 0.2919708 ],\n", + " [0.07729469, 0.88985115, 0.80291971],\n", + " [0.1131815 , 0.85304465, 0.4379562 ],\n", + " [0.12560386, 0.83843031, 0.17274939],\n", + " [0.13802622, 0.82462788, 0.1946472 ],\n", + " [0.16770186, 0.78673884, 0.486618 ],\n", + " [0.1773637 , 0.77050068, 0.24087591],\n", + " [0.1863354 , 0.75832206, 0.19708029],\n", + " [0.19806763, 0.74073072, 0.26520681],\n", + " [0.20979986, 0.72665765, 0.17274939],\n", + " [0.22222222, 0.71258457, 0.19221411],\n", + " [0.30710835, 0.63734777, 1. ],\n", + " [0.32091097, 0.62219215, 0.19221411],\n", + " [0.36922015, 0.57104195, 0.6107056 ],\n", + " [0.38854382, 0.55074425, 0.2919708 ],\n", + " [0.39820566, 0.5391069 , 0.18978102],\n", + " [0.41614907, 0.51096076, 0.44282238],\n", + " [0.436853 , 0.48985115, 0.3406326 ],\n", + " [0.46031746, 0.47198917, 0.243309 ],\n", + " [0.47273982, 0.4579161 , 0.1946472 ],\n", + " [0.48516218, 0.44303112, 0.19221411],\n", + " [0.52242926, 0.40947226, 0.44038929],\n", + " [0.53347136, 0.39566982, 0.1703163 ],\n", + " [0.57971014, 0.35994587, 0.50851582],\n", + " [0.59006211, 0.34695535, 0.1946472 ],\n", + " [0.60179434, 0.33396482, 0.17274939],\n", + " [0.62594893, 0.31935047, 0.243309 ],\n", + " [0.67425811, 0.26792963, 0.68126521],\n", + " [0.68461008, 0.25493911, 0.1703163 ],\n", + " [0.69565217, 0.24194858, 0.21654501],\n", + " [0.72808834, 0.21163735, 0.4379562 ],\n", + " [0.75017253, 0.18592693, 0.34306569],\n", + " [0.77294686, 0.16833559, 0.2189781 ],\n", + " [0.79503106, 0.15074425, 0.243309 ],\n", + " [0.80607315, 0.13775372, 0.1946472 ],\n", + " [0.82953761, 0.12368065, 0.23844282],\n", + " [0.85231194, 0.10960758, 0.19708029],\n", + " [0.87784679, 0.09039242, 0.2189781 ],\n", + " [0.90407177, 0.06982409, 0.29440389],\n", + " [0.92822636, 0.05033829, 0.2189781 ],\n", + " [0.95238095, 0.03193505, 0.24087591],\n", + " [1. , 0. , 0.486618 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10016287, 0.10016353, 0.95833333],\n", + " [0.2019544 , 0.20134914, 0.95833333],\n", + " [0.3029316 , 0.30294358, 0.98611111],\n", + " [0.40553746, 0.40576451, 0.98611111],\n", + " [0.50732899, 0.50735895, 0.97222222],\n", + " [0.60830619, 0.60752249, 0.94444444],\n", + " [0.71091205, 0.71075225, 1. ],\n", + " [0.81107492, 0.81071137, 0.95833333],\n", + " [0.91205212, 0.91169256, 0.97222222],\n", + " [1. , 1. , 0.84722222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09769094, 0.09785714, 0.98591549],\n", + " [0.19937833, 0.19880952, 0.98591549],\n", + " [0.30106572, 0.3002381 , 1. ],\n", + " [0.39831261, 0.39738095, 0.97183099],\n", + " [0.49955595, 0.49880952, 1. ],\n", + " [0.60079929, 0.60047619, 0.98591549],\n", + " [0.69937833, 0.69928571, 0.97183099],\n", + " [0.79973357, 0.79952381, 1. ],\n", + " [0.90008881, 0.8997619 , 0.97183099],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.10130548, 0.90441176, 0.85 ],\n", + " [0.19112272, 0.80441176, 0.7625 ],\n", + " [0.29190601, 0.68676471, 0.8625 ],\n", + " [0.39425587, 0.56911765, 0.875 ],\n", + " [0.48250653, 0.47058824, 0.7625 ],\n", + " [0.58537859, 0.35588235, 0.8625 ],\n", + " [0.67362924, 0.27205882, 0.7625 ],\n", + " [0.7772846 , 0.19117647, 0.875 ],\n", + " [0.88250653, 0.10294118, 0.875 ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11636557, 0.33333333, 0.875 ],\n", + " [0.23166844, 0.73333333, 0.875 ],\n", + " [0.36716259, 0.86666667, 1. ],\n", + " [0.49760893, 1. , 0.9875 ],\n", + " [0.61716259, 0.8 , 0.9 ],\n", + " [0.74920298, 0.86666667, 0.9875 ],\n", + " [0.88469713, 0.73333333, 1. ],\n", + " [1. , 0.8 , 0.875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12187029, 0.8752314 , 1. ],\n", + " [0.24705882, 0.75083302, 1. ],\n", + " [0.37164404, 0.62495372, 1. ],\n", + " [0.4974359 , 0.50092558, 1. ],\n", + " [0.62262443, 0.37541651, 1. ],\n", + " [0.74600302, 0.25138837, 1. ],\n", + " [0.87209653, 0.12699 , 1. ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92123629, 0.92134831, 0.98591549],\n", + " [0.85377202, 0.85495403, 0.85915493],\n", + " [0.77500831, 0.77596187, 0.98591549],\n", + " [0.69657694, 0.6969697 , 0.98591549],\n", + " [0.6184779 , 0.61797753, 0.98591549],\n", + " [0.54104354, 0.54000681, 0.97183099],\n", + " [0.46095048, 0.45965271, 0.98591549],\n", + " [0.38351612, 0.38032005, 1. ],\n", + " [0.30408774, 0.30064692, 0.98591549],\n", + " [0.2369558 , 0.23323119, 0.85915493],\n", + " [0.15952144, 0.15491999, 0.95774648],\n", + " [0.07909605, 0.0783112 , 0.98591549],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11606061, 0.11318619, 0.63063063],\n", + " [0.24242424, 0.23599321, 0.72072072],\n", + " [0.37363636, 0.36785512, 0.72072072],\n", + " [0.48484848, 0.48104131, 0.63963964],\n", + " [0.61606061, 0.61346916, 0.71171171],\n", + " [0.79272727, 0.79230334, 1. ],\n", + " [0.90393939, 0.90548953, 0.62162162],\n", + " [1. , 1. , 0.54954955]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.875 , 0.83475987, 0.88235294],\n", + " [0.71428571, 0.6766524 , 0.82352941],\n", + " [0.64285714, 0.55634807, 0.64705882],\n", + " [0.49107143, 0.43223966, 0.64705882],\n", + " [0.3125 , 0.24488825, 1. ],\n", + " [0.19642857, 0.11959106, 0.64705882],\n", + " [0. , 0. , 0.64705882]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08661417, 0.90934514, 0.98591549],\n", + " [0.19685039, 0.81799114, 0.98591549],\n", + " [0.31496063, 0.72547192, 0.98591549],\n", + " [0.42519685, 0.64646935, 0.85915493],\n", + " [0.44094488, 0.55721277, 0.95774648],\n", + " [0.48818898, 0.46306222, 0.98591549],\n", + " [0.63779528, 0.37147518, 1. ],\n", + " [0.72440945, 0.279189 , 0.98591549],\n", + " [0.77952756, 0.18573759, 0.98591549],\n", + " [0.91338583, 0.09298532, 0.98591549],\n", + " [1. , 0. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87470135, 0.12380416, 1. ],\n", + " [0.75126095, 0.2447946 , 0.97014925],\n", + " [0.6339262 , 0.3629713 , 0.91044776],\n", + " [0.50836209, 0.4895892 , 0.98507463],\n", + " [0.38093974, 0.61733258, 0.97014925],\n", + " [0.25298646, 0.74563872, 0.98507463],\n", + " [0.12874967, 0.86944288, 0.98507463],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90091337, 0.90187891, 0.97183099],\n", + " [0.80293385, 0.80584551, 0.98591549],\n", + " [0.70218655, 0.70563674, 1. ],\n", + " [0.60060891, 0.60542797, 0.98591549],\n", + " [0.50345973, 0.51148225, 0.97183099],\n", + " [0.40354276, 0.41127349, 0.98591549],\n", + " [0.30196513, 0.30688935, 0.98591549],\n", + " [0.2014946 , 0.20876827, 0.98591549],\n", + " [0.10323831, 0.10647182, 0.98591549],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89617656, 0.91666667, 0.85185185],\n", + " [0.79266397, 0.82666667, 0.87654321],\n", + " [0.68915138, 0.74333333, 0.85185185],\n", + " [0.59061237, 0.65291667, 0.86419753],\n", + " [0.46627293, 0.54875 , 1. ],\n", + " [0.36773391, 0.46541667, 0.86419753],\n", + " [0.27447933, 0.3475 , 0.86419753],\n", + " [0.19676717, 0.24333333, 0.75308642],\n", + " [0.10879702, 0.13208333, 0.83950617],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14485981, 0.13969608, 0.90410959],\n", + " [0.29014444, 0.28472407, 0.90410959],\n", + " [0.43118097, 0.42708611, 0.89041096],\n", + " [0.58751062, 0.58651026, 1. ],\n", + " [0.72812234, 0.72673954, 0.89041096],\n", + " [0.8606627 , 0.85897094, 0.83561644],\n", + " [1. , 1. , 0.90410959]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87482806, 0.89054726, 0.98507463],\n", + " [0.74828061, 0.7761194 , 1. ],\n", + " [0.62310867, 0.65174129, 0.98507463],\n", + " [0.49766162, 0.51741294, 0.98507463],\n", + " [0.37248968, 0.38308458, 0.98507463],\n", + " [0.24951857, 0.25373134, 0.97014925],\n", + " [0.12489684, 0.12935323, 0.98507463],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.05254692, 0.95153514, 1. ],\n", + " [0.10616622, 0.89951789, 0.98591549],\n", + " [0.16407507, 0.84242578, 0.98591549],\n", + " [0.22144772, 0.78685613, 0.97183099],\n", + " [0.28150134, 0.72722659, 0.98591549],\n", + " [0.34048257, 0.66734331, 0.98591549],\n", + " [0.39302949, 0.61532606, 0.85915493],\n", + " [0.45469169, 0.55468155, 0.97183099],\n", + " [0.50670241, 0.5044405 , 0.85915493],\n", + " [0.55924933, 0.45166201, 0.98591549],\n", + " [0.61126005, 0.40040599, 0.97183099],\n", + " [0.66112601, 0.35041868, 0.98591549],\n", + " [0.71635389, 0.29307282, 0.98591549],\n", + " [0.78176944, 0.22608475, 0.97183099],\n", + " [0.84235925, 0.16366404, 0.85915493],\n", + " [0.91849866, 0.08652626, 0.98591549],\n", + " [1. , 0. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88880188, 0.11210222, 0.98507463],\n", + " [0.7807361 , 0.22540984, 0.98507463],\n", + " [0.67188724, 0.33654773, 0.97014925],\n", + " [0.5614722 , 0.45154291, 1. ],\n", + " [0.45184025, 0.56726133, 0.98507463],\n", + " [0.33907596, 0.68008679, 0.98507463],\n", + " [0.22317933, 0.78977821, 0.97014925],\n", + " [0.11589663, 0.89079074, 0.91044776],\n", + " [0. , 1. , 0.97014925]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12015177, 0.12409812, 1. ],\n", + " [0.2272344 , 0.22655123, 0.85185185],\n", + " [0.3351602 , 0.33391053, 0.88888889],\n", + " [0.45320405, 0.45656566, 0.97530864],\n", + " [0.57504216, 0.57489177, 0.97530864],\n", + " [0.67959528, 0.67878788, 0.86419753],\n", + " [0.78583474, 0.78989899, 0.88888889],\n", + " [0.89333895, 0.8966811 , 0.85185185],\n", + " [1. , 1. , 0.86419753]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92156863, 0.16892809, 1. ],\n", + " [0.84313725, 0.33808232, 1. ],\n", + " [0.74509804, 0.45251018, 0.66666667],\n", + " [0.58823529, 0.52849389, 0.44444444],\n", + " [0.37254902, 0.63432836, 0.61666667],\n", + " [0.21568627, 0.70081411, 0.38888889],\n", + " [0. , 0.7663953 , 0.38333333],\n", + " [0. , 0.83333333, 0.39444444],\n", + " [0.01960784, 0.89891452, 0.38888889],\n", + " [0.11764706, 1. , 0.60555556]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15355418, 0.15366884, 1. ],\n", + " [0.29399586, 0.29466001, 0.94366197],\n", + " [0.43512767, 0.43565117, 0.92957746],\n", + " [0.57625949, 0.57587399, 0.91549296],\n", + " [0.7173913 , 0.71686516, 0.94366197],\n", + " [0.85852312, 0.85862466, 0.92957746],\n", + " [1. , 1. , 0.91549296]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91375167, 0.91364903, 0.7625 ],\n", + " [0.80453939, 0.80501393, 0.875 ],\n", + " [0.68891856, 0.68895079, 1. ],\n", + " [0.58878505, 0.58960074, 0.85 ],\n", + " [0.49933244, 0.50139276, 0.7625 ],\n", + " [0.40106809, 0.40575673, 0.875 ],\n", + " [0.29372497, 0.29712163, 0.875 ],\n", + " [0.20694259, 0.21077066, 0.7625 ],\n", + " [0.10146862, 0.10584958, 0.875 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.0738202 , 0.1875 , 0.85185185],\n", + " [0.13867651, 0.28125 , 0.75308642],\n", + " [0.21091484, 0.34375 , 0.86419753],\n", + " [0.28368046, 0.34375 , 0.85185185],\n", + " [0.34827313, 0.40625 , 0.75308642],\n", + " [0.42393883, 0.40625 , 0.86419753],\n", + " [0.50962299, 0.5625 , 0.97530864],\n", + " [0.5950435 , 0.59375 , 0.98765432],\n", + " [0.68310045, 0.71875 , 1. ],\n", + " [0.75902979, 0.84375 , 0.85185185],\n", + " [0.83733193, 0.9375 , 0.86419753],\n", + " [0.9243343 , 1. , 0.98765432],\n", + " [1. , 1. , 0.86419753]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12487512, 0.12654867, 0.90410959],\n", + " [0.25224775, 0.24837758, 0.90410959],\n", + " [0.37712288, 0.37168142, 0.89041096],\n", + " [0.51048951, 0.51032448, 1. ],\n", + " [0.63086913, 0.63126844, 0.90410959],\n", + " [0.75524476, 0.75575221, 0.89041096],\n", + " [0.87912088, 0.87728614, 0.91780822],\n", + " [1. , 1. , 0.90410959]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.16264547, 0.8392385 , 1. ],\n", + " [0.30059608, 0.70333157, 0.84259259],\n", + " [0.43315356, 0.56848228, 0.83333333],\n", + " [0.56713029, 0.43151772, 0.84259259],\n", + " [0.68833381, 0.31147541, 0.74074074],\n", + " [0.79165484, 0.20888419, 0.63888889],\n", + " [0.89753051, 0.10312004, 0.65740741],\n", + " [1. , 0. , 0.63888889]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11284047, 0.01290323, 0.84415584],\n", + " [0.21893645, 0.01612903, 0.80519481],\n", + " [0.35019455, 0.20322581, 1. ],\n", + " [0.46018158, 0.25483871, 0.84415584],\n", + " [0.5618677 , 0.33225806, 0.79220779],\n", + " [0.67367056, 0.53225806, 0.84415584],\n", + " [0.77535668, 0.67741935, 0.79220779],\n", + " [0.89805447, 0.83548387, 0.92207792],\n", + " [1. , 1. , 0.79220779]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13545151, 0.14425428, 0.91666667],\n", + " [0.27090301, 0.26650367, 0.91666667],\n", + " [0.40635452, 0.40831296, 0.91666667],\n", + " [0.54586718, 0.55012225, 0.91666667],\n", + " [0.69732441, 0.69315403, 1. ],\n", + " [0.84065934, 0.83618582, 0.91666667],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0.73807662, 0.04898157, 0. ],\n", + " [0.7898749 , 0.11493695, 0.00122874],\n", + " [0.83229085, 0.25703201, 0.00134576],\n", + " [0.86903831, 0.42531523, 0.00138477],\n", + " [0.90402658, 0.57807953, 0.00138477],\n", + " [0.93647381, 0.72162949, 0.00134576],\n", + " [0.96696638, 0.85935984, 0.00136527],\n", + " [0.99354965, 0.98399612, 0.00136527],\n", + " [1. , 1. , 1. ],\n", + " [0.9601251 , 0.81959263, 0.00136527],\n", + " [0.92044566, 0.63773036, 0.00136527],\n", + " [0.8842846 , 0.46605238, 0.00118973],\n", + " [0.83893667, 0.26527643, 0.00136527],\n", + " [0.7898749 , 0.08680892, 0.00122874],\n", + " [0.71813917, 0. , 0.00122874],\n", + " [0.64953088, 0.05674103, 0.00122874],\n", + " [0.59030493, 0.18865179, 0.00118973],\n", + " [0.52501955, 0.35984481, 0.00130676],\n", + " [0.45895231, 0.53782735, 0.00128725],\n", + " [0.38838937, 0.68477207, 0.00120924],\n", + " [0.30942142, 0.76333657, 0.00120924],\n", + " [0.22888976, 0.73617847, 0.00120924],\n", + " [0.14347146, 0.67895247, 0.00128725],\n", + " [0.06333073, 0.61833172, 0.00120924],\n", + " [0. , 0.47623666, 0.00122874]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12961985, 0.28125 , 0.97222222],\n", + " [0.24630412, 0.53125 , 0.86111111],\n", + " [0.38252376, 0.5 , 1. ],\n", + " [0.51742344, 0.5 , 0.98611111],\n", + " [0.63516367, 0.5625 , 0.86111111],\n", + " [0.76795143, 0.71875 , 0.95833333],\n", + " [0.88595565, 0.875 , 0.86111111],\n", + " [1. , 1. , 0.84722222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12338518, 0.12470588, 0.91666667],\n", + " [0.25731611, 0.24705882, 1. ],\n", + " [0.3825468 , 0.38823529, 0.90277778],\n", + " [0.49327709, 0.48470588, 0.84722222],\n", + " [0.62799895, 0.62117647, 0.98611111],\n", + " [0.75270235, 0.75058824, 0.93055556],\n", + " [0.87687846, 0.87529412, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92434783, 0.919375 , 0.77777778],\n", + " [0.86 , 0.85375 , 0.67777778],\n", + " [0.7826087 , 0.78125 , 0.77777778],\n", + " [0.71014493, 0.708125 , 0.77777778],\n", + " [0.63275362, 0.635 , 0.77777778],\n", + " [0.56028986, 0.5625 , 0.76666667],\n", + " [0.48318841, 0.47875 , 0.76666667],\n", + " [0.39623188, 0.395625 , 0.9 ],\n", + " [0.29942029, 0.301875 , 1. ],\n", + " [0.22695652, 0.22875 , 0.77777778],\n", + " [0.15130435, 0.151875 , 0.77777778],\n", + " [0.0773913 , 0.0725 , 0.77777778],\n", + " [0. , 0. , 0.76666667]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13733469, 0.13391813, 0.85714286],\n", + " [0.28585961, 0.28391813, 0.93506494],\n", + " [0.42217701, 0.41988304, 0.85714286],\n", + " [0.56052899, 0.55555556, 0.87012987],\n", + " [0.69125127, 0.69122807, 0.85714286],\n", + " [0.85198372, 0.85146199, 1. ],\n", + " [1. , 1. , 0.94805195]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88619034, 0.90289017, 1. ],\n", + " [0.78565377, 0.80809249, 0.88607595],\n", + " [0.68568201, 0.71445087, 0.88607595],\n", + " [0.58599266, 0.62774566, 0.87341772],\n", + " [0.48263202, 0.52485549, 0.91139241],\n", + " [0.36825755, 0.40346821, 1. ],\n", + " [0.28212369, 0.30520231, 0.7721519 ],\n", + " [0.18554081, 0.19421965, 0.86075949],\n", + " [0.0971477 , 0.0982659 , 0.7721519 ],\n", + " [0. , 0. , 0.87341772]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.98819777, 0.98237256, 0.72477064],\n", + " [0.97639553, 0.9642687 , 0.73394495],\n", + " [0.96491228, 0.95092901, 0.64220183],\n", + " [0.95279107, 0.93520724, 0.64220183],\n", + " [0.94066986, 0.91996189, 0.65137615],\n", + " [0.92950558, 0.9037637 , 0.64220183],\n", + " [0.91929825, 0.88851834, 0.64220183],\n", + " [0.90813397, 0.8737494 , 0.64220183],\n", + " [0.89760766, 0.85898047, 0.63302752],\n", + " [0.88580542, 0.84373511, 0.73394495],\n", + " [0.87368421, 0.82991901, 0.65137615],\n", + " [0.85454545, 0.81086232, 1. ],\n", + " [0.84242424, 0.79752263, 0.65137615],\n", + " [0.82966507, 0.78275369, 0.73394495],\n", + " [0.81594896, 0.76846117, 0.72477064],\n", + " [0.80287081, 0.75512149, 0.65137615],\n", + " [0.78947368, 0.73939971, 0.72477064],\n", + " [0.77607656, 0.72129586, 0.74311927],\n", + " [0.76650718, 0.7060505 , 0.64220183],\n", + " [0.75470494, 0.69414007, 0.63302752],\n", + " [0.73971292, 0.67746546, 0.83486239],\n", + " [0.72759171, 0.66507861, 0.64220183],\n", + " [0.71259968, 0.65269176, 0.73394495],\n", + " [0.6969697 , 0.63792282, 0.72477064],\n", + " [0.68484848, 0.6236303 , 0.64220183],\n", + " [0.67400319, 0.60790853, 0.65137615],\n", + " [0.66092504, 0.587899 , 0.83486239],\n", + " [0.64816587, 0.57265364, 0.72477064],\n", + " [0.63732057, 0.56026679, 0.63302752],\n", + " [0.63189793, 0.55407337, 0.28440367],\n", + " [0.61881978, 0.53978085, 0.81651376],\n", + " [0.60637959, 0.527394 , 0.65137615],\n", + " [0.59170654, 0.51310148, 0.82568807],\n", + " [0.58086124, 0.50166746, 0.63302752],\n", + " [0.56937799, 0.48928061, 0.64220183],\n", + " [0.55789474, 0.47832301, 0.64220183],\n", + " [0.54545455, 0.46831825, 0.65137615],\n", + " [0.53301435, 0.45831348, 0.63302752],\n", + " [0.52089314, 0.44640305, 0.65137615],\n", + " [0.50940989, 0.4340162 , 0.63302752],\n", + " [0.49920255, 0.42067651, 0.64220183],\n", + " [0.48931419, 0.40686041, 0.65137615],\n", + " [0.4800638 , 0.39304431, 0.63302752],\n", + " [0.47145136, 0.38018104, 0.64220183],\n", + " [0.461563 , 0.36827061, 0.66055046],\n", + " [0.45103668, 0.35778942, 0.63302752],\n", + " [0.44051037, 0.34540257, 0.63302752],\n", + " [0.43030303, 0.33396856, 0.64220183],\n", + " [0.41913876, 0.32062887, 0.65137615],\n", + " [0.41020734, 0.30728919, 0.64220183],\n", + " [0.40095694, 0.29347308, 0.65137615],\n", + " [0.3923445 , 0.2801334 , 0.63302752],\n", + " [0.38245614, 0.26679371, 0.72477064],\n", + " [0.37192982, 0.25678895, 0.65137615],\n", + " [0.36172249, 0.24583135, 0.64220183],\n", + " [0.35183413, 0.23439733, 0.63302752],\n", + " [0.34035088, 0.22201048, 0.74311927],\n", + " [0.33110048, 0.21200572, 0.63302752],\n", + " [0.32185008, 0.20152454, 0.64220183],\n", + " [0.31164274, 0.19056694, 0.65137615],\n", + " [0.30239234, 0.17913292, 0.63302752],\n", + " [0.29314195, 0.16912816, 0.64220183],\n", + " [0.28293461, 0.16007623, 0.65137615],\n", + " [0.27113238, 0.1538828 , 0.63302752],\n", + " [0.25837321, 0.14911863, 0.64220183],\n", + " [0.24370016, 0.14244879, 0.73394495],\n", + " [0.23157895, 0.13482611, 0.64220183],\n", + " [0.2185008 , 0.12434493, 0.74311927],\n", + " [0.20701754, 0.11719867, 0.63302752],\n", + " [0.19202552, 0.10957599, 0.74311927],\n", + " [0.17958533, 0.10147689, 0.63302752],\n", + " [0.16523126, 0.09290138, 0.74311927],\n", + " [0.15311005, 0.0852787 , 0.64220183],\n", + " [0.14035088, 0.07813244, 0.63302752],\n", + " [0.12822967, 0.07050977, 0.64220183],\n", + " [0.11515152, 0.06336351, 0.64220183],\n", + " [0.10207337, 0.05669366, 0.64220183],\n", + " [0.08835726, 0.05002382, 0.64220183],\n", + " [0.07496013, 0.04478323, 0.65137615],\n", + " [0.06220096, 0.03668414, 0.65137615],\n", + " [0.04944179, 0.02858504, 0.63302752],\n", + " [0.03572568, 0.02000953, 0.72477064],\n", + " [0.02296651, 0.01333969, 0.64220183],\n", + " [0.01180223, 0.00666984, 0.64220183],\n", + " [0. , 0. , 0.65137615]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89076418, 0.89660303, 0.5 ],\n", + " [0.78105954, 0.78105629, 0.55 ],\n", + " [0.64041256, 0.64046615, 0.66666667],\n", + " [0.54664791, 0.5494669 , 0.45 ],\n", + " [0.33567745, 0.3429209 , 1. ],\n", + " [0.23441163, 0.23555666, 0.5 ],\n", + " [0.15611814, 0.15695512, 0.38333333],\n", + " [0. , 0. , 0.72777778]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89904102, 0.8974359 , 0.9 ],\n", + " [0.80154502, 0.7985348 , 0.85 ],\n", + " [0.70458178, 0.6996337 , 0.875 ],\n", + " [0.60602025, 0.6007326 , 0.875 ],\n", + " [0.5045285 , 0.503663 , 0.8875 ],\n", + " [0.40623335, 0.4029304 , 0.875 ],\n", + " [0.30900373, 0.30769231, 0.8625 ],\n", + " [0.2088439 , 0.21245421, 0.8875 ],\n", + " [0.11214704, 0.11355311, 0.8625 ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89627756, 0.89419007, 1. ],\n", + " [0.79689194, 0.79607541, 0.97183099],\n", + " [0.69497651, 0.6921893 , 1. ],\n", + " [0.59559089, 0.59176606, 0.95774648],\n", + " [0.49403686, 0.49095806, 0.98591549],\n", + " [0.40693892, 0.4043863 , 0.85915493],\n", + " [0.30430069, 0.30165448, 0.98591549],\n", + " [0.20310806, 0.20123124, 0.98591549],\n", + " [0.09866281, 0.09926895, 1. ],\n", + " [0. , 0. , 0.95774648]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14568345, 0.14525586, 0.98507463],\n", + " [0.28642086, 0.28624733, 0.97014925],\n", + " [0.42985612, 0.42963753, 1. ],\n", + " [0.57194245, 0.57302772, 0.97014925],\n", + " [0.7153777 , 0.71588486, 1. ],\n", + " [0.85836331, 0.85794243, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88754468, 0.11363636, 0.98591549],\n", + " [0.7742645 , 0.22494172, 0.98591549],\n", + " [0.66098433, 0.33566434, 0.97183099],\n", + " [0.54935386, 0.44463869, 0.97183099],\n", + " [0.45092109, 0.54137529, 0.87323944],\n", + " [0.33929062, 0.6532634 , 0.97183099],\n", + " [0.22463569, 0.76981352, 0.98591549],\n", + " [0.11135551, 0.88636364, 1. ],\n", + " [0. , 1. , 0.97183099]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.04347826, 0.12502831, 0.84705882],\n", + " [0.06521739, 0.23148358, 0.77647059],\n", + " [0.1 , 0.34609287, 0.77647059],\n", + " [0.23913043, 0.48629672, 1. ],\n", + " [0.41304348, 0.60973952, 0.83529412],\n", + " [0.64347826, 0.75084938, 1. ],\n", + " [0.84782609, 0.85685164, 0.76470588],\n", + " [1. , 1. , 0.98823529]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13333333, 0.12178189, 0.90277778],\n", + " [0.25941043, 0.24645647, 0.91666667],\n", + " [0.38321995, 0.37199884, 0.91666667],\n", + " [0.49569161, 0.48625976, 0.84722222],\n", + " [0.61904762, 0.61209141, 0.91666667],\n", + " [0.74240363, 0.73763379, 0.90277778],\n", + " [0.86575964, 0.86317616, 0.93055556],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85664336, 0.85861846, 0.91549296],\n", + " [0.70745921, 0.71766731, 0.92957746],\n", + " [0.56293706, 0.57628578, 0.94366197],\n", + " [0.42540793, 0.43468905, 0.92957746],\n", + " [0.28787879, 0.29309232, 0.92957746],\n", + " [0.13636364, 0.13922961, 1. ],\n", + " [0. , 0. , 0.92957746]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87453738, 0.86698766, 0.90909091],\n", + " [0.76350851, 0.75082757, 0.80808081],\n", + " [0.66469282, 0.64790852, 0.70707071],\n", + " [0.52553664, 0.50165513, 1. ],\n", + " [0.42227979, 0.40445381, 0.70707071],\n", + " [0.31754256, 0.30544689, 0.71717172],\n", + " [0.20910437, 0.20523623, 0.70707071],\n", + " [0.10658771, 0.10592838, 0.68686869],\n", + " [0. , 0. , 0.72727273]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.160401 , 0.16309013, 0.90277778],\n", + " [0.32105263, 0.31974249, 0.91666667],\n", + " [0.49373434, 0.50214592, 0.93055556],\n", + " [0.65438596, 0.66094421, 0.91666667],\n", + " [0.8273183 , 0.82832618, 1. ],\n", + " [1. , 1. , 0.98611111]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87482806, 0.89054726, 0.98507463],\n", + " [0.74828061, 0.7761194 , 1. ],\n", + " [0.62310867, 0.65174129, 0.98507463],\n", + " [0.49766162, 0.51741294, 0.98507463],\n", + " [0.37248968, 0.38308458, 0.98507463],\n", + " [0.24951857, 0.25373134, 0.97014925],\n", + " [0.12489684, 0.12935323, 0.98507463],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11128818, 0.11242604, 0.92957746],\n", + " [0.22231076, 0.22633136, 0.91549296],\n", + " [0.33306773, 0.33727811, 0.94366197],\n", + " [0.44409031, 0.44970414, 0.92957746],\n", + " [0.56334661, 0.57100592, 1. ],\n", + " [0.67569721, 0.68343195, 0.94366197],\n", + " [0.78565737, 0.79142012, 0.92957746],\n", + " [0.8937583 , 0.8964497 , 0.91549296],\n", + " [1. , 1. , 0.88732394]]),\n", + " array([[0.51428571, 1. , 0. ],\n", + " [0.62857143, 0.89462762, 0.71717172],\n", + " [1. , 0.7477519 , 1. ],\n", + " [0.48571429, 0.62992852, 0.80808081],\n", + " [0.48571429, 0.52778418, 0.71717172],\n", + " [0.48571429, 0.39681808, 0.8989899 ],\n", + " [0.34285714, 0.30827761, 0.61616162],\n", + " [0.31428571, 0.20659442, 0.6969697 ],\n", + " [0.31428571, 0.10099147, 0.72727273],\n", + " [0. , 0. , 0.6969697 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11284047, 0.01290323, 0.84415584],\n", + " [0.21893645, 0.01612903, 0.80519481],\n", + " [0.35019455, 0.20322581, 1. ],\n", + " [0.46018158, 0.25483871, 0.84415584],\n", + " [0.5618677 , 0.33225806, 0.79220779],\n", + " [0.67367056, 0.53225806, 0.84415584],\n", + " [0.77535668, 0.67741935, 0.79220779],\n", + " [0.89805447, 0.83548387, 0.92207792],\n", + " [1. , 1. , 0.79220779]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86013793, 0.85895628, 0.78888889],\n", + " [0.72993103, 0.72637518, 0.73333333],\n", + " [0.59806897, 0.59238364, 0.73333333],\n", + " [0.42482759, 0.42172073, 1. ],\n", + " [0.25737931, 0.25952045, 0.93333333],\n", + " [0.1257931 , 0.12552891, 0.73333333],\n", + " [0. , 0. , 0.73333333]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.83045213, 0.83052147, 0.97014925],\n", + " [0.66289894, 0.66334356, 0.98507463],\n", + " [0.5 , 0.49897751, 0.98507463],\n", + " [0.33244681, 0.33205521, 1. ],\n", + " [0.16755319, 0.16717791, 0.97014925],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11266861, 0.11625148, 0.98507463],\n", + " [0.22427929, 0.23013049, 0.98507463],\n", + " [0.33350965, 0.34519573, 0.97014925],\n", + " [0.4443269 , 0.45670225, 0.98507463],\n", + " [0.55593758, 0.56702254, 0.98507463],\n", + " [0.66675483, 0.6737841 , 0.98507463],\n", + " [0.77810103, 0.78173191, 1. ],\n", + " [0.88971172, 0.89323843, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87790198, 0.12320789, 1. ],\n", + " [0.75408426, 0.24887993, 0.98484848],\n", + " [0.63026655, 0.375 , 1. ],\n", + " [0.5038693 , 0.50134409, 1. ],\n", + " [0.3783319 , 0.62791219, 1. ],\n", + " [0.24935512, 0.75492832, 1. ],\n", + " [0.11951849, 0.88216846, 1. ],\n", + " [0. , 1. , 0.92424242]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90390051, 0.90627763, 0.53435115],\n", + " [0.79423403, 0.79840849, 0.61068702],\n", + " [0.61560204, 0.622458 , 1. ],\n", + " [0.51950254, 0.52608311, 0.51908397],\n", + " [0.40729226, 0.41290893, 0.6259542 ],\n", + " [0.28688525, 0.29266136, 0.67938931],\n", + " [0.19135105, 0.19628647, 0.53435115],\n", + " [0.09581685, 0.09814324, 0.53435115],\n", + " [0. , 0. , 0.53435115]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16517106, 0.16003351, 0.96875 ],\n", + " [0.33062255, 0.32509426, 0.96875 ],\n", + " [0.49579361, 0.49350649, 0.96875 ],\n", + " [0.66825575, 0.6627566 , 1. ],\n", + " [0.83538979, 0.82907415, 0.96875 ],\n", + " [1. , 1. , 0.953125 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.0959041 , 0.09644939, 0.91666667],\n", + " [0.21628372, 0.21701113, 0.91666667],\n", + " [0.31818182, 0.31849497, 0.90277778],\n", + " [0.43456543, 0.43296237, 0.84722222],\n", + " [0.54795205, 0.54583996, 0.91666667],\n", + " [0.65784216, 0.65686275, 0.91666667],\n", + " [0.77922078, 0.77768945, 1. ],\n", + " [0.89010989, 0.88871224, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87470908, 0.87533693, 0.97222222],\n", + " [0.74864236, 0.75134771, 0.97222222],\n", + " [0.62335144, 0.62668464, 0.97222222],\n", + " [0.49767261, 0.50202156, 0.97222222],\n", + " [0.37315749, 0.37668464, 0.97222222],\n", + " [0.25096974, 0.25336927, 0.95833333],\n", + " [0.12684251, 0.1287062 , 0.97222222],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11482112, 0.11618705, 0.89873418],\n", + " [0.2153322 , 0.22158273, 0.88607595],\n", + " [0.32436116, 0.33093525, 0.86075949],\n", + " [0.42316865, 0.42733813, 0.7721519 ],\n", + " [0.54003407, 0.54244604, 0.89873418],\n", + " [0.64804089, 0.64964029, 0.87341772],\n", + " [0.76218058, 0.76438849, 0.87341772],\n", + " [0.8746167 , 0.87410072, 0.89873418],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.928 , 0.06551724, 0.98591549],\n", + " [0.85381818, 0.13275862, 1. ],\n", + " [0.78254545, 0.19950739, 0.98591549],\n", + " [0.71563636, 0.26256158, 0.97183099],\n", + " [0.64727273, 0.3270936 , 0.97183099],\n", + " [0.58763636, 0.38325123, 0.85915493],\n", + " [0.51854545, 0.44581281, 0.97183099],\n", + " [0.44872727, 0.51034483, 1. ],\n", + " [0.37963636, 0.57389163, 0.98591549],\n", + " [0.33090909, 0.62931034, 0.85915493],\n", + " [0.28072727, 0.69359606, 0.95774648],\n", + " [0.23854545, 0.74950739, 0.85915493],\n", + " [0.18254545, 0.8137931 , 0.98591549],\n", + " [0.12072727, 0.87931034, 0.98591549],\n", + " [0.06472727, 0.93448276, 0.85915493],\n", + " [0. , 1. , 0.95774648]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.1000535 , 0.90861813, 0.85185185],\n", + " [0.20278224, 0.81624567, 0.88888889],\n", + " [0.30551097, 0.72362556, 0.86419753],\n", + " [0.40342429, 0.63447251, 0.85185185],\n", + " [0.50775816, 0.54160475, 0.86419753],\n", + " [0.5917603 , 0.46433878, 0.75308642],\n", + " [0.68967362, 0.37270926, 0.85185185],\n", + " [0.79026217, 0.26597325, 1. ],\n", + " [0.87693954, 0.17360079, 0.85185185],\n", + " [0.93953986, 0.0936107 , 0.75308642],\n", + " [1. , 0. , 0.85185185]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89591281, 0.10855263, 1. ],\n", + " [0.79509537, 0.21513158, 1. ],\n", + " [0.69155313, 0.32368421, 1. ],\n", + " [0.60081744, 0.41907895, 0.87142857],\n", + " [0.49945504, 0.52171053, 1. ],\n", + " [0.4 , 0.62302632, 0.98571429],\n", + " [0.29564033, 0.73157895, 1. ],\n", + " [0.20790191, 0.8125 , 0.87142857],\n", + " [0.1027248 , 0.90789474, 1. ],\n", + " [0. , 1. , 0.97142857]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.0312256 , 0.85023041, 0.92957746],\n", + " [0.06713505, 0.70766129, 0.94366197],\n", + " [0.12021858, 0.57517281, 0.91549296],\n", + " [0.19203747, 0.4593894 , 0.94366197],\n", + " [0.29000781, 0.36837558, 0.85915493],\n", + " [0.42935207, 0.30645161, 0.97183099],\n", + " [0.58235753, 0.24193548, 1. ],\n", + " [0.73497268, 0.17108295, 0.98591549],\n", + " [0.88290398, 0.09331797, 0.98591549],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89893914, 0.88740617, 0.875 ],\n", + " [0.80374093, 0.77898249, 0.875 ],\n", + " [0.71580123, 0.68306922, 0.7625 ],\n", + " [0.61418202, 0.58131776, 0.875 ],\n", + " [0.50083752, 0.46872394, 1. ],\n", + " [0.40061418, 0.36864053, 0.85 ],\n", + " [0.29927415, 0.26605505, 0.8875 ],\n", + " [0.20156337, 0.17431193, 0.8875 ],\n", + " [0.09631491, 0.08340284, 0.875 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.0946715 , 0.92010444, 0.95522388],\n", + " [0.19503363, 0.83916449, 0.98507463],\n", + " [0.29591309, 0.75587467, 1. ],\n", + " [0.37144335, 0.67023499, 0.95522388],\n", + " [0.43455768, 0.58328982, 0.94029851],\n", + " [0.50336265, 0.48955614, 1. ],\n", + " [0.57578893, 0.40469974, 0.94029851],\n", + " [0.64769788, 0.32140992, 0.94029851],\n", + " [0.72995344, 0.23603133, 0.95522388],\n", + " [0.81376099, 0.15665796, 0.94029851],\n", + " [0.90481117, 0.07754569, 0.94029851],\n", + " [1. , 0. , 0.94029851]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87419769, 0.12661969, 0.98507463],\n", + " [0.74967908, 0.24960218, 0.97014925],\n", + " [0.63157895, 0.37599454, 1. ],\n", + " [0.50834403, 0.49943169, 0.98507463],\n", + " [0.38510911, 0.62400546, 0.98507463],\n", + " [0.2593068 , 0.74903387, 0.98507463],\n", + " [0.13478819, 0.87383496, 0.98507463],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13116016, 0.13471503, 0.91 ],\n", + " [0.27900411, 0.27875648, 1. ],\n", + " [0.3798768 , 0.37823834, 0.68 ],\n", + " [0.48459959, 0.48393782, 0.72 ],\n", + " [0.58957906, 0.58756477, 0.69 ],\n", + " [0.68942505, 0.69222798, 0.69 ],\n", + " [0.81211499, 0.8134715 , 0.8 ],\n", + " [0.89938398, 0.8984456 , 0.62 ],\n", + " [1. , 1. , 0.68 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.06137184, 0.91177206, 0.76666667],\n", + " [0.12274368, 0.82654336, 0.76666667],\n", + " [0.18411552, 0.73406648, 0.78888889],\n", + " [0.27797834, 0.61934516, 1. ],\n", + " [0.38628159, 0.52836791, 0.77777778],\n", + " [0.50541516, 0.43964009, 0.77777778],\n", + " [0.60649819, 0.35016246, 0.77777778],\n", + " [0.70758123, 0.26018495, 0.76666667],\n", + " [0.79061372, 0.18395401, 0.67777778],\n", + " [0.89530686, 0.09297676, 0.76666667],\n", + " [1. , 0. , 0.8 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89785992, 0.10197817, 1. ],\n", + " [0.80058366, 0.19815825, 0.98591549],\n", + " [0.70071336, 0.29774898, 0.97183099],\n", + " [0.59954604, 0.39938608, 0.98591549],\n", + " [0.5 , 0.49965894, 0.98591549],\n", + " [0.40175097, 0.59856753, 1. ],\n", + " [0.30220493, 0.69884038, 0.97183099],\n", + " [0.20201038, 0.79911323, 0.98591549],\n", + " [0.10149157, 0.89904502, 0.98591549],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91031693, 0.89806212, 0.91428571],\n", + " [0.82063385, 0.78762941, 1. ],\n", + " [0.73027647, 0.67693125, 0.98571429],\n", + " [0.65205664, 0.58401911, 0.87142857],\n", + " [0.56169926, 0.48659411, 0.9 ],\n", + " [0.44976399, 0.38492169, 0.94285714],\n", + " [0.33715442, 0.29652243, 0.88571429],\n", + " [0.2137559 , 0.19033714, 0.97142857],\n", + " [0.10114633, 0.09742501, 0.91428571],\n", + " [0. , 0. , 0.9 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12722989, 0.12621359, 1. ],\n", + " [0.24503534, 0.24271845, 0.92424242],\n", + " [0.37125547, 0.36997226, 1. ],\n", + " [0.49680242, 0.49653259, 1. ],\n", + " [0.62302255, 0.62309293, 1. ],\n", + " [0.74890609, 0.74965326, 1. ],\n", + " [0.87546281, 0.87552011, 1. ],\n", + " [1. , 1. , 0.98484848]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.16876122, 0.82142857, 0.91666667],\n", + " [0.33290587, 0.65 , 0.91666667],\n", + " [0.49705053, 0.48571429, 0.90277778],\n", + " [0.64939728, 0.34285714, 0.84722222],\n", + " [0.8181585 , 0.17142857, 0.91666667],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08724832, 0.10430892, 0.7752809 ],\n", + " [0.1901566 , 0.21497528, 0.79775281],\n", + " [0.3064877 , 0.32258065, 0.78651685],\n", + " [0.42505593, 0.42971509, 0.78651685],\n", + " [0.54138702, 0.53732046, 0.78651685],\n", + " [0.64653244, 0.64516129, 0.78651685],\n", + " [0.78747204, 0.78172828, 1. ],\n", + " [0.89261745, 0.89004003, 0.78651685],\n", + " [1. , 1. , 0.79775281]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.93250359, 0.89351082, 0.97142857],\n", + " [0.87266635, 0.80057048, 0.88571429],\n", + " [0.80469124, 0.69954837, 1. ],\n", + " [0.73623743, 0.60446874, 0.98571429],\n", + " [0.64528483, 0.52151177, 1. ],\n", + " [0.53853518, 0.44877585, 1. ],\n", + " [0.43178554, 0.37794153, 1. ],\n", + " [0.32072762, 0.3075826 , 1. ],\n", + " [0.22211584, 0.24696934, 0.87142857],\n", + " [0.11488751, 0.17161873, 0.97142857],\n", + " [0.03973193, 0.09531733, 0.88571429],\n", + " [0. , 0. , 0.98571429]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85641244, 0.85544267, 0.98507463],\n", + " [0.70941628, 0.70798258, 0.97014925],\n", + " [0.56838517, 0.56806967, 1. ],\n", + " [0.42394546, 0.42351234, 0.98507463],\n", + " [0.28845334, 0.28795356, 0.98507463],\n", + " [0.13634427, 0.13642961, 0.98507463],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91449275, 0.9394166 , 0.59166667],\n", + " [0.82985507, 0.87808527, 0.575 ],\n", + " [0.74550725, 0.81226627, 0.59166667],\n", + " [0.65101449, 0.72849663, 0.65833333],\n", + " [0.50869565, 0.57217651, 1. ],\n", + " [0.42434783, 0.47718773, 0.58333333],\n", + " [0.34144928, 0.38444278, 0.59166667],\n", + " [0.26 , 0.29244577, 0.575 ],\n", + " [0.16608696, 0.18698579, 0.66666667],\n", + " [0.08492754, 0.09498878, 0.575 ],\n", + " [0. , 0. , 0.59166667]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.10954151, 0.86764706, 0.91666667],\n", + " [0.21933086, 0.76470588, 0.91666667],\n", + " [0.32887237, 0.67647059, 0.91666667],\n", + " [0.44039653, 0.55882353, 0.93055556],\n", + " [0.56009913, 0.42647059, 1. ],\n", + " [0.66815366, 0.29411765, 0.90277778],\n", + " [0.77992565, 0.19117647, 0.93055556],\n", + " [0.888228 , 0.11764706, 0.90277778],\n", + " [1. , 0. , 0.93055556]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88925895, 0.8981209 , 0.98591549],\n", + " [0.76519567, 0.79986416, 0.97183099],\n", + " [0.65445462, 0.69979624, 1. ],\n", + " [0.53039134, 0.59769074, 0.97183099],\n", + " [0.41798501, 0.4996604 , 0.98591549],\n", + " [0.29641965, 0.40095087, 1. ],\n", + " [0.20732723, 0.29816618, 0.95774648],\n", + " [0.15237302, 0.20760697, 0.85915493],\n", + " [0.06827644, 0.10572787, 0.97183099],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10995542, 0.0775463 , 0.58333333],\n", + " [0.31352155, 0.19837963, 0.91666667],\n", + " [0.45319465, 0.2875 , 0.65833333],\n", + " [0.57206538, 0.36759259, 0.6 ],\n", + " [0.72659733, 0.47731481, 0.83333333],\n", + " [0.90044577, 0.58958333, 0.825 ],\n", + " [0.97028232, 0.65601852, 0.50833333],\n", + " [1. , 0.75601852, 0.73333333],\n", + " [0.90936107, 0.89907407, 1. ],\n", + " [0.80832095, 1. , 0.675 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9106652 , 0.91666667, 0.8875 ],\n", + " [0.81913139, 0.82564103, 0.875 ],\n", + " [0.73062122, 0.72179487, 0.875 ],\n", + " [0.62699285, 0.61282051, 1. ],\n", + " [0.5371083 , 0.5474359 , 0.875 ],\n", + " [0.44832325, 0.46025641, 0.8625 ],\n", + " [0.35816383, 0.3525641 , 0.8875 ],\n", + " [0.2680044 , 0.25769231, 0.875 ],\n", + " [0.17921935, 0.18589744, 0.8625 ],\n", + " [0.0893348 , 0.10384615, 0.875 ],\n", + " [0. , 0. , 0.8875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11616572, 0.88108614, 1. ],\n", + " [0.23206066, 0.76310861, 1. ],\n", + " [0.3463309 , 0.64794007, 0.98571429],\n", + " [0.4486867 , 0.54868914, 0.88571429],\n", + " [0.56566477, 0.43164794, 0.98571429],\n", + " [0.66558354, 0.33146067, 0.87142857],\n", + " [0.78012456, 0.21722846, 0.97142857],\n", + " [0.88058489, 0.1170412 , 0.87142857],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92243187, 0.94441871, 0.98591549],\n", + " [0.84696017, 0.88906901, 0.98591549],\n", + " [0.77358491, 0.83441408, 0.97183099],\n", + " [0.69601677, 0.77813803, 0.98591549],\n", + " [0.62683438, 0.72255674, 1. ],\n", + " [0.5639413 , 0.66581751, 1. ],\n", + " [0.50314465, 0.60954145, 0.98591549],\n", + " [0.45073375, 0.55349699, 0.97183099],\n", + " [0.39622642, 0.49675776, 0.98591549],\n", + " [0.34591195, 0.44001853, 0.97183099],\n", + " [0.29350105, 0.3832793 , 0.98591549],\n", + " [0.24947589, 0.3258453 , 1. ],\n", + " [0.20754717, 0.27721167, 0.85915493],\n", + " [0.16771488, 0.22163038, 0.95774648],\n", + " [0.12997904, 0.17392311, 0.85915493],\n", + " [0.09224319, 0.1167207 , 0.97183099],\n", + " [0.04192872, 0.05882353, 1. ],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89975213, 0.89925373, 0.97222222],\n", + " [0.79399614, 0.80410448, 1. ],\n", + " [0.69429909, 0.67910448, 0.95833333],\n", + " [0.60258882, 0.59141791, 0.84722222],\n", + " [0.50179014, 0.49626866, 0.95833333],\n", + " [0.41448637, 0.40485075, 0.84722222],\n", + " [0.31065822, 0.30783582, 0.97222222],\n", + " [0.20655467, 0.18656716, 0.95833333],\n", + " [0.10355274, 0.08955224, 0.97222222],\n", + " [0. , 0. , 0.98611111]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10188473, 0.38461538, 0.85185185],\n", + " [0.19011199, 0.78021978, 0.75308642],\n", + " [0.3045616 , 1. , 0.98765432],\n", + " [0.40590003, 0.92307692, 0.86419753],\n", + " [0.50450697, 0.91208791, 0.86419753],\n", + " [0.60010926, 0.89010989, 0.85185185],\n", + " [0.71483201, 0.75824176, 1. ],\n", + " [0.80223983, 0.69230769, 0.75308642],\n", + " [0.90084676, 0.54945055, 0.85185185],\n", + " [1. , 0.47252747, 0.87654321]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14216282, 0.14292301, 0.98507463],\n", + " [0.2855407 , 0.28446289, 0.98507463],\n", + " [0.42648846, 0.42369756, 0.98507463],\n", + " [0.56136087, 0.56569848, 0.98507463],\n", + " [0.70959903, 0.71069617, 0.98507463],\n", + " [0.85783718, 0.8526971 , 0.98507463],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12199264, 0.13542795, 0.93055556],\n", + " [0.25870365, 0.28494041, 1. ],\n", + " [0.38126238, 0.40520043, 0.91666667],\n", + " [0.50325502, 0.54279523, 0.91666667],\n", + " [0.62666289, 0.66413868, 0.91666667],\n", + " [0.75035381, 0.77789816, 0.90277778],\n", + " [0.87630909, 0.89057421, 0.91666667],\n", + " [1. , 1. , 0.93055556]]),\n", + " array([[0.13333333, 0. , 0. ],\n", + " [0.06666667, 0.10958276, 0.98591549],\n", + " [0.4 , 0.22077029, 0.98591549],\n", + " [0.53333333, 0.33402109, 0.98591549],\n", + " [0.53333333, 0.44360385, 0.98591549],\n", + " [0.8 , 0.55479138, 0.97183099],\n", + " [1. , 0.66712517, 1. ],\n", + " [0.86666667, 0.77624943, 0.98591549],\n", + " [0.46666667, 0.88766621, 0.98591549],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16368013, 0.17495987, 0.90410959],\n", + " [0.32789516, 0.34028892, 0.90410959],\n", + " [0.4947847 , 0.50561798, 0.90410959],\n", + " [0.65792993, 0.66292135, 0.90410959],\n", + " [0.82187751, 0.82504013, 0.89041096],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09802877, 0.91176471, 0.78888889],\n", + " [0.19072989, 0.80882353, 0.75555556],\n", + " [0.28875866, 0.72794118, 0.78888889],\n", + " [0.41182738, 0.64705882, 0.98888889],\n", + " [0.50932339, 0.52941176, 0.78888889],\n", + " [0.63345765, 0.41911765, 1. ],\n", + " [0.72935535, 0.32352941, 0.77777778],\n", + " [0.82285562, 0.22058824, 0.76666667],\n", + " [0.90463506, 0.08823529, 0.67777778],\n", + " [1. , 0. , 0.78888889]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11344853, 0.88550186, 0.55 ],\n", + " [0.22238918, 0.77348203, 0.55 ],\n", + " [0.34109692, 0.65254027, 0.59166667],\n", + " [0.45229151, 0.54027261, 0.55 ],\n", + " [0.56799399, 0.42552664, 0.55833333],\n", + " [0.68069121, 0.31449814, 0.54166667],\n", + " [0.79413974, 0.20272615, 0.55 ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12194488, 0.12121212, 0.91666667],\n", + " [0.2574103 , 0.25575758, 1. ],\n", + " [0.38117525, 0.38181818, 0.90277778],\n", + " [0.50468019, 0.50545455, 0.93055556],\n", + " [0.62844514, 0.63030303, 0.91666667],\n", + " [0.75195008, 0.75393939, 0.91666667],\n", + " [0.87597504, 0.87757576, 0.90277778],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8551049 , 0.14726027, 0.90410959],\n", + " [0.71440559, 0.28938356, 0.89041096],\n", + " [0.55832168, 0.45034247, 1. ],\n", + " [0.41538462, 0.59246575, 0.89041096],\n", + " [0.28559441, 0.72089041, 0.83561644],\n", + " [0.14265734, 0.86130137, 0.89041096],\n", + " [0. , 1. , 0.90410959]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11288292, 0.1053818 , 0.88607595],\n", + " [0.22408728, 0.21301775, 0.86075949],\n", + " [0.33780948, 0.32544379, 0.89873418],\n", + " [0.44901385, 0.43702451, 0.87341772],\n", + " [0.56063785, 0.54860524, 0.89873418],\n", + " [0.68443139, 0.67540152, 1. ],\n", + " [0.78136802, 0.77345731, 0.7721519 ],\n", + " [0.88921527, 0.88503804, 0.87341772],\n", + " [1. , 1. , 0.89873418]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08492569, 0.09134731, 1. ],\n", + " [0.17409766, 0.18028441, 0.97183099],\n", + " [0.26326964, 0.27235478, 1. ],\n", + " [0.35244161, 0.36249699, 0.97183099],\n", + " [0.43949045, 0.45336226, 0.98591549],\n", + " [0.52866242, 0.54302242, 0.98591549],\n", + " [0.62420382, 0.63557484, 0.98591549],\n", + " [0.71762208, 0.72644011, 0.98591549],\n", + " [0.80679406, 0.81610027, 0.98591549],\n", + " [0.90233546, 0.90841167, 0.98591549],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89164905, 0.89003055, 0.875 ],\n", + " [0.78171247, 0.78033879, 0.875 ],\n", + " [0.6717759 , 0.67092474, 0.875 ],\n", + " [0.56342495, 0.56289919, 0.8625 ],\n", + " [0.45454545, 0.45348514, 0.875 ],\n", + " [0.34302326, 0.34296029, 0.9 ],\n", + " [0.21934461, 0.21993891, 0.975 ],\n", + " [0.09513742, 0.09497362, 1. ],\n", + " [0. , 0. , 0.7625 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87603306, 0.11446819, 0.98591549],\n", + " [0.74655647, 0.22647998, 1. ],\n", + " [0.64187328, 0.33971997, 0.98591549],\n", + " [0.55096419, 0.45001228, 0.95774648],\n", + " [0.4600551 , 0.54728568, 0.85915493],\n", + " [0.31404959, 0.66077131, 1. ],\n", + " [0.19008264, 0.77425694, 0.98591549],\n", + " [0.1046832 , 0.88749693, 0.98591549],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09632446, 0.09997369, 0.85915493],\n", + " [0.21863118, 0.21652197, 0.97183099],\n", + " [0.33586819, 0.33017627, 0.97183099],\n", + " [0.44803549, 0.44330439, 1. ],\n", + " [0.57034221, 0.56116811, 0.97183099],\n", + " [0.68948035, 0.67640095, 0.98591549],\n", + " [0.78453739, 0.77821626, 0.85915493],\n", + " [0.89797212, 0.89871087, 0.98591549],\n", + " [1. , 1. , 0.85915493]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.81282496, 0.80597015, 1. ],\n", + " [0.67764298, 0.67116797, 0.69651741],\n", + " [0.59965338, 0.59369818, 0.39303483],\n", + " [0.51299827, 0.50698887, 0.44776119],\n", + " [0.45060659, 0.44065387, 0.34825871],\n", + " [0.32235702, 0.30514096, 0.69651741],\n", + " [0.23916811, 0.2283819 , 0.39800995],\n", + " [0.16984402, 0.1596778 , 0.35323383],\n", + " [0. , 0. , 0.84079602]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09215686, 0.09499264, 1. ],\n", + " [0.18235294, 0.18630339, 0.98591549],\n", + " [0.27310924, 0.27540501, 0.97183099],\n", + " [0.36694678, 0.37776141, 1. ],\n", + " [0.45910364, 0.47790869, 0.98591549],\n", + " [0.55182073, 0.56553756, 0.97183099],\n", + " [0.62997199, 0.6377025 , 0.85915493],\n", + " [0.72240896, 0.73637703, 0.98591549],\n", + " [0.81512605, 0.82842415, 0.98591549],\n", + " [0.90756303, 0.91531664, 0.98591549],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11954023, 0.11458594, 0.8452381 ],\n", + " [0.2316092 , 0.22316738, 0.79761905],\n", + " [0.36781609, 0.35951964, 1. ],\n", + " [0.5045977 , 0.49487115, 1. ],\n", + " [0.64195402, 0.62997248, 1. ],\n", + " [0.75977011, 0.74555917, 0.85714286],\n", + " [0.88103448, 0.87140355, 0.92857143],\n", + " [1. , 1. , 0.92857143]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90452962, 0.91005724, 0.75824176],\n", + " [0.80905923, 0.82038703, 0.76923077],\n", + " [0.71428571, 0.73017171, 0.76923077],\n", + " [0.61811847, 0.63750341, 0.78021978],\n", + " [0.51986063, 0.5448351 , 0.75824176],\n", + " [0.40627178, 0.43663123, 0.87912088],\n", + " [0.28083624, 0.31452712, 1. ],\n", + " [0.16724739, 0.20496048, 0.87912088],\n", + " [0.06968641, 0.11147452, 0.75824176],\n", + " [0. , 0. , 0.87912088]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89868825, 0.8994614 , 0.97222222],\n", + " [0.79877198, 0.7989228 , 0.97222222],\n", + " [0.69718113, 0.69928187, 0.97222222],\n", + " [0.59921853, 0.60502693, 0.97222222],\n", + " [0.50153503, 0.50628366, 0.97222222],\n", + " [0.40106056, 0.3967684 , 0.95833333],\n", + " [0.30142339, 0.30071813, 1. ],\n", + " [0.20318169, 0.2010772 , 0.95833333],\n", + " [0.1046609 , 0.09874327, 0.95833333],\n", + " [0. , 0. , 0.98611111]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12967844, 0.12897727, 0.78217822],\n", + " [0.29098577, 0.29034091, 1. ],\n", + " [0.40379547, 0.40340909, 0.69306931],\n", + " [0.53083817, 0.53096591, 0.78217822],\n", + " [0.64575646, 0.64744318, 0.7029703 ],\n", + " [0.75751186, 0.75880682, 0.68316832],\n", + " [0.87084871, 0.87130682, 0.7029703 ],\n", + " [1. , 1. , 0.78217822]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.9375 , 0.08505155, 0.98591549],\n", + " [0.86299435, 0.16899853, 0.98591549],\n", + " [0.78425141, 0.25036819, 1. ],\n", + " [0.70550847, 0.32768778, 0.95774648],\n", + " [0.62535311, 0.4039028 , 1. ],\n", + " [0.55120056, 0.4808542 , 0.97183099],\n", + " [0.47316384, 0.56001473, 1. ],\n", + " [0.39371469, 0.63917526, 0.98591549],\n", + " [0.32485876, 0.70765832, 0.85915493],\n", + " [0.24435028, 0.78755523, 0.97183099],\n", + " [0.1634887 , 0.86782032, 0.97183099],\n", + " [0.07733051, 0.93888071, 0.98591549],\n", + " [0. , 1. , 0.85915493]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8697101 , 0.12604522, 1. ],\n", + " [0.74508497, 0.25147104, 0.98507463],\n", + " [0.62179274, 0.38216166, 0.98507463],\n", + " [0.4985005 , 0.51316197, 0.97014925],\n", + " [0.36987671, 0.63765872, 0.98507463],\n", + " [0.25158281, 0.74914834, 0.91044776],\n", + " [0.1242919 , 0.8733354 , 0.98507463],\n", + " [0. , 1. , 0.97014925]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.01102589, 0.98979592, 0.21935484],\n", + " [0.02636625, 0.97667638, 0.29354839],\n", + " [0.0388303 , 0.96618076, 0.22903226],\n", + " [0.05656759, 0.95014577, 0.3516129 ],\n", + " [0.06855225, 0.93731778, 0.22903226],\n", + " [0.084372 , 0.92536443, 0.32258065],\n", + " [0.0949185 , 0.91516035, 0.22258065],\n", + " [0.10834132, 0.90437318, 0.22903226],\n", + " [0.1198466 , 0.8941691 , 0.22580645],\n", + " [0.13566635, 0.88104956, 0.29032258],\n", + " [0.14860978, 0.87172012, 0.22580645],\n", + " [0.16059444, 0.86122449, 0.22580645],\n", + " [0.17066155, 0.85131195, 0.22580645],\n", + " [0.18264621, 0.84110787, 0.22258065],\n", + " [0.19558965, 0.83002915, 0.26129032],\n", + " [0.21955896, 0.80962099, 0.41935484],\n", + " [0.2325024 , 0.79883382, 0.22580645],\n", + " [0.26366251, 0.77376093, 0.5483871 ],\n", + " [0.27708533, 0.76209913, 0.22580645],\n", + " [0.29050815, 0.74927114, 0.25483871],\n", + " [0.30920422, 0.73381924, 0.32580645],\n", + " [0.31208054, 0.7212828 , 0.25806452],\n", + " [0.32502397, 0.71049563, 0.22580645],\n", + " [0.3451582 , 0.69941691, 0.22580645],\n", + " [0.35522531, 0.68804665, 0.22258065],\n", + " [0.37296261, 0.67609329, 0.22903226],\n", + " [0.38398849, 0.66618076, 0.22258065],\n", + " [0.3978907 , 0.65451895, 0.22580645],\n", + " [0.41754554, 0.6361516 , 0.38709677],\n", + " [0.42905081, 0.62536443, 0.22903226],\n", + " [0.4400767 , 0.6148688 , 0.22580645],\n", + " [0.45206136, 0.60408163, 0.22258065],\n", + " [0.46788111, 0.58950437, 0.29354839],\n", + " [0.47986577, 0.57842566, 0.22580645],\n", + " [0.49616491, 0.5638484 , 0.28709677],\n", + " [0.5071908 , 0.55306122, 0.22903226],\n", + " [0.53259827, 0.53061224, 0.4516129 ],\n", + " [0.55608821, 0.51078717, 0.38709677],\n", + " [0.56615532, 0.49825073, 0.22580645],\n", + " [0.57670182, 0.48658892, 0.22580645],\n", + " [0.58868648, 0.47434402, 0.21935484],\n", + " [0.60306807, 0.46355685, 0.23225806],\n", + " [0.61649089, 0.44664723, 0.29032258],\n", + " [0.63279003, 0.43294461, 0.25483871],\n", + " [0.65340364, 0.41457726, 0.35483871],\n", + " [0.6653883 , 0.4 , 0.25806452],\n", + " [0.68120805, 0.38396501, 0.29354839],\n", + " [0.71332694, 0.35247813, 0.60967742],\n", + " [0.7325024 , 0.33061224, 0.41935484],\n", + " [0.75263663, 0.31020408, 0.38709677],\n", + " [0.76845638, 0.29067055, 0.38709677],\n", + " [0.78619367, 0.27113703, 0.35806452],\n", + " [0.80105465, 0.25510204, 0.29032258],\n", + " [0.81303931, 0.24169096, 0.25806452],\n", + " [0.82358581, 0.22886297, 0.22580645],\n", + " [0.83652924, 0.21690962, 0.22580645],\n", + " [0.84659636, 0.20466472, 0.22258065],\n", + " [0.86529243, 0.18134111, 0.42258065],\n", + " [0.87631831, 0.16909621, 0.22580645],\n", + " [0.8873442 , 0.15714286, 0.22580645],\n", + " [0.90747843, 0.13323615, 0.4483871 ],\n", + " [0.91946309, 0.1180758 , 0.29354839],\n", + " [0.93384468, 0.09883382, 0.38709677],\n", + " [0.9472675 , 0.08804665, 0.22580645],\n", + " [0.95541707, 0.07638484, 0.22580645],\n", + " [0.96260786, 0.06472303, 0.22258065],\n", + " [0.96883988, 0.05364431, 0.22580645],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91173521, 0.8968254 , 0.87341772],\n", + " [0.82372116, 0.8042328 , 0.87341772],\n", + " [0.74648947, 0.71957672, 0.7721519 ],\n", + " [0.64368104, 0.62433862, 1. ],\n", + " [0.55115346, 0.53439153, 0.91139241],\n", + " [0.46288867, 0.44179894, 0.88607595],\n", + " [0.37261785, 0.34920635, 0.87341772],\n", + " [0.28284855, 0.27777778, 0.88607595],\n", + " [0.19257773, 0.18783069, 0.88607595],\n", + " [0.10205617, 0.1005291 , 0.89873418],\n", + " [0. , 0. , 0.98734177]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14301192, 0.14224781, 1. ],\n", + " [0.28060672, 0.28300277, 1. ],\n", + " [0.41928494, 0.42653018, 1. ],\n", + " [0.56554713, 0.57005758, 1. ],\n", + " [0.72372698, 0.71251866, 1. ],\n", + " [0.86457205, 0.85604607, 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87430684, 0.132287 , 0.98484848],\n", + " [0.75547927, 0.24663677, 0.92424242],\n", + " [0.62661738, 0.37892377, 1. ],\n", + " [0.49907579, 0.5044843 , 0.98484848],\n", + " [0.37919197, 0.61883408, 0.92424242],\n", + " [0.24900977, 0.75112108, 1. ],\n", + " [0.12094006, 0.87443946, 0.98484848],\n", + " [0. , 1. , 0.92424242]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10354331, 0.10197869, 1. ],\n", + " [0.20314961, 0.20395738, 0.95833333],\n", + " [0.30314961, 0.30715373, 0.95833333],\n", + " [0.40472441, 0.41065449, 0.98611111],\n", + " [0.50551181, 0.50837139, 0.95833333],\n", + " [0.59645669, 0.59452055, 0.86111111],\n", + " [0.7 , 0.69315068, 0.95833333],\n", + " [0.8003937 , 0.79299848, 0.97222222],\n", + " [0.9003937 , 0.89497717, 0.97222222],\n", + " [1. , 1. , 0.97222222]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.83898305, 0.84104628, 1. ],\n", + " [0.74152542, 0.7444668 , 0.61616162],\n", + " [0.5960452 , 0.6004599 , 0.90909091],\n", + " [0.48399247, 0.48950848, 0.6969697 ],\n", + " [0.36723164, 0.37338316, 0.71717172],\n", + " [0.22363465, 0.2282265 , 0.8989899 ],\n", + " [0.11393597, 0.1167002 , 0.71717172],\n", + " [0. , 0. , 0.71717172]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.23364486, 0.23500612, 1. ],\n", + " [0.45794393, 0.4626683 , 0.94 ],\n", + " [0.59813084, 0.6004896 , 0.59333333],\n", + " [0.70654206, 0.71113831, 0.46666667],\n", + " [0.85420561, 0.85434517, 0.6 ],\n", + " [1. , 1. , 0.60666667]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.94292453, 0.04454148, 0.87341772],\n", + " [0.87924528, 0.09723435, 0.88607595],\n", + " [0.82358491, 0.13275109, 0.88607595],\n", + " [0.75896226, 0.18427948, 0.88607595],\n", + " [0.70188679, 0.22066958, 0.89873418],\n", + " [0.63820755, 0.26055313, 0.88607595],\n", + " [0.56650943, 0.3062591 , 1. ],\n", + " [0.50849057, 0.35283843, 0.7721519 ],\n", + " [0.44858491, 0.39388646, 0.86075949],\n", + " [0.38773585, 0.42649199, 0.88607595],\n", + " [0.32830189, 0.46870451, 0.89873418],\n", + " [0.26462264, 0.51120815, 0.88607595],\n", + " [0.21792453, 0.56040757, 0.89873418],\n", + " [0.18632075, 0.6154294 , 0.88607595],\n", + " [0.16132075, 0.66870451, 0.86075949],\n", + " [0.13443396, 0.72489083, 0.89873418],\n", + " [0.10566038, 0.77962154, 0.88607595],\n", + " [0.08207547, 0.82852984, 0.7721519 ],\n", + " [0.05377358, 0.88471616, 0.87341772],\n", + " [0.02830189, 0.94061135, 0.88607595],\n", + " [0. , 1. , 0.88607595]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12772074, 0.87162162, 0.72619048],\n", + " [0.26406571, 0.73519949, 0.77380952],\n", + " [0.38809035, 0.60875161, 0.72619048],\n", + " [0.5301848 , 0.46846847, 0.78571429],\n", + " [0.68049281, 0.31885457, 0.85714286],\n", + " [0.85913758, 0.14189189, 1. ],\n", + " [1. , 0. , 0.78571429]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90033138, 0.11888112, 0.875 ],\n", + " [0.80168239, 0.2027972 , 0.875 ],\n", + " [0.6997196 , 0.27972028, 0.875 ],\n", + " [0.60183533, 0.39160839, 0.8625 ],\n", + " [0.49987255, 0.51748252, 0.8875 ],\n", + " [0.40020393, 0.59440559, 0.8625 ],\n", + " [0.29926077, 0.70629371, 0.875 ],\n", + " [0.18429773, 0.83916084, 1. ],\n", + " [0.08564874, 0.93006993, 0.8625 ],\n", + " [0. , 1. , 0.7625 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91891892, 0.91747688, 0.95833333],\n", + " [0.84324324, 0.84443917, 0.84722222],\n", + " [0.75675676, 0.76025611, 0.97222222],\n", + " [0.67297297, 0.67725871, 0.95833333],\n", + " [0.58108108, 0.59283851, 0.98611111],\n", + " [0.4972973 , 0.50652122, 0.97222222],\n", + " [0.41351351, 0.42281243, 0.95833333],\n", + " [0.32702703, 0.33696941, 0.98611111],\n", + " [0.24324324, 0.25420915, 0.95833333],\n", + " [0.15675676, 0.16836614, 0.97222222],\n", + " [0.07567568, 0.08252312, 1. ],\n", + " [0. , 0. , 0.94444444]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90151515, 0.88947118, 0.94444444],\n", + " [0.80606061, 0.791091 , 0.86111111],\n", + " [0.67424242, 0.67937113, 0.95833333],\n", + " [0.55757576, 0.56788947, 0.97222222],\n", + " [0.44242424, 0.45545498, 0.95833333],\n", + " [0.33181818, 0.3406384 , 1. ],\n", + " [0.22121212, 0.22868032, 0.94444444],\n", + " [0.10757576, 0.11362554, 1. ],\n", + " [0. , 0. , 0.95833333]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90951743, 0.0944217 , 0.75308642],\n", + " [0.80093834, 0.20061412, 0.86419753],\n", + " [0.69369973, 0.30962129, 0.86419753],\n", + " [0.5730563 , 0.43091095, 0.98765432],\n", + " [0.44705094, 0.55552712, 0.98765432],\n", + " [0.3424933 , 0.66248721, 0.86419753],\n", + " [0.23324397, 0.76970317, 0.85185185],\n", + " [0.10656836, 0.89406346, 1. ],\n", + " [0. , 1. , 0.85185185]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12021247, 0.12688442, 0.87142857],\n", + " [0.25552139, 0.26507538, 1. ],\n", + " [0.37517473, 0.37939698, 0.88571429],\n", + " [0.49482807, 0.49371859, 0.88571429],\n", + " [0.62566396, 0.62562814, 0.98571429],\n", + " [0.74531731, 0.74120603, 0.87142857],\n", + " [0.88034666, 0.87562814, 1. ],\n", + " [1. , 1. , 0.88571429]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89207868, 0.12365591, 0.86419753],\n", + " [0.78495481, 0.23655914, 0.85185185],\n", + " [0.66214779, 0.37096774, 1. ],\n", + " [0.54093567, 0.48924731, 0.97530864],\n", + " [0.43168527, 0.58602151, 0.87654321],\n", + " [0.32402977, 0.67741935, 0.85185185],\n", + " [0.2169059 , 0.77956989, 0.86419753],\n", + " [0.10712387, 0.87634409, 0.87654321],\n", + " [0. , 1. , 0.86419753]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11139896, 0.86465993, 0.79856115],\n", + " [0.2253886 , 0.75505515, 0.64748201],\n", + " [0.33160622, 0.65877757, 0.56834532],\n", + " [0.42487047, 0.5714614 , 0.51798561],\n", + " [0.51036269, 0.48690257, 0.50359712],\n", + " [0.60362694, 0.38901654, 0.56834532],\n", + " [0.68393782, 0.3046875 , 0.49640288],\n", + " [0.81865285, 0.16888787, 0.79856115],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90065862, 0.90753425, 1. ],\n", + " [0.79802415, 0.79794521, 0.98591549],\n", + " [0.69978046, 0.70205479, 0.98591549],\n", + " [0.60373216, 0.62157534, 0.95774648],\n", + " [0.50274424, 0.51369863, 1. ],\n", + " [0.40257958, 0.40410959, 0.97183099],\n", + " [0.30159166, 0.30479452, 1. ],\n", + " [0.201427 , 0.20376712, 0.98591549],\n", + " [0.09906696, 0.09760274, 1. ],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87821483, 0.11592179, 0.91666667],\n", + " [0.75642965, 0.23184358, 0.93055556],\n", + " [0.63035804, 0.37150838, 0.90277778],\n", + " [0.49571357, 0.48882682, 1. ],\n", + " [0.37392839, 0.62849162, 0.91666667],\n", + " [0.24659607, 0.7472067 , 0.93055556],\n", + " [0.12607161, 0.88407821, 0.90277778],\n", + " [0. , 1. , 0.91666667]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89876808, 0.09226933, 0.97183099],\n", + " [0.79753615, 0.19118869, 1. ],\n", + " [0.69898232, 0.28512053, 0.98591549],\n", + " [0.59882164, 0.38320865, 0.98591549],\n", + " [0.49892876, 0.48295927, 0.98591549],\n", + " [0.39903589, 0.58187864, 0.98591549],\n", + " [0.29780396, 0.68661679, 0.98591549],\n", + " [0.1981789 , 0.7921862 , 0.98591549],\n", + " [0.09989288, 0.8960931 , 0.98591549],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8968254 , 0.89921671, 1. ],\n", + " [0.79470899, 0.79843342, 1. ],\n", + " [0.69259259, 0.69608355, 1. ],\n", + " [0.59365079, 0.59582245, 0.98571429],\n", + " [0.50634921, 0.50704961, 0.87142857],\n", + " [0.40687831, 0.40443864, 1. ],\n", + " [0.3037037 , 0.30261097, 1. ],\n", + " [0.2047619 , 0.20339426, 0.98571429],\n", + " [0.1015873 , 0.10208877, 1. ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.76241135, 0.17019667, 1. ],\n", + " [0.58156028, 0.33282905, 0.98507463],\n", + " [0.46453901, 0.50151286, 0.97014925],\n", + " [0.23404255, 0.67145739, 1. ],\n", + " [0.04964539, 0.82980333, 0.98507463],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11183879, 0.11057692, 0.93055556],\n", + " [0.22191436, 0.22115385, 0.90277778],\n", + " [0.33148615, 0.33052885, 0.91666667],\n", + " [0.44206549, 0.44711538, 0.91666667],\n", + " [0.55062972, 0.55769231, 0.90277778],\n", + " [0.64987406, 0.66105769, 0.84722222],\n", + " [0.77103275, 0.77644231, 1. ],\n", + " [0.87858942, 0.88341346, 0.91666667],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11026409, 0.10839786, 0.97183099],\n", + " [0.22025592, 0.2173913 , 0.98591549],\n", + " [0.33297032, 0.3305539 , 0.98591549],\n", + " [0.44541247, 0.44609887, 1. ],\n", + " [0.55676559, 0.55807028, 0.98591549],\n", + " [0.66648516, 0.66646814, 0.97183099],\n", + " [0.77919956, 0.77963073, 1. ],\n", + " [0.89028042, 0.89041096, 0.98591549],\n", + " [1. , 1. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91915593, 0.91686844, 0.85185185],\n", + " [0.83529734, 0.83454399, 0.87654321],\n", + " [0.74897232, 0.74818402, 0.87654321],\n", + " [0.66566183, 0.66343826, 0.86419753],\n", + " [0.58399562, 0.58353511, 0.83950617],\n", + " [0.51274322, 0.51089588, 0.75308642],\n", + " [0.42861058, 0.42211461, 0.86419753],\n", + " [0.34667032, 0.33898305, 0.86419753],\n", + " [0.26171554, 0.25504439, 0.86419753],\n", + " [0.18059742, 0.17191283, 0.85185185],\n", + " [0.09619074, 0.08878128, 0.87654321],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.20615634, 0.20499451, 1. ],\n", + " [0.3564196 , 0.35620198, 0.72527473],\n", + " [0.509113 , 0.50905598, 0.72527473],\n", + " [0.68489267, 0.685236 , 0.85714286],\n", + " [0.83556096, 0.83589462, 0.71428571],\n", + " [1. , 1. , 0.79120879]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09492386, 0.902267 , 0.85185185],\n", + " [0.20558376, 0.78916877, 0.98765432],\n", + " [0.30507614, 0.6884131 , 0.87654321],\n", + " [0.4035533 , 0.59118388, 0.85185185],\n", + " [0.51725888, 0.47732997, 1. ],\n", + " [0.61218274, 0.37808564, 0.86419753],\n", + " [0.70913706, 0.28060453, 0.85185185],\n", + " [0.8 , 0.19521411, 0.75308642],\n", + " [0.9035533 , 0.09874055, 0.85185185],\n", + " [1. , 0. , 0.86419753]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16400426, 0.16579634, 0.98507463],\n", + " [0.33013845, 0.32924282, 0.97014925],\n", + " [0.49574015, 0.50052219, 1. ],\n", + " [0.66453674, 0.66657963, 0.98507463],\n", + " [0.83226837, 0.83342037, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8155922 , 0.91096901, 0.98591549],\n", + " [0.64917541, 0.82046237, 1. ],\n", + " [0.47976012, 0.73290703, 0.98591549],\n", + " [0.31034483, 0.64731923, 0.98591549],\n", + " [0.13643178, 0.5627152 , 0.97183099],\n", + " [0.01349325, 0.47761928, 0.97183099],\n", + " [0. , 0.4021151 , 0.85915493],\n", + " [0.11994003, 0.32341367, 1. ],\n", + " [0.29835082, 0.25356616, 0.97183099],\n", + " [0.47976012, 0.18396458, 0.98591549],\n", + " [0.65367316, 0.11854402, 0.98591549],\n", + " [0.8035982 , 0.05853419, 1. ],\n", + " [0.95952024, 0. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92812142, 0.92900302, 0.75308642],\n", + " [0.84593356, 0.8489426 , 0.83950617],\n", + " [0.76088202, 0.76359517, 0.86419753],\n", + " [0.68900344, 0.69259819, 0.75308642],\n", + " [0.60538373, 0.60876133, 0.85185185],\n", + " [0.50859107, 0.51283988, 1. ],\n", + " [0.42754868, 0.4305136 , 0.85185185],\n", + " [0.33132875, 0.33383686, 1. ],\n", + " [0.24713631, 0.24697885, 0.86419753],\n", + " [0.16380298, 0.16314199, 0.86419753],\n", + " [0.08075601, 0.08006042, 0.86419753],\n", + " [0. , 0. , 0.85185185]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11434854, 0.11373093, 0.84722222],\n", + " [0.24793843, 0.24632455, 0.97222222],\n", + " [0.36558549, 0.36366158, 0.86111111],\n", + " [0.49917537, 0.49653259, 0.95833333],\n", + " [0.61462342, 0.61192788, 0.86111111],\n", + " [0.7482133 , 0.74674064, 0.97222222],\n", + " [0.88235294, 0.88321775, 1. ],\n", + " [1. , 1. , 0.86111111]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.94401042, 0.94427313, 0.85915493],\n", + " [0.87825521, 0.88017621, 0.98591549],\n", + " [0.81510417, 0.81674009, 0.98591549],\n", + " [0.75195312, 0.75242291, 0.97183099],\n", + " [0.68554688, 0.68722467, 1. ],\n", + " [0.62304688, 0.62290749, 0.98591549],\n", + " [0.56054688, 0.55969163, 0.98591549],\n", + " [0.49414062, 0.49625551, 0.97183099],\n", + " [0.44140625, 0.4407489 , 0.85915493],\n", + " [0.37630208, 0.37555066, 0.98591549],\n", + " [0.3125 , 0.31189427, 0.98591549],\n", + " [0.24934896, 0.24735683, 0.97183099],\n", + " [0.19270833, 0.19317181, 0.85915493],\n", + " [0.12825521, 0.12907489, 0.98591549],\n", + " [0.06575521, 0.06387665, 0.98591549],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.84090909, 0.15348451, 1. ],\n", + " [0.71948052, 0.26963496, 0.75824176],\n", + " [0.59545455, 0.38882743, 0.79120879],\n", + " [0.45194805, 0.52488938, 0.87912088],\n", + " [0.32987013, 0.64131637, 0.75824176],\n", + " [0.20584416, 0.75912611, 0.76923077],\n", + " [0.09545455, 0.87914823, 0.76923077],\n", + " [0. , 1. , 0.75824176]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88213024, 0.11742892, 0.73333333],\n", + " [0.71933367, 0.28059333, 1. ],\n", + " [0.60323069, 0.40049444, 0.73333333],\n", + " [0.48308935, 0.52533993, 0.73333333],\n", + " [0.36648157, 0.63658838, 0.73333333],\n", + " [0.24835941, 0.75648949, 0.73333333],\n", + " [0.11862696, 0.88380717, 0.78888889],\n", + " [0. , 1. , 0.73333333]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88578947, 0.92735043, 1. ],\n", + " [0.77631579, 0.78632479, 1. ],\n", + " [0.66210526, 0.71367521, 1. ],\n", + " [0.55842105, 0.57692308, 0.88571429],\n", + " [0.45157895, 0.42735043, 0.95714286],\n", + " [0.33763158, 0.35897436, 0.98571429],\n", + " [0.22263158, 0.20512821, 1. ],\n", + " [0.10947368, 0.07264957, 1. ],\n", + " [0. , 0. , 0.97142857]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85454545, 0.88110255, 0.95384615],\n", + " [0.74545455, 0.75426302, 0.98461538],\n", + " [0.65454545, 0.63116094, 0.95384615],\n", + " [0.51515152, 0.4998832 , 0.98461538],\n", + " [0.38181818, 0.38028498, 0.95384615],\n", + " [0.23030303, 0.25134314, 0.98461538],\n", + " [0.12121212, 0.1298762 , 0.93846154],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.07806081, 0.92176387, 0.86419753],\n", + " [0.18488085, 0.81564723, 1. ],\n", + " [0.26376335, 0.73456615, 0.85185185],\n", + " [0.34880855, 0.64921764, 0.86419753],\n", + " [0.42810189, 0.571266 , 0.87654321],\n", + " [0.50698439, 0.48790896, 0.85185185],\n", + " [0.58915366, 0.40625889, 0.86419753],\n", + " [0.68981101, 0.3086771 , 0.86419753],\n", + " [0.75472473, 0.24096728, 0.75308642],\n", + " [0.84182416, 0.1541963 , 0.86419753],\n", + " [0.91824158, 0.08108108, 0.86419753],\n", + " [1. , 0. , 0.83950617]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88095238, 0.12059369, 0.84615385],\n", + " [0.75678443, 0.24397032, 0.85897436],\n", + " [0.63722478, 0.36270872, 0.84615385],\n", + " [0.51510497, 0.48330241, 0.84615385],\n", + " [0.37403994, 0.62523191, 1. ],\n", + " [0.25576037, 0.7458256 , 0.83333333],\n", + " [0.13364055, 0.86641929, 0.85897436],\n", + " [0. , 1. , 0.91025641]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11457286, 0.11613475, 1. ],\n", + " [0.21306533, 0.21830674, 0.86419753],\n", + " [0.31155779, 0.31715426, 0.86419753],\n", + " [0.41407035, 0.41710993, 0.86419753],\n", + " [0.51557789, 0.51684397, 0.85185185],\n", + " [0.6040201 , 0.60217199, 0.75308642],\n", + " [0.70150754, 0.7016844 , 0.86419753],\n", + " [0.79899497, 0.80097518, 0.86419753],\n", + " [0.89748744, 0.90004433, 0.85185185],\n", + " [1. , 1. , 0.87654321]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90345528, 0.89888777, 0.97183099],\n", + " [0.80182927, 0.79575329, 1. ],\n", + " [0.70223577, 0.69464105, 0.98591549],\n", + " [0.6046748 , 0.59656218, 0.95774648],\n", + " [0.49898374, 0.49368049, 1. ],\n", + " [0.39634146, 0.39054601, 1. ],\n", + " [0.29471545, 0.29019211, 0.97183099],\n", + " [0.19105691, 0.19084934, 0.97183099],\n", + " [0.10162602, 0.10187058, 0.85915493],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08701473, 0.91350357, 1. ],\n", + " [0.16733601, 0.82815735, 0.98591549],\n", + " [0.25033467, 0.74557166, 0.98591549],\n", + " [0.33065596, 0.66551645, 0.98591549],\n", + " [0.40294511, 0.58868185, 0.95774648],\n", + " [0.47925033, 0.52518979, 0.85915493],\n", + " [0.56358768, 0.45594663, 0.98591549],\n", + " [0.64257028, 0.3910743 , 1. ],\n", + " [0.708166 , 0.32850242, 0.98591549],\n", + " [0.76171352, 0.26938118, 0.97183099],\n", + " [0.81659973, 0.20749942, 1. ],\n", + " [0.86746988, 0.14929837, 0.98591549],\n", + " [0.91566265, 0.09546814, 0.98591549],\n", + " [0.95850067, 0.04600874, 0.97183099],\n", + " [1. , 0. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.93935894, 0.9380117 , 0.78481013],\n", + " [0.8749639 , 0.87076023, 0.83544304],\n", + " [0.81230147, 0.80994152, 0.81012658],\n", + " [0.75310424, 0.74853801, 0.7721519 ],\n", + " [0.68899798, 0.68947368, 0.82278481],\n", + " [0.62546925, 0.62397661, 0.83544304],\n", + " [0.56396188, 0.5625731 , 0.79746835],\n", + " [0.50043315, 0.5 , 0.83544304],\n", + " [0.42333237, 0.42222222, 1. ],\n", + " [0.36038117, 0.3619883 , 0.82278481],\n", + " [0.30262778, 0.30409357, 0.7721519 ],\n", + " [0.24487439, 0.24385965, 0.7721519 ],\n", + " [0.18481086, 0.18421053, 0.7721519 ],\n", + " [0.12214843, 0.12397661, 0.83544304],\n", + " [0.05948599, 0.05672515, 0.83544304],\n", + " [0. , 0. , 0.78481013]]),\n", + " array([[5.80154181e-01, 9.22352269e-01, 0.00000000e+00],\n", + " [5.38050998e-01, 9.11504425e-01, 5.00000000e-01],\n", + " [4.96145483e-01, 8.99514702e-01, 4.85915493e-01],\n", + " [4.53251631e-01, 8.86383100e-01, 5.00000000e-01],\n", + " [4.17078474e-01, 8.76677134e-01, 4.29577465e-01],\n", + " [3.74184621e-01, 8.64972880e-01, 4.92957746e-01],\n", + " [3.34651117e-01, 8.53268627e-01, 4.78873239e-01],\n", + " [2.95117612e-01, 8.41849843e-01, 5.00000000e-01],\n", + " [2.56967780e-01, 8.31287468e-01, 4.92957746e-01],\n", + " [2.24747974e-01, 8.22723380e-01, 4.92957746e-01],\n", + " [1.96086183e-01, 8.13588353e-01, 4.85915493e-01],\n", + " [1.70389405e-01, 8.04453326e-01, 5.00000000e-01],\n", + " [1.48448310e-01, 7.99029403e-01, 4.92957746e-01],\n", + " [1.28088555e-01, 7.98172995e-01, 5.00000000e-01],\n", + " [1.10891481e-01, 8.00171282e-01, 4.92957746e-01],\n", + " [9.58687488e-02, 8.06166143e-01, 4.78873239e-01],\n", + " [8.28226922e-02, 8.14730231e-01, 5.00000000e-01],\n", + " [7.15556434e-02, 8.25007137e-01, 4.85915493e-01],\n", + " [6.18699348e-02, 8.36711390e-01, 5.00000000e-01],\n", + " [5.31725637e-02, 8.47559235e-01, 4.85915493e-01],\n", + " [4.52658628e-02, 8.58121610e-01, 4.92957746e-01],\n", + " [3.79521645e-02, 8.68969455e-01, 5.07042254e-01],\n", + " [3.12314687e-02, 8.77533543e-01, 4.92957746e-01],\n", + " [2.54991105e-02, 8.84670283e-01, 4.85915493e-01],\n", + " [2.01620874e-02, 8.91521553e-01, 4.92957746e-01],\n", + " [1.54180668e-02, 8.97801884e-01, 4.92957746e-01],\n", + " [1.16623839e-02, 9.04367685e-01, 4.85915493e-01],\n", + " [8.30203598e-03, 9.10648016e-01, 4.92957746e-01],\n", + " [5.73235817e-03, 9.15786469e-01, 4.92957746e-01],\n", + " [3.55801542e-03, 9.21495861e-01, 5.00000000e-01],\n", + " [2.17434276e-03, 9.26919783e-01, 4.85915493e-01],\n", + " [9.88337616e-04, 9.30345418e-01, 4.92957746e-01],\n", + " [1.97667523e-04, 9.34912932e-01, 5.07042254e-01],\n", + " [0.00000000e+00, 9.38338567e-01, 4.78873239e-01],\n", + " [0.00000000e+00, 9.41764202e-01, 4.92957746e-01],\n", + " [5.93002570e-04, 9.44904368e-01, 4.92957746e-01],\n", + " [1.38367266e-03, 9.48330003e-01, 4.92957746e-01],\n", + " [2.56967780e-03, 9.50613760e-01, 4.92957746e-01],\n", + " [5.13935560e-03, 9.54895804e-01, 1.00000000e+00],\n", + " [7.11603084e-03, 9.57179560e-01, 4.85915493e-01],\n", + " [8.69737102e-03, 9.59177848e-01, 4.92957746e-01],\n", + " [1.10693813e-02, 9.60605196e-01, 5.00000000e-01],\n", + " [1.34413916e-02, 9.61461604e-01, 4.78873239e-01],\n", + " [1.54180668e-02, 9.62603483e-01, 4.92957746e-01],\n", + " [1.75924096e-02, 9.63459892e-01, 4.92957746e-01],\n", + " [1.99644198e-02, 9.64887240e-01, 5.00000000e-01],\n", + " [2.21387626e-02, 9.65458179e-01, 5.00000000e-01],\n", + " [2.45107729e-02, 9.66314587e-01, 4.85915493e-01],\n", + " [2.70804507e-02, 9.67456466e-01, 5.00000000e-01],\n", + " [2.94524610e-02, 9.67741935e-01, 4.85915493e-01],\n", + " [3.20221388e-02, 9.69169283e-01, 4.92957746e-01],\n", + " [3.43941490e-02, 9.70025692e-01, 4.85915493e-01],\n", + " [3.69638268e-02, 9.70882101e-01, 4.92957746e-01],\n", + " [3.97311722e-02, 9.71453040e-01, 5.00000000e-01],\n", + " [4.23008500e-02, 9.72594919e-01, 4.85915493e-01],\n", + " [4.48705278e-02, 9.73165858e-01, 5.00000000e-01],\n", + " [4.76378731e-02, 9.74022267e-01, 4.92957746e-01],\n", + " [5.02075509e-02, 9.74593206e-01, 4.92957746e-01],\n", + " [5.29748962e-02, 9.75449615e-01, 4.92957746e-01],\n", + " [5.61375766e-02, 9.76020554e-01, 4.92957746e-01],\n", + " [5.96955920e-02, 9.76591493e-01, 4.85915493e-01],\n", + " [6.28582724e-02, 9.77162432e-01, 5.07042254e-01],\n", + " [6.58232852e-02, 9.78304311e-01, 4.85915493e-01],\n", + " [6.87882981e-02, 9.78589780e-01, 4.85915493e-01],\n", + " [7.21486460e-02, 9.79446189e-01, 5.00000000e-01],\n", + " [7.51136588e-02, 9.80873537e-01, 4.92957746e-01],\n", + " [7.78810042e-02, 9.81444476e-01, 4.92957746e-01],\n", + " [8.08460170e-02, 9.82015415e-01, 4.92957746e-01],\n", + " [8.36133623e-02, 9.83157294e-01, 5.00000000e-01],\n", + " [8.63807076e-02, 9.84013703e-01, 4.85915493e-01],\n", + " [8.93457205e-02, 9.85155581e-01, 4.85915493e-01],\n", + " [9.25084009e-02, 9.86297459e-01, 4.92957746e-01],\n", + " [9.54734137e-02, 9.87153868e-01, 4.92957746e-01],\n", + " [9.90314291e-02, 9.88295747e-01, 4.92957746e-01],\n", + " [1.02194110e-01, 9.89152155e-01, 4.92957746e-01],\n", + " [1.05554457e-01, 9.90579503e-01, 4.92957746e-01],\n", + " [1.08519470e-01, 9.91435912e-01, 5.00000000e-01],\n", + " [1.11879818e-01, 9.93148730e-01, 4.92957746e-01],\n", + " [1.15240166e-01, 9.94576078e-01, 4.92957746e-01],\n", + " [1.18205179e-01, 9.95717956e-01, 4.85915493e-01],\n", + " [1.21565527e-01, 9.96003426e-01, 4.92957746e-01],\n", + " [1.24530540e-01, 9.97145304e-01, 5.00000000e-01],\n", + " [1.27693220e-01, 9.97716243e-01, 4.92957746e-01],\n", + " [1.31053568e-01, 9.98572652e-01, 4.85915493e-01],\n", + " [1.34413916e-01, 9.99143591e-01, 5.00000000e-01],\n", + " [1.37576596e-01, 9.99429061e-01, 4.85915493e-01],\n", + " [1.39948606e-01, 9.99143591e-01, 4.36619718e-01],\n", + " [1.43111287e-01, 9.99429061e-01, 4.85915493e-01],\n", + " [1.46273967e-01, 1.00000000e+00, 5.00000000e-01],\n", + " [1.49634315e-01, 9.99429061e-01, 4.92957746e-01],\n", + " [1.53587666e-01, 9.99143591e-01, 4.92957746e-01],\n", + " [1.56552678e-01, 9.98858122e-01, 4.78873239e-01],\n", + " [1.59913026e-01, 9.99429061e-01, 4.29577465e-01],\n", + " [1.63273374e-01, 9.99143591e-01, 4.92957746e-01],\n", + " [1.66436055e-01, 9.98572652e-01, 4.29577465e-01],\n", + " [1.70389405e-01, 9.98858122e-01, 4.85915493e-01],\n", + " [1.74145088e-01, 9.98858122e-01, 4.85915493e-01],\n", + " [1.77505436e-01, 9.98858122e-01, 4.29577465e-01],\n", + " [1.81656454e-01, 9.98572652e-01, 5.00000000e-01],\n", + " [1.85016802e-01, 9.98001713e-01, 4.78873239e-01],\n", + " [1.88179482e-01, 9.97430774e-01, 4.29577465e-01],\n", + " [1.92330500e-01, 9.97145304e-01, 4.92957746e-01],\n", + " [1.96086183e-01, 9.96859834e-01, 4.85915493e-01],\n", + " [2.00237201e-01, 9.96859834e-01, 5.07042254e-01],\n", + " [2.04783554e-01, 9.96288895e-01, 5.63380282e-01],\n", + " [2.09132240e-01, 9.96288895e-01, 4.85915493e-01],\n", + " [2.13085590e-01, 9.96003426e-01, 4.85915493e-01],\n", + " [2.16841273e-01, 9.95432486e-01, 4.92957746e-01],\n", + " [2.20596956e-01, 9.94576078e-01, 5.00000000e-01],\n", + " [2.24154971e-01, 9.93434199e-01, 5.00000000e-01],\n", + " [2.28305989e-01, 9.92577790e-01, 4.92957746e-01],\n", + " [2.32852342e-01, 9.91435912e-01, 5.63380282e-01],\n", + " [2.37201028e-01, 9.90864973e-01, 4.92957746e-01],\n", + " [2.41549713e-01, 9.90294034e-01, 4.78873239e-01],\n", + " [2.46096066e-01, 9.89152155e-01, 5.63380282e-01],\n", + " [2.50049417e-01, 9.88295747e-01, 4.92957746e-01],\n", + " [2.54200435e-01, 9.87439338e-01, 5.07042254e-01],\n", + " [2.57758450e-01, 9.86297459e-01, 4.85915493e-01],\n", + " [2.61711801e-01, 9.85441051e-01, 4.92957746e-01],\n", + " [2.65665151e-01, 9.84299172e-01, 4.92957746e-01],\n", + " [2.69420834e-01, 9.83728233e-01, 4.92957746e-01],\n", + " [2.73769520e-01, 9.82586355e-01, 4.85915493e-01],\n", + " [2.77920538e-01, 9.81444476e-01, 5.00000000e-01],\n", + " [2.81873888e-01, 9.80302598e-01, 4.85915493e-01],\n", + " [2.85827239e-01, 9.79160719e-01, 4.92957746e-01],\n", + " [2.89978257e-01, 9.78018841e-01, 5.07042254e-01],\n", + " [2.93733940e-01, 9.76876963e-01, 4.85915493e-01],\n", + " [2.97884958e-01, 9.75735084e-01, 4.85915493e-01],\n", + " [3.02233643e-01, 9.74307736e-01, 5.00000000e-01],\n", + " [3.05989326e-01, 9.73451327e-01, 4.85915493e-01],\n", + " [3.10535679e-01, 9.72594919e-01, 4.92957746e-01],\n", + " [3.14884364e-01, 9.71453040e-01, 5.00000000e-01],\n", + " [3.18640047e-01, 9.70311162e-01, 4.92957746e-01],\n", + " [3.22791065e-01, 9.69169283e-01, 4.85915493e-01],\n", + " [3.26942083e-01, 9.68027405e-01, 4.92957746e-01],\n", + " [3.31883771e-01, 9.66600057e-01, 4.92957746e-01],\n", + " [3.36232457e-01, 9.65458179e-01, 5.00000000e-01],\n", + " [3.40383475e-01, 9.64316300e-01, 4.92957746e-01],\n", + " [3.44929828e-01, 9.62888952e-01, 5.00000000e-01],\n", + " [3.48487843e-01, 9.61747074e-01, 4.78873239e-01],\n", + " [3.52243526e-01, 9.60319726e-01, 4.92957746e-01],\n", + " [3.56987547e-01, 9.58321439e-01, 5.00000000e-01],\n", + " [3.61336232e-01, 9.56608621e-01, 5.00000000e-01],\n", + " [3.65487250e-01, 9.54610334e-01, 4.85915493e-01],\n", + " [3.69638268e-01, 9.52612047e-01, 4.85915493e-01],\n", + " [3.74382289e-01, 9.50613760e-01, 4.92957746e-01],\n", + " [3.78533307e-01, 9.48330003e-01, 4.92957746e-01],\n", + " [3.82684325e-01, 9.46617185e-01, 4.29577465e-01],\n", + " [3.87428346e-01, 9.44333428e-01, 4.85915493e-01],\n", + " [3.92370034e-01, 9.42049672e-01, 4.92957746e-01],\n", + " [3.97114054e-01, 9.39765915e-01, 5.00000000e-01],\n", + " [4.02451077e-01, 9.37767628e-01, 5.00000000e-01],\n", + " [4.07392765e-01, 9.35198401e-01, 4.85915493e-01],\n", + " [4.12136786e-01, 9.32629175e-01, 4.85915493e-01],\n", + " [4.16880806e-01, 9.30059949e-01, 4.92957746e-01],\n", + " [4.21427160e-01, 9.28061661e-01, 4.29577465e-01],\n", + " [4.26764183e-01, 9.25777905e-01, 4.92957746e-01],\n", + " [4.32101206e-01, 9.23494148e-01, 4.85915493e-01],\n", + " [4.37240561e-01, 9.21495861e-01, 4.92957746e-01],\n", + " [4.42775252e-01, 9.19212104e-01, 4.92957746e-01],\n", + " [4.48112275e-01, 9.16357408e-01, 5.00000000e-01],\n", + " [4.53251631e-01, 9.13788182e-01, 4.92957746e-01],\n", + " [4.58588654e-01, 9.11504425e-01, 4.92957746e-01],\n", + " [4.64123345e-01, 9.09506138e-01, 4.92957746e-01],\n", + " [4.69262700e-01, 9.07222381e-01, 4.85915493e-01],\n", + " [4.74204388e-01, 9.04653154e-01, 4.92957746e-01],\n", + " [4.78750741e-01, 9.01798458e-01, 4.92957746e-01],\n", + " [4.84087764e-01, 8.99514702e-01, 4.92957746e-01],\n", + " [4.89227120e-01, 8.96945475e-01, 4.92957746e-01],\n", + " [4.94959478e-01, 8.94376249e-01, 5.00000000e-01],\n", + " [4.99901166e-01, 8.92092492e-01, 4.92957746e-01],\n", + " [5.05238189e-01, 8.89808735e-01, 4.92957746e-01],\n", + " [5.10970548e-01, 8.87524979e-01, 4.92957746e-01],\n", + " [5.16505238e-01, 8.84955752e-01, 4.85915493e-01],\n", + " [5.22237596e-01, 8.82386526e-01, 5.00000000e-01],\n", + " [5.28167622e-01, 8.80102769e-01, 4.92957746e-01],\n", + " [5.33702313e-01, 8.78104482e-01, 4.92957746e-01],\n", + " [5.39237003e-01, 8.75820725e-01, 4.92957746e-01],\n", + " [5.44969362e-01, 8.73536968e-01, 4.92957746e-01],\n", + " [5.50701720e-01, 8.71253212e-01, 4.85915493e-01],\n", + " [5.56236410e-01, 8.69254924e-01, 5.07042254e-01],\n", + " [5.61771101e-01, 8.66971168e-01, 4.85915493e-01],\n", + " [5.67305792e-01, 8.64972880e-01, 4.85915493e-01],\n", + " [5.72642815e-01, 8.62974593e-01, 4.92957746e-01],\n", + " [5.77782170e-01, 8.60976306e-01, 4.29577465e-01],\n", + " [5.84107531e-01, 8.58978019e-01, 4.92957746e-01],\n", + " [5.89642222e-01, 8.56979732e-01, 4.92957746e-01],\n", + " [5.95572247e-01, 8.54981444e-01, 5.00000000e-01],\n", + " [6.01106938e-01, 8.52983157e-01, 4.78873239e-01],\n", + " [6.05653291e-01, 8.50984870e-01, 4.29577465e-01],\n", + " [6.10990314e-01, 8.48701113e-01, 4.92957746e-01],\n", + " [6.16129670e-01, 8.46702826e-01, 4.85915493e-01],\n", + " [6.22059696e-01, 8.44133600e-01, 5.00000000e-01],\n", + " [6.27792054e-01, 8.41564373e-01, 4.85915493e-01],\n", + " [6.33524412e-01, 8.38995147e-01, 4.92957746e-01],\n", + " [6.39059103e-01, 8.36711390e-01, 5.00000000e-01],\n", + " [6.44593793e-01, 8.34142164e-01, 4.92957746e-01],\n", + " [6.50326151e-01, 8.31572937e-01, 4.85915493e-01],\n", + " [6.56256177e-01, 8.29003711e-01, 5.00000000e-01],\n", + " [6.61988535e-01, 8.26149015e-01, 4.92957746e-01],\n", + " [6.67918561e-01, 8.23579789e-01, 4.92957746e-01],\n", + " [6.74046254e-01, 8.20439623e-01, 5.56338028e-01],\n", + " [6.78987942e-01, 8.17584927e-01, 5.00000000e-01],\n", + " [6.84522633e-01, 8.14730231e-01, 4.92957746e-01],\n", + " [6.90254991e-01, 8.12161005e-01, 4.92957746e-01],\n", + " [6.96185017e-01, 8.09591778e-01, 4.92957746e-01],\n", + " [7.01522040e-01, 8.06737083e-01, 4.85915493e-01],\n", + " [7.07056731e-01, 8.04167856e-01, 5.00000000e-01],\n", + " [7.12591421e-01, 8.01313160e-01, 4.92957746e-01],\n", + " [7.18323779e-01, 7.99029403e-01, 4.29577465e-01],\n", + " [7.23463135e-01, 7.96174707e-01, 4.85915493e-01],\n", + " [7.28207156e-01, 7.93890951e-01, 4.29577465e-01],\n", + " [7.33939514e-01, 7.91036255e-01, 4.78873239e-01],\n", + " [7.39671872e-01, 7.88467028e-01, 4.92957746e-01],\n", + " [7.45206563e-01, 7.85897802e-01, 5.00000000e-01],\n", + " [7.50938921e-01, 7.83328576e-01, 4.85915493e-01],\n", + " [7.56473611e-01, 7.81330288e-01, 4.92957746e-01],\n", + " [7.62403637e-01, 7.79046532e-01, 4.92957746e-01],\n", + " [7.67938328e-01, 7.76477305e-01, 5.00000000e-01],\n", + " [7.73275351e-01, 7.73622609e-01, 4.85915493e-01],\n", + " [7.79205377e-01, 7.71338852e-01, 4.92957746e-01],\n", + " [7.84542400e-01, 7.68198687e-01, 5.00000000e-01],\n", + " [7.90077090e-01, 7.65629460e-01, 4.85915493e-01],\n", + " [7.94821111e-01, 7.63060234e-01, 4.29577465e-01],\n", + " [8.00355802e-01, 7.60776477e-01, 4.85915493e-01],\n", + " [8.06088160e-01, 7.57921781e-01, 5.00000000e-01],\n", + " [8.11622850e-01, 7.55352555e-01, 4.85915493e-01],\n", + " [8.17552876e-01, 7.52497859e-01, 5.00000000e-01],\n", + " [8.23285234e-01, 7.49643163e-01, 4.85915493e-01],\n", + " [8.29412927e-01, 7.47359406e-01, 5.00000000e-01],\n", + " [8.35342953e-01, 7.44790180e-01, 4.92957746e-01],\n", + " [8.41668314e-01, 7.41935484e-01, 4.92957746e-01],\n", + " [8.47400672e-01, 7.39080788e-01, 4.92957746e-01],\n", + " [8.53923700e-01, 7.36797031e-01, 4.85915493e-01],\n", + " [8.60051394e-01, 7.34227805e-01, 5.00000000e-01],\n", + " [8.66376754e-01, 7.31373109e-01, 5.00000000e-01],\n", + " [8.71911445e-01, 7.28518413e-01, 4.85915493e-01],\n", + " [8.77248468e-01, 7.26520126e-01, 4.29577465e-01],\n", + " [8.83376161e-01, 7.24521838e-01, 4.78873239e-01],\n", + " [8.89701522e-01, 7.22238082e-01, 4.92957746e-01],\n", + " [8.96026883e-01, 7.19954325e-01, 5.00000000e-01],\n", + " [9.02352244e-01, 7.17385098e-01, 4.85915493e-01],\n", + " [9.08282269e-01, 7.14530403e-01, 4.92957746e-01],\n", + " [9.14607630e-01, 7.12246646e-01, 4.92957746e-01],\n", + " [9.20339988e-01, 7.09677419e-01, 5.00000000e-01],\n", + " [9.26665349e-01, 7.06822723e-01, 4.92957746e-01],\n", + " [9.32793042e-01, 7.04538967e-01, 4.85915493e-01],\n", + " [9.38920735e-01, 7.01969740e-01, 5.00000000e-01],\n", + " [9.45641431e-01, 6.99400514e-01, 5.00000000e-01],\n", + " [9.51373789e-01, 6.96545818e-01, 4.78873239e-01],\n", + " [9.57896818e-01, 6.94262061e-01, 5.00000000e-01],\n", + " [9.64617513e-01, 6.91692835e-01, 4.92957746e-01],\n", + " [9.70547539e-01, 6.88838139e-01, 4.92957746e-01],\n", + " [9.76675232e-01, 6.86554382e-01, 4.92957746e-01],\n", + " [9.82605258e-01, 6.84270625e-01, 4.92957746e-01],\n", + " [9.88732951e-01, 6.81701399e-01, 5.00000000e-01],\n", + " [9.95848982e-01, 6.89409078e-01, 4.85915493e-01],\n", + " [1.00000000e+00, 7.06251784e-01, 4.29577465e-01],\n", + " [9.98418660e-01, 7.33371396e-01, 4.85915493e-01],\n", + " [9.84977268e-01, 7.57065373e-01, 4.92957746e-01],\n", + " [9.63431508e-01, 7.67056808e-01, 4.92957746e-01],\n", + " [9.36548725e-01, 7.67342278e-01, 4.92957746e-01],\n", + " [9.08084602e-01, 7.65914930e-01, 4.92957746e-01],\n", + " [8.78632141e-01, 7.63345704e-01, 4.92957746e-01],\n", + " [8.47598340e-01, 7.61632886e-01, 4.92957746e-01],\n", + " [8.15971536e-01, 7.60205538e-01, 5.00000000e-01],\n", + " [7.86321407e-01, 7.57921781e-01, 4.85915493e-01],\n", + " [7.60229294e-01, 7.54781616e-01, 4.85915493e-01],\n", + " [7.31369836e-01, 7.53354268e-01, 5.00000000e-01],\n", + " [7.06068393e-01, 7.49643163e-01, 4.85915493e-01],\n", + " [6.83731963e-01, 7.45932058e-01, 5.00000000e-01],\n", + " [6.64162878e-01, 7.42791893e-01, 4.85915493e-01],\n", + " [6.47163471e-01, 7.40793605e-01, 4.92957746e-01],\n", + " [6.31547737e-01, 7.36797031e-01, 5.00000000e-01],\n", + " [6.18699348e-01, 7.33942335e-01, 4.85915493e-01],\n", + " [6.07234631e-01, 7.31373109e-01, 4.92957746e-01],\n", + " [5.96362918e-01, 7.29374822e-01, 4.92957746e-01],\n", + " [5.86677209e-01, 7.26520126e-01, 5.00000000e-01],\n", + " [5.78770508e-01, 7.23094490e-01, 4.92957746e-01],\n", + " [5.71061475e-01, 7.21096203e-01, 4.92957746e-01],\n", + " [5.64143111e-01, 7.17385098e-01, 4.92957746e-01],\n", + " [5.59003756e-01, 7.16243220e-01, 4.92957746e-01],\n", + " [5.53864400e-01, 7.13673994e-01, 4.85915493e-01],\n", + " [5.49713382e-01, 7.11390237e-01, 4.92957746e-01],\n", + " [5.45167029e-01, 7.08821011e-01, 5.00000000e-01],\n", + " [5.42597351e-01, 7.07108193e-01, 4.29577465e-01],\n", + " [5.40027673e-01, 7.04824436e-01, 4.85915493e-01],\n", + " [5.37853331e-01, 7.02540679e-01, 4.85915493e-01],\n", + " [5.35876655e-01, 7.00256923e-01, 5.00000000e-01],\n", + " [5.33702313e-01, 6.97973166e-01, 4.85915493e-01],\n", + " [5.32516308e-01, 6.94833000e-01, 5.07042254e-01],\n", + " [5.31923305e-01, 6.91978304e-01, 4.85915493e-01],\n", + " [5.32120973e-01, 6.86268912e-01, 9.85915493e-01],\n", + " [5.32318640e-01, 6.83128747e-01, 4.85915493e-01],\n", + " [5.33306978e-01, 6.79988581e-01, 4.92957746e-01],\n", + " [5.34690650e-01, 6.76277476e-01, 5.00000000e-01],\n", + " [5.36469658e-01, 6.73422780e-01, 5.00000000e-01],\n", + " [5.38841668e-01, 6.70853554e-01, 4.85915493e-01],\n", + " [5.41411346e-01, 6.67713389e-01, 4.92957746e-01],\n", + " [5.44376359e-01, 6.64287753e-01, 4.85915493e-01],\n", + " [5.47934374e-01, 6.61147588e-01, 4.92957746e-01],\n", + " [5.51690057e-01, 6.57721953e-01, 5.00000000e-01],\n", + " [5.55841075e-01, 6.54010848e-01, 5.00000000e-01],\n", + " [5.59992093e-01, 6.50870682e-01, 4.78873239e-01],\n", + " [5.64933781e-01, 6.46874108e-01, 4.92957746e-01],\n", + " [5.70073137e-01, 6.43448473e-01, 4.92957746e-01],\n", + " [5.75014825e-01, 6.40308307e-01, 4.36619718e-01],\n", + " [5.80549516e-01, 6.36311733e-01, 4.78873239e-01],\n", + " [5.86677209e-01, 6.31458750e-01, 5.00000000e-01],\n", + " [5.92409567e-01, 6.26891236e-01, 4.85915493e-01],\n", + " [5.93200237e-01, 6.30602341e-01, 4.29577465e-01],\n", + " [5.85886539e-01, 6.44019412e-01, 4.92957746e-01],\n", + " [5.71259142e-01, 6.51441621e-01, 4.43661972e-01],\n", + " [5.52283060e-01, 6.37739081e-01, 4.64788732e-01],\n", + " [5.22830599e-01, 6.08621182e-01, 5.07042254e-01],\n", + " [4.87843447e-01, 5.65515273e-01, 4.92957746e-01],\n", + " [4.50484285e-01, 5.17841850e-01, 4.78873239e-01],\n", + " [4.09171773e-01, 4.66742792e-01, 5.00000000e-01],\n", + " [3.66277921e-01, 4.12503568e-01, 4.85915493e-01],\n", + " [3.24174738e-01, 3.49700257e-01, 5.00000000e-01],\n", + " [2.79897213e-01, 2.84042250e-01, 4.85915493e-01],\n", + " [2.34038347e-01, 2.15529546e-01, 5.00000000e-01],\n", + " [1.88377150e-01, 1.49871539e-01, 4.92957746e-01],\n", + " [1.45087962e-01, 7.45075649e-02, 4.92957746e-01],\n", + " [1.02787112e-01, 0.00000000e+00, 4.92957746e-01]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13779423, 0.12975779, 0.84615385],\n", + " [0.27585295, 0.25951557, 0.85897436],\n", + " [0.43797937, 0.41176471, 1. ],\n", + " [0.57550912, 0.5432526 , 0.83333333],\n", + " [0.71356784, 0.67301038, 0.84615385],\n", + " [0.86247025, 0.83737024, 0.93589744],\n", + " [1. , 1. , 0.83333333]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.85393258, 0.14061401, 0.91666667],\n", + " [0.69101124, 0.27935318, 0.91666667],\n", + " [0.52247191, 0.42840403, 1. ],\n", + " [0.39325843, 0.56948676, 0.91666667],\n", + " [0.28089888, 0.70822592, 0.91666667],\n", + " [0.12921348, 0.86055777, 1. ],\n", + " [0. , 1. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92513114, 0.92289372, 0.68539326],\n", + " [0.81545064, 0.80976481, 1. ],\n", + " [0.71149261, 0.70586484, 0.91011236],\n", + " [0.62613257, 0.62072045, 0.78651685],\n", + " [0.52598951, 0.52009527, 0.8988764 ],\n", + " [0.43919886, 0.43286692, 0.78651685],\n", + " [0.35431569, 0.34742483, 0.7752809 ],\n", + " [0.26514068, 0.25930336, 0.79775281],\n", + " [0.18121125, 0.17386127, 0.7752809 ],\n", + " [0.09394373, 0.08693063, 0.78651685],\n", + " [0. , 0. , 0.79775281]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.97721128, 0.975458 , 0.95833333],\n", + " [0.95365006, 0.95229865, 0.97222222],\n", + " [0.92854384, 0.92879364, 0.98611111],\n", + " [0.90305137, 0.9073626 , 0.95833333],\n", + " [0.87794515, 0.88385759, 0.98611111],\n", + " [0.85515643, 0.86035258, 0.95833333],\n", + " [0.83120896, 0.8365019 , 0.98611111],\n", + " [0.80571649, 0.81610785, 0.95833333],\n", + " [0.78331402, 0.7974421 , 0.84722222],\n", + " [0.75859405, 0.77808503, 0.95833333],\n", + " [0.73387408, 0.75803664, 0.98611111],\n", + " [0.70876786, 0.73695126, 0.95833333],\n", + " [0.68636539, 0.71552022, 0.98611111],\n", + " [0.66319042, 0.69374352, 0.95833333],\n", + " [0.63924295, 0.67058417, 0.97222222],\n", + " [0.61684048, 0.64707916, 0.97222222],\n", + " [0.59791425, 0.62737643, 0.84722222],\n", + " [0.57396678, 0.6049084 , 0.94444444],\n", + " [0.55156431, 0.58071206, 1. ],\n", + " [0.52954809, 0.55789838, 0.95833333],\n", + " [0.50560062, 0.53543035, 0.97222222],\n", + " [0.47856315, 0.51434497, 0.97222222],\n", + " [0.45616068, 0.49256827, 0.97222222],\n", + " [0.43144071, 0.47010024, 0.97222222],\n", + " [0.40942449, 0.44694089, 0.95833333],\n", + " [0.38624952, 0.42896647, 0.84722222],\n", + " [0.3626883 , 0.4051158 , 0.98611111],\n", + " [0.33989958, 0.38161078, 0.97222222],\n", + " [0.3182696 , 0.35637746, 0.97222222],\n", + " [0.29818463, 0.3314898 , 0.95833333],\n", + " [0.27500966, 0.30729347, 0.97222222],\n", + " [0.25337968, 0.28136882, 0.98611111],\n", + " [0.23213596, 0.2561355 , 0.97222222],\n", + " [0.20625724, 0.23263049, 0.97222222],\n", + " [0.18462727, 0.20636018, 0.97222222],\n", + " [0.1637698 , 0.17974421, 0.97222222],\n", + " [0.13750483, 0.15589354, 0.95833333],\n", + " [0.11201236, 0.12996889, 0.98611111],\n", + " [0.09076864, 0.10438991, 0.95833333],\n", + " [0.06720742, 0.07846526, 0.98611111],\n", + " [0.04441869, 0.0535776 , 0.95833333],\n", + " [0.02162997, 0.02730729, 0.97222222],\n", + " [0. , 0. , 0.97222222]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90399344, 0.88769036, 0.79775281],\n", + " [0.80415755, 0.79758883, 0.78651685],\n", + " [0.67724289, 0.70114213, 1. ],\n", + " [0.57904814, 0.59771574, 0.79775281],\n", + " [0.48550328, 0.4822335 , 0.78651685],\n", + " [0.38785558, 0.38769036, 0.7752809 ],\n", + " [0.28774617, 0.30647208, 0.79775281],\n", + " [0.19119256, 0.21954315, 0.78651685],\n", + " [0.09682713, 0.11357868, 0.7752809 ],\n", + " [0. , 0. , 0.79775281]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11173498, 0.90486486, 0.77647059],\n", + " [0.22431218, 0.80486486, 0.78823529],\n", + " [0.33043234, 0.70162162, 0.76470588],\n", + " [0.43711398, 0.59081081, 0.77647059],\n", + " [0.57664234, 0.44540541, 1. ],\n", + " [0.67770915, 0.3427027 , 0.71764706],\n", + " [0.78747894, 0.23297297, 0.77647059],\n", + " [0.89472207, 0.11837838, 0.78823529],\n", + " [1. , 0. , 0.77647059]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90282968, 0.81818182, 0.88607595],\n", + " [0.80485852, 0.6969697 , 0.88607595],\n", + " [0.70848905, 0.48484848, 0.87341772],\n", + " [0.61105179, 0.39393939, 0.89873418],\n", + " [0.51521623, 0.24242424, 0.87341772],\n", + " [0.41777896, 0. , 0.88607595],\n", + " [0.31847304, 0. , 0.89873418],\n", + " [0.20928991, 0.39393939, 1. ],\n", + " [0.11078484, 0.57575758, 0.89873418],\n", + " [0. , 0.66666667, 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85943775, 0.87030812, 0.88888889],\n", + " [0.73436604, 0.75042017, 0.76666667],\n", + " [0.61445783, 0.63977591, 0.78888889],\n", + " [0.49110729, 0.51876751, 0.76666667],\n", + " [0.37865749, 0.40588235, 0.77777778],\n", + " [0.2713712 , 0.29047619, 0.78888889],\n", + " [0.12621916, 0.13501401, 1. ],\n", + " [0. , 0. , 0.87777778]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89944867, 0.89569991, 0.97183099],\n", + " [0.79732213, 0.7904849 , 0.98591549],\n", + " [0.69703334, 0.68984446, 0.98591549],\n", + " [0.59280651, 0.5873742 , 1. ],\n", + " [0.49120504, 0.4894785 , 0.98591549],\n", + " [0.39012864, 0.3915828 , 0.98591549],\n", + " [0.28852717, 0.29094236, 0.98591549],\n", + " [0.18850092, 0.18664227, 0.98591549],\n", + " [0.08821213, 0.084172 , 0.97183099],\n", + " [0. , 0. , 0.85915493]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12314887, 0.87906977, 0.97014925],\n", + " [0.24993505, 0.75116279, 0.98507463],\n", + " [0.37490257, 0.62093023, 0.98507463],\n", + " [0.49831125, 0.49767442, 0.98507463],\n", + " [0.62535724, 0.36976744, 1. ],\n", + " [0.74876591, 0.24418605, 0.97014925],\n", + " [0.87425305, 0.1255814 , 0.98507463],\n", + " [1. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11481087, 0.12121212, 0.84146341],\n", + " [0.25332978, 0.26136364, 1. ],\n", + " [0.3857219 , 0.39267677, 0.93902439],\n", + " [0.50825786, 0.51388889, 0.87804878],\n", + " [0.62386787, 0.63131313, 0.84146341],\n", + " [0.7637187 , 0.77020202, 1. ],\n", + " [0.88012786, 0.88383838, 0.82926829],\n", + " [1. , 1. , 0.85365854]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15254237, 0.09308176, 0.98591549],\n", + " [0.28248588, 0.18490566, 0.97183099],\n", + " [0.34745763, 0.26540881, 0.85915493],\n", + " [0.43079096, 0.35798742, 0.97183099],\n", + " [0.51694915, 0.45157233, 1. ],\n", + " [0.60451977, 0.54490566, 1. ],\n", + " [0.68220339, 0.64025157, 0.98591549],\n", + " [0.77683616, 0.73333333, 0.98591549],\n", + " [0.85169492, 0.82540881, 0.97183099],\n", + " [0.9180791 , 0.90566038, 0.85915493],\n", + " [1. , 1. , 0.97183099]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08530021, 0.91389375, 0.86419753],\n", + " [0.17184265, 0.82837128, 0.87654321],\n", + " [0.25300207, 0.74751897, 0.85185185],\n", + " [0.33954451, 0.66141273, 0.87654321],\n", + " [0.42070393, 0.58085231, 0.85185185],\n", + " [0.50144928, 0.5 , 0.85185185],\n", + " [0.5863354 , 0.41330998, 0.86419753],\n", + " [0.65755694, 0.34238179, 0.75308642],\n", + " [0.73830228, 0.26123759, 0.86419753],\n", + " [0.83354037, 0.16666667, 1. ],\n", + " [0.91925466, 0.08114419, 0.86419753],\n", + " [1. , 0. , 0.85185185]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11545338, 0.11961722, 0.97014925],\n", + " [0.21762452, 0.20813397, 0.91044776],\n", + " [0.32950192, 0.31100478, 0.97014925],\n", + " [0.44265645, 0.43779904, 0.98507463],\n", + " [0.55632184, 0.55741627, 0.98507463],\n", + " [0.66590038, 0.64593301, 1. ],\n", + " [0.77445722, 0.73684211, 0.98507463],\n", + " [0.88965517, 0.86842105, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92534538, 0.93382353, 0.88732394],\n", + " [0.83953241, 0.86029412, 1. ],\n", + " [0.76301807, 0.74632353, 0.91549296],\n", + " [0.68836344, 0.69485294, 0.90140845],\n", + " [0.61663124, 0.61029412, 0.88732394],\n", + " [0.54038257, 0.54779412, 0.88732394],\n", + " [0.4651966 , 0.45220588, 0.91549296],\n", + " [0.37964931, 0.36764706, 0.98591549],\n", + " [0.30605739, 0.29779412, 0.87323944],\n", + " [0.22715197, 0.23161765, 0.92957746],\n", + " [0.15196599, 0.16176471, 0.85915493],\n", + " [0.07757705, 0.08088235, 0.88732394],\n", + " [0. , 0. , 0.92957746]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11839482, 0.11568938, 0.77647059],\n", + " [0.23703888, 0.24088748, 0.77647059],\n", + " [0.3773679 , 0.37400951, 0.91764706],\n", + " [0.49401795, 0.49286846, 0.76470588],\n", + " [0.64656032, 0.65293185, 1. ],\n", + " [0.76545364, 0.76545166, 0.77647059],\n", + " [0.88210369, 0.88114105, 0.76470588],\n", + " [1. , 1. , 0.77647059]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11521456, 0.11986002, 1. ],\n", + " [0.22782835, 0.23009624, 0.97222222],\n", + " [0.33836151, 0.34383202, 0.95833333],\n", + " [0.4520156 , 0.46631671, 0.97222222],\n", + " [0.56306892, 0.5791776 , 0.97222222],\n", + " [0.67438231, 0.68853893, 0.95833333],\n", + " [0.77061118, 0.78040245, 0.84722222],\n", + " [0.88816645, 0.89501312, 0.98611111],\n", + " [1. , 1. , 0.97222222]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.98026667, 0.98327392, 0.86419753],\n", + " [0.95946667, 0.96682205, 0.87654321],\n", + " [0.93973333, 0.95064437, 0.85185185],\n", + " [0.92 , 0.93391829, 0.87654321],\n", + " [0.90026667, 0.91746641, 0.85185185],\n", + " [0.88106667, 0.90074033, 0.86419753],\n", + " [0.86186667, 0.88428846, 0.86419753],\n", + " [0.84693333, 0.87057856, 0.75308642],\n", + " [0.82773333, 0.85440088, 0.86419753],\n", + " [0.8096 , 0.837949 , 0.83950617],\n", + " [0.79306667, 0.82231971, 0.7654321 ],\n", + " [0.77386667, 0.80504524, 0.85185185],\n", + " [0.75573333, 0.78749657, 0.87654321],\n", + " [0.73653333, 0.7704963 , 0.86419753],\n", + " [0.71786667, 0.75322183, 0.86419753],\n", + " [0.6992 , 0.73594735, 0.86419753],\n", + " [0.6816 , 0.71812449, 0.85185185],\n", + " [0.66026667, 0.69810803, 0.98765432],\n", + " [0.64213333, 0.67781738, 1. ],\n", + " [0.6224 , 0.65917192, 0.85185185],\n", + " [0.6032 , 0.64052646, 0.86419753],\n", + " [0.5872 , 0.62270359, 0.87654321],\n", + " [0.56853333, 0.60460653, 0.83950617],\n", + " [0.54986667, 0.58650946, 0.88888889],\n", + " [0.53226667, 0.56868659, 0.85185185],\n", + " [0.5152 , 0.55086372, 0.86419753],\n", + " [0.4976 , 0.53304086, 0.86419753],\n", + " [0.47946667, 0.51494379, 0.86419753],\n", + " [0.46186667, 0.49794352, 0.87654321],\n", + " [0.44266667, 0.48039485, 0.85185185],\n", + " [0.424 , 0.46339457, 0.87654321],\n", + " [0.40746667, 0.4455717 , 0.85185185],\n", + " [0.39253333, 0.43131341, 0.75308642],\n", + " [0.37226667, 0.41376474, 0.85185185],\n", + " [0.35466667, 0.39594187, 0.86419753],\n", + " [0.33653333, 0.37757061, 0.86419753],\n", + " [0.31733333, 0.35782835, 0.86419753],\n", + " [0.2992 , 0.33890869, 0.86419753],\n", + " [0.2848 , 0.32355361, 0.75308642],\n", + " [0.2672 , 0.30573074, 0.86419753],\n", + " [0.2512 , 0.28598848, 0.86419753],\n", + " [0.23093333, 0.26487524, 0.97530864],\n", + " [0.21653333, 0.24897176, 0.75308642],\n", + " [0.19946667, 0.2303263 , 0.85185185],\n", + " [0.18293333, 0.21140664, 0.87654321],\n", + " [0.1648 , 0.19221278, 0.86419753],\n", + " [0.14773333, 0.17274472, 0.86419753],\n", + " [0.13066667, 0.15382506, 0.85185185],\n", + " [0.11466667, 0.1346312 , 0.86419753],\n", + " [0.096 , 0.11242117, 1. ],\n", + " [0.07946667, 0.09295311, 0.86419753],\n", + " [0.06346667, 0.07403345, 0.85185185],\n", + " [0.04746667, 0.054017 , 0.86419753],\n", + " [0.03306667, 0.03729092, 0.75308642],\n", + " [0.01653333, 0.01864546, 0.83950617],\n", + " [0. , 0. , 0.87654321]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.05260333, 0.13806487, 0.89041096],\n", + " [0.15727322, 0.26919878, 0.90410959],\n", + " [0.30220075, 0.40033269, 1. ],\n", + " [0.4417606 , 0.51899085, 0.90410959],\n", + " [0.58507783, 0.64014416, 0.90410959],\n", + " [0.72141707, 0.75602994, 0.89041096],\n", + " [0.86151369, 0.87912393, 0.91780822],\n", + " [1. , 1. , 0.90410959]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90921087, 0.93075684, 0.875 ],\n", + " [0.81710214, 0.86151369, 0.8875 ],\n", + " [0.72578517, 0.79388084, 0.8625 ],\n", + " [0.64713645, 0.7310789 , 0.7625 ],\n", + " [0.55634732, 0.64573269, 0.875 ],\n", + " [0.46634996, 0.54267311, 0.8625 ],\n", + " [0.37529691, 0.44122383, 0.875 ],\n", + " [0.28503563, 0.33816425, 0.875 ],\n", + " [0.1942465 , 0.23027375, 0.875 ],\n", + " [0.09026128, 0.10628019, 1. ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.02151364, 0.91272189, 0.77777778],\n", + " [0.07760277, 0.84201183, 0.82716049],\n", + " [0.14252785, 0.7816568 , 0.85185185],\n", + " [0.20591625, 0.72248521, 0.86419753],\n", + " [0.27660392, 0.66627219, 0.86419753],\n", + " [0.34959662, 0.6147929 , 0.87654321],\n", + " [0.42451018, 0.56183432, 0.86419753],\n", + " [0.51363811, 0.49940828, 0.85185185],\n", + " [0.62005378, 0.41863905, 0.86419753],\n", + " [0.72685363, 0.33254438, 0.86419753],\n", + " [0.86438725, 0.2204142 , 1. ],\n", + " [0.953131 , 0.11005917, 0.85185185],\n", + " [1. , 0. , 0.79012346]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11078717, 0.91412349, 0.97222222],\n", + " [0.22643343, 0.83818311, 0.97222222],\n", + " [0.33041788, 0.75159688, 0.97222222],\n", + " [0.42662779, 0.66879584, 0.94444444],\n", + " [0.52089407, 0.58552165, 0.97222222],\n", + " [0.60155491, 0.49893542, 1. ],\n", + " [0.67930029, 0.41968299, 0.97222222],\n", + " [0.74344023, 0.3354625 , 0.95833333],\n", + " [0.80660836, 0.25384433, 0.97222222],\n", + " [0.8707483 , 0.16702153, 0.98611111],\n", + " [0.93586006, 0.08682281, 0.95833333],\n", + " [1. , 0. , 0.97222222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12092906, 0.14975845, 0.953125 ],\n", + " [0.24816965, 0.28019324, 0.984375 ],\n", + " [0.37414794, 0.41545894, 0.96875 ],\n", + " [0.50290331, 0.51690821, 1. ],\n", + " [0.62989144, 0.66666667, 1. ],\n", + " [0.75511235, 0.78743961, 1. ],\n", + " [0.87755617, 0.89371981, 0.96875 ],\n", + " [1. , 1. , 0.96875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14429791, 0.15139442, 0.98507463],\n", + " [0.2906646 , 0.29880478, 0.98507463],\n", + " [0.43392811, 0.43957503, 1. ],\n", + " [0.57900181, 0.58167331, 0.97014925],\n", + " [0.72019653, 0.72377158, 0.97014925],\n", + " [0.85285751, 0.85922975, 0.91044776],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08083333, 0.08108108, 0.95774648],\n", + " [0.15444444, 0.15015015, 0.87323944],\n", + " [0.23888889, 0.24024024, 0.97183099],\n", + " [0.3225 , 0.32132132, 0.98591549],\n", + " [0.41 , 0.40540541, 1. ],\n", + " [0.49444444, 0.48648649, 0.97183099],\n", + " [0.57805556, 0.57057057, 0.97183099],\n", + " [0.66555556, 0.65165165, 1. ],\n", + " [0.75305556, 0.72972973, 1. ],\n", + " [0.83833333, 0.84084084, 0.95774648],\n", + " [0.9125 , 0.91591592, 0.85915493],\n", + " [1. , 1. , 0.97183099]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13843236, 0.13931034, 0.95522388],\n", + " [0.28318584, 0.28505747, 1. ],\n", + " [0.42414665, 0.42574713, 0.98507463],\n", + " [0.56731985, 0.56873563, 0.98507463],\n", + " [0.71333755, 0.71356322, 0.98507463],\n", + " [0.85493047, 0.8537931 , 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9012987 , 0.90759754, 0.58333333],\n", + " [0.80285714, 0.83778234, 0.58333333],\n", + " [0.67662338, 0.71047228, 0.75833333],\n", + " [0.54961039, 0.60985626, 0.74166667],\n", + " [0.38103896, 0.44558522, 1. ],\n", + " [0.20961039, 0.2587269 , 1. ],\n", + " [0.11558442, 0.15605749, 0.575 ],\n", + " [0. , 0. , 0.675 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11849711, 0.11510791, 1. ],\n", + " [0.21728849, 0.23021583, 0.88571429],\n", + " [0.33499737, 0.37410072, 0.97142857],\n", + " [0.43483973, 0.48561151, 0.9 ],\n", + " [0.54913295, 0.60791367, 1. ],\n", + " [0.6660536 , 0.70863309, 1. ],\n", + " [0.78271151, 0.80215827, 0.95714286],\n", + " [0.89963216, 0.90647482, 0.98571429],\n", + " [1. , 1. , 0.87142857]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8843599 , 0.88255699, 0.87341772],\n", + " [0.78713768, 0.78691774, 0.89873418],\n", + " [0.67542271, 0.67542121, 0.88607595],\n", + " [0.55253623, 0.55153617, 1. ],\n", + " [0.43025362, 0.43409316, 0.91139241],\n", + " [0.3227657 , 0.32259663, 1. ],\n", + " [0.20591787, 0.20317146, 0.88607595],\n", + " [0.1053744 , 0.10455897, 0.87341772],\n", + " [0. , 0. , 0.89873418]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89562842, 0.89632701, 0.97222222],\n", + " [0.79590164, 0.79265403, 0.95833333],\n", + " [0.69726776, 0.69312796, 0.97222222],\n", + " [0.59234973, 0.5936019 , 1. ],\n", + " [0.4931694 , 0.49170616, 0.94444444],\n", + " [0.38989071, 0.38803318, 0.97222222],\n", + " [0.30136612, 0.30331754, 0.86111111],\n", + " [0.19726776, 0.19964455, 0.95833333],\n", + " [0.0989071 , 0.1007109 , 0.97222222],\n", + " [0. , 0. , 0.97222222]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88354577, 0.88541667, 1. ],\n", + " [0.77230591, 0.77380952, 0.97183099],\n", + " [0.67555041, 0.67633929, 0.85915493],\n", + " [0.5631518 , 0.56473214, 0.97183099],\n", + " [0.45307068, 0.45337302, 0.97183099],\n", + " [0.34125145, 0.34102183, 1. ],\n", + " [0.22827346, 0.2281746 , 0.97183099],\n", + " [0.11355736, 0.11383929, 1. ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13505435, 0.13846154, 0.85897436],\n", + " [0.27853261, 0.28923077, 0.84615385],\n", + " [0.41440217, 0.42153846, 0.83333333],\n", + " [0.55842391, 0.56 , 0.85897436],\n", + " [0.69429348, 0.69846154, 0.84615385],\n", + " [0.8388587 , 0.84307692, 0.83333333],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92218137, 0.91220347, 0.97222222],\n", + " [0.84129902, 0.82660797, 0.98611111],\n", + " [0.76164216, 0.739056 , 0.95833333],\n", + " [0.68198529, 0.65028124, 0.97222222],\n", + " [0.60355392, 0.56419663, 0.95833333],\n", + " [0.51776961, 0.4793348 , 0.97222222],\n", + " [0.42463235, 0.39471753, 1. ],\n", + " [0.33578431, 0.31352409, 0.95833333],\n", + " [0.24019608, 0.23208608, 0.98611111],\n", + " [0.14522059, 0.14795794, 0.95833333],\n", + " [0.06311275, 0.07581316, 0.86111111],\n", + " [0. , 0. , 0.86111111]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90829932, 0.90315789, 0.8625 ],\n", + " [0.8155102 , 0.81684211, 0.8875 ],\n", + " [0.72653061, 0.72631579, 0.875 ],\n", + " [0.64217687, 0.61473684, 0.8625 ],\n", + " [0.55646259, 0.53684211, 0.875 ],\n", + " [0.46666667, 0.46315789, 0.875 ],\n", + " [0.3755102 , 0.38105263, 0.875 ],\n", + " [0.27346939, 0.28842105, 1. ],\n", + " [0.18367347, 0.20210526, 0.875 ],\n", + " [0.09170068, 0.09894737, 0.8875 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.0730897 , 0.15336323, 0.98412698],\n", + " [0.14950166, 0.30627803, 0.98412698],\n", + " [0.23225612, 0.44932735, 0.98412698],\n", + " [0.32890365, 0.57130045, 0.98412698],\n", + " [0.43219571, 0.66636771, 0.98412698],\n", + " [0.54032014, 0.75650224, 0.98412698],\n", + " [0.65206886, 0.82735426, 0.98412698],\n", + " [0.76834793, 0.88609865, 0.98412698],\n", + " [0.88160677, 0.9426009 , 0.98412698],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89518519, 0.09816164, 0.95454545],\n", + " [0.7962963 , 0.19667014, 0.95454545],\n", + " [0.69407407, 0.30107527, 0.95454545],\n", + " [0.59259259, 0.39889005, 0.96969697],\n", + " [0.49407407, 0.49705168, 0.95454545],\n", + " [0.39407407, 0.60006937, 0.93939394],\n", + " [0.30259259, 0.69961845, 0.92424242],\n", + " [0.2037037 , 0.79188345, 0.92424242],\n", + " [0.10518519, 0.89594173, 0.95454545],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16117436, 0.15540363, 0.69072165],\n", + " [0.31755542, 0.30712595, 0.68041237],\n", + " [0.47693229, 0.46331843, 0.67010309],\n", + " [0.69862193, 0.68971864, 1. ],\n", + " [0.84961055, 0.84380752, 0.67010309],\n", + " [1. , 1. , 0.69072165]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12153918, 0.12887305, 0.98507463],\n", + " [0.247771 , 0.25582671, 0.98507463],\n", + " [0.36461755, 0.36989306, 0.91044776],\n", + " [0.49225716, 0.49629833, 0.97014925],\n", + " [0.6194275 , 0.62270359, 0.98507463],\n", + " [0.74659784, 0.74910886, 0.98507463],\n", + " [0.87236039, 0.87359474, 0.97014925],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09700064, 0.90128449, 0.875 ],\n", + " [0.21059349, 0.79019981, 0.9875 ],\n", + " [0.31844288, 0.67673644, 1. ],\n", + " [0.41608168, 0.57611798, 0.875 ],\n", + " [0.52776005, 0.46717412, 0.9875 ],\n", + " [0.6094448 , 0.38058991, 0.7625 ],\n", + " [0.70963625, 0.28235014, 0.875 ],\n", + " [0.79897894, 0.19838249, 0.7625 ],\n", + " [0.89917039, 0.09871551, 0.8625 ],\n", + " [1. , 0. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09530634, 0.09535604, 0.97183099],\n", + " [0.18487997, 0.18637771, 0.98591549],\n", + " [0.27337872, 0.27616099, 0.97183099],\n", + " [0.35865281, 0.3622291 , 0.87323944],\n", + " [0.45252598, 0.45510836, 0.95774648],\n", + " [0.54317449, 0.54582043, 1. ],\n", + " [0.62916517, 0.63157895, 0.85915493],\n", + " [0.72053028, 0.72291022, 0.97183099],\n", + " [0.8172698 , 0.81950464, 1. ],\n", + " [0.9082766 , 0.90959752, 0.95774648],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11010597, 0.91390728, 0.89873418],\n", + " [0.21555958, 0.82119205, 0.87341772],\n", + " [0.32618248, 0.72847682, 0.89873418],\n", + " [0.43680538, 0.62251656, 0.89873418],\n", + " [0.56164384, 0.48344371, 1. ],\n", + " [0.66787284, 0.35761589, 0.87341772],\n", + " [0.78030499, 0.2384106 , 0.89873418],\n", + " [0.88963556, 0.10596026, 0.88607595],\n", + " [1. , 0. , 0.88607595]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90500864, 0.89541716, 0.8875 ],\n", + " [0.82210708, 0.80023502, 0.85 ],\n", + " [0.74265976, 0.7106933 , 0.7625 ],\n", + " [0.62867012, 0.60987074, 0.875 ],\n", + " [0.52158895, 0.51374853, 0.875 ],\n", + " [0.39896373, 0.39882491, 1. ],\n", + " [0.2970639 , 0.2972973 , 0.8875 ],\n", + " [0.19861831, 0.19835488, 0.8625 ],\n", + " [0.10189983, 0.10105758, 0.875 ],\n", + " [0. , 0. , 0.8875 ]]),\n", + " array([[0.93979592, 0.97787398, 0. ],\n", + " [0.95408163, 0.97763348, 0.01236338],\n", + " [0.9622449 , 0.98027898, 0.03601505],\n", + " [0.95918367, 0.97643098, 0.02526429],\n", + " [0.95714286, 0.98075998, 0.03189393],\n", + " [0.95408163, 0.97715248, 0.06450457],\n", + " [0.96530612, 0.97883598, 0.22612435],\n", + " [0.97755102, 0.98003848, 0.70883354],\n", + " [0.96938776, 0.97883598, 0.3228812 ],\n", + " [0.9744898 , 0.98148148, 0.16090306],\n", + " [0.9755102 , 0.97787398, 0.03278982],\n", + " [0.97040816, 0.98124098, 0.03207311],\n", + " [0.98061224, 0.98244348, 0.03189393],\n", + " [0.9744898 , 0.97787398, 0.03278982],\n", + " [0.97040816, 0.98244348, 0.06414621],\n", + " [0.97244898, 0.97763348, 0.03243146],\n", + " [0.96428571, 0.97883598, 0.03189393],\n", + " [0.97244898, 0.97667148, 0.12954668],\n", + " [0.96428571, 0.98075998, 0.09675685],\n", + " [0.96938776, 0.97763348, 0.03243146],\n", + " [0.96428571, 0.97546898, 0.28973302],\n", + " [0.9744898 , 0.97594998, 0.48378427],\n", + " [0.97959184, 0.97835498, 0.19351371],\n", + " [0.96530612, 0.98003848, 0.22612435],\n", + " [0.96938776, 0.97763348, 0.64468733],\n", + " [0.96428571, 0.97546898, 0.80684465],\n", + " [0.9744898 , 0.98027898, 0.06432539],\n", + " [0.9744898 , 0.97763348, 0.03171475],\n", + " [0.98469388, 0.97835498, 0.09693603],\n", + " [0.97040816, 0.97715248, 0.29044974],\n", + " [0.98265306, 0.97715248, 0.03225228],\n", + " [0.9755102 , 0.98003848, 0.06468375],\n", + " [0.95510204, 0.98725349, 0.03207311],\n", + " [0.97040816, 0.97907648, 0.03243146],\n", + " [0.96734694, 0.97667148, 0.03225228],\n", + " [0.97755102, 0.97667148, 0.03171475],\n", + " [0.96938776, 0.97835498, 0.06504211],\n", + " [0.97244898, 0.97546898, 0.03171475],\n", + " [0.97244898, 0.97955748, 0.09729439],\n", + " [0.97040816, 0.97643098, 0.09639849],\n", + " [0.96938776, 0.98027898, 0.09657767],\n", + " [0.96938776, 0.97667148, 0.2908081 ],\n", + " [0.96020408, 0.97474747, 0.16090306],\n", + " [0.96530612, 0.97835498, 0.25801828],\n", + " [0.96428571, 0.97546898, 0.19333453],\n", + " [0.9744898 , 0.97522848, 0.22612435],\n", + " [0.99489796, 0.97907648, 0.1614406 ],\n", + " [0.98571429, 0.98075998, 0.16090306],\n", + " [0.97755102, 0.98388648, 0.80648629],\n", + " [0.9877551 , 0.98364598, 0.35441677],\n", + " [0.99591837, 0.98027898, 0.22576599],\n", + " [0.99285714, 0.98364598, 0.03243146],\n", + " [0.98061224, 0.98124098, 0.09657767],\n", + " [0.98979592, 0.98148148, 0.19369289],\n", + " [0.98061224, 0.97955748, 1. ],\n", + " [0.9744898 , 0.98436748, 0.19369289],\n", + " [0.98265306, 0.97835498, 0.06414621],\n", + " [0.98469388, 0.98244348, 0.1614406 ],\n", + " [0.99591837, 0.98148148, 0.25801828],\n", + " [0.98979592, 0.98508899, 0.19369289],\n", + " [0.99591837, 0.98268398, 0.06450457],\n", + " [0.99081633, 0.98484848, 0.06450457],\n", + " [1. , 0.98268398, 0.06468375],\n", + " [0.98979592, 0.98244348, 0.1284716 ],\n", + " [0.97959184, 0.98436748, 0.09675685],\n", + " [0.99081633, 0.98148148, 0.09675685],\n", + " [0.97755102, 0.98316498, 0.1293675 ],\n", + " [0.99489796, 0.98027898, 0.03207311],\n", + " [0.98469388, 0.98268398, 0.09675685],\n", + " [0.98061224, 0.98003848, 0.16108224],\n", + " [0.97244898, 0.97715248, 0.29062892],\n", + " [0.96020408, 0.97594998, 0.03207311],\n", + " [0.94693878, 0.97306397, 0.03243146],\n", + " [0.95204082, 0.97715248, 0.61225587],\n", + " [0.95408163, 0.97282347, 0.03261064],\n", + " [0.95204082, 0.97667148, 0.48360509],\n", + " [0.94387755, 0.97907648, 0.09693603],\n", + " [0.95204082, 0.97787398, 0.03243146],\n", + " [0.95918367, 0.97594998, 0.06396703],\n", + " [0.94897959, 0.97715248, 0.03225228],\n", + " [0.95714286, 0.97594998, 0.03243146],\n", + " [0.93979592, 0.98075998, 0.09657767],\n", + " [0.94897959, 0.97546898, 0.06522129],\n", + " [0.95408163, 0.97186147, 0.64486651],\n", + " [0.96020408, 0.97787398, 0.06414621],\n", + " [0.96020408, 0.97522848, 0.03278982],\n", + " [0.94897959, 0.97354497, 0.03189393],\n", + " [0.96020408, 0.97402597, 0.12900914],\n", + " [0.94183673, 0.97522848, 0.03243146],\n", + " [0.95204082, 0.97306397, 0.06432539],\n", + " [0.95408163, 0.97546898, 0.38684824],\n", + " [0.94489796, 0.97402597, 0.25819746],\n", + " [0.94387755, 0.97667148, 0.12918832],\n", + " [0.94387755, 0.97402597, 0.16090306],\n", + " [0.93979592, 0.97715248, 0.22576599],\n", + " [0.95510204, 0.97667148, 0.45189034],\n", + " [0.94183673, 0.97643098, 0.12865078],\n", + " [0.95204082, 0.97667148, 0.06486293],\n", + " [0.95918367, 0.97474747, 0.41874216],\n", + " [0.95408163, 0.97835498, 0.12918832],\n", + " [0.95204082, 0.97474747, 0.06450457],\n", + " [0.94897959, 0.97787398, 0.06468375],\n", + " [0.95204082, 0.98027898, 0.09693603],\n", + " [0.94183673, 0.97763348, 0.03207311],\n", + " [0.94693878, 0.97426647, 0.03189393],\n", + " [0.94387755, 0.97715248, 0.06468375],\n", + " [0.95510204, 0.97282347, 0.03225228],\n", + " [0.93979592, 0.97907648, 0.03243146],\n", + " [0.94897959, 0.97426647, 0.03189393],\n", + " [0.94489796, 0.97715248, 0.38702741],\n", + " [0.95204082, 0.97282347, 0.03243146],\n", + " [0.93877551, 0.97546898, 0.23830855],\n", + " [0.91428571, 0.97546898, 0.01272173],\n", + " [0.88877551, 0.97715248, 0.01236338],\n", + " [0.86734694, 0.98316498, 0.01146748],\n", + " [0.84489796, 0.98869649, 0.0112883 ],\n", + " [0.84489796, 0.9963925 , 0.01146748],\n", + " [0.86326531, 1. , 0.0112883 ],\n", + " [0.84489796, 0.9987975 , 0.03691095],\n", + " [0.81938776, 0.98917749, 0.01272173],\n", + " [0.78877551, 0.97065897, 0.01254256],\n", + " [0.76020408, 0.94660895, 0.01254256],\n", + " [0.73265306, 0.91871092, 0.01236338],\n", + " [0.70510204, 0.88263588, 0.01254256],\n", + " [0.67653061, 0.84175084, 0.01272173],\n", + " [0.64387755, 0.8003848 , 0.01254256],\n", + " [0.60816327, 0.75781626, 0.01236338],\n", + " [0.56938776, 0.71212121, 0.01272173],\n", + " [0.53163265, 0.66522367, 0.01254256],\n", + " [0.49489796, 0.62169312, 0.01236338],\n", + " [0.45510204, 0.57142857, 0.01254256],\n", + " [0.42142857, 0.52982203, 0.01092994],\n", + " [0.38877551, 0.47931698, 0.01236338],\n", + " [0.34489796, 0.42448292, 0.01236338],\n", + " [0.30408163, 0.36820587, 0.01290091],\n", + " [0.26020408, 0.31409331, 0.01254256],\n", + " [0.20918367, 0.25877826, 0.01236338],\n", + " [0.16326531, 0.1996152 , 0.01272173],\n", + " [0.12346939, 0.14502165, 0.01236338],\n", + " [0.07755102, 0.08922559, 0.01254256],\n", + " [0.03877551, 0.04569505, 0.01092994],\n", + " [0. , 0. , 0.01236338]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1303781 , 0.15514019, 0.91025641],\n", + " [0.25110821, 0.3046729 , 0.84615385],\n", + " [0.38852673, 0.46728972, 1. ],\n", + " [0.51160365, 0.59252336, 0.84615385],\n", + " [0.63624511, 0.69158879, 0.84615385],\n", + " [0.75619296, 0.79439252, 0.85897436],\n", + " [0.88187744, 0.90093458, 0.83333333],\n", + " [1. , 1. , 0.84615385]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86635945, 0.11473121, 0.84146341],\n", + " [0.77419355, 0.20781941, 0.74390244],\n", + " [0.65437788, 0.31347452, 0.82926829],\n", + " [0.52995392, 0.44333256, 1. ],\n", + " [0.42857143, 0.55783104, 0.85365854],\n", + " [0.32258065, 0.66395159, 0.82926829],\n", + " [0.20737327, 0.78007912, 0.87804878],\n", + " [0.11520737, 0.88666512, 0.85365854],\n", + " [0. , 1. , 0.84146341]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12522407, 0.12554745, 0.98507463],\n", + " [0.24814341, 0.24817518, 0.97014925],\n", + " [0.37490397, 0.37372263, 1. ],\n", + " [0.49987196, 0.50072993, 0.98507463],\n", + " [0.62279129, 0.62189781, 0.97014925],\n", + " [0.75006402, 0.75182482, 0.98507463],\n", + " [0.87503201, 0.87591241, 1. ],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10034058, 0.09915966, 0.98591549],\n", + " [0.20696882, 0.20504202, 0.98591549],\n", + " [0.30599948, 0.29747899, 0.97183099],\n", + " [0.41131779, 0.40168067, 0.98591549],\n", + " [0.49331936, 0.48571429, 0.85915493],\n", + " [0.59732774, 0.60336134, 0.98591549],\n", + " [0.70159811, 0.69747899, 0.98591549],\n", + " [0.79905685, 0.78991597, 0.97183099],\n", + " [0.89651559, 0.89411765, 0.98591549],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.0754902 , 0.9233916 , 0.97222222],\n", + " [0.15326797, 0.84678319, 0.95833333],\n", + " [0.22712418, 0.77277798, 0.95833333],\n", + " [0.30653595, 0.69245073, 1. ],\n", + " [0.38267974, 0.61547044, 0.97222222],\n", + " [0.45915033, 0.5396058 , 0.95833333],\n", + " [0.53627451, 0.46336928, 0.98611111],\n", + " [0.6127451 , 0.38638899, 0.97222222],\n", + " [0.68986928, 0.30903682, 0.95833333],\n", + " [0.76699346, 0.23131276, 0.98611111],\n", + " [0.84379085, 0.15693566, 0.95833333],\n", + " [0.92058824, 0.0792116 , 0.95833333],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90215924, 0.09635974, 0.50833333],\n", + " [0.78609987, 0.21493576, 0.58333333],\n", + " [0.67139001, 0.33217345, 0.575 ],\n", + " [0.55870445, 0.44780514, 0.58333333],\n", + " [0.44197031, 0.56691649, 0.58333333],\n", + " [0.32591093, 0.68335118, 0.59166667],\n", + " [0.20917679, 0.80192719, 0.575 ],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.19902518, 0.21813842, 1. ],\n", + " [0.37043054, 0.37494033, 0.73825503],\n", + " [0.48009748, 0.47565632, 0.46979866],\n", + " [0.60357433, 0.59164678, 0.53020134],\n", + " [0.77010561, 0.76634845, 0.80536913],\n", + " [0.89114541, 0.89952267, 0.61073826],\n", + " [1. , 1. , 0.46308725]]),\n", + " array([[0.01182894, 0. , 0. ],\n", + " [0. , 0.10011312, 0.97222222],\n", + " [0.03548681, 0.19852941, 0.98611111],\n", + " [0.0955414 , 0.28450226, 0.94444444],\n", + " [0.17515924, 0.3594457 , 0.98611111],\n", + " [0.26979072, 0.41798643, 0.95833333],\n", + " [0.35395814, 0.45701357, 0.84722222],\n", + " [0.45177434, 0.49519231, 0.95833333],\n", + " [0.53867152, 0.52658371, 0.84722222],\n", + " [0.64240218, 0.56165158, 0.95833333],\n", + " [0.74840764, 0.59983032, 1. ],\n", + " [0.84167425, 0.64988688, 0.95833333],\n", + " [0.91856233, 0.71973982, 0.97222222],\n", + " [0.98089172, 0.80656109, 0.97222222],\n", + " [1. , 0.89847285, 0.875 ],\n", + " [0.99499545, 1. , 0.94444444]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92142328, 0.9245424 , 0.98591549],\n", + " [0.84581171, 0.85095256, 0.97183099],\n", + " [0.76575241, 0.77325364, 0.98591549],\n", + " [0.68865827, 0.70003736, 0.98591549],\n", + " [0.60896961, 0.6242062 , 1. ],\n", + " [0.53150482, 0.55024281, 0.98591549],\n", + " [0.45515196, 0.47254389, 0.98591549],\n", + " [0.3795404 , 0.39223011, 0.98591549],\n", + " [0.30355819, 0.31378409, 0.98591549],\n", + " [0.22646405, 0.23459096, 0.98591549],\n", + " [0.153447 , 0.1580127 , 0.97183099],\n", + " [0.0767235 , 0.07919313, 1. ],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08695652, 0.94240715, 0.75308642],\n", + " [0.1826087 , 0.88316878, 0.83950617],\n", + " [0.28695652, 0.82628115, 0.87654321],\n", + " [0.48695652, 0.76680771, 1. ],\n", + " [0.65217391, 0.7157969 , 0.86419753],\n", + " [0.72173913, 0.66995769, 0.85185185],\n", + " [0.83478261, 0.61988717, 0.85185185],\n", + " [0.93913043, 0.55594734, 0.87654321],\n", + " [1. , 0.45886225, 0.98765432],\n", + " [0.89565217, 0.36600846, 0.86419753],\n", + " [0.7826087 , 0.26962858, 0.86419753],\n", + " [0.72173913, 0.16690174, 0.87654321],\n", + " [0.70434783, 0.07287259, 0.85185185],\n", + " [0.70434783, 0. , 0.75308642]]),\n", + " array([[0.96470588, 1. , 0. ],\n", + " [0.98431373, 0.94561572, 0.875 ],\n", + " [1. , 0.89362722, 0.8625 ],\n", + " [0.94509804, 0.83972209, 0.875 ],\n", + " [0.9254902 , 0.78581696, 0.8875 ],\n", + " [0.90196078, 0.73287015, 0.8625 ],\n", + " [0.8627451 , 0.68040249, 0.8875 ],\n", + " [0.81568627, 0.62577863, 0.8875 ],\n", + " [0.75686275, 0.56756109, 0.8625 ],\n", + " [0.68627451, 0.50646862, 0.875 ],\n", + " [0.59215686, 0.4425012 , 0.8875 ],\n", + " [0.51372549, 0.38021083, 0.875 ],\n", + " [0.43529412, 0.3186392 , 0.8625 ],\n", + " [0.34509804, 0.24676569, 1. ],\n", + " [0.25882353, 0.1825587 , 0.8625 ],\n", + " [0.16862745, 0.11859128, 0.875 ],\n", + " [0.07843137, 0.06276953, 0.7625 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10401003, 0.1039865 , 0.98591549],\n", + " [0.20864662, 0.20839485, 0.97183099],\n", + " [0.30388471, 0.29761654, 0.85915493],\n", + " [0.410401 , 0.39991563, 0.97183099],\n", + " [0.51754386, 0.50727695, 1. ],\n", + " [0.60463659, 0.59755326, 0.85915493],\n", + " [0.70238095, 0.70132883, 0.95774648],\n", + " [0.79010025, 0.79160515, 0.85915493],\n", + " [0.89598997, 0.89748998, 0.98591549],\n", + " [1. , 1. , 0.97183099]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12607204, 0.12433989, 0.98507463],\n", + " [0.25557461, 0.25132021, 0.97014925],\n", + " [0.38336192, 0.37566011, 0.98507463],\n", + " [0.51200686, 0.50120019, 0.98507463],\n", + " [0.6406518 , 0.62698032, 1. ],\n", + " [0.75471698, 0.74843975, 0.98507463],\n", + " [0.87049743, 0.87469995, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11562897, 0.99578652, 0.88732394],\n", + " [0.227446 , 0.98291199, 0.90140845],\n", + " [0.31766201, 0.96067416, 0.88732394],\n", + " [0.39135959, 0.92485955, 0.94366197],\n", + " [0.45489199, 0.87874532, 0.98591549],\n", + " [0.50825921, 0.82420412, 0.97183099],\n", + " [0.54637865, 0.76755618, 0.98591549],\n", + " [0.58831004, 0.70201311, 0.98591549],\n", + " [0.63532402, 0.62710674, 1. ],\n", + " [0.68360864, 0.54775281, 0.98591549],\n", + " [0.73189327, 0.46839888, 0.98591549],\n", + " [0.78144854, 0.3883427 , 0.97183099],\n", + " [0.83100381, 0.30781835, 0.98591549],\n", + " [0.87674714, 0.22846442, 0.98591549],\n", + " [0.91486658, 0.15941011, 0.85915493],\n", + " [0.96188056, 0.08052434, 0.98591549],\n", + " [1. , 0. , 0.97183099]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.0857014 , 0.9123977 , 0.77777778],\n", + " [0.19079838, 0.80327372, 0.96296296],\n", + " [0.28101037, 0.71445893, 0.77777778],\n", + " [0.38926477, 0.60775993, 0.97530864],\n", + " [0.50202977, 0.49772658, 0.97530864],\n", + " [0.61208841, 0.38648075, 1. ],\n", + " [0.71853857, 0.27796302, 0.96296296],\n", + " [0.8037889 , 0.19248257, 0.75308642],\n", + " [0.91249436, 0.08608669, 0.97530864],\n", + " [1. , 0. , 0.7654321 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10288858, 0.09943002, 0.69306931],\n", + " [0.20412655, 0.20012666, 0.68316832],\n", + " [0.30866575, 0.30525649, 0.7029703 ],\n", + " [0.41155433, 0.40785307, 0.69306931],\n", + " [0.54277854, 0.53704877, 0.88118812],\n", + " [0.64566713, 0.64091197, 0.69306931],\n", + " [0.74828061, 0.74794174, 0.69306931],\n", + " [0.89628611, 0.90120329, 1. ],\n", + " [1. , 1. , 0.68316832]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90769231, 0.91040089, 0.84931507],\n", + " [0.8021978 , 0.8058378 , 0.94520548],\n", + " [0.71428571, 0.71623868, 0.89041096],\n", + " [0.61538462, 0.61333826, 0.87671233],\n", + " [0.5032967 , 0.50748199, 0.95890411],\n", + " [0.3978022 , 0.40458156, 0.91780822],\n", + " [0.29450549, 0.29872529, 0.95890411],\n", + " [0.2043956 , 0.20912618, 0.84931507],\n", + " [0.1032967 , 0.10604101, 0.91780822],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85447761, 0.90103189, 1. ],\n", + " [0.72910448, 0.81355535, 0.87142857],\n", + " [0.58656716, 0.71693246, 1. ],\n", + " [0.44104478, 0.61984053, 0.97142857],\n", + " [0.30671642, 0.5325985 , 0.87142857],\n", + " [0.19701493, 0.42636023, 1. ],\n", + " [0.14328358, 0.31754221, 0.98571429],\n", + " [0.09626866, 0.2206848 , 0.88571429],\n", + " [0.05074627, 0.11045966, 0.98571429],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88820043, 0.88438134, 1. ],\n", + " [0.79229526, 0.79107505, 0.86419753],\n", + " [0.68292026, 0.68559838, 0.98765432],\n", + " [0.58701509, 0.5862069 , 0.85185185],\n", + " [0.47737069, 0.48073022, 0.98765432],\n", + " [0.38200431, 0.37728195, 0.87654321],\n", + " [0.28609914, 0.28803245, 0.87654321],\n", + " [0.19342672, 0.20081136, 0.83950617],\n", + " [0.09509698, 0.09736308, 0.87654321],\n", + " [0. , 0. , 0.85185185]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91606847, 0.90762125, 0.8875 ],\n", + " [0.83296521, 0.81755196, 0.875 ],\n", + " [0.74765323, 0.72979215, 0.875 ],\n", + " [0.65323026, 0.62586605, 1. ],\n", + " [0.57261182, 0.5404157 , 0.85 ],\n", + " [0.50027609, 0.4665127 , 0.7625 ],\n", + " [0.41579238, 0.36951501, 0.875 ],\n", + " [0.33296521, 0.26789838, 0.875 ],\n", + " [0.24986195, 0.18475751, 0.8875 ],\n", + " [0.1667587 , 0.08775982, 0.8625 ],\n", + " [0.08393153, 0.03002309, 0.8625 ],\n", + " [0. , 0. , 0.8875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.13684211, 0.90286885, 1. ],\n", + " [0.26315789, 0.80840164, 1. ],\n", + " [0.36842105, 0.71741803, 0.95774648],\n", + " [0.42105263, 0.62151639, 1. ],\n", + " [0.45263158, 0.52766393, 1. ],\n", + " [0.45263158, 0.44282787, 0.98591549],\n", + " [0.49473684, 0.36086066, 0.97183099],\n", + " [0.61052632, 0.2727459 , 1. ],\n", + " [0.73684211, 0.18606557, 0.95774648],\n", + " [0.89473684, 0.0932377 , 1. ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08838568, 0.90770332, 0.97222222],\n", + " [0.18115413, 0.81278321, 0.97222222],\n", + " [0.27611395, 0.71571667, 0.97222222],\n", + " [0.36961286, 0.61769616, 0.95833333],\n", + " [0.46749452, 0.51419032, 1. ],\n", + " [0.56245435, 0.41354639, 0.95833333],\n", + " [0.65960555, 0.31027904, 0.97222222],\n", + " [0.75748722, 0.20581922, 0.97222222],\n", + " [0.87582177, 0.10302886, 0.97222222],\n", + " [1. , 0. , 0.97222222]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87419769, 0.12661969, 0.98507463],\n", + " [0.74967908, 0.24960218, 0.97014925],\n", + " [0.63157895, 0.37599454, 1. ],\n", + " [0.50834403, 0.49943169, 0.98507463],\n", + " [0.38510911, 0.62400546, 0.98507463],\n", + " [0.2593068 , 0.74903387, 0.98507463],\n", + " [0.13478819, 0.87383496, 0.98507463],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.06985605, 0.07512953, 0.69306931],\n", + " [0.1257409 , 0.17227979, 0.78217822],\n", + " [0.16892464, 0.2613342 , 0.71287129],\n", + " [0.21718882, 0.33257772, 0.61386139],\n", + " [0.2938188 , 0.39604922, 0.66336634],\n", + " [0.40304826, 0.47797927, 0.9009901 ],\n", + " [0.47502117, 0.54145078, 0.67326733],\n", + " [0.56054191, 0.60330311, 0.7029703 ],\n", + " [0.69983065, 0.69170984, 1. ],\n", + " [0.7811177 , 0.75744819, 0.68316832],\n", + " [0.85097375, 0.83678756, 0.69306931],\n", + " [0.92082981, 0.91645078, 0.69306931],\n", + " [1. , 1. , 0.69306931]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14454776, 0.13888889, 0.98507463],\n", + " [0.28909552, 0.28253968, 0.98507463],\n", + " [0.42011834, 0.41904762, 0.91044776],\n", + " [0.56213018, 0.56507937, 0.97014925],\n", + " [0.7097774 , 0.71111111, 1. ],\n", + " [0.8548887 , 0.85238095, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88547665, 0.88594099, 1. ],\n", + " [0.77415227, 0.77287379, 1. ],\n", + " [0.67370441, 0.67344409, 0.87142857],\n", + " [0.55918106, 0.56062485, 0.98571429],\n", + " [0.44273832, 0.44359038, 1. ],\n", + " [0.32885477, 0.32853955, 1. ],\n", + " [0.22840691, 0.22836598, 0.87142857],\n", + " [0.11516315, 0.11480288, 0.98571429],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90077178, 0.90071344, 1. ],\n", + " [0.79713341, 0.79667063, 0.97183099],\n", + " [0.69652701, 0.69560048, 0.98591549],\n", + " [0.60915105, 0.60939358, 0.85915493],\n", + " [0.51074972, 0.51129608, 0.97183099],\n", + " [0.40656009, 0.40725327, 0.97183099],\n", + " [0.30733186, 0.30915577, 1. ],\n", + " [0.2053473 , 0.20630202, 0.97183099],\n", + " [0.09867696, 0.0980975 , 1. ],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10070452, 0.10668103, 0.77380952],\n", + " [0.20679652, 0.21659483, 0.78571429],\n", + " [0.31123083, 0.32516164, 0.78571429],\n", + " [0.42353916, 0.44423491, 0.85714286],\n", + " [0.53087443, 0.55010776, 0.78571429],\n", + " [0.63945296, 0.65517241, 0.79761905],\n", + " [0.75093245, 0.76050647, 0.78571429],\n", + " [0.86033983, 0.86584052, 0.77380952],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12094595, 0.88481968, 0.64285714],\n", + " [0.22972973, 0.78221974, 0.57142857],\n", + " [0.33108108, 0.68157674, 0.57857143],\n", + " [0.47432432, 0.53816047, 0.79285714],\n", + " [0.56216216, 0.44786134, 0.49285714],\n", + " [0.73783784, 0.26977914, 1. ],\n", + " [0.87162162, 0.13055633, 0.77857143],\n", + " [1. , 0. , 0.71428571]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12235511, 0.87933025, 0.84615385],\n", + " [0.24471021, 0.76270208, 0.84615385],\n", + " [0.37749157, 0.63625866, 0.92307692],\n", + " [0.49800675, 0.51847575, 0.84615385],\n", + " [0.61821527, 0.39896074, 0.84615385],\n", + " [0.7598896 , 0.25808314, 1. ],\n", + " [0.88071144, 0.12586605, 0.84615385],\n", + " [1. , 0. , 0.85897436]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88912868, 0.88344988, 1. ],\n", + " [0.78014567, 0.76923077, 0.97183099],\n", + " [0.66765579, 0.65501166, 1. ],\n", + " [0.5578635 , 0.54778555, 0.97183099],\n", + " [0.4448341 , 0.43356643, 0.98591549],\n", + " [0.33207445, 0.33100233, 1. ],\n", + " [0.22093337, 0.22144522, 1. ],\n", + " [0.10952252, 0.10955711, 0.97183099],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12446675, 0.84671533, 0.98507463],\n", + " [0.24968632, 0.75912409, 0.98507463],\n", + " [0.37340025, 0.62043796, 0.98507463],\n", + " [0.49887077, 0.50364964, 1. ],\n", + " [0.62434128, 0.37226277, 0.98507463],\n", + " [0.75056462, 0.26277372, 0.98507463],\n", + " [0.87377666, 0.12408759, 0.97014925],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0.90909091, 1. , 0. ],\n", + " [1. , 0.84618814, 0.98630137],\n", + " [0.77272727, 0.7068658 , 0.90410959],\n", + " [0.63636364, 0.56977263, 0.89041096],\n", + " [0.36363636, 0.41596077, 1. ],\n", + " [0.45454545, 0.27797593, 0.90410959],\n", + " [0.36363636, 0.14132858, 0.89041096],\n", + " [0. , 0. , 0.91780822]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10122699, 0.11042642, 0.98591549],\n", + " [0.18711656, 0.21888095, 1. ],\n", + " [0.26380368, 0.33029332, 0.98591549],\n", + " [0.33128834, 0.44614247, 0.97183099],\n", + " [0.40797546, 0.55533646, 0.98591549],\n", + " [0.52147239, 0.66428395, 0.98591549],\n", + " [0.62269939, 0.77939364, 0.98591549],\n", + " [0.78527607, 0.89351738, 0.98591549],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87549744, 0.12984496, 1. ],\n", + " [0.74900512, 0.25484496, 1. ],\n", + " [0.64212621, 0.35658915, 0.8625 ],\n", + " [0.54434338, 0.45736434, 0.775 ],\n", + " [0.43746447, 0.56492248, 0.875 ],\n", + " [0.32603752, 0.67344961, 0.875 ],\n", + " [0.21972712, 0.78003876, 0.8625 ],\n", + " [0.10801592, 0.8875969 , 0.8875 ],\n", + " [0. , 1. , 0.8625 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91743917, 0.08354922, 0.97183099],\n", + " [0.83198146, 0.16968912, 1. ],\n", + " [0.74797219, 0.25388601, 0.98591549],\n", + " [0.66541136, 0.33678756, 0.97183099],\n", + " [0.58140209, 0.42033679, 0.98591549],\n", + " [0.49913094, 0.50194301, 0.98591549],\n", + " [0.41338355, 0.58873057, 1. ],\n", + " [0.33140209, 0.67163212, 0.97183099],\n", + " [0.24681344, 0.75453368, 0.98591549],\n", + " [0.16512167, 0.83549223, 1. ],\n", + " [0.08285052, 0.91904145, 0.97183099],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92225032, 0.1052374 , 0.98591549],\n", + " [0.83754741, 0.21096427, 1. ],\n", + " [0.7528445 , 0.31179638, 0.97183099],\n", + " [0.64538559, 0.41385218, 0.98591549],\n", + " [0.52907712, 0.51419481, 1. ],\n", + " [0.43552465, 0.60058737, 0.85915493],\n", + " [0.32996207, 0.69921684, 0.97183099],\n", + " [0.21871049, 0.79882526, 0.98591549],\n", + " [0.10366625, 0.89965737, 0.98591549],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85259516, 0.96371134, 0.77777778],\n", + " [0.683391 , 0.89525773, 0.9 ],\n", + " [0.52975779, 0.79051546, 0.87777778],\n", + " [0.36712803, 0.63917526, 1. ],\n", + " [0.2532872 , 0.48948454, 0.8 ],\n", + " [0.16262976, 0.33443299, 0.74444444],\n", + " [0.08062284, 0.17030928, 0.72222222],\n", + " [0. , 0. , 0.74444444]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14765101, 0.13244867, 0.86111111],\n", + " [0.27516779, 0.27115674, 0.875 ],\n", + " [0.42281879, 0.41462193, 0.91666667],\n", + " [0.57718121, 0.55783676, 0.93055556],\n", + " [0.72483221, 0.71382073, 1. ],\n", + " [0.88255034, 0.8575363 , 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87644092, 0.87342882, 1. ],\n", + " [0.75324207, 0.75007308, 1. ],\n", + " [0.62644092, 0.62262496, 1. ],\n", + " [0.50576369, 0.50160772, 1. ],\n", + " [0.37824207, 0.37562116, 1. ],\n", + " [0.25252161, 0.25197311, 1. ],\n", + " [0.12752161, 0.1271558 , 1. ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12169312, 0.12145073, 0.93055556],\n", + " [0.25396825, 0.25459318, 1. ],\n", + " [0.37830688, 0.37675972, 0.91666667],\n", + " [0.4973545 , 0.49773324, 0.90277778],\n", + " [0.62037037, 0.620377 , 0.93055556],\n", + " [0.75529101, 0.75471248, 1. ],\n", + " [0.87962963, 0.87640181, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91076257, 0.90163934, 0.875 ],\n", + " [0.82287723, 0.79391101, 0.8625 ],\n", + " [0.73201731, 0.70023419, 0.8875 ],\n", + " [0.6430503 , 0.6088993 , 0.875 ],\n", + " [0.55164954, 0.51522248, 0.875 ],\n", + " [0.46106003, 0.41920375, 0.875 ],\n", + " [0.37182261, 0.32552693, 0.875 ],\n", + " [0.26960519, 0.22716628, 1. ],\n", + " [0.17982693, 0.15222482, 0.875 ],\n", + " [0.08869659, 0.08196721, 0.8875 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89590255, 0.88209983, 0.91666667],\n", + " [0.79955703, 0.77423982, 0.84722222],\n", + " [0.6910299 , 0.66150316, 0.91666667],\n", + " [0.58065707, 0.55048766, 0.91666667],\n", + " [0.47065338, 0.44176707, 0.90277778],\n", + " [0.36581764, 0.34136546, 0.84722222],\n", + " [0.24031008, 0.22317843, 1. ],\n", + " [0.12513843, 0.11560528, 0.90277778],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92137592, 0.91666667, 0.74725275],\n", + " [0.84766585, 0.84682765, 0.67032967],\n", + " [0.74078624, 0.73697917, 1. ],\n", + " [0.65847666, 0.65435606, 0.76923077],\n", + " [0.58599509, 0.56889205, 0.76923077],\n", + " [0.50614251, 0.48768939, 0.74725275],\n", + " [0.43243243, 0.41595644, 0.67032967],\n", + " [0.34520885, 0.33072917, 0.78021978],\n", + " [0.25552826, 0.24928977, 0.76923077],\n", + " [0.16830467, 0.16619318, 0.75824176],\n", + " [0.07616708, 0.0842803 , 0.78021978],\n", + " [0. , 0. , 0.76923077]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88945796, 0.11057174, 0.87341772],\n", + " [0.77720871, 0.22168285, 0.88607595],\n", + " [0.65300896, 0.346548 , 1. ],\n", + " [0.55569782, 0.44606257, 0.78481013],\n", + " [0.446863 , 0.55582524, 0.87341772],\n", + " [0.33504055, 0.66855448, 0.89873418],\n", + " [0.2240717 , 0.77696872, 0.87341772],\n", + " [0.11139565, 0.88915858, 0.88607595],\n", + " [0. , 1. , 0.88607595]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88776306, 0.89086294, 0.88888889],\n", + " [0.79111458, 0.79695431, 0.78888889],\n", + " [0.69264744, 0.70050761, 0.77777778],\n", + " [0.60820992, 0.6142132 , 0.67777778],\n", + " [0.51415952, 0.51903553, 0.76666667],\n", + " [0.41699143, 0.42893401, 0.78888889],\n", + " [0.31982333, 0.33883249, 0.76666667],\n", + " [0.22213562, 0.23857868, 0.77777778],\n", + " [0.0971681 , 0.10025381, 1. ],\n", + " [0. , 0. , 0.77777778]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87319885, 0.88933333, 0.55279503],\n", + " [0.76421273, 0.77866667, 0.50310559],\n", + " [0.6463191 , 0.64533333, 0.55279503],\n", + " [0.44982971, 0.44533333, 0.86335404],\n", + " [0.23133351, 0.22266667, 1. ],\n", + " [0.11789363, 0.112 , 0.50310559],\n", + " [0. , 0. , 0.54658385]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92609971, 0.07053034, 0.86419753],\n", + " [0.85571848, 0.14160744, 0.86419753],\n", + " [0.78709677, 0.21377802, 0.86419753],\n", + " [0.71554252, 0.28430837, 0.86419753],\n", + " [0.64633431, 0.35347184, 0.86419753],\n", + " [0.57478006, 0.42017496, 0.85185185],\n", + " [0.50674487, 0.48715145, 0.86419753],\n", + " [0.42521994, 0.56670312, 0.98765432],\n", + " [0.34134897, 0.6470749 , 1. ],\n", + " [0.27096774, 0.71623838, 0.86419753],\n", + " [0.20234604, 0.78540186, 0.86419753],\n", + " [0.13020528, 0.86194642, 0.97530864],\n", + " [0.06392962, 0.93083652, 0.86419753],\n", + " [0. , 1. , 0.86419753]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12216495, 0.875 , 0.98507463],\n", + " [0.25180412, 0.74305556, 1. ],\n", + " [0.37706186, 0.60069444, 0.98507463],\n", + " [0.50128866, 0.47916667, 0.98507463],\n", + " [0.62319588, 0.35069444, 0.97014925],\n", + " [0.74690722, 0.23263889, 0.98507463],\n", + " [0.8742268 , 0.11458333, 1. ],\n", + " [1. , 0. , 0.97014925]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13523957, 0.14097136, 1. ],\n", + " [0.27820711, 0.28368618, 1. ],\n", + " [0.42272025, 0.42665006, 1. ],\n", + " [0.56568779, 0.56936488, 1. ],\n", + " [0.70942813, 0.71108344, 1. ],\n", + " [0.85471406, 0.85603985, 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14223331, 0.15036803, 0.98507463],\n", + " [0.28758578, 0.29810726, 0.97014925],\n", + " [0.42919526, 0.44426919, 1. ],\n", + " [0.57267623, 0.58885384, 0.97014925],\n", + " [0.71334997, 0.72607781, 0.98507463],\n", + " [0.86119775, 0.8659306 , 1. ],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8388497 , 0.98436214, 0.875 ],\n", + " [0.67715681, 0.96817558, 0.8875 ],\n", + " [0.5002713 , 0.95198903, 1. ],\n", + " [0.35973956, 0.91879287, 0.875 ],\n", + " [0.23114487, 0.87078189, 0.875 ],\n", + " [0.14324471, 0.8090535 , 0.7875 ],\n", + " [0.0759631 , 0.73223594, 0.8375 ],\n", + " [0.03798155, 0.64224966, 0.8875 ],\n", + " [0.03581118, 0.55198903, 0.875 ],\n", + " [0.03147043, 0.45843621, 0.8625 ],\n", + " [0.02333152, 0.36433471, 0.875 ],\n", + " [0.017363 , 0.27215364, 0.875 ],\n", + " [0.01193706, 0.17668038, 0.875 ],\n", + " [0.00488334, 0.09410151, 0.7625 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8874352 , 0.10502283, 0.81818182],\n", + " [0.79066897, 0.20273973, 0.6969697 ],\n", + " [0.69143421, 0.30319635, 0.71717172],\n", + " [0.58331276, 0.4109589 , 0.78787879],\n", + " [0.48160948, 0.51324201, 0.72727273],\n", + " [0.38262157, 0.61187215, 0.70707071],\n", + " [0.25623303, 0.74155251, 0.8989899 ],\n", + " [0.140706 , 0.85753425, 0.81818182],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87940208, 0.90277778, 0.91666667],\n", + " [0.75728401, 0.80555556, 0.91666667],\n", + " [0.63136559, 0.73611111, 0.93055556],\n", + " [0.51102103, 0.65277778, 0.90277778],\n", + " [0.37724854, 0.48611111, 1. ],\n", + " [0.25462376, 0.33333333, 0.93055556],\n", + " [0.13326577, 0.18055556, 0.90277778],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.78651685, 0.86210293, 0.97014925],\n", + " [0.58426966, 0.72395962, 1. ],\n", + " [0.39325843, 0.58827875, 0.98507463],\n", + " [0.28089888, 0.46614134, 0.97014925],\n", + " [0.21348315, 0.34892884, 0.97014925],\n", + " [0.13483146, 0.23023886, 0.98507463],\n", + " [0.05617978, 0.11647377, 0.92537313],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.21848739, 0.85865169, 0.75833333],\n", + " [0.44537815, 0.67325843, 1. ],\n", + " [0.57983193, 0.56494382, 0.58333333],\n", + " [0.68067227, 0.46089888, 0.56666667],\n", + " [0.66386555, 0.34921348, 0.59166667],\n", + " [0.73529412, 0.24179775, 0.58333333],\n", + " [0.8697479 , 0.13505618, 0.58333333],\n", + " [1. , 0. , 0.75 ]]),\n", + " array([[1. , 0.86547085, 0. ],\n", + " [0.90095847, 0.89686099, 0.8625 ],\n", + " [0.81203408, 0.91479821, 0.775 ],\n", + " [0.71379127, 0.95964126, 0.875 ],\n", + " [0.59904153, 1. , 1. ],\n", + " [0.49840256, 0.87892377, 0.8625 ],\n", + " [0.39882854, 0.72197309, 0.875 ],\n", + " [0.29792332, 0.5426009 , 0.8875 ],\n", + " [0.20101171, 0.3632287 , 0.8625 ],\n", + " [0.09984026, 0.17040359, 0.8875 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11358473, 0.11722413, 0.98591549],\n", + " [0.24216265, 0.22882151, 1. ],\n", + " [0.37755566, 0.32979056, 0.95774648],\n", + " [0.49750114, 0.4195061 , 0.85915493],\n", + " [0.62017265, 0.51172241, 0.85915493],\n", + " [0.75329396, 0.61863082, 0.97183099],\n", + " [0.84507042, 0.74210691, 0.98591549],\n", + " [0.92912313, 0.86902157, 0.98591549],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92313788, 0.90489914, 0.98611111],\n", + " [0.84812467, 0.81556196, 0.95833333],\n", + " [0.77126255, 0.73775216, 0.97222222],\n", + " [0.6967776 , 0.65417867, 0.95833333],\n", + " [0.61938722, 0.56195965, 1. ],\n", + " [0.54358162, 0.4870317 , 0.94444444],\n", + " [0.46698362, 0.43227666, 0.98611111],\n", + " [0.38880085, 0.37175793, 0.97222222],\n", + " [0.31220285, 0.31123919, 0.97222222],\n", + " [0.23454834, 0.24495677, 0.95833333],\n", + " [0.15662969, 0.16426513, 0.98611111],\n", + " [0.07686212, 0.0778098 , 0.98611111],\n", + " [0. , 0. , 0.94444444]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.23504722, 0.76533742, 1. ],\n", + " [0.42462399, 0.57592025, 0.78571429],\n", + " [0.62854145, 0.37154908, 0.85714286],\n", + " [0.81532004, 0.18443252, 0.79761905],\n", + " [1. , 0. , 0.77380952]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11025093, 0.0619883 , 0.875 ],\n", + " [0.22156967, 0.17660819, 0.875 ],\n", + " [0.32728243, 0.32397661, 0.875 ],\n", + " [0.43619861, 0.44093567, 0.8625 ],\n", + " [0.54618259, 0.5122807 , 0.8875 ],\n", + " [0.67351842, 0.62222222, 1. ],\n", + " [0.78270155, 0.75438596, 0.8875 ],\n", + " [0.89054992, 0.89824561, 0.85 ],\n", + " [1. , 1. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14278729, 0.14273356, 0.91666667],\n", + " [0.28361858, 0.28402537, 0.91666667],\n", + " [0.42689487, 0.42387543, 0.91666667],\n", + " [0.5794621 , 0.57756632, 1. ],\n", + " [0.71882641, 0.71597463, 0.91666667],\n", + " [0.86161369, 0.85870819, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1455518 , 0.13947001, 1. ],\n", + " [0.28631757, 0.27894003, 1. ],\n", + " [0.43186937, 0.41980474, 1. ],\n", + " [0.57263514, 0.55927476, 1. ],\n", + " [0.71818694, 0.69874477, 1. ],\n", + " [0.8589527 , 0.86052999, 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12225948, 0.16 , 0.91666667],\n", + " [0.24632448, 0.44 , 0.93055556],\n", + " [0.36652051, 0.68 , 0.90277778],\n", + " [0.49987103, 0.76 , 1. ],\n", + " [0.63322156, 0.72 , 1. ],\n", + " [0.75548104, 0.72 , 0.91666667],\n", + " [0.87774052, 0.84 , 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14014442, 0.16620499, 0.97014925],\n", + " [0.28617277, 0.32686981, 0.98507463],\n", + " [0.4263172 , 0.47922438, 1. ],\n", + " [0.57341535, 0.60941828, 0.98507463],\n", + " [0.71409468, 0.73407202, 0.98507463],\n", + " [0.85771597, 0.85872576, 0.97014925],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10849577, 0.09481601, 0.94444444],\n", + " [0.22177271, 0.18802041, 1. ],\n", + " [0.32879735, 0.28095622, 0.95833333],\n", + " [0.43692534, 0.37550363, 0.97222222],\n", + " [0.54836337, 0.46978243, 0.98611111],\n", + " [0.65575579, 0.56003223, 0.95833333],\n", + " [0.75652814, 0.66022025, 0.97222222],\n", + " [0.83891136, 0.77706151, 0.95833333],\n", + " [0.91982346, 0.89041096, 0.98611111],\n", + " [1. , 1. , 0.95833333]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90623557, 0.90636288, 0.7625 ],\n", + " [0.79630485, 0.79744373, 0.875 ],\n", + " [0.68452656, 0.68657961, 0.8875 ],\n", + " [0.57321016, 0.57515977, 0.875 ],\n", + " [0.46558891, 0.46707419, 0.875 ],\n", + " [0.33856813, 0.34009447, 1. ],\n", + " [0.23140878, 0.23228675, 0.875 ],\n", + " [0.12332564, 0.12253404, 0.8625 ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1156306 , 0.11653117, 0.98507463],\n", + " [0.22307496, 0.22086721, 0.98507463],\n", + " [0.33384497, 0.32926829, 0.98507463],\n", + " [0.44614991, 0.44715447, 0.97014925],\n", + " [0.54873369, 0.55284553, 0.91044776],\n", + " [0.66001535, 0.66124661, 0.98507463],\n", + " [0.77385521, 0.77642276, 0.97014925],\n", + " [0.88257866, 0.88753388, 0.98507463],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86095965, 0.24509804, 0.90410959],\n", + " [0.72028353, 0.47058824, 0.89041096],\n", + " [0.5648855 , 0.70588235, 1. ],\n", + " [0.42666303, 1. , 0.89041096],\n", + " [0.282988 , 1. , 0.91780822],\n", + " [0.14367503, 0.70588235, 0.90410959],\n", + " [0. , 0.21568627, 0.90410959]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89742294, 0.09586466, 0.57983193],\n", + " [0.79661445, 0.18421053, 0.58823529],\n", + " [0.69302678, 0.28383459, 0.59663866],\n", + " [0.58943911, 0.39097744, 0.58823529],\n", + " [0.48938858, 0.4962406 , 0.58823529],\n", + " [0.38782213, 0.60338346, 0.58823529],\n", + " [0.28802425, 0.70864662, 0.57983193],\n", + " [0.17180394, 0.81954887, 0.68067227],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.17153285, 0.85333333, 0.98507463],\n", + " [0.33829309, 0.68 , 0.98507463],\n", + " [0.50421112, 0.51111111, 1. ],\n", + " [0.66928692, 0.34444444, 0.97014925],\n", + " [0.83436272, 0.16777778, 0.98507463],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.0858328 , 0.08700834, 0.97530864],\n", + " [0.14901085, 0.15256257, 0.75308642],\n", + " [0.23420549, 0.23837902, 0.98765432],\n", + " [0.31876197, 0.32578466, 0.97530864],\n", + " [0.40427569, 0.41716329, 1. ],\n", + " [0.48947033, 0.50337704, 0.98765432],\n", + " [0.57211232, 0.5856178 , 0.97530864],\n", + " [0.65698787, 0.67143425, 0.98765432],\n", + " [0.74473516, 0.76162098, 1. ],\n", + " [0.82514359, 0.84306714, 0.97530864],\n", + " [0.91033823, 0.92491061, 0.98765432],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12091837, 0.12007505, 0.77777778],\n", + " [0.26020408, 0.26025194, 1. ],\n", + " [0.40816327, 0.4087376 , 1. ],\n", + " [0.52295918, 0.52345216, 0.78888889],\n", + " [0.64438776, 0.64620745, 0.87777778],\n", + " [0.76122449, 0.7619941 , 0.77777778],\n", + " [0.86989796, 0.86974002, 0.78888889],\n", + " [1. , 1. , 0.86666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88588667, 0.87341772, 1. ],\n", + " [0.77544596, 0.74864376, 0.97183099],\n", + " [0.66343127, 0.61301989, 0.98591549],\n", + " [0.54905561, 0.49728752, 1. ],\n", + " [0.43546695, 0.39240506, 1. ],\n", + " [0.32214061, 0.28571429, 0.97183099],\n", + " [0.2250787 , 0.20072333, 0.85915493],\n", + " [0.11437566, 0.10126582, 0.97183099],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88276671, 0.88243462, 0.91666667],\n", + " [0.76553341, 0.76278639, 0.91666667],\n", + " [0.63305979, 0.62902106, 1. ],\n", + " [0.5017585 , 0.50451284, 0.90277778],\n", + " [0.37514654, 0.38787318, 0.84722222],\n", + " [0.24032825, 0.26220782, 0.91666667],\n", + " [0.11488863, 0.13214534, 0.91666667],\n", + " [0. , 0. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90600882, 0.90483619, 0.78888889],\n", + " [0.79713341, 0.78627145, 0.88888889],\n", + " [0.70341786, 0.69110764, 0.77777778],\n", + " [0.60970232, 0.5975039 , 0.77777778],\n", + " [0.5146086 , 0.50702028, 0.78888889],\n", + " [0.40656009, 0.39937598, 0.87777778],\n", + " [0.31256891, 0.30577223, 0.76666667],\n", + " [0.21664829, 0.21372855, 0.78888889],\n", + " [0.12348401, 0.12168487, 0.77777778],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90016685, 0.88480392, 0.98571429],\n", + " [0.79810901, 0.76715686, 1. ],\n", + " [0.69549499, 0.66421569, 1. ],\n", + " [0.60567297, 0.57352941, 0.88571429],\n", + " [0.50389321, 0.47058824, 0.98571429],\n", + " [0.39988877, 0.37254902, 0.98571429],\n", + " [0.2942158 , 0.28431373, 0.98571429],\n", + " [0.20439377, 0.20588235, 0.87142857],\n", + " [0.09510567, 0.08823529, 1. ],\n", + " [0. , 0. , 0.87142857]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11771147, 0.10663507, 0.85185185],\n", + " [0.25485902, 0.23815166, 0.98765432],\n", + " [0.37448672, 0.35308057, 0.86419753],\n", + " [0.51355051, 0.49407583, 1. ],\n", + " [0.62934574, 0.60900474, 0.85185185],\n", + " [0.74979469, 0.72985782, 0.87654321],\n", + " [0.88256228, 0.87322275, 0.97530864],\n", + " [1. , 1. , 0.85185185]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91282189, 0.92619926, 0.68316832],\n", + " [0.8251073 , 0.85055351, 0.69306931],\n", + " [0.73658798, 0.7804428 , 0.71287129],\n", + " [0.64994635, 0.70110701, 0.68316832],\n", + " [0.57483906, 0.62730627, 0.6039604 ],\n", + " [0.48712446, 0.53690037, 0.68316832],\n", + " [0.39002146, 0.43357934, 0.78217822],\n", + " [0.30069742, 0.33394834, 0.7029703 ],\n", + " [0.21378755, 0.23431734, 0.69306931],\n", + " [0.08798283, 0.09594096, 1. ],\n", + " [0. , 0. , 0.68316832]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12146379, 0.74074074, 0.90277778],\n", + " [0.2470802 , 0.44444444, 0.93055556],\n", + " [0.36880353, 0.37037037, 0.90277778],\n", + " [0.5037633 , 0.33333333, 1. ],\n", + " [0.6273034 , 0.14814815, 0.91666667],\n", + " [0.75266026, 0. , 0.93055556],\n", + " [0.87620036, 0. , 0.90277778],\n", + " [1. , 0. , 0.93055556]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08532974, 0.10072595, 0.875 ],\n", + " [0.18734859, 0.22323049, 1. ],\n", + " [0.2756393 , 0.32849365, 0.875 ],\n", + " [0.36769852, 0.43284936, 0.8875 ],\n", + " [0.45733513, 0.52631579, 0.8625 ],\n", + " [0.5461642 , 0.62431942, 0.875 ],\n", + " [0.63580081, 0.7168784 , 0.8875 ],\n", + " [0.72570659, 0.78584392, 0.8875 ],\n", + " [0.81588156, 0.85753176, 0.8625 ],\n", + " [0.90794078, 0.9246824 , 0.875 ],\n", + " [1. , 1. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.18 , 0.14519962, 0.97014925],\n", + " [0.325 , 0.2901616 , 0.98507463],\n", + " [0.455 , 0.43536122, 0.98507463],\n", + " [0.595 , 0.58032319, 1. ],\n", + " [0.705 , 0.72172053, 0.97014925],\n", + " [0.835 , 0.85289924, 0.91044776],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8905007 , 0.89092277, 0.89873418],\n", + " [0.78380908, 0.77683049, 0.88607595],\n", + " [0.672438 , 0.67151454, 0.88607595],\n", + " [0.54749649, 0.54638917, 1. ],\n", + " [0.44080487, 0.4390672 , 0.88607595],\n", + " [0.32990173, 0.32848546, 0.88607595],\n", + " [0.22040243, 0.21965898, 0.88607595],\n", + " [0.10903135, 0.10882648, 0.89873418],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87565938, 0.87650086, 0.98507463],\n", + " [0.75307712, 0.75643225, 0.97014925],\n", + " [0.62572218, 0.62950257, 1. ],\n", + " [0.5001256 , 0.50428816, 0.98507463],\n", + " [0.37528259, 0.37392796, 0.98507463],\n", + " [0.25244913, 0.25214408, 0.97014925],\n", + " [0.12635016, 0.12692967, 0.98507463],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91994178, 0.09620253, 1. ],\n", + " [0.84716157, 0.17974684, 0.91139241],\n", + " [0.77438137, 0.26467204, 0.87341772],\n", + " [0.70305677, 0.35005754, 0.89873418],\n", + " [0.62299854, 0.43222094, 0.87341772],\n", + " [0.5371179 , 0.51438435, 0.87341772],\n", + " [0.45269287, 0.5976985 , 0.88607595],\n", + " [0.36972344, 0.66996548, 0.7721519 ],\n", + " [0.27802038, 0.75166858, 0.87341772],\n", + " [0.18049491, 0.83613349, 0.91139241],\n", + " [0.09024745, 0.91829689, 0.87341772],\n", + " [0. , 1. , 0.88607595]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88923627, 0.88978345, 0.84810127],\n", + " [0.77981242, 0.78095502, 0.83544304],\n", + " [0.67128182, 0.67157135, 0.82278481],\n", + " [0.57257704, 0.57245974, 0.7721519 ],\n", + " [0.46538633, 0.46557468, 0.82278481],\n", + " [0.35685574, 0.35674625, 0.83544304],\n", + " [0.22778026, 0.22598556, 1. ],\n", + " [0.11210362, 0.10882843, 0.89873418],\n", + " [0. , 0. , 0.84810127]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86993769, 0.12693284, 0.98507463],\n", + " [0.73987539, 0.2499423 , 0.98507463],\n", + " [0.62305296, 0.37687514, 0.98507463],\n", + " [0.49376947, 0.49988461, 0.98507463],\n", + " [0.37694704, 0.62681745, 0.97014925],\n", + " [0.24688474, 0.74867297, 0.98507463],\n", + " [0.11682243, 0.87699054, 1. ],\n", + " [0. , 1. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88156336, 0.88254172, 0.88888889],\n", + " [0.77615476, 0.78080873, 0.76666667],\n", + " [0.67114094, 0.67394095, 0.78888889],\n", + " [0.56573233, 0.56675225, 0.77777778],\n", + " [0.46032373, 0.47047497, 0.76666667],\n", + " [0.32885906, 0.33697047, 1. ],\n", + " [0.22345045, 0.22978177, 0.78888889],\n", + " [0.10501382, 0.11232349, 0.88888889],\n", + " [0. , 0. , 0.77777778]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10882648, 0.08256881, 0.95833333],\n", + " [0.22291876, 0.20183486, 0.97222222],\n", + " [0.31945838, 0.30275229, 0.84722222],\n", + " [0.43229689, 0.43119266, 0.97222222],\n", + " [0.54363089, 0.52293578, 0.95833333],\n", + " [0.65872618, 0.6146789 , 0.97222222],\n", + " [0.77031093, 0.67889908, 0.95833333],\n", + " [0.88515547, 0.8440367 , 1. ],\n", + " [1. , 1. , 0.97222222]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08613905, 0.91552578, 0.98591549],\n", + " [0.16965457, 0.83338188, 0.98591549],\n", + " [0.25491911, 0.74803379, 0.98591549],\n", + " [0.33799738, 0.66501602, 0.98591549],\n", + " [0.42326192, 0.57966793, 0.98591549],\n", + " [0.50940096, 0.49373726, 1. ],\n", + " [0.59160472, 0.41071949, 0.97183099],\n", + " [0.66375164, 0.33877075, 0.85915493],\n", + " [0.74682991, 0.25575299, 0.97183099],\n", + " [0.83384346, 0.16894844, 1. ],\n", + " [0.91473546, 0.08680454, 0.97183099],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12492492, 0.12566955, 0.98765432],\n", + " [0.23153153, 0.23320972, 0.83950617],\n", + " [0.35465465, 0.35805521, 1. ],\n", + " [0.44804805, 0.45282241, 0.75308642],\n", + " [0.55585586, 0.56159868, 0.86419753],\n", + " [0.66066066, 0.66625464, 0.83950617],\n", + " [0.77087087, 0.77214668, 0.87654321],\n", + " [0.87747748, 0.87886279, 0.86419753],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09876543, 0.10189573, 0.98591549],\n", + " [0.20042028, 0.2014218 , 1. ],\n", + " [0.29944838, 0.30331754, 0.95774648],\n", + " [0.39952719, 0.40047393, 1. ],\n", + " [0.49960599, 0.50236967, 0.98591549],\n", + " [0.59994747, 0.59952607, 0.97183099],\n", + " [0.70028894, 0.70616114, 1. ],\n", + " [0.80194379, 0.8056872 , 0.98591549],\n", + " [0.90254794, 0.9028436 , 1. ],\n", + " [1. , 1. , 0.95774648]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90854161, 0.8968347 , 0.75 ],\n", + " [0.78769569, 0.76436108, 0.97826087],\n", + " [0.69761055, 0.65416178, 0.75 ],\n", + " [0.60148311, 0.53692849, 0.7826087 ],\n", + " [0.50947542, 0.45838218, 0.75 ],\n", + " [0.41636913, 0.38218054, 0.76086957],\n", + " [0.32243889, 0.29777257, 0.75 ],\n", + " [0.20021972, 0.18405627, 1. ],\n", + " [0.09475419, 0.08675264, 0.85869565],\n", + " [0. , 0. , 0.77173913]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90268676, 0.09867629, 0.8625 ],\n", + " [0.80439056, 0.19815483, 0.875 ],\n", + " [0.70478375, 0.29963899, 0.8875 ],\n", + " [0.60648755, 0.39911753, 0.875 ],\n", + " [0.4921363 , 0.51263538, 1. ],\n", + " [0.39580603, 0.60689932, 0.8625 ],\n", + " [0.29423329, 0.70758123, 0.8875 ],\n", + " [0.19724771, 0.80505415, 0.875 ],\n", + " [0.09895151, 0.90332932, 0.8625 ],\n", + " [0. , 1. , 0.8875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.02861314, 0.97211464, 0.78021978],\n", + " [0.05839416, 0.94113091, 0.75824176],\n", + " [0.0870073 , 0.91092177, 0.76923077],\n", + " [0.1249635 , 0.87141751, 0.98901099],\n", + " [0.15416058, 0.83888459, 0.78021978],\n", + " [0.18248175, 0.80945004, 0.75824176],\n", + " [0.21547445, 0.77459334, 0.87912088],\n", + " [0.24817518, 0.74051123, 0.87912088],\n", + " [0.28262774, 0.70487994, 0.87912088],\n", + " [0.31678832, 0.67079783, 0.86813187],\n", + " [0.34656934, 0.64136328, 0.76923077],\n", + " [0.37576642, 0.61192874, 0.76923077],\n", + " [0.40525547, 0.580945 , 0.78021978],\n", + " [0.4350365 , 0.55073586, 0.75824176],\n", + " [0.46481752, 0.5228505 , 0.76923077],\n", + " [0.49343066, 0.49419055, 0.76923077],\n", + " [0.52350365, 0.4655306 , 0.78021978],\n", + " [0.55270073, 0.43841983, 0.76923077],\n", + " [0.58248175, 0.40898528, 0.76923077],\n", + " [0.61109489, 0.38187452, 0.76923077],\n", + " [0.64467153, 0.348567 , 0.87912088],\n", + " [0.67824818, 0.31603408, 0.87912088],\n", + " [0.70948905, 0.28505035, 0.87912088],\n", + " [0.73810219, 0.25793958, 0.76923077],\n", + " [0.76642336, 0.22927963, 0.78021978],\n", + " [0.79766423, 0.19984508, 0.85714286],\n", + " [0.82715328, 0.17118513, 0.78021978],\n", + " [0.86423358, 0.13632843, 1. ],\n", + " [0.89255474, 0.10921766, 0.76923077],\n", + " [0.92029197, 0.0813323 , 0.74725275],\n", + " [0.94364964, 0.0580945 , 0.67032967],\n", + " [0.97080292, 0.02943455, 0.75824176],\n", + " [1. , 0. , 0.78021978]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90257252, 0.89949324, 0.79120879],\n", + " [0.80706076, 0.80658784, 0.75824176],\n", + " [0.68390805, 0.68412162, 0.98901099],\n", + " [0.58976464, 0.58783784, 0.75824176],\n", + " [0.49151615, 0.4847973 , 0.79120879],\n", + " [0.39709907, 0.3910473 , 0.75824176],\n", + " [0.27285167, 0.26942568, 1. ],\n", + " [0.18007663, 0.17736486, 0.74725275],\n", + " [0.09660646, 0.09628378, 0.67032967],\n", + " [0. , 0. , 0.78021978]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13449275, 0.13301663, 0.98765432],\n", + " [0.2342029 , 0.2327791 , 0.75308642],\n", + " [0.36695652, 0.3655318 , 0.97530864],\n", + " [0.50492754, 0.50092373, 0.98765432],\n", + " [0.63072464, 0.63288467, 1. ],\n", + " [0.76521739, 0.76405384, 0.97530864],\n", + " [0.90086957, 0.90129322, 0.98765432],\n", + " [1. , 1. , 0.75308642]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87085834, 0.8773913 , 0.90277778],\n", + " [0.75006522, 0.75826087, 0.91666667],\n", + " [0.62222802, 0.62782609, 0.91666667],\n", + " [0.49986955, 0.5 , 0.91666667],\n", + " [0.37307592, 0.37391304, 0.91666667],\n", + " [0.25384816, 0.26 , 0.91666667],\n", + " [0.11896687, 0.12956522, 1. ],\n", + " [0. , 0. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90481786, 0.90340741, 0.91139241],\n", + " [0.81668625, 0.81274074, 0.86075949],\n", + " [0.72581277, 0.72088889, 0.89873418],\n", + " [0.63650607, 0.6322963 , 0.88607595],\n", + " [0.54680768, 0.54488889, 0.89873418],\n", + " [0.44731688, 0.44651852, 1. ],\n", + " [0.36036036, 0.3602963 , 0.88607595],\n", + " [0.26400313, 0.2637037 , 1. ],\n", + " [0.17587152, 0.17422222, 0.91139241],\n", + " [0.08852331, 0.08711111, 0.87341772],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.13200723, 0.88497217, 0.85714286],\n", + " [0.26220615, 0.76808905, 0.84415584],\n", + " [0.37251356, 0.65491651, 0.79220779],\n", + " [0.49439421, 0.52912801, 0.85714286],\n", + " [0.6358047 , 0.3825603 , 1. ],\n", + " [0.75768535, 0.25269017, 0.87012987],\n", + " [0.88137432, 0.12356215, 0.85714286],\n", + " [1. , 0. , 0.85714286]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12503151, 0.11764706, 1. ],\n", + " [0.23140913, 0.22875817, 0.85185185],\n", + " [0.3408117 , 0.33986928, 0.87654321],\n", + " [0.44844971, 0.45751634, 0.86419753],\n", + " [0.55432317, 0.5620915 , 0.86419753],\n", + " [0.66498614, 0.66666667, 0.87654321],\n", + " [0.78497605, 0.81045752, 0.96296296],\n", + " [0.89412654, 0.90849673, 0.87654321],\n", + " [1. , 1. , 0.85185185]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89951691, 0.90607424, 0.7625 ],\n", + " [0.78164251, 0.79836895, 0.8625 ],\n", + " [0.66135266, 0.68869516, 0.8875 ],\n", + " [0.54444444, 0.58239595, 0.8625 ],\n", + " [0.43381643, 0.46878515, 0.8875 ],\n", + " [0.31497585, 0.34111361, 1. ],\n", + " [0.20821256, 0.22581552, 0.8875 ],\n", + " [0.1057971 , 0.11473566, 0.85 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8994695 , 0.89759503, 0.98591549],\n", + " [0.80132626, 0.79674166, 0.98591549],\n", + " [0.70185676, 0.6935609 , 0.98591549],\n", + " [0.60291777, 0.60046548, 0.97183099],\n", + " [0.50159151, 0.49650892, 1. ],\n", + " [0.40212202, 0.39953452, 0.98591549],\n", + " [0.29920424, 0.29402638, 0.98591549],\n", + " [0.19973475, 0.19782777, 0.98591549],\n", + " [0.09761273, 0.0969744 , 0.98591549],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86006084, 0.860252 , 0.85714286],\n", + " [0.69578444, 0.69730813, 1. ],\n", + " [0.54019991, 0.54266896, 0.94805195],\n", + " [0.40243372, 0.40292096, 0.84415584],\n", + " [0.27509778, 0.27634593, 0.79220779],\n", + " [0.13733159, 0.13659794, 0.85714286],\n", + " [0. , 0. , 0.84415584]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.85458613, 0.14687567, 0.98571429],\n", + " [0.70469799, 0.29568392, 0.98571429],\n", + " [0.57941834, 0.42301911, 0.87142857],\n", + " [0.45637584, 0.55228688, 0.87142857],\n", + " [0.3064877 , 0.69980674, 0.98571429],\n", + " [0.15659955, 0.85076229, 1. ],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91930541, 0. , 0.75308642],\n", + " [0.8299285 , 0.51515152, 0.83950617],\n", + " [0.74055158, 0.51515152, 0.87654321],\n", + " [0.65117467, 0.51515152, 0.85185185],\n", + " [0.55745659, 0.51515152, 0.87654321],\n", + " [0.46807967, 0.51515152, 0.86419753],\n", + " [0.37436159, 0.51515152, 0.85185185],\n", + " [0.28498468, 1. , 0.87654321],\n", + " [0.19560776, 1. , 0.85185185],\n", + " [0.10214505, 1. , 0.86419753],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91784573, 0.08055266, 0.87323944],\n", + " [0.8224555 , 0.17440042, 0.97183099],\n", + " [0.72797809, 0.26903024, 0.98591549],\n", + " [0.63441351, 0.36470282, 0.98591549],\n", + " [0.55043359, 0.44838373, 0.85915493],\n", + " [0.45595618, 0.54249218, 0.95774648],\n", + " [0.35965313, 0.63842544, 0.98591549],\n", + " [0.27567321, 0.72288843, 0.87323944],\n", + " [0.18165221, 0.81725756, 0.98591549],\n", + " [0.09082611, 0.90901981, 0.97183099],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86902655, 0.12535211, 1. ],\n", + " [0.74690265, 0.24812207, 0.97014925],\n", + " [0.61946903, 0.37488263, 1. ],\n", + " [0.49026549, 0.50093897, 0.98507463],\n", + " [0.36814159, 0.62394366, 0.98507463],\n", + " [0.24778761, 0.74906103, 0.97014925],\n", + " [0.12389381, 0.87394366, 1. ],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8857288 , 0.87096774, 0.8875 ],\n", + " [0.77475876, 0.76129032, 0.875 ],\n", + " [0.66404266, 0.64193548, 0.875 ],\n", + " [0.55485018, 0.53870968, 0.8625 ],\n", + " [0.44210259, 0.43548387, 0.8875 ],\n", + " [0.31538852, 0.31612903, 1. ],\n", + " [0.21965465, 0.22903226, 0.7625 ],\n", + " [0.10893855, 0.13548387, 0.8625 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92769148, 0.07264472, 0.84722222],\n", + " [0.84413498, 0.15323496, 0.95833333],\n", + " [0.75977504, 0.23723042, 0.97222222],\n", + " [0.67300482, 0.32236095, 1. ],\n", + " [0.59078736, 0.40068104, 0.94444444],\n", + " [0.50535619, 0.48240636, 0.97222222],\n", + " [0.4196572 , 0.56413167, 1. ],\n", + " [0.33556508, 0.64812713, 0.95833333],\n", + " [0.25147295, 0.73439274, 0.98611111],\n", + " [0.16711302, 0.82065834, 0.95833333],\n", + " [0.08302089, 0.90805902, 0.98611111],\n", + " [0. , 1. , 0.95833333]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.83310947, 0.16734034, 1. ],\n", + " [0.6692411 , 0.33225546, 0.98507463],\n", + " [0.49932841, 0.50080841, 0.98507463],\n", + " [0.33344527, 0.66855295, 0.98507463],\n", + " [0.16655473, 0.83306386, 0.98507463],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90694239, 0.09647651, 0.98591549],\n", + " [0.81585426, 0.18624161, 0.98591549],\n", + " [0.7282127 , 0.27600671, 0.98591549],\n", + " [0.63860167, 0.36465324, 1. ],\n", + " [0.54751354, 0.45441834, 0.98591549],\n", + " [0.45642541, 0.54502237, 0.98591549],\n", + " [0.36681438, 0.63422819, 0.97183099],\n", + " [0.27572624, 0.72455257, 0.98591549],\n", + " [0.18463811, 0.81487696, 0.98591549],\n", + " [0.09256524, 0.90715884, 1. ],\n", + " [0. , 1. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8719346 , 0.87076393, 1. ],\n", + " [0.75095368, 0.75071798, 0.97014925],\n", + " [0.62615804, 0.62894888, 0.98507463],\n", + " [0.50108992, 0.50430787, 0.98507463],\n", + " [0.37574932, 0.3750718 , 0.98507463],\n", + " [0.24686649, 0.24641011, 1. ],\n", + " [0.12561308, 0.12349225, 0.97014925],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1171875 , 0.11153119, 0.98591549],\n", + " [0.22526042, 0.22448015, 1. ],\n", + " [0.33203125, 0.33175803, 0.97183099],\n", + " [0.44921875, 0.44305293, 0.98591549],\n", + " [0.55859375, 0.55529301, 1. ],\n", + " [0.67057292, 0.6665879 , 0.98591549],\n", + " [0.77604167, 0.77599244, 0.97183099],\n", + " [0.88802083, 0.88775992, 0.98591549],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88561525, 0.11497105, 1. ],\n", + " [0.77192374, 0.22746071, 0.97183099],\n", + " [0.6592721 , 0.33995037, 1. ],\n", + " [0.54696707, 0.45437 , 0.94366197],\n", + " [0.45233969, 0.55059278, 0.87323944],\n", + " [0.3407279 , 0.66087676, 0.98591549],\n", + " [0.22426343, 0.77695065, 1. ],\n", + " [0.11091854, 0.8891646 , 0.98591549],\n", + " [0. , 1. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91450777, 0.92163009, 0.8875 ],\n", + " [0.82279793, 0.84639498, 0.8875 ],\n", + " [0.73860104, 0.76489028, 0.8625 ],\n", + " [0.64585492, 0.68652038, 0.8875 ],\n", + " [0.56165803, 0.60815047, 0.8625 ],\n", + " [0.46917098, 0.52351097, 0.8875 ],\n", + " [0.38212435, 0.46081505, 0.8625 ],\n", + " [0.28367876, 0.37617555, 1. ],\n", + " [0.18134715, 0.25705329, 1. ],\n", + " [0.09015544, 0.12225705, 0.8875 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91088833, 0.10162602, 0.88607595],\n", + " [0.82066277, 0.20325203, 0.88607595],\n", + " [0.7315511 , 0.29268293, 0.89873418],\n", + " [0.64104706, 0.38211382, 0.89873418],\n", + " [0.55277082, 0.47560976, 0.86075949],\n", + " [0.4619883 , 0.56910569, 0.91139241],\n", + " [0.36090226, 0.66666667, 1. ],\n", + " [0.26984127, 0.75203252, 0.88607595],\n", + " [0.18156502, 0.83739837, 0.88607595],\n", + " [0.09161793, 0.90650407, 0.87341772],\n", + " [0. , 1. , 0.89873418]]),\n", + " array([[0. , 0.8368336 , 0. ],\n", + " [0.11335722, 0.93699515, 0.89873418],\n", + " [0.22569089, 1. , 0.88607595],\n", + " [0.35363357, 0.99030695, 1. ],\n", + " [0.46264074, 0.8723748 , 0.88607595],\n", + " [0.56704197, 0.68012924, 0.88607595],\n", + " [0.67349028, 0.453958 , 0.89873418],\n", + " [0.78019447, 0.26171244, 0.88607595],\n", + " [0.89124872, 0.12439418, 0.88607595],\n", + " [1. , 0. , 0.87341772]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09876543, 0.10189573, 0.98591549],\n", + " [0.20042028, 0.2014218 , 1. ],\n", + " [0.29944838, 0.30331754, 0.95774648],\n", + " [0.39952719, 0.40047393, 1. ],\n", + " [0.49960599, 0.50236967, 0.98591549],\n", + " [0.59994747, 0.59952607, 0.97183099],\n", + " [0.70028894, 0.70616114, 1. ],\n", + " [0.80194379, 0.8056872 , 0.98591549],\n", + " [0.90254794, 0.9028436 , 1. ],\n", + " [1. , 1. , 0.95774648]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89282178, 0.47619048, 0.91666667],\n", + " [0.78415842, 0.76190476, 1. ],\n", + " [0.67277228, 0.76190476, 0.91666667],\n", + " [0.56138614, 1. , 0.93055556],\n", + " [0.43985149, 0.85714286, 1. ],\n", + " [0.31559406, 0.76190476, 0.90277778],\n", + " [0.21460396, 0.71428571, 0.91666667],\n", + " [0.11633663, 0.71428571, 0.91666667],\n", + " [0. , 0.52380952, 0.93055556]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16842105, 0.17538555, 1. ],\n", + " [0.34035088, 0.34623526, 0.98630137],\n", + " [0.51428571, 0.51285153, 0.97260274],\n", + " [0.67468672, 0.66918657, 0.90410959],\n", + " [0.83057644, 0.83035984, 0.90410959],\n", + " [1. , 1. , 0.98630137]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11912034, 0.11916708, 0.86419753],\n", + " [0.23824068, 0.23532363, 0.86419753],\n", + " [0.35736103, 0.35173106, 0.85185185],\n", + " [0.49908369, 0.49121927, 1. ],\n", + " [0.63103238, 0.62418465, 0.97530864],\n", + " [0.75259621, 0.74460612, 0.87654321],\n", + " [0.86805131, 0.86251882, 0.85185185],\n", + " [1. , 1. , 0.97530864]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11085973, 0.11615487, 0.92424242],\n", + " [0.24384113, 0.25233645, 1. ],\n", + " [0.37405732, 0.3858478 , 0.98484848],\n", + " [0.48919055, 0.49933244, 0.92424242],\n", + " [0.61789844, 0.62616822, 1. ],\n", + " [0.74912016, 0.75300401, 1. ],\n", + " [0.8743087 , 0.87316422, 1. ],\n", + " [1. , 1. , 0.98484848]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.115727 , 0.11044705, 0.98507463],\n", + " [0.22848665, 0.22137222, 0.98507463],\n", + " [0.33531157, 0.33229739, 1. ],\n", + " [0.4421365 , 0.44489601, 0.98507463],\n", + " [0.55192878, 0.5543868 , 0.97014925],\n", + " [0.66765579, 0.66363854, 0.98507463],\n", + " [0.78041543, 0.77671528, 1. ],\n", + " [0.88724036, 0.88811858, 0.97014925],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89961176, 0.90430622, 0.98591549],\n", + " [0.79922352, 0.81339713, 0.98591549],\n", + " [0.70022185, 0.715311 , 0.98591549],\n", + " [0.59844703, 0.61363636, 1. ],\n", + " [0.5 , 0.51196172, 0.97183099],\n", + " [0.39794786, 0.40909091, 1. ],\n", + " [0.29811425, 0.30502392, 0.98591549],\n", + " [0.19994454, 0.19856459, 0.97183099],\n", + " [0.09872435, 0.09808612, 1. ],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89634748, 0.88903326, 0.79761905],\n", + " [0.79022705, 0.77988565, 0.77380952],\n", + " [0.69299112, 0.68035343, 0.72619048],\n", + " [0.58588351, 0.57016632, 0.77380952],\n", + " [0.4792695 , 0.46049896, 0.78571429],\n", + " [0.33711747, 0.32380457, 1. ],\n", + " [0.22408687, 0.21673597, 0.79761905],\n", + " [0.11105627, 0.10758836, 0.78571429],\n", + " [0. , 0. , 0.78571429]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13 , 0.12199112, 0.98765432],\n", + " [0.2425 , 0.23229727, 0.86419753],\n", + " [0.3475 , 0.34050012, 0.86419753],\n", + " [0.475 , 0.46249124, 1. ],\n", + " [0.585 , 0.56905819, 0.85185185],\n", + " [0.6875 , 0.67889694, 0.87654321],\n", + " [0.7925 , 0.78569759, 0.86419753],\n", + " [0.9 , 0.89483524, 0.86419753],\n", + " [1. , 1. , 0.85185185]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.84266834, 0.96865792, 0.82926829],\n", + " [0.67526746, 0.939191 , 0.86585366],\n", + " [0.50723726, 0.91079561, 0.85365854],\n", + " [0.33920705, 0.87945352, 0.84146341],\n", + " [0.18187539, 0.83927136, 0.82926829],\n", + " [0.06670862, 0.77685508, 0.7804878 ],\n", + " [0.01384519, 0.69193678, 0.75609756],\n", + " [0. , 0.5898741 , 0.76829268],\n", + " [0.02454374, 0.48566836, 0.7804878 ],\n", + " [0.04468219, 0.36967586, 0.85365854],\n", + " [0.04531152, 0.25448701, 0.85365854],\n", + " [0.05601007, 0.13822663, 0.84146341],\n", + " [0.05601007, 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14516129, 0.14243673, 1. ],\n", + " [0.28990902, 0.28457916, 0.98507463],\n", + " [0.43382961, 0.4267216 , 0.98507463],\n", + " [0.57733664, 0.56886404, 0.97014925],\n", + " [0.71588089, 0.71041789, 0.98507463],\n", + " [0.85897436, 0.85726898, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08260325, 0.91874694, 0.77777778],\n", + " [0.16739675, 0.83749388, 0.78888889],\n", + " [0.24937422, 0.7670093 , 0.76666667],\n", + " [0.33573217, 0.69309838, 0.78888889],\n", + " [0.42052566, 0.61674009, 0.78888889],\n", + " [0.4965582 , 0.52716593, 0.76666667],\n", + " [0.57478098, 0.43808125, 0.76666667],\n", + " [0.6548811 , 0.35633872, 0.78888889],\n", + " [0.76376721, 0.25648556, 1. ],\n", + " [0.83416771, 0.18502203, 0.67777778],\n", + " [0.9120776 , 0.09789525, 0.75555556],\n", + " [1. , 0. , 0.88888889]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.17448043, 0.17320169, 0.92307692],\n", + " [0.36104398, 0.35881523, 1. ],\n", + " [0.51909135, 0.51932299, 0.84615385],\n", + " [0.67182214, 0.67052186, 0.83333333],\n", + " [0.82745288, 0.82708039, 0.85897436],\n", + " [1. , 1. , 0.92307692]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12133228, 0.13953488, 0.91666667],\n", + " [0.24636532, 0.27906977, 0.91666667],\n", + " [0.36954798, 0.39534884, 0.91666667],\n", + " [0.49088025, 0.5 , 0.90277778],\n", + " [0.61644198, 0.62790698, 0.93055556],\n", + " [0.73988898, 0.73255814, 0.91666667],\n", + " [0.87549564, 0.88372093, 1. ],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12781955, 0.91399109, 0.5785124 ],\n", + " [0.2481203 , 0.82423248, 0.59504132],\n", + " [0.37593985, 0.73048981, 0.6446281 ],\n", + " [0.5037594 , 0.6444809 , 0.5785124 ],\n", + " [0.62406015, 0.54698852, 0.66115702],\n", + " [0.7518797 , 0.40239044, 1. ],\n", + " [0.7518797 , 0.29294586, 0.74380165],\n", + " [0.87969925, 0.20717131, 0.5785124 ],\n", + " [1. , 0.08600891, 0.81818182],\n", + " [1. , 0. , 0.58677686]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.94736842, 0.87674531, 0.9 ],\n", + " [0.86466165, 0.77106403, 0.79 ],\n", + " [0.7443609 , 0.6747713 , 0.71 ],\n", + " [0.66917293, 0.56571979, 0.8 ],\n", + " [0.4962406 , 0.44246509, 0.89 ],\n", + " [0.2481203 , 0.30548869, 1. ],\n", + " [0. , 0.20871449, 0.71 ],\n", + " [0.01503759, 0.11169957, 0.7 ],\n", + " [0.09774436, 0. , 0.8 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88895366, 0.88815394, 0.97222222],\n", + " [0.77674147, 0.77510523, 1. ],\n", + " [0.66569513, 0.66506314, 0.95833333],\n", + " [0.55639755, 0.55802766, 0.97222222],\n", + " [0.44622559, 0.44918821, 0.95833333],\n", + " [0.33226465, 0.33553818, 0.98611111],\n", + " [0.2212183 , 0.2230908 , 0.97222222],\n", + " [0.11221218, 0.11184606, 0.97222222],\n", + " [0. , 0. , 0.97222222]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86507206, 0.954047 , 0.60169492],\n", + " [0.72401104, 0.8386423 , 0.6779661 ],\n", + " [0.57988347, 0.66318538, 0.75423729],\n", + " [0.46366145, 0.52950392, 0.60169492],\n", + " [0.26617602, 0.30391645, 1. ],\n", + " [0.13308801, 0.15195822, 0.68644068],\n", + " [0. , 0. , 0.68644068]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1299435 , 0.13474026, 0.92424242],\n", + " [0.27791229, 0.29707792, 1. ],\n", + " [0.42157654, 0.45941558, 1. ],\n", + " [0.56497175, 0.59415584, 1. ],\n", + " [0.71294054, 0.73051948, 1. ],\n", + " [0.85633575, 0.86525974, 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.17650334, 0.17418351, 0.97260274],\n", + " [0.35022272, 0.34888543, 1. ],\n", + " [0.51057906, 0.50311042, 0.90410959],\n", + " [0.66982183, 0.66977709, 0.90410959],\n", + " [0.82516704, 0.82529808, 0.90410959],\n", + " [1. , 1. , 0.97260274]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90554791, 0.05406204, 0.97222222],\n", + " [0.80926181, 0.10664697, 0.98611111],\n", + " [0.70701513, 0.1633678 , 0.98611111],\n", + " [0.61256304, 0.22304284, 0.95833333],\n", + " [0.53278313, 0.29039882, 0.97222222],\n", + " [0.46217331, 0.36011817, 0.97222222],\n", + " [0.39431453, 0.43840473, 0.98611111],\n", + " [0.33975241, 0.51816839, 0.94444444],\n", + " [0.2783127 , 0.59763663, 1. ],\n", + " [0.22283356, 0.67710487, 0.97222222],\n", + " [0.16964695, 0.75864106, 0.95833333],\n", + " [0.11370931, 0.8437223 , 0.97222222],\n", + " [0.0522696 , 0.92703102, 0.97222222],\n", + " [0. , 1. , 0.84722222]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.51492537, 0.92191313, 0.77777778],\n", + " [0.73880597, 0.84309419, 0.76666667],\n", + " [0.96268657, 0.74280137, 1. ],\n", + " [1. , 0.66105417, 0.78888889],\n", + " [0.96268657, 0.58223524, 0.77777778],\n", + " [0.91791045, 0.50268424, 0.76666667],\n", + " [0.85820896, 0.4114202 , 0.91111111],\n", + " [0.79850746, 0.33235725, 0.75555556],\n", + " [0.75373134, 0.25207418, 0.78888889],\n", + " [0.69402985, 0.17179112, 0.77777778],\n", + " [0.65671642, 0.08223524, 0.88888889],\n", + " [0.58955224, 0. , 0.78888889]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90277404, 0.90537084, 0.85185185],\n", + " [0.80123889, 0.8056266 , 0.87654321],\n", + " [0.70401293, 0.71355499, 0.86419753],\n", + " [0.60463237, 0.60358056, 0.87654321],\n", + " [0.50605979, 0.50127877, 0.86419753],\n", + " [0.40883383, 0.40920716, 0.85185185],\n", + " [0.31079989, 0.31202046, 0.86419753],\n", + " [0.21088069, 0.21227621, 0.87654321],\n", + " [0.11553999, 0.11253197, 0.83950617],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91644562, 0.91833333, 0.87654321],\n", + " [0.83454907, 0.83541667, 0.86419753],\n", + " [0.75066313, 0.75166667, 0.87654321],\n", + " [0.66909814, 0.67041667, 0.85185185],\n", + " [0.58819629, 0.59 , 0.85185185],\n", + " [0.50431034, 0.50875 , 0.86419753],\n", + " [0.42208223, 0.42708333, 0.86419753],\n", + " [0.32625995, 0.33 , 1. ],\n", + " [0.23408488, 0.23833333, 0.97530864],\n", + " [0.15119363, 0.15458333, 0.86419753],\n", + " [0.07062334, 0.07083333, 0.86419753],\n", + " [0. , 0. , 0.75308642]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16398964, 0.16256158, 1. ],\n", + " [0.29637306, 0.29228243, 0.8 ],\n", + " [0.41062176, 0.40722496, 0.71 ],\n", + " [0.52512953, 0.52052545, 0.69 ],\n", + " [0.63937824, 0.63546798, 0.7 ],\n", + " [0.75518135, 0.75533662, 0.71 ],\n", + " [0.8857513 , 0.88341544, 0.8 ],\n", + " [1. , 1. , 0.7 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85601188, 0.8575983 , 1. ],\n", + " [0.71400297, 0.71572795, 0.98507463],\n", + " [0.57298367, 0.5727949 , 0.97014925],\n", + " [0.42998516, 0.4303932 , 1. ],\n", + " [0.28698664, 0.2869288 , 0.97014925],\n", + " [0.14448293, 0.14293305, 1. ],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.79546599, 0.22012579, 1. ],\n", + " [0.68816121, 0.33962264, 0.54615385],\n", + " [0.53098237, 0.49685535, 0.76153846],\n", + " [0.42241814, 0.59748428, 0.53846154],\n", + " [0.31486146, 0.71698113, 0.53846154],\n", + " [0.1302267 , 0.87421384, 0.92307692],\n", + " [0. , 1. , 0.62307692]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87784309, 0.87480438, 0.90410959],\n", + " [0.75210836, 0.74960876, 0.91780822],\n", + " [0.630207 , 0.62441315, 0.89041096],\n", + " [0.49348326, 0.48826291, 1. ],\n", + " [0.37004856, 0.36306729, 0.90410959],\n", + " [0.24559162, 0.23787167, 0.89041096],\n", + " [0.1216458 , 0.12050078, 0.91780822],\n", + " [0. , 0. , 0.89041096]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09758551, 0.15602606, 0.92222222],\n", + " [0.18175721, 0.29348534, 0.82222222],\n", + " [0.27800134, 0.43452769, 0.85555556],\n", + " [0.37391013, 0.53745928, 0.73333333],\n", + " [0.46981891, 0.62312704, 0.68888889],\n", + " [0.58718981, 0.70977199, 0.77777778],\n", + " [0.74279007, 0.81889251, 1. ],\n", + " [0.86049631, 0.90228013, 0.77777778],\n", + " [1. , 1. , 0.9 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16693214, 0.1671882 , 1. ],\n", + " [0.33418286, 0.33348234, 1. ],\n", + " [0.49824785, 0.49754135, 1. ],\n", + " [0.66772858, 0.6656236 , 1. ],\n", + " [0.83434215, 0.83236477, 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13866069, 0.15498938, 0.91666667],\n", + " [0.29424944, 0.29299363, 1. ],\n", + " [0.43340802, 0.42887473, 0.91666667],\n", + " [0.57879014, 0.56900212, 0.93055556],\n", + " [0.7154593 , 0.72186837, 0.90277778],\n", + " [0.86109037, 0.85774947, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13690312, 0.16226415, 1. ],\n", + " [0.26028153, 0.29433962, 0.91666667],\n", + " [0.39000828, 0.46415094, 0.91666667],\n", + " [0.51697488, 0.58490566, 0.91666667],\n", + " [0.64449351, 0.69056604, 0.93055556],\n", + " [0.7673199 , 0.86037736, 0.91666667],\n", + " [0.88683412, 0.96226415, 0.90277778],\n", + " [1. , 1. , 0.84722222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14438944, 0.14377289, 0.97014925],\n", + " [0.28025303, 0.28113553, 0.91044776],\n", + " [0.42986799, 0.43131868, 1. ],\n", + " [0.57975798, 0.58241758, 0.98507463],\n", + " [0.72222222, 0.72527473, 0.95522388],\n", + " [0.86221122, 0.86446886, 0.92537313],\n", + " [1. , 1. , 0.92537313]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.16226415, 0.8384 , 0.89041096],\n", + " [0.31059507, 0.68906667, 0.83561644],\n", + " [0.4862119 , 0.51573333, 0.90410959],\n", + " [0.66966618, 0.33493333, 0.89041096],\n", + " [0.82699565, 0.17333333, 1. ],\n", + " [1. , 0. , 0.90410959]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11443038, 0.12075472, 1. ],\n", + " [0.22759494, 0.23962264, 0.98507463],\n", + " [0.33873418, 0.34528302, 0.97014925],\n", + " [0.44860759, 0.47358491, 0.98507463],\n", + " [0.56 , 0.57358491, 0.98507463],\n", + " [0.6721519 , 0.67924528, 0.98507463],\n", + " [0.78405063, 0.80943396, 1. ],\n", + " [0.89316456, 0.9 , 0.97014925],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8741226 , 0.87664114, 0.94366197],\n", + " [0.75198877, 0.75519694, 0.91549296],\n", + " [0.6284511 , 0.63129103, 0.92957746],\n", + " [0.50444548, 0.50738512, 0.94366197],\n", + " [0.38090781, 0.38293217, 0.92957746],\n", + " [0.25409453, 0.2571116 , 0.92957746],\n", + " [0.12306972, 0.12527352, 1. ],\n", + " [0. , 0. , 0.92957746]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1203376 , 0.11774461, 0.90277778],\n", + " [0.25564933, 0.25870647, 1. ],\n", + " [0.37544242, 0.39137645, 0.91666667],\n", + " [0.51075415, 0.53565506, 1. ],\n", + " [0.62918595, 0.65339967, 0.91666667],\n", + " [0.75333515, 0.76451078, 0.93055556],\n", + " [0.87802886, 0.88059701, 0.90277778],\n", + " [1. , 1. , 0.93055556]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12348668, 0.12221095, 0.87804878],\n", + " [0.24455206, 0.24137931, 0.82926829],\n", + " [0.38256659, 0.38057809, 1. ],\n", + " [0.50121065, 0.4994929 , 0.82926829],\n", + " [0.63922518, 0.63894523, 1. ],\n", + " [0.76029056, 0.75887424, 0.84146341],\n", + " [0.87893462, 0.87981744, 0.86585366],\n", + " [1. , 1. , 0.85365854]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09476534, 0.90813397, 1. ],\n", + " [0.18592058, 0.81578947, 0.98591549],\n", + " [0.27436823, 0.7222488 , 0.98591549],\n", + " [0.36552347, 0.6284689 , 0.98591549],\n", + " [0.4467509 , 0.5492823 , 0.85915493],\n", + " [0.53429603, 0.45645933, 0.97183099],\n", + " [0.61281588, 0.36363636, 0.97183099],\n", + " [0.68592058, 0.28157895, 0.85915493],\n", + " [0.7734657 , 0.18755981, 1. ],\n", + " [0.89259928, 0.09497608, 0.98591549],\n", + " [1. , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88640815, 0.88275862, 1. ],\n", + " [0.77634156, 0.76827586, 0.95833333],\n", + " [0.66666667, 0.65310345, 0.95833333],\n", + " [0.55346651, 0.5362069 , 0.97222222],\n", + " [0.44457501, 0.42275862, 0.97222222],\n", + " [0.33333333, 0.30793103, 0.98611111],\n", + " [0.21699961, 0.19931034, 0.95833333],\n", + " [0.11594203, 0.1062069 , 0.84722222],\n", + " [0. , 0. , 0.95833333]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89111593, 0.88541667, 0.85365854],\n", + " [0.78060672, 0.77083333, 0.86585366],\n", + " [0.66982665, 0.65451389, 0.86585366],\n", + " [0.56040087, 0.54166667, 0.84146341],\n", + " [0.45287107, 0.4375 , 0.86585366],\n", + " [0.34588299, 0.33159722, 0.82926829],\n", + " [0.23510293, 0.22395833, 0.85365854],\n", + " [0.12784399, 0.12152778, 0.85365854],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.0923913 , 0.9196409 , 0.63888889],\n", + " [0.0923913 , 0.85395227, 0.56481481],\n", + " [0.18478261, 0.77381213, 0.65740741],\n", + " [0.18478261, 0.68622728, 0.73148148],\n", + " [0.27173913, 0.59864243, 0.73148148],\n", + " [0.36413043, 0.51828334, 0.66666667],\n", + " [0.54347826, 0.39785417, 1. ],\n", + " [0.63586957, 0.29559886, 0.84259259],\n", + " [0.72826087, 0.20078826, 0.82407407],\n", + " [0.81521739, 0.10225531, 0.83333333],\n", + " [1. , 0. , 0.83333333]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.83921016, 0.83811262, 0.91549296],\n", + " [0.67606958, 0.67335766, 0.92957746],\n", + " [0.51104843, 0.50834202, 0.92957746],\n", + " [0.34508698, 0.34410845, 0.92957746],\n", + " [0.18053597, 0.17935349, 0.94366197],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09046214, 0.08468873, 0.95833333],\n", + " [0.20648968, 0.15647785, 0.98611111],\n", + " [0.31563422, 0.20386988, 0.84722222],\n", + " [0.4473943 , 0.25182277, 0.97222222],\n", + " [0.5840708 , 0.29781268, 0.97222222],\n", + " [0.71583088, 0.34548514, 0.95833333],\n", + " [0.82645034, 0.40437465, 0.95833333],\n", + " [0.91445428, 0.47504206, 0.98611111],\n", + " [0.96951819, 0.54879417, 0.84722222],\n", + " [1. , 0.64890634, 0.95833333],\n", + " [0.99410029, 0.76135726, 0.98611111],\n", + " [0.97689282, 0.87521032, 0.94444444],\n", + " [0.95231072, 1. , 1. ]]),\n", + " array([[1. , 0.3 , 0. ],\n", + " [0.89031912, 0.2 , 0.984375 ],\n", + " [0.77607938, 0.2 , 0.984375 ],\n", + " [0.66237597, 0. , 0.984375 ],\n", + " [0.55457227, 0.1 , 0.984375 ],\n", + " [0.44220971, 0.3 , 0.984375 ],\n", + " [0.33172432, 0.6 , 0.96875 ],\n", + " [0.21909359, 0.6 , 1. ],\n", + " [0.11021722, 1. , 0.96875 ],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10846995, 0.03846154, 0.98591549],\n", + " [0.21830601, 0.07051282, 0.98591549],\n", + " [0.32650273, 0.10897436, 0.97183099],\n", + " [0.43579235, 0.16025641, 0.98591549],\n", + " [0.5489071 , 0.30448718, 0.98591549],\n", + " [0.66229508, 0.48076923, 1. ],\n", + " [0.77295082, 0.65384615, 0.97183099],\n", + " [0.88360656, 0.83012821, 0.98591549],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88127854, 0.11935921, 0.84615385],\n", + " [0.75913242, 0.23668773, 0.84615385],\n", + " [0.63013699, 0.36732852, 0.91025641],\n", + " [0.51255708, 0.48713899, 0.85897436],\n", + " [0.39269406, 0.60740072, 0.84615385],\n", + " [0.2716895 , 0.72901625, 0.85897436],\n", + " [0.14269406, 0.85785199, 0.91025641],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.14477612, 0.74930362, 1. ],\n", + " [0.28532338, 0.5097493 , 0.97014925],\n", + " [0.43283582, 0.28133705, 1. ],\n", + " [0.5761194 , 0.08077994, 0.97014925],\n", + " [0.72039801, 0. , 0.98507463],\n", + " [0.86641791, 0.03064067, 1. ],\n", + " [1. , 0.05571031, 0.91044776]]),\n", + " array([[1. , 0.0625 , 0. ],\n", + " [0.88338271, 0. , 0.61068702],\n", + " [0.77673041, 0.1875 , 0.53435115],\n", + " [0.67250202, 0.25 , 0.53435115],\n", + " [0.56881228, 0.1875 , 0.53435115],\n", + " [0.46593051, 0.375 , 0.52671756],\n", + " [0.26986264, 0.5625 , 1. ],\n", + " [0.13493132, 0.8125 , 0.6870229 ],\n", + " [0. , 1. , 0.6870229 ]]),\n", + " array([[1. , 0.4516129 , 0. ],\n", + " [0.96747738, 0.36856555, 0.79012346],\n", + " [0.92449095, 0.33081675, 0.82716049],\n", + " [0.87754525, 0.30885381, 0.85185185],\n", + " [0.82664027, 0.2889499 , 0.86419753],\n", + " [0.77516968, 0.26835964, 0.86419753],\n", + " [0.72285068, 0.25463281, 0.87654321],\n", + " [0.66855204, 0.24021963, 0.86419753],\n", + " [0.61340498, 0.22443377, 0.85185185],\n", + " [0.55627828, 0.20727522, 0.88888889],\n", + " [0.50084842, 0.19492107, 0.83950617],\n", + " [0.44739819, 0.18256692, 0.87654321],\n", + " [0.39649321, 0.17227179, 0.85185185],\n", + " [0.34756787, 0.16060398, 0.86419753],\n", + " [0.30090498, 0.15305422, 0.87654321],\n", + " [0.25735294, 0.13452299, 0.86419753],\n", + " [0.22143665, 0.09608785, 0.86419753],\n", + " [0.19117647, 0.05284832, 0.86419753],\n", + " [0.15865385, 0.00960879, 1. ],\n", + " [0.12895928, 0. , 0.85185185],\n", + " [0.09615385, 0.03088538, 0.86419753],\n", + " [0.06617647, 0.08647907, 0.85185185],\n", + " [0.04100679, 0.1674674 , 0.87654321],\n", + " [0.02856335, 0.2676733 , 0.86419753],\n", + " [0.02432127, 0.37542896, 0.85185185],\n", + " [0.01979638, 0.49485244, 0.86419753],\n", + " [0.0155543 , 0.62251201, 0.87654321],\n", + " [0.01074661, 0.74742622, 0.85185185],\n", + " [0.0053733 , 0.87508579, 0.86419753],\n", + " [0. , 1. , 0.87654321]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89447486, 0.89591386, 0.80898876],\n", + " [0.79243405, 0.7923799 , 0.76404494],\n", + " [0.67297163, 0.67145224, 0.91011236],\n", + " [0.57192633, 0.56985091, 0.78651685],\n", + " [0.45047287, 0.44864716, 0.88764045],\n", + " [0.34843206, 0.3451132 , 0.78651685],\n", + " [0.22399204, 0.22197681, 0.91011236],\n", + " [0.09059233, 0.09110988, 1. ],\n", + " [0. , 0. , 0.68539326]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.07497714, 0.09354005, 0.7625 ],\n", + " [0.1722036 , 0.2124031 , 0.975 ],\n", + " [0.25083816, 0.30284238, 0.7625 ],\n", + " [0.33008229, 0.38242894, 0.7625 ],\n", + " [0.43523316, 0.48062016, 0.975 ],\n", + " [0.5184395 , 0.55710594, 0.775 ],\n", + " [0.62511429, 0.65529716, 0.9875 ],\n", + " [0.70649192, 0.73023256, 0.7625 ],\n", + " [0.81316672, 0.82739018, 0.9875 ],\n", + " [0.91923194, 0.92661499, 1. ],\n", + " [1. , 1. , 0.7625 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87470135, 0.12380416, 1. ],\n", + " [0.75126095, 0.2447946 , 0.97014925],\n", + " [0.6339262 , 0.3629713 , 0.91044776],\n", + " [0.50836209, 0.4895892 , 0.98507463],\n", + " [0.38093974, 0.61733258, 0.97014925],\n", + " [0.25298646, 0.74563872, 0.98507463],\n", + " [0.12874967, 0.86944288, 0.98507463],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88743039, 0.88480663, 0.98507463],\n", + " [0.77684964, 0.77541436, 0.97014925],\n", + " [0.66865553, 0.66381215, 1. ],\n", + " [0.55608592, 0.55331492, 0.98507463],\n", + " [0.4451074 , 0.44254144, 0.97014925],\n", + " [0.33571997, 0.33093923, 0.98507463],\n", + " [0.22434368, 0.2218232 , 1. ],\n", + " [0.11018298, 0.10883978, 0.98507463],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14588305, 0.1395655 , 1. ],\n", + " [0.28818616, 0.27781435, 0.97014925],\n", + " [0.43078759, 0.41935484, 0.98507463],\n", + " [0.57547733, 0.55892034, 0.98507463],\n", + " [0.72106205, 0.70046083, 1. ],\n", + " [0.86127685, 0.8439763 , 0.97014925],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86649215, 0.13206181, 0.78823529],\n", + " [0.73298429, 0.2648479 , 0.77647059],\n", + " [0.59685864, 0.39666828, 0.76470588],\n", + " [0.42670157, 0.56711733, 1. ],\n", + " [0.27748691, 0.72163206, 0.90588235],\n", + " [0.13612565, 0.86576533, 0.85882353],\n", + " [0. , 1. , 0.77647059]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10826873, 0.10446344, 0.94366197],\n", + " [0.21524548, 0.21367521, 0.92957746],\n", + " [0.31757106, 0.31623932, 0.88732394],\n", + " [0.43152455, 0.42545109, 0.97183099],\n", + " [0.54315245, 0.54226021, 0.97183099],\n", + " [0.65865633, 0.65242165, 1. ],\n", + " [0.77416021, 0.76923077, 1. ],\n", + " [0.88552972, 0.88793922, 0.97183099],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0.55557847, 0.33853702, 0. ],\n", + " [0.59826768, 0.29549509, 0.0020017 ],\n", + " [0.61889049, 0.27319358, 0.00116766],\n", + " [0.63910085, 0.25223015, 0.00118434],\n", + " [0.66240462, 0.22725245, 0.00131779],\n", + " [0.68735822, 0.20049063, 0.00131779],\n", + " [0.70983708, 0.17662801, 0.00118434],\n", + " [0.74840173, 0.14295272, 0.00181821],\n", + " [0.77892349, 0.1206512 , 0.00135115],\n", + " [0.84697876, 0.07850134, 0.00281906],\n", + " [0.90843473, 0.04281891, 0.00268562],\n", + " [0.94060631, 0.0249777 , 0.00150128],\n", + " [0.98803877, 0.00356824, 0.00265225],\n", + " [1. , 0.00958965, 0.00125106],\n", + " [0.9919571 , 0.01516503, 0.0024354 ],\n", + " [0.98577026, 0.00646744, 0.00106757],\n", + " [0.98247061, 0. , 0.00143455],\n", + " [0.9632914 , 0.0073595 , 0.00333617],\n", + " [0.94823675, 0.01873327, 0.00118434],\n", + " [0.92905754, 0.029438 , 0.0011343 ],\n", + " [0.90657868, 0.04281891, 0.00118434],\n", + " [0.88409981, 0.05553078, 0.00116766],\n", + " [0.84553516, 0.07627119, 0.0020017 ],\n", + " [0.80263972, 0.09968778, 0.00233532],\n", + " [0.77273665, 0.11663693, 0.0016514 ],\n", + " [0.74530831, 0.13470116, 0.00150128],\n", + " [0.70694989, 0.16703836, 0.00233532],\n", + " [0.66426067, 0.21008029, 0.00285242],\n", + " [0.63641988, 0.23728814, 0.00183489],\n", + " [0.597649 , 0.27408564, 0.00250213],\n", + " [0.55599093, 0.31400535, 0.00265225],\n", + " [0.51350794, 0.35660125, 0.00266894],\n", + " [0.4809239 , 0.39250669, 0.00216851],\n", + " [0.45968241, 0.41413916, 0.00135115],\n", + " [0.43184162, 0.44446922, 0.00183489],\n", + " [0.41451846, 0.46431757, 0.00116766],\n", + " [0.39802021, 0.48438894, 0.00118434],\n", + " [0.38296556, 0.50646744, 0.00115098],\n", + " [0.34543205, 0.56043711, 0.00298587],\n", + " [0.32171582, 0.59299732, 0.00186825],\n", + " [0.30707362, 0.61418376, 0.0011343 ],\n", + " [0.23757476, 0.70963426, 0.0040034 ],\n", + " [0.17302537, 0.78099911, 0.00351966],\n", + " [0.14415343, 0.80798394, 0.0020017 ],\n", + " [0.11198185, 0.83920607, 0.00300255],\n", + " [0.09362755, 0.85191793, 0.00248545],\n", + " [0.0866158 , 0.85793934, 0.00186825],\n", + " [0.08166632, 0.86351472, 0.0016514 ],\n", + " [0.07877913, 0.86574487, 0.0014846 ],\n", + " [0.07382966, 0.86797502, 0.00468732],\n", + " [0.07073623, 0.86864407, 0.08362108],\n", + " [0.07259229, 0.86819804, 0.00598842],\n", + " [0.07135492, 0.8706512 , 1. ],\n", + " [0.07238606, 0.86864407, 0.00895761],\n", + " [0.07094246, 0.87154326, 0.08410482],\n", + " [0.07238606, 0.86864407, 0.00303591],\n", + " [0.06949887, 0.86953613, 0.36332549],\n", + " [0.07259229, 0.86819804, 0.00295251],\n", + " [0.07135492, 0.87109723, 0.06907538],\n", + " [0.07238606, 0.8690901 , 0.00301923],\n", + " [0.07073623, 0.87310437, 0.15319688],\n", + " [0.06743658, 0.88983051, 0.00290247],\n", + " [0.05898123, 0.90321142, 0.00126774],\n", + " [0.04681378, 0.91971454, 0.00116766],\n", + " [0.03134667, 0.93956289, 0.00116766],\n", + " [0.01546711, 0.9647636 , 0.00118434],\n", + " [0. , 1. , 0.00115098]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.83478009, 0.16591115, 1. ],\n", + " [0.6646412 , 0.33544878, 0.98507463],\n", + " [0.49826389, 0.50135993, 0.97014925],\n", + " [0.34085648, 0.66001813, 0.91044776],\n", + " [0.171875 , 0.82864914, 0.98507463],\n", + " [0. , 1. , 0.97014925]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11291224, 0.1025 , 0.95774648],\n", + " [0.21352711, 0.21777778, 0.97183099],\n", + " [0.32643935, 0.33944444, 1. ],\n", + " [0.43152599, 0.44138889, 0.85915493],\n", + " [0.54723309, 0.55527778, 0.97183099],\n", + " [0.66741196, 0.67361111, 1. ],\n", + " [0.78088317, 0.78583333, 0.97183099],\n", + " [0.89938513, 0.90138889, 0.97183099],\n", + " [1. , 1. , 0.85915493]]),\n", + " array([[0.29007634, 0. , 0. ],\n", + " [0.21374046, 0.09984609, 0.50387597],\n", + " [0.10687023, 0.19584456, 0.48062016],\n", + " [0.00763359, 0.31377453, 0.58914729],\n", + " [0. , 0.4107349 , 0.48062016],\n", + " [0.02290076, 0.50673336, 0.48062016],\n", + " [0.2519084 , 0.63524432, 0.62790698],\n", + " [0.85496183, 0.80088496, 0.8372093 ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15813028, 0.15571708, 1. ],\n", + " [0.30084535, 0.29326251, 0.90410959],\n", + " [0.44256589, 0.43388314, 0.90410959],\n", + " [0.58229736, 0.57170814, 0.89041096],\n", + " [0.72650423, 0.71764048, 0.91780822],\n", + " [0.86176032, 0.85826111, 0.90410959],\n", + " [1. , 1. , 0.90410959]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90099938, 0.90231171, 0.88607595],\n", + " [0.80293567, 0.80275913, 0.88607595],\n", + " [0.70487196, 0.70469799, 0.88607595],\n", + " [0.60493442, 0.60514541, 0.89873418],\n", + " [0.50780762, 0.50894855, 0.87341772],\n", + " [0.408807 , 0.40976883, 0.88607595],\n", + " [0.29793879, 0.29828486, 1. ],\n", + " [0.19706433, 0.19873229, 0.89873418],\n", + " [0.09962523, 0.09992543, 0.87341772],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13313609, 0.13158516, 0.90277778],\n", + " [0.27218935, 0.2605717 , 0.93055556],\n", + " [0.39053254, 0.38625089, 0.91666667],\n", + " [0.52366864, 0.52043468, 1. ],\n", + " [0.64497041, 0.64186156, 0.91666667],\n", + " [0.76923077, 0.76234349, 0.91666667],\n", + " [0.8816568 , 0.88188046, 0.91666667],\n", + " [1. , 1. , 0.90277778]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89259259, 0.11350796, 0.8625 ],\n", + " [0.8 , 0.20852594, 0.7625 ],\n", + " [0.68518519, 0.32280431, 0.8875 ],\n", + " [0.56888889, 0.43888033, 0.875 ],\n", + " [0.45925926, 0.55059065, 0.85 ],\n", + " [0.36444444, 0.64560863, 0.7625 ],\n", + " [0.23185185, 0.7742681 , 1. ],\n", + " [0.11481481, 0.88854648, 0.875 ],\n", + " [0. , 1. , 0.8875 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91712707, 0.08315514, 0.875 ],\n", + " [0.83867403, 0.1644096 , 0.875 ],\n", + " [0.75359116, 0.2482775 , 0.875 ],\n", + " [0.6839779 , 0.31765265, 0.7625 ],\n", + " [0.59889503, 0.40080779, 0.875 ],\n", + " [0.51381215, 0.48562604, 0.875 ],\n", + " [0.43093923, 0.56830601, 0.875 ],\n", + " [0.33149171, 0.66809218, 1. ],\n", + " [0.25303867, 0.74839629, 0.875 ],\n", + " [0.16464088, 0.8372535 , 0.875 ],\n", + " [0.08176796, 0.91708244, 0.875 ],\n", + " [0. , 1. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10736424, 0.12337662, 0.88607595],\n", + " [0.22266303, 0.25324675, 0.89873418],\n", + " [0.33027523, 0.35064935, 0.87341772],\n", + " [0.43020084, 0.45454545, 0.7721519 ],\n", + " [0.54103645, 0.55194805, 0.87341772],\n", + " [0.64716092, 0.67532468, 0.87341772],\n", + " [0.75998016, 0.80519481, 0.91139241],\n", + " [0.88817258, 0.90909091, 1. ],\n", + " [1. , 1. , 0.89873418]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89120178, 0.89985591, 0.875 ],\n", + " [0.76325284, 0.78314121, 1. ],\n", + " [0.65473217, 0.68299712, 0.875 ],\n", + " [0.54537885, 0.57204611, 0.875 ],\n", + " [0.4346378 , 0.4574928 , 0.875 ],\n", + " [0.32722731, 0.34365994, 0.8625 ],\n", + " [0.21842909, 0.22766571, 0.8875 ],\n", + " [0.1110186 , 0.11455331, 0.8625 ],\n", + " [0. , 0. , 0.8875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1171831 , 0.1095176 , 1. ],\n", + " [0.22985915, 0.2398957 , 1. ],\n", + " [0.34732394, 0.34810952, 1. ],\n", + " [0.46 , 0.45632334, 0.97142857],\n", + " [0.55859155, 0.56584094, 0.87142857],\n", + " [0.67126761, 0.67405476, 1. ],\n", + " [0.77464789, 0.78226858, 0.87142857],\n", + " [0.88253521, 0.89178618, 0.98571429],\n", + " [1. , 1. , 0.98571429]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.25 , 0.11624297, 1. ],\n", + " [0.45 , 0.22375315, 1. ],\n", + " [0.6 , 0.34193674, 0.96875 ],\n", + " [0.7 , 0.44944692, 0.984375 ],\n", + " [0.9 , 0.56957112, 0.984375 ],\n", + " [0.95 , 0.67746944, 0.953125 ],\n", + " [0.95 , 0.78497962, 0.953125 ],\n", + " [1. , 0.89268387, 0.953125 ],\n", + " [0.9 , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92313788, 0.90489914, 0.98611111],\n", + " [0.84812467, 0.81556196, 0.95833333],\n", + " [0.77126255, 0.73775216, 0.97222222],\n", + " [0.6967776 , 0.65417867, 0.95833333],\n", + " [0.61938722, 0.56195965, 1. ],\n", + " [0.54358162, 0.4870317 , 0.94444444],\n", + " [0.46698362, 0.43227666, 0.98611111],\n", + " [0.38880085, 0.37175793, 0.97222222],\n", + " [0.31220285, 0.31123919, 0.97222222],\n", + " [0.23454834, 0.24495677, 0.95833333],\n", + " [0.15662969, 0.16426513, 0.98611111],\n", + " [0.07686212, 0.0778098 , 0.98611111],\n", + " [0. , 0. , 0.94444444]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87902716, 0.12082159, 0.98507463],\n", + " [0.75268478, 0.24848973, 0.98507463],\n", + " [0.62634239, 0.36931132, 0.98507463],\n", + " [0.5 , 0.4901329 , 1. ],\n", + " [0.37365761, 0.61739831, 0.97014925],\n", + " [0.25268478, 0.74506645, 0.98507463],\n", + " [0.12634239, 0.8727346 , 0.98507463],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.05468026, 0.04773791, 0.875 ],\n", + " [0.10704356, 0.09765991, 0.875 ],\n", + " [0.1570899 , 0.14633385, 0.8625 ],\n", + " [0.20296571, 0.19937598, 0.875 ],\n", + " [0.2557924 , 0.25429017, 1. ],\n", + " [0.30722892, 0.30577223, 0.8875 ],\n", + " [0.35681186, 0.35631825, 0.8625 ],\n", + " [0.40871177, 0.40686427, 0.8875 ],\n", + " [0.46478221, 0.46365055, 1. ],\n", + " [0.51529194, 0.51419657, 0.875 ],\n", + " [0.56719184, 0.56474259, 0.875 ],\n", + " [0.61584801, 0.61185647, 0.8625 ],\n", + " [0.66774791, 0.6599064 , 0.8875 ],\n", + " [0.71269694, 0.70982839, 0.875 ],\n", + " [0.76088971, 0.7575663 , 0.875 ],\n", + " [0.81278962, 0.80561622, 0.8625 ],\n", + " [0.85912882, 0.85335413, 0.875 ],\n", + " [0.90361446, 0.90171607, 0.875 ],\n", + " [0.95088044, 0.95070203, 0.8875 ],\n", + " [1. , 1. , 0.8625 ]]),\n", + " array([[1. , 0.09090909, 0. ],\n", + " [0.88365727, 0.54545455, 1. ],\n", + " [0.77388448, 1. , 1. ],\n", + " [0.66329045, 0.72727273, 0.98571429],\n", + " [0.55899261, 0.45454545, 0.87142857],\n", + " [0.44894607, 0.45454545, 1. ],\n", + " [0.33397208, 0.27272727, 1. ],\n", + " [0.22447304, 0. , 0.98571429],\n", + " [0.11004654, 0. , 1. ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89365122, 0.89690722, 0.87341772],\n", + " [0.78569515, 0.7812142 , 0.88607595],\n", + " [0.67398875, 0.66895762, 0.89873418],\n", + " [0.5657648 , 0.55441008, 0.88607595],\n", + " [0.45754085, 0.45475372, 0.88607595],\n", + " [0.33351192, 0.32531501, 1. ],\n", + " [0.22153764, 0.21993127, 0.89873418],\n", + " [0.11197428, 0.10538373, 0.88607595],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.83310947, 0.16734034, 1. ],\n", + " [0.6692411 , 0.33225546, 0.98507463],\n", + " [0.49932841, 0.50080841, 0.98507463],\n", + " [0.33344527, 0.66855295, 0.98507463],\n", + " [0.16655473, 0.83306386, 0.98507463],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.04642758, 0.02919708, 0.49586777],\n", + " [0.09285516, 0.06131387, 0.49311295],\n", + " [0.15429525, 0.10364964, 0.66115702],\n", + " [0.20155685, 0.14306569, 0.50413223],\n", + " [0.24826244, 0.18686131, 0.48760331],\n", + " [0.29524604, 0.22919708, 0.49586777],\n", + " [0.34278565, 0.27737226, 0.49862259],\n", + " [0.39143731, 0.32262774, 0.50137741],\n", + " [0.43842091, 0.36642336, 0.49586777],\n", + " [0.48457048, 0.41167883, 0.49311295],\n", + " [0.53183208, 0.45839416, 0.49586777],\n", + " [0.57853767, 0.49927007, 0.49862259],\n", + " [0.62496525, 0.54452555, 0.49586777],\n", + " [0.67083681, 0.60145985, 0.49311295],\n", + " [0.764804 , 0.7080292 , 0.9862259 ],\n", + " [0.85988324, 0.8189781 , 1. ],\n", + " [0.90631081, 0.87737226, 0.49586777],\n", + " [0.95273839, 0.93722628, 0.48760331],\n", + " [1. , 1. , 0.50413223]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8052017 , 0.09638554, 0.98591549],\n", + " [0.62845011, 0.17570281, 0.85915493],\n", + " [0.46921444, 0.25527108, 0.85915493],\n", + " [0.30997877, 0.33057229, 0.85915493],\n", + " [0.18577495, 0.41842369, 0.87323944],\n", + " [0.12420382, 0.52309237, 0.94366197],\n", + " [0.08864119, 0.64006024, 0.98591549],\n", + " [0.06581741, 0.76029116, 0.97183099],\n", + " [0.0403397 , 0.88002008, 0.98591549],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.68845121, 0.07122371, 0.97183099],\n", + " [0.38137869, 0.14244742, 0.98591549],\n", + " [0.13428827, 0.22848948, 0.98591549],\n", + " [0.0080573 , 0.31859465, 0.88732394],\n", + " [0. , 0.40989484, 0.95774648],\n", + " [0.04297225, 0.49545889, 0.97183099],\n", + " [0.09131603, 0.57767686, 1. ],\n", + " [0.13876455, 0.65463671, 0.97183099],\n", + " [0.18173679, 0.73111855, 1. ],\n", + " [0.23187108, 0.81070746, 0.95774648],\n", + " [0.29364369, 0.90081262, 1. ],\n", + " [0.36794987, 1. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.94292453, 0.04454148, 0.87341772],\n", + " [0.87924528, 0.09723435, 0.88607595],\n", + " [0.82358491, 0.13275109, 0.88607595],\n", + " [0.75896226, 0.18427948, 0.88607595],\n", + " [0.70188679, 0.22066958, 0.89873418],\n", + " [0.63820755, 0.26055313, 0.88607595],\n", + " [0.56650943, 0.3062591 , 1. ],\n", + " [0.50849057, 0.35283843, 0.7721519 ],\n", + " [0.44858491, 0.39388646, 0.86075949],\n", + " [0.38773585, 0.42649199, 0.88607595],\n", + " [0.32830189, 0.46870451, 0.89873418],\n", + " [0.26462264, 0.51120815, 0.88607595],\n", + " [0.21792453, 0.56040757, 0.89873418],\n", + " [0.18632075, 0.6154294 , 0.88607595],\n", + " [0.16132075, 0.66870451, 0.86075949],\n", + " [0.13443396, 0.72489083, 0.89873418],\n", + " [0.10566038, 0.77962154, 0.88607595],\n", + " [0.08207547, 0.82852984, 0.7721519 ],\n", + " [0.05377358, 0.88471616, 0.87341772],\n", + " [0.02830189, 0.94061135, 0.88607595],\n", + " [0. , 1. , 0.88607595]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10866373, 0.11042065, 1. ],\n", + " [0.22026432, 0.22179732, 1. ],\n", + " [0.32892805, 0.33365201, 1. ],\n", + " [0.43318649, 0.44407266, 1. ],\n", + " [0.54478708, 0.55544933, 1. ],\n", + " [0.65638767, 0.666826 , 1. ],\n", + " [0.76651982, 0.77844168, 1. ],\n", + " [0.88105727, 0.88910134, 0.98484848],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09164312, 0.0915357 , 0.92307692],\n", + " [0.18368995, 0.18389854, 0.8974359 ],\n", + " [0.27048849, 0.27102288, 0.8974359 ],\n", + " [0.35809447, 0.35787152, 0.87179487],\n", + " [0.45094873, 0.44995864, 0.91025641],\n", + " [0.54178442, 0.54121864, 0.91025641],\n", + " [0.6439241 , 0.64433416, 1. ],\n", + " [0.73274122, 0.73338848, 0.92307692],\n", + " [0.82034719, 0.82078853, 0.87179487],\n", + " [0.91239403, 0.91315136, 0.92307692],\n", + " [1. , 1. , 0.88461538]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.16833612, 0.84359862, 1. ],\n", + " [0.3344463 , 0.68650519, 1. ],\n", + " [0.50083472, 0.51695502, 1. ],\n", + " [0.66694491, 0.34117647, 1. ],\n", + " [0.83416806, 0.16539792, 1. ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89912281, 0.89830508, 0.875 ],\n", + " [0.79927761, 0.78644068, 0.8625 ],\n", + " [0.70975232, 0.69830508, 0.775 ],\n", + " [0.61068111, 0.59661017, 0.875 ],\n", + " [0.50928793, 0.48813559, 0.8625 ],\n", + " [0.42027864, 0.41016949, 0.7625 ],\n", + " [0.30417957, 0.31186441, 1. ],\n", + " [0.20485036, 0.20677966, 0.8625 ],\n", + " [0.10113519, 0.10169492, 0.8875 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92248377, 0.07721893, 0.875 ],\n", + " [0.84780844, 0.15207101, 0.875 ],\n", + " [0.76988636, 0.22781065, 0.875 ],\n", + " [0.69358766, 0.30532544, 0.8875 ],\n", + " [0.60795455, 0.39260355, 1. ],\n", + " [0.53043831, 0.46775148, 0.875 ],\n", + " [0.44439935, 0.55532544, 0.9875 ],\n", + " [0.36810065, 0.6316568 , 0.875 ],\n", + " [0.29261364, 0.70591716, 0.8625 ],\n", + " [0.22727273, 0.77189349, 0.7625 ],\n", + " [0.15097403, 0.84940828, 0.8875 ],\n", + " [0.07305195, 0.92633136, 0.875 ],\n", + " [0. , 1. , 0.85 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.84960422, 0.85021603, 1. ],\n", + " [0.7005277 , 0.69899184, 1. ],\n", + " [0.55145119, 0.55280845, 1. ],\n", + " [0.40897098, 0.40902544, 1. ],\n", + " [0.26649077, 0.26836294, 0.98484848],\n", + " [0.13720317, 0.14042247, 0.92424242],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08991228, 0.09179894, 0.97183099],\n", + " [0.17909357, 0.18386243, 1. ],\n", + " [0.25438596, 0.26243386, 0.85915493],\n", + " [0.33625731, 0.34973545, 0.95774648],\n", + " [0.42032164, 0.43915344, 0.98591549],\n", + " [0.49342105, 0.51560847, 0.85915493],\n", + " [0.57894737, 0.60502646, 0.98591549],\n", + " [0.6630117 , 0.69417989, 1. ],\n", + " [0.73976608, 0.77777778, 0.98591549],\n", + " [0.81359649, 0.85767196, 0.97183099],\n", + " [0.90423977, 0.93121693, 0.98591549],\n", + " [1. , 1. , 0.97183099]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89095574, 0.11177885, 0.73493976],\n", + " [0.76908275, 0.23036859, 0.79518072],\n", + " [0.64849262, 0.34855769, 0.78313253],\n", + " [0.52501604, 0.47636218, 0.80722892],\n", + " [0.39576652, 0.60376603, 0.85542169],\n", + " [0.27100706, 0.72836538, 0.80722892],\n", + " [0.15426555, 0.84735577, 0.79518072],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15966754, 0.16248109, 0.90277778],\n", + " [0.33070866, 0.33797277, 1. ],\n", + " [0.49343832, 0.50226929, 0.93055556],\n", + " [0.65398075, 0.65960666, 0.91666667],\n", + " [0.83333333, 0.83721634, 0.98611111],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90549961, 0.89603025, 0.87341772],\n", + " [0.80686806, 0.80907372, 0.89873418],\n", + " [0.71159308, 0.71077505, 0.86075949],\n", + " [0.61399432, 0.61625709, 0.89873418],\n", + " [0.51768655, 0.52362949, 0.88607595],\n", + " [0.40511232, 0.4026465 , 1. ],\n", + " [0.30570617, 0.31758034, 0.91139241],\n", + " [0.19571392, 0.19659735, 1. ],\n", + " [0.09630777, 0.09073724, 0.88607595],\n", + " [0. , 0. , 0.87341772]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88753056, 0.11025887, 0.98591549],\n", + " [0.78728606, 0.22267498, 1. ],\n", + " [0.70171149, 0.33293384, 0.98591549],\n", + " [0.56479218, 0.44271333, 0.98591549],\n", + " [0.43765281, 0.55417066, 0.97183099],\n", + " [0.3594132 , 0.665628 , 0.98591549],\n", + " [0.24694377, 0.77612656, 0.98591549],\n", + " [0.12224939, 0.88878236, 1. ],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90076336, 0.90233978, 0.88888889],\n", + " [0.82442748, 0.81993896, 0.77777778],\n", + " [0.70992366, 0.71236012, 1. ],\n", + " [0.63358779, 0.62614446, 0.78888889],\n", + " [0.54961832, 0.53229908, 0.87777778],\n", + " [0.48854962, 0.44811801, 0.77777778],\n", + " [0.39694656, 0.35147508, 0.88888889],\n", + " [0.30534351, 0.25457782, 0.88888889],\n", + " [0.19083969, 0.1698881 , 0.77777778],\n", + " [0.08396947, 0.08519837, 0.77777778],\n", + " [0. , 0. , 0.77777778]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14285714, 0.14230769, 0.91666667],\n", + " [0.28390269, 0.28365385, 0.90277778],\n", + " [0.42650104, 0.42788462, 0.91666667],\n", + " [0.57401656, 0.57019231, 0.93055556],\n", + " [0.72722567, 0.725 , 1. ],\n", + " [0.87034161, 0.86826923, 0.90277778],\n", + " [1. , 1. , 0.84722222]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90901537, 0.13140567, 1. ],\n", + " [0.82841712, 0.22301746, 0.75 ],\n", + " [0.74906523, 0.31090753, 0.77173913],\n", + " [0.67760698, 0.38963642, 0.68478261],\n", + " [0.59867054, 0.47695391, 0.77173913],\n", + " [0.51599501, 0.56799313, 0.76086957],\n", + " [0.42958039, 0.66332665, 0.77173913],\n", + " [0.33901122, 0.75150301, 0.75 ],\n", + " [0.23930204, 0.83338105, 0.75 ],\n", + " [0.12712921, 0.91468652, 0.76086957],\n", + " [0. , 1. , 0.77173913]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10206752, 0.10437236, 0.91044776],\n", + " [0.21408008, 0.22143865, 0.98507463],\n", + " [0.32583093, 0.3370945 , 0.97014925],\n", + " [0.4378435 , 0.45557123, 0.98507463],\n", + " [0.54959435, 0.56840621, 0.98507463],\n", + " [0.66213033, 0.67277856, 1. ],\n", + " [0.77466632, 0.78138223, 0.97014925],\n", + " [0.88694059, 0.89280677, 1. ],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87961985, 0.87734488, 1. ],\n", + " [0.7687434 , 0.76479076, 1. ],\n", + " [0.65681098, 0.65488215, 0.91428571],\n", + " [0.54593453, 0.54280904, 0.92857143],\n", + " [0.43822598, 0.43650794, 0.94285714],\n", + " [0.32523759, 0.32467532, 0.94285714],\n", + " [0.21119324, 0.21164021, 0.95714286],\n", + " [0.09714889, 0.0981241 , 0.92857143],\n", + " [0. , 0. , 0.87142857]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12513062, 0.11428571, 0.98507463],\n", + " [0.24973877, 0.24761905, 1. ],\n", + " [0.37643678, 0.39047619, 0.98507463],\n", + " [0.49895507, 0.48571429, 0.98507463],\n", + " [0.62460815, 0.63809524, 0.98507463],\n", + " [0.74973877, 0.76190476, 0.98507463],\n", + " [0.87408568, 0.88571429, 0.97014925],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1171831 , 0.1095176 , 1. ],\n", + " [0.22985915, 0.2398957 , 1. ],\n", + " [0.34732394, 0.34810952, 1. ],\n", + " [0.46 , 0.45632334, 0.97142857],\n", + " [0.55859155, 0.56584094, 0.87142857],\n", + " [0.67126761, 0.67405476, 1. ],\n", + " [0.77464789, 0.78226858, 0.87142857],\n", + " [0.88253521, 0.89178618, 0.98571429],\n", + " [1. , 1. , 0.98571429]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9108299 , 0.90959925, 0.68686869],\n", + " [0.83313714, 0.83224604, 0.61616162],\n", + " [0.71600942, 0.71528425, 0.90909091],\n", + " [0.61124191, 0.61090401, 0.81818182],\n", + " [0.48263685, 0.48229264, 1. ],\n", + " [0.36462625, 0.36439888, 0.91919192],\n", + " [0.27310182, 0.27353215, 0.70707071],\n", + " [0.18363743, 0.18313141, 0.6969697 ],\n", + " [0.09270159, 0.09273066, 0.70707071],\n", + " [0. , 0. , 0.70707071]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12324127, 0.12348668, 0.98507463],\n", + " [0.24882751, 0.24697337, 0.98507463],\n", + " [0.3741532 , 0.37288136, 0.98507463],\n", + " [0.4994789 , 0.49636804, 0.98507463],\n", + " [0.62428348, 0.61985472, 0.98507463],\n", + " [0.74960917, 0.74576271, 0.97014925],\n", + " [0.87493486, 0.87409201, 1. ],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92743702, 0.93573668, 0.97183099],\n", + " [0.85651698, 0.86677116, 1. ],\n", + " [0.78559693, 0.78996865, 0.97183099],\n", + " [0.71221249, 0.71316614, 1. ],\n", + " [0.63882804, 0.63793103, 0.98591549],\n", + " [0.56626506, 0.56269592, 0.98591549],\n", + " [0.49589266, 0.48746082, 0.98591549],\n", + " [0.42387733, 0.4153605 , 0.97183099],\n", + " [0.34884995, 0.34952978, 1. ],\n", + " [0.27847755, 0.28840125, 0.97183099],\n", + " [0.21686747, 0.22413793, 0.85915493],\n", + " [0.14375685, 0.14733542, 0.98591549],\n", + " [0.07228916, 0.07836991, 0.98591549],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.03042376, 0.9676259 , 0.85915493],\n", + " [0.05976096, 0.93021583, 0.97183099],\n", + " [0.09127128, 0.89100719, 0.98591549],\n", + " [0.12459254, 0.85107914, 1. ],\n", + " [0.15574067, 0.81330935, 0.97183099],\n", + " [0.18580225, 0.77517986, 0.98591549],\n", + " [0.21876132, 0.73417266, 1. ],\n", + " [0.24918508, 0.69568345, 0.98591549],\n", + " [0.27852227, 0.65899281, 0.97183099],\n", + " [0.30967041, 0.62086331, 0.98591549],\n", + " [0.34118073, 0.58417266, 1. ],\n", + " [0.37269105, 0.54964029, 0.97183099],\n", + " [0.403477 , 0.51906475, 1. ],\n", + " [0.43534951, 0.49208633, 0.97183099],\n", + " [0.47048171, 0.46294964, 0.98591549],\n", + " [0.51104672, 0.42841727, 1. ],\n", + " [0.56175299, 0.38741007, 0.97183099],\n", + " [0.62115176, 0.3352518 , 1. ],\n", + " [0.68055053, 0.27913669, 0.97183099],\n", + " [0.74176023, 0.21870504, 1. ],\n", + " [0.80441869, 0.15503597, 0.98591549],\n", + " [0.86707715, 0.09676259, 0.98591549],\n", + " [0.93444404, 0.04280576, 0.98591549],\n", + " [1. , 0. , 0.98591549]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09113924, 0.90918214, 0.88607595],\n", + " [0.16708861, 0.83115906, 0.7721519 ],\n", + " [0.25417722, 0.73933768, 0.88607595],\n", + " [0.35443038, 0.63447065, 1. ],\n", + " [0.44303797, 0.54290015, 0.88607595],\n", + " [0.53468354, 0.45208229, 0.88607595],\n", + " [0.62835443, 0.35875564, 0.89873418],\n", + " [0.72 , 0.26818866, 0.88607595],\n", + " [0.81063291, 0.18038133, 0.87341772],\n", + " [0.90835443, 0.08780733, 0.91139241],\n", + " [1. , 0. , 0.87341772]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11183533, 0.88659794, 0.91666667],\n", + " [0.20377358, 0.79843583, 0.75 ],\n", + " [0.32281304, 0.67365802, 1. ],\n", + " [0.42092624, 0.57483114, 0.83333333],\n", + " [0.51423671, 0.48524707, 0.76190476],\n", + " [0.6102916 , 0.39033061, 0.78571429],\n", + " [0.70120069, 0.30181301, 0.75 ],\n", + " [0.79073756, 0.21507288, 0.76190476],\n", + " [0.89296741, 0.10842517, 0.85714286],\n", + " [1. , 0. , 0.92857143]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.07493857, 0.9235348 , 0.97183099],\n", + " [0.14864865, 0.84478022, 1. ],\n", + " [0.22727273, 0.76831502, 0.97183099],\n", + " [0.30712531, 0.68978938, 1. ],\n", + " [0.38329238, 0.61446886, 0.98591549],\n", + " [0.46437346, 0.54235348, 0.98591549],\n", + " [0.53194103, 0.4720696 , 0.97183099],\n", + " [0.5982801 , 0.40132784, 1. ],\n", + " [0.66584767, 0.3331044 , 0.97183099],\n", + " [0.73587224, 0.2657967 , 1. ],\n", + " [0.8046683 , 0.19894689, 0.98591549],\n", + " [0.87223587, 0.1334707 , 0.97183099],\n", + " [0.93611794, 0.066163 , 0.98591549],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11971472, 0.12044456, 0.85897436],\n", + " [0.24859908, 0.25096924, 0.91025641],\n", + " [0.36933265, 0.37425691, 0.85897436],\n", + " [0.51197147, 0.51744637, 1. ],\n", + " [0.63066735, 0.63711553, 0.83333333],\n", + " [0.74325013, 0.74877229, 0.78205128],\n", + " [0.86500255, 0.8666322 , 0.83333333],\n", + " [1. , 1. , 0.93589744]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16577279, 0.16811847, 0.85714286],\n", + " [0.32179425, 0.32084785, 0.78571429],\n", + " [0.51828376, 0.51655052, 1. ],\n", + " [0.66991711, 0.67044135, 0.78571429],\n", + " [0.84641638, 0.84843206, 0.92857143],\n", + " [1. , 1. , 0.77380952]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1 , 0.1134482 , 0.83544304],\n", + " [0.225 , 0.23249049, 0.83544304],\n", + " [0.325 , 0.3624972 , 0.91139241],\n", + " [0.475 , 0.48869993, 0.91139241],\n", + " [0.61666667, 0.60908481, 0.84810127],\n", + " [0.75 , 0.73707765, 0.89873418],\n", + " [0.86666667, 0.87200716, 1. ],\n", + " [1. , 1. , 0.91139241]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.918897 , 0.06410256, 0.98591549],\n", + " [0.85158151, 0.13230769, 0.98591549],\n", + " [0.78426602, 0.19641026, 0.97183099],\n", + " [0.72992701, 0.26487179, 0.98591549],\n", + " [0.66261152, 0.33333333, 0.98591549],\n", + " [0.594485 , 0.40153846, 0.98591549],\n", + " [0.54095702, 0.46564103, 1. ],\n", + " [0.47283049, 0.53410256, 1. ],\n", + " [0.405515 , 0.6025641 , 0.98591549],\n", + " [0.35117599, 0.66666667, 0.95774648],\n", + " [0.27007299, 0.73487179, 1. ],\n", + " [0.2027575 , 0.80333333, 0.98591549],\n", + " [0.13544201, 0.8674359 , 0.97183099],\n", + " [0.06731549, 0.93153846, 1. ],\n", + " [0. , 1. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90535642, 0.92314119, 0.97183099],\n", + " [0.83125252, 0.8512949 , 0.85915493],\n", + " [0.74748288, 0.76552492, 0.97183099],\n", + " [0.66290777, 0.67836257, 1. ],\n", + " [0.58034636, 0.59370649, 0.97183099],\n", + " [0.49496577, 0.50654414, 1. ],\n", + " [0.41159887, 0.42133111, 0.98591549],\n", + " [0.33064841, 0.33834586, 0.97183099],\n", + " [0.24808699, 0.25396825, 1. ],\n", + " [0.16673379, 0.17070454, 0.97183099],\n", + " [0.08296416, 0.08437761, 0.98591549],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87714988, 0.87810384, 0.90410959],\n", + " [0.74348894, 0.74467018, 0.98630137],\n", + " [0.62113022, 0.62202157, 0.91780822],\n", + " [0.4987715 , 0.49937296, 0.89041096],\n", + " [0.37641278, 0.37772761, 0.91780822],\n", + " [0.25503686, 0.25507901, 0.90410959],\n", + " [0.13316953, 0.13343366, 0.89041096],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11818182, 0.15018315, 0.91666667],\n", + " [0.2507177 , 0.29517705, 0.91666667],\n", + " [0.39330144, 0.43650794, 0.91666667],\n", + " [0.54545455, 0.59126984, 1. ],\n", + " [0.69090909, 0.73015873, 0.91666667],\n", + " [0.8430622 , 0.86630037, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11592289, 0.88461538, 0.91044776],\n", + " [0.24161605, 0.75721154, 0.97014925],\n", + " [0.36783734, 0.63341346, 1. ],\n", + " [0.49247425, 0.50841346, 0.97014925],\n", + " [0.62080803, 0.37740385, 1. ],\n", + " [0.74729337, 0.25120192, 0.97014925],\n", + " [0.87193029, 0.12860577, 0.98507463],\n", + " [1. , 0. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86141414, 0.86026436, 0.89041096],\n", + " [0.72242424, 0.72133801, 0.91780822],\n", + " [0.56929293, 0.56757486, 0.98630137],\n", + " [0.43070707, 0.42837874, 0.90410959],\n", + " [0.29131313, 0.29295927, 0.89041096],\n", + " [0.1389899 , 0.13703804, 1. ],\n", + " [0. , 0. , 0.90410959]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08984375, 0.85667656, 0.98507463],\n", + " [0.17617188, 0.72106825, 0.97014925],\n", + " [0.2640625 , 0.58991098, 0.98507463],\n", + " [0.378125 , 0.47596439, 1. ],\n", + " [0.5046875 , 0.37418398, 0.98507463],\n", + " [0.63632813, 0.26884273, 0.98507463],\n", + " [0.76640625, 0.1735905 , 0.97014925],\n", + " [0.88203125, 0.09376855, 0.91044776],\n", + " [1. , 0. , 0.97014925]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10547945, 0.10156028, 0.95774648],\n", + " [0.21598174, 0.21219858, 1. ],\n", + " [0.31232877, 0.30808511, 0.85915493],\n", + " [0.43105023, 0.42297872, 0.97183099],\n", + " [0.53424658, 0.52283688, 0.85915493],\n", + " [0.65251142, 0.64141844, 0.97183099],\n", + " [0.7716895 , 0.7670922 , 0.98591549],\n", + " [0.88356164, 0.88198582, 0.91549296],\n", + " [1. , 1. , 0.94366197]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89241223, 0.10612639, 0.875 ],\n", + " [0.77916195, 0.21900627, 0.875 ],\n", + " [0.67157418, 0.32633864, 0.8625 ],\n", + " [0.5605889 , 0.43777135, 0.875 ],\n", + " [0.44960362, 0.5458273 , 0.8875 ],\n", + " [0.33069083, 0.66931983, 1. ],\n", + " [0.21857305, 0.78147612, 0.8875 ],\n", + " [0.11098528, 0.88904969, 0.875 ],\n", + " [0. , 1. , 0.875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8843599 , 0.88255699, 0.87341772],\n", + " [0.78713768, 0.78691774, 0.89873418],\n", + " [0.67542271, 0.67542121, 0.88607595],\n", + " [0.55253623, 0.55153617, 1. ],\n", + " [0.43025362, 0.43409316, 0.91139241],\n", + " [0.3227657 , 0.32259663, 1. ],\n", + " [0.20591787, 0.20317146, 0.88607595],\n", + " [0.1053744 , 0.10455897, 0.87341772],\n", + " [0. , 0. , 0.89873418]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.05128205, 0.11339735, 1. ],\n", + " [0.12820513, 0.22176497, 0.97014925],\n", + " [0.25641026, 0.33561957, 0.98507463],\n", + " [0.35897436, 0.44947417, 1. ],\n", + " [0.48717949, 0.55989941, 0.97014925],\n", + " [0.58974359, 0.66209419, 0.91044776],\n", + " [0.74358974, 0.77640604, 0.98507463],\n", + " [0.87179487, 0.88728852, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[0.86896713, 0.50993049, 0. ],\n", + " [0.89228258, 0.5571003 , 0.00143794],\n", + " [0.9107018 , 0.59334657, 0.001329 ],\n", + " [0.92609 , 0.63157895, 0.00137258],\n", + " [0.93774773, 0.67428004, 0.00143794],\n", + " [0.94497552, 0.71747766, 0.00139437],\n", + " [0.95220331, 0.76911619, 0.00165581],\n", + " [0.9568664 , 0.816286 , 0.00152509],\n", + " [0.96059688, 0.86146971, 0.00152509],\n", + " [0.9645605 , 0.90317776, 0.00152509],\n", + " [0.96782467, 0.9285005 , 0.00145973],\n", + " [0.97062252, 0.94637537, 0.00139437],\n", + " [0.97551877, 0.96176763, 0.00152509],\n", + " [0.98134763, 0.97318769, 0.00143794],\n", + " [0.98671019, 0.98460775, 0.00139437],\n", + " [0.99090697, 0.99006951, 0.00137258],\n", + " [0.99347167, 0.98659384, 0.00143794],\n", + " [0.99580322, 0.99006951, 0.00429203],\n", + " [0.99766845, 0.99304866, 0.00145973],\n", + " [1. , 0.98460775, 0.0080176 ],\n", + " [0.99836792, 0.99255214, 0.00782152],\n", + " [0.99323852, 0.98311817, 0.00396523],\n", + " [0.99020751, 0.98411122, 0.00389987],\n", + " [0.99347167, 0.98510427, 0.0078651 ],\n", + " [0.99137328, 0.98609732, 0.33721868],\n", + " [0.99347167, 0.98510427, 0.22357786],\n", + " [0.99557006, 0.9836147 , 1. ],\n", + " [0.99347167, 0.98560079, 0.34116212],\n", + " [0.99580322, 0.98510427, 0.41179546],\n", + " [0.99370483, 0.98560079, 0.5804048 ],\n", + " [0.99580322, 0.98411122, 0.4000305 ],\n", + " [0.99393798, 0.98659384, 0.67055927],\n", + " [0.99183959, 0.98609732, 0.2980675 ],\n", + " [0.99463744, 0.98560079, 0.11767141],\n", + " [0.99673584, 0.9836147 , 0.19996078],\n", + " [0.99323852, 0.98560079, 0.04710342],\n", + " [0.99626953, 0.98411122, 0.01176496],\n", + " [0.99417114, 0.98510427, 0.09015447],\n", + " [0.99207274, 0.98560079, 0.14904464],\n", + " [0.99463744, 0.98560079, 0.41963877],\n", + " [0.99673584, 0.9836147 , 0.20000436],\n", + " [0.99277221, 0.98560079, 0.21176932],\n", + " [0.9948706 , 0.98609732, 0.58036123],\n", + " [0.99673584, 0.9836147 , 0.22355607],\n", + " [0.99440429, 0.98510427, 0.16078782],\n", + " [0.9923059 , 0.98411122, 0.06666812],\n", + " [0.99463744, 0.98560079, 0.57256149],\n", + " [0.9923059 , 0.98560079, 0.46275518],\n", + " [0.99463744, 0.98510427, 0.42353864],\n", + " [0.99300536, 0.98907646, 0.05882481],\n", + " [0.98997435, 1. , 0.00394344],\n", + " [0.97598508, 0.9448858 , 0.00392165],\n", + " [0.96222896, 0.84558093, 0.00389987],\n", + " [0.94637445, 0.74230387, 0.00392165],\n", + " [0.94590814, 0.68222443, 0.00392165],\n", + " [0.96899044, 0.75819265, 0.00394344],\n", + " [0.96409419, 0.74925521, 0.00392165],\n", + " [0.94194451, 0.69860973, 0.00228763],\n", + " [0.91862905, 0.64001986, 0.0015033 ],\n", + " [0.88948473, 0.5714995 , 0.00152509],\n", + " [0.85614362, 0.48957299, 0.00152509],\n", + " [0.82140359, 0.41161867, 0.00152509],\n", + " [0.79179296, 0.35153923, 0.001329 ],\n", + " [0.75915132, 0.28202582, 0.00152509],\n", + " [0.72604337, 0.22293942, 0.00152509],\n", + " [0.68967125, 0.19463754, 0.00152509],\n", + " [0.65376545, 0.17030785, 0.0015033 ],\n", + " [0.61832595, 0.14548163, 0.00152509],\n", + " [0.57822336, 0.12065541, 0.00176474],\n", + " [0.54371648, 0.0958292 , 0.00152509],\n", + " [0.50920961, 0.07199603, 0.0015033 ],\n", + " [0.4758685 , 0.04518371, 0.0015033 ],\n", + " [0.44112847, 0.02730884, 0.00154687],\n", + " [0.4070879 , 0.01390268, 0.0015033 ],\n", + " [0.37701096, 0.00546177, 0.001329 ],\n", + " [0.340872 , 0. , 0.00154687],\n", + " [0.30146887, 0.00446872, 0.0015033 ],\n", + " [0.25623689, 0.02135055, 0.00152509],\n", + " [0.20540919, 0.03972195, 0.0015033 ],\n", + " [0.15877827, 0.06951341, 0.001329 ],\n", + " [0.10048962, 0.10724926, 0.00154687],\n", + " [0.04383306, 0.17080437, 0.0015033 ],\n", + " [0. , 0.25173784, 0.001329 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09489796, 0.09597315, 0.85915493],\n", + " [0.21020408, 0.21006711, 0.98591549],\n", + " [0.31530612, 0.32326622, 1. ],\n", + " [0.4255102 , 0.43422819, 0.97183099],\n", + " [0.54183673, 0.54876957, 0.98591549],\n", + " [0.65714286, 0.66129754, 0.98591549],\n", + " [0.77142857, 0.77427293, 0.98591549],\n", + " [0.88469388, 0.88680089, 0.98591549],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11211644, 0.88765987, 1. ],\n", + " [0.22029898, 0.77773937, 0.97183099],\n", + " [0.33044847, 0.6657449 , 0.98591549],\n", + " [0.44138474, 0.55478742, 0.98591549],\n", + " [0.55192762, 0.44348427, 0.98591549],\n", + " [0.66404406, 0.33045282, 0.98591549],\n", + " [0.77104642, 0.22122364, 0.97183099],\n", + " [0.88316286, 0.10750086, 0.98591549],\n", + " [1. , 0. , 0.98591549]]),\n", + " array([[0.37808642, 0.28623976, 0. ],\n", + " [0.3287037 , 0.2499582 , 0.00157598],\n", + " [0.27777778, 0.2110015 , 0.00180851],\n", + " [0.23611111, 0.17371677, 0.00183434],\n", + " [0.21759259, 0.13960876, 0.00178267],\n", + " [0.19135802, 0.10901187, 0.00180851],\n", + " [0.16820988, 0.08276208, 0.00180851],\n", + " [0.13580247, 0.06119378, 0.00180851],\n", + " [0.10802469, 0.04681491, 0.00180851],\n", + " [0.12808642, 0.03644875, 0.00157598],\n", + " [0.13734568, 0.02541381, 0.00162765],\n", + " [0.12654321, 0.0172212 , 0.00162765],\n", + " [0.10030864, 0.01187092, 0.00160182],\n", + " [0.06790123, 0.00919579, 0.00165349],\n", + " [0.10648148, 0.00819261, 0.00534801],\n", + " [0.1404321 , 0.00652065, 0.00183434],\n", + " [0.16203704, 0.00518308, 0.00178267],\n", + " [0.18364198, 0.00384551, 0.00178267],\n", + " [0.19598765, 0.00468149, 0.00364285],\n", + " [0.20987654, 0.0043471 , 0.01482974],\n", + " [0.19598765, 0.00501588, 0.04658193],\n", + " [0.20833333, 0.0041799 , 0.01397716],\n", + " [0.19444444, 0.00367831, 0.39996383],\n", + " [0.22067901, 0.00334392, 0.00470211],\n", + " [0.19907407, 0.0045143 , 0.01384798],\n", + " [0.21141975, 0.00267514, 0.0231747 ],\n", + " [0.20216049, 0.0041799 , 0.06975663],\n", + " [0.21759259, 0.0041799 , 1. ],\n", + " [0.20061728, 0.0043471 , 0.00927505],\n", + " [0.20987654, 0.00769102, 0.26517853],\n", + " [0.20061728, 0.00501588, 0.00462461],\n", + " [0.18518519, 0.00401271, 0.03715186],\n", + " [0.2037037 , 0.0045143 , 0.00477962],\n", + " [0.19753086, 0.00284233, 0.27429856],\n", + " [0.20679012, 0.00468149, 0.00930088],\n", + " [0.19290123, 0.00585186, 0.09760761],\n", + " [0.2037037 , 0.0043471 , 0.00467628],\n", + " [0.18364198, 0.00551747, 0.07394202],\n", + " [0.15895062, 0.00468149, 0.00180851],\n", + " [0.13271605, 0.00401271, 0.00180851],\n", + " [0.09104938, 0.00501588, 0.00180851],\n", + " [0.0617284 , 0.00367831, 0.00180851],\n", + " [0.02314815, 0.00167196, 0.00178267],\n", + " [0.00771605, 0. , 0.00180851],\n", + " [0.00154321, 0.00384551, 0.00183434],\n", + " [0. , 0.01454606, 0.00157598],\n", + " [0.01388889, 0.03644875, 0.00178267],\n", + " [0.04166667, 0.06738004, 0.00178267],\n", + " [0.07561728, 0.1036616 , 0.00183434],\n", + " [0.12808642, 0.14178231, 0.00178267],\n", + " [0.18518519, 0.18007022, 0.00157598],\n", + " [0.25308642, 0.22772112, 0.00180851],\n", + " [0.32561728, 0.27771276, 0.00178267],\n", + " [0.39969136, 0.33238589, 0.00183434],\n", + " [0.47376543, 0.38388229, 0.00178267],\n", + " [0.54166667, 0.43404113, 0.00180851],\n", + " [0.61265432, 0.48369838, 0.00183434],\n", + " [0.67438272, 0.52917572, 0.00180851],\n", + " [0.69907407, 0.57548905, 0.00180851],\n", + " [0.65432099, 0.62113359, 0.00178267],\n", + " [0.55555556, 0.67129243, 0.00180851],\n", + " [0.44444444, 0.72512958, 0.00183434],\n", + " [0.39969136, 0.78063869, 0.00180851],\n", + " [0.47839506, 0.83481023, 0.00178267],\n", + " [0.6558642 , 0.8878114 , 0.00180851],\n", + " [0.83641975, 0.94248453, 0.00183434],\n", + " [1. , 1. , 0.00180851]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89916506, 0.90027933, 0.76666667],\n", + " [0.77970456, 0.78128492, 0.9 ],\n", + " [0.67244701, 0.6773743 , 0.78888889],\n", + " [0.56968529, 0.57458101, 0.76666667],\n", + " [0.46820809, 0.47346369, 0.77777778],\n", + " [0.34168272, 0.35335196, 0.88888889],\n", + " [0.20873475, 0.22150838, 1. ],\n", + " [0.10276172, 0.11871508, 0.77777778],\n", + " [0. , 0. , 0.88888889]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90171804, 0.89302326, 0.85915493],\n", + " [0.78928752, 0.8 , 0.97183099],\n", + " [0.67812026, 0.71627907, 0.98591549],\n", + " [0.56392117, 0.59534884, 1. ],\n", + " [0.451238 , 0.49302326, 0.97183099],\n", + " [0.3403234 , 0.38139535, 0.98591549],\n", + " [0.22612431, 0.24651163, 1. ],\n", + " [0.11318848, 0.13023256, 0.97183099],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89517876, 0.92907801, 0.8625 ],\n", + " [0.77139762, 0.8108747 , 1. ],\n", + " [0.66088841, 0.69030733, 0.8875 ],\n", + " [0.55444204, 0.58156028, 0.875 ],\n", + " [0.42930661, 0.45390071, 1. ],\n", + " [0.32204767, 0.34042553, 0.875 ],\n", + " [0.2156013 , 0.22458629, 0.875 ],\n", + " [0.10780065, 0.11347518, 0.875 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8526373 , 0.13913282, 0.91666667],\n", + " [0.70799347, 0.27963776, 0.91666667],\n", + " [0.56824361, 0.41822173, 0.91666667],\n", + " [0.42631865, 0.55927552, 0.91666667],\n", + " [0.28602501, 0.70032931, 0.91666667],\n", + " [0.14953779, 0.84248079, 0.91666667],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90478628, 0.90769231, 0.7721519 ],\n", + " [0.77860251, 0.80512821, 1. ],\n", + " [0.66547223, 0.66153846, 0.88607595],\n", + " [0.55490146, 0.52307692, 0.89873418],\n", + " [0.4463783 , 0.39487179, 0.86075949],\n", + " [0.33452777, 0.31282051, 0.89873418],\n", + " [0.22216534, 0.21538462, 0.89873418],\n", + " [0.11389813, 0.1025641 , 0.86075949],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.13227045, 0.86840253, 0.97014925],\n", + " [0.26424565, 0.73539761, 0.98507463],\n", + " [0.39326838, 0.60380014, 0.98507463],\n", + " [0.51992914, 0.4799437 , 0.98507463],\n", + " [0.64363744, 0.35749472, 1. ],\n", + " [0.76616475, 0.23363828, 0.97014925],\n", + " [0.8768822 , 0.12385644, 0.91044776],\n", + " [1. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12532774, 0.11647255, 0.98507463],\n", + " [0.25144206, 0.25291181, 1. ],\n", + " [0.37414788, 0.3843594 , 0.97014925],\n", + " [0.50052438, 0.49916805, 1. ],\n", + " [0.62532774, 0.61730449, 0.97014925],\n", + " [0.7501311 , 0.75207987, 1. ],\n", + " [0.87519664, 0.87354409, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12655547, 0.87096774, 0.6875 ],\n", + " [0.30791634, 0.67741935, 1. ],\n", + " [0.43155944, 0.56682028, 0.6875 ],\n", + " [0.55599682, 0.43778802, 0.67708333],\n", + " [0.69473127, 0.29493088, 0.76041667],\n", + " [0.82922955, 0.16589862, 0.75 ],\n", + " [1. , 0. , 0.9375 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88892519, 0.88787879, 1. ],\n", + " [0.79157138, 0.79134199, 0.8875 ],\n", + " [0.69519765, 0.6952381 , 0.85 ],\n", + " [0.59719046, 0.5965368 , 0.8875 ],\n", + " [0.49885658, 0.4987013 , 0.875 ],\n", + " [0.38908853, 0.39134199, 1. ],\n", + " [0.29010127, 0.29480519, 0.8875 ],\n", + " [0.1950343 , 0.2017316 , 0.85 ],\n", + " [0.09735381, 0.1008658 , 0.8875 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86659719, 0.85674393, 1. ],\n", + " [0.76498176, 0.75006981, 0.74311927],\n", + " [0.69359041, 0.67104161, 0.55963303],\n", + " [0.57894737, 0.54984641, 0.8440367 ],\n", + " [0.46013549, 0.43730801, 0.82568807],\n", + " [0.37571652, 0.35101927, 0.6146789 ],\n", + " [0.28295987, 0.26836079, 0.60550459],\n", + " [0.18394997, 0.17173974, 0.70642202],\n", + " [0.09223554, 0.08852276, 0.60550459],\n", + " [0. , 0. , 0.64220183]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85517241, 0.85358025, 0.98507463],\n", + " [0.71724138, 0.70962963, 0.98507463],\n", + " [0.5862069 , 0.57382716, 0.98507463],\n", + " [0.42758621, 0.42271605, 0.98507463],\n", + " [0.30344828, 0.28691358, 1. ],\n", + " [0.13793103, 0.14049383, 0.98507463],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12962963, 0.09155937, 1. ],\n", + " [0.25925926, 0.18407248, 0.98591549],\n", + " [0.38683128, 0.27539342, 1. ],\n", + " [0.51234568, 0.36599905, 0.95774648],\n", + " [0.63786008, 0.45779685, 0.98591549],\n", + " [0.76748971, 0.54911779, 0.98591549],\n", + " [0.89917695, 0.64210777, 1. ],\n", + " [1. , 0.73056748, 0.97183099],\n", + " [0.93209877, 0.81592752, 0.98591549],\n", + " [0.84156379, 0.90724845, 1. ],\n", + " [0.75308642, 1. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88812714, 0.11279826, 1. ],\n", + " [0.77126831, 0.23318872, 0.98571429],\n", + " [0.65783733, 0.35140998, 0.92857143],\n", + " [0.5344344 , 0.48318872, 0.92857143],\n", + " [0.40729199, 0.62255965, 0.95714286],\n", + " [0.27890309, 0.76193059, 0.92857143],\n", + " [0.14178872, 0.88882863, 0.95714286],\n", + " [0. , 1. , 0.92857143]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89225182, 0.10917979, 0.8875 ],\n", + " [0.76937046, 0.23275394, 1. ],\n", + " [0.66162228, 0.34139055, 0.8625 ],\n", + " [0.53571429, 0.46740902, 1. ],\n", + " [0.42675545, 0.57631722, 0.875 ],\n", + " [0.31476998, 0.68929929, 0.8875 ],\n", + " [0.20762712, 0.79603476, 0.85 ],\n", + " [0.11016949, 0.89163498, 0.775 ],\n", + " [0. , 1. , 0.8625 ]]),\n", + " array([[9.61117002e-01, 8.14209115e-01, 0.00000000e+00],\n", + " [9.62884411e-01, 7.95710456e-01, 2.11732037e-02],\n", + " [9.51572994e-01, 7.94369973e-01, 2.42971191e-02],\n", + " [9.41322022e-01, 8.01876676e-01, 2.42971191e-02],\n", + " [9.33191941e-01, 8.07238606e-01, 2.39500174e-02],\n", + " [9.22234005e-01, 8.10455764e-01, 2.46442208e-02],\n", + " [9.11629551e-01, 8.09115282e-01, 2.39500174e-02],\n", + " [9.03145988e-01, 8.05093834e-01, 2.46442208e-02],\n", + " [8.96783316e-01, 7.87667560e-01, 6.52551198e-02],\n", + " [8.91834571e-01, 7.71313673e-01, 6.24783061e-02],\n", + " [8.89713680e-01, 7.57640751e-01, 6.24783061e-02],\n", + " [8.90774125e-01, 7.47721180e-01, 6.24783061e-02],\n", + " [8.91481089e-01, 7.42091153e-01, 6.24783061e-02],\n", + " [8.93955461e-01, 7.38873995e-01, 6.24783061e-02],\n", + " [8.95015907e-01, 7.35656836e-01, 3.74869837e-01],\n", + " [8.97843761e-01, 7.33512064e-01, 1.24956612e-01],\n", + " [8.94662425e-01, 7.34852547e-01, 2.49913225e-01],\n", + " [8.97843761e-01, 7.33243968e-01, 2.49913225e-01],\n", + " [8.98904206e-01, 7.30026810e-01, 1.87434918e-01],\n", + " [9.01732061e-01, 7.28686327e-01, 3.74869837e-01],\n", + " [9.03499470e-01, 7.26273458e-01, 1.87434918e-01],\n", + " [9.05973842e-01, 7.24396783e-01, 1.87434918e-01],\n", + " [9.09155179e-01, 7.21715818e-01, 2.49913225e-01],\n", + " [9.12336515e-01, 7.20107239e-01, 1.87434918e-01],\n", + " [9.15517851e-01, 7.18230563e-01, 2.49913225e-01],\n", + " [9.18345705e-01, 7.16353887e-01, 2.50260326e-01],\n", + " [9.18345705e-01, 7.20911528e-01, 1.24609511e-01],\n", + " [9.20466596e-01, 7.18498660e-01, 3.74869837e-01],\n", + " [9.17285260e-01, 7.21447721e-01, 6.24783061e-02],\n", + " [9.17992223e-01, 7.17962466e-01, 1.87434918e-01],\n", + " [9.24354896e-01, 7.17426273e-01, 1.24956612e-01],\n", + " [9.27536232e-01, 7.18230563e-01, 6.24783061e-02],\n", + " [9.31071050e-01, 7.16085791e-01, 6.24783061e-02],\n", + " [9.32838459e-01, 7.12868633e-01, 6.24783061e-02],\n", + " [9.36373277e-01, 7.11796247e-01, 4.99826449e-01],\n", + " [9.40615058e-01, 7.12600536e-01, 1.24956612e-01],\n", + " [9.42028986e-01, 7.15281501e-01, 1.87434918e-01],\n", + " [9.46977731e-01, 7.15013405e-01, 4.99826449e-01],\n", + " [9.53693885e-01, 7.14209115e-01, 3.12391531e-01],\n", + " [9.57935666e-01, 7.14745308e-01, 1.87434918e-01],\n", + " [9.60410039e-01, 7.17158177e-01, 2.50260326e-01],\n", + " [9.63237893e-01, 7.20911528e-01, 1.87087817e-01],\n", + " [9.66419229e-01, 7.20375335e-01, 1.87434918e-01],\n", + " [9.69954047e-01, 7.22520107e-01, 1.87434918e-01],\n", + " [9.73842347e-01, 7.21983914e-01, 2.49913225e-01],\n", + " [9.76316720e-01, 7.24396783e-01, 6.24783061e-02],\n", + " [9.80205019e-01, 7.26541555e-01, 6.25130163e-01],\n", + " [9.82679392e-01, 7.28686327e-01, 1.24609511e-01],\n", + " [9.84800283e-01, 7.32975871e-01, 1.25303714e-01],\n", + " [9.87274655e-01, 7.35388740e-01, 6.24783061e-02],\n", + " [9.89749028e-01, 7.37265416e-01, 6.24783061e-02],\n", + " [9.92930364e-01, 7.38873995e-01, 6.21312044e-02],\n", + " [9.94697773e-01, 7.43699732e-01, 1.24956612e-01],\n", + " [9.97172146e-01, 7.45844504e-01, 6.28254078e-02],\n", + " [9.98232591e-01, 7.50402145e-01, 6.24783061e-02],\n", + " [9.97879109e-01, 7.54423592e-01, 6.24783061e-02],\n", + " [9.97879109e-01, 7.58713137e-01, 6.24783061e-02],\n", + " [9.97879109e-01, 7.64075067e-01, 6.24783061e-02],\n", + " [9.97879109e-01, 7.68096515e-01, 6.21312044e-02],\n", + " [9.96818664e-01, 7.71849866e-01, 6.28254078e-02],\n", + " [9.94697773e-01, 7.73994638e-01, 6.21312044e-02],\n", + " [9.94344291e-01, 7.79624665e-01, 6.28254078e-02],\n", + " [9.93990809e-01, 7.84450402e-01, 6.21312044e-02],\n", + " [9.93990809e-01, 7.89544236e-01, 6.28254078e-02],\n", + " [9.93990809e-01, 7.94906166e-01, 6.24783061e-02],\n", + " [9.91869919e-01, 7.99463807e-01, 6.24783061e-02],\n", + " [9.88688583e-01, 8.03753351e-01, 6.24783061e-02],\n", + " [9.84446801e-01, 8.06702413e-01, 6.24783061e-02],\n", + " [9.81618947e-01, 8.09919571e-01, 6.24783061e-02],\n", + " [9.78791092e-01, 8.12600536e-01, 6.24783061e-02],\n", + " [9.74902793e-01, 8.13941019e-01, 1.24956612e-01],\n", + " [9.71721456e-01, 8.16353887e-01, 1.87434918e-01],\n", + " [9.68186638e-01, 8.17158177e-01, 6.24783061e-02],\n", + " [9.64651820e-01, 8.18498660e-01, 6.24783061e-02],\n", + " [9.60410039e-01, 8.20107239e-01, 1.24956612e-01],\n", + " [9.64651820e-01, 8.16890080e-01, 3.74869837e-01],\n", + " [9.69600566e-01, 8.15281501e-01, 1.24956612e-01],\n", + " [9.73842347e-01, 8.13136729e-01, 6.24783061e-02],\n", + " [9.77730647e-01, 8.12332440e-01, 6.24783061e-02],\n", + " [9.82325910e-01, 8.09919571e-01, 6.24783061e-02],\n", + " [9.88335101e-01, 8.06434316e-01, 6.24783061e-02],\n", + " [9.90809473e-01, 8.03753351e-01, 6.24783061e-02],\n", + " [9.92930364e-01, 7.99195710e-01, 6.24783061e-02],\n", + " [9.95404737e-01, 7.97050938e-01, 6.24783061e-02],\n", + " [9.98232591e-01, 7.94638070e-01, 1.24609511e-01],\n", + " [9.93990809e-01, 7.98659517e-01, 1.87782020e-01],\n", + " [9.89042064e-01, 8.05093834e-01, 6.24783061e-02],\n", + " [9.84800283e-01, 8.08847185e-01, 6.24783061e-02],\n", + " [9.81618947e-01, 8.11528150e-01, 6.24783061e-02],\n", + " [9.78084129e-01, 8.13136729e-01, 6.24783061e-02],\n", + " [9.74902793e-01, 8.14209115e-01, 6.24783061e-02],\n", + " [9.77730647e-01, 8.12600536e-01, 1.87434918e-01],\n", + " [9.74195829e-01, 8.15013405e-01, 2.49913225e-01],\n", + " [9.71014493e-01, 8.16621984e-01, 8.12217980e-01],\n", + " [9.68186638e-01, 8.18498660e-01, 3.74869837e-01],\n", + " [9.63944857e-01, 8.19571046e-01, 1.87434918e-01],\n", + " [9.60763521e-01, 8.19302949e-01, 2.49913225e-01],\n", + " [9.63237893e-01, 8.21983914e-01, 6.24783061e-02],\n", + " [9.59703075e-01, 8.21179625e-01, 1.87434918e-01],\n", + " [9.56168257e-01, 8.21983914e-01, 2.49913225e-01],\n", + " [9.54400848e-01, 8.24396783e-01, 8.12217980e-01],\n", + " [9.58642630e-01, 8.23324397e-01, 1.24956612e-01],\n", + " [9.54754330e-01, 8.22788204e-01, 1.24956612e-01],\n", + " [9.57935666e-01, 8.21983914e-01, 1.00000000e+00],\n", + " [9.61117002e-01, 8.21715818e-01, 1.87434918e-01],\n", + " [9.56875221e-01, 8.23324397e-01, 3.12391531e-01],\n", + " [9.54400848e-01, 8.21447721e-01, 3.12044429e-01],\n", + " [9.50866030e-01, 8.21447721e-01, 1.24956612e-01],\n", + " [9.46270767e-01, 8.23592493e-01, 6.28254078e-02],\n", + " [9.43796394e-01, 8.20643432e-01, 1.24609511e-01],\n", + " [9.40261577e-01, 8.20911528e-01, 1.87434918e-01],\n", + " [9.35666313e-01, 8.20375335e-01, 6.24783061e-02],\n", + " [9.32131495e-01, 8.18498660e-01, 6.24783061e-02],\n", + " [9.28950159e-01, 8.17158177e-01, 6.24783061e-02],\n", + " [9.32484977e-01, 8.19034853e-01, 3.12391531e-01],\n", + " [9.36373277e-01, 8.20107239e-01, 1.87434918e-01],\n", + " [9.33191941e-01, 8.20107239e-01, 3.12391531e-01],\n", + " [9.30717568e-01, 8.17426273e-01, 1.24956612e-01],\n", + " [9.27182750e-01, 8.16890080e-01, 1.25303714e-01],\n", + " [9.22234005e-01, 8.13941019e-01, 1.24956612e-01],\n", + " [9.19759632e-01, 8.11260054e-01, 6.21312044e-02],\n", + " [9.13750442e-01, 8.08042895e-01, 1.25303714e-01],\n", + " [9.11629551e-01, 8.04825737e-01, 1.24609511e-01],\n", + " [9.08094733e-01, 8.01608579e-01, 1.24956612e-01],\n", + " [9.04206433e-01, 7.98927614e-01, 6.24783061e-02],\n", + " [9.02439024e-01, 7.95442359e-01, 6.28254078e-02],\n", + " [9.02439024e-01, 7.91420912e-01, 1.87087817e-01],\n", + " [8.98550725e-01, 7.86327078e-01, 1.24956612e-01],\n", + " [8.97490279e-01, 7.81769437e-01, 6.24783061e-02],\n", + " [8.98197243e-01, 7.76943700e-01, 6.24783061e-02],\n", + " [8.98550725e-01, 7.71045576e-01, 6.24783061e-02],\n", + " [8.97490279e-01, 7.63270777e-01, 6.24783061e-02],\n", + " [8.98904206e-01, 7.58176944e-01, 6.28254078e-02],\n", + " [9.01732061e-01, 7.53351206e-01, 6.21312044e-02],\n", + " [9.05973842e-01, 7.50670241e-01, 6.28254078e-02],\n", + " [9.05973842e-01, 7.46916890e-01, 6.21312044e-02],\n", + " [9.09155179e-01, 7.45040214e-01, 6.24783061e-02],\n", + " [9.12689996e-01, 7.39946381e-01, 6.24783061e-02],\n", + " [9.17638742e-01, 7.35656836e-01, 6.28254078e-02],\n", + " [9.22940969e-01, 7.33780161e-01, 6.21312044e-02],\n", + " [9.26475786e-01, 7.30563003e-01, 6.24783061e-02],\n", + " [9.31778013e-01, 7.29490617e-01, 1.87782020e-01],\n", + " [9.36373277e-01, 7.29222520e-01, 4.37001041e-01],\n", + " [9.43089431e-01, 7.28150134e-01, 1.87434918e-01],\n", + " [9.47331212e-01, 7.28954424e-01, 1.25303714e-01],\n", + " [9.51219512e-01, 7.28686327e-01, 3.12044429e-01],\n", + " [9.55814776e-01, 7.28150134e-01, 1.24956612e-01],\n", + " [9.58996112e-01, 7.26809651e-01, 2.49913225e-01],\n", + " [9.59703075e-01, 7.23592493e-01, 5.00173551e-01],\n", + " [9.55107812e-01, 7.25469169e-01, 6.87261368e-01],\n", + " [9.58289148e-01, 7.24664879e-01, 3.74522735e-01],\n", + " [9.61470484e-01, 7.24128686e-01, 1.87782020e-01],\n", + " [9.64298339e-01, 7.25737265e-01, 2.49913225e-01],\n", + " [9.67126193e-01, 7.27345845e-01, 1.24956612e-01],\n", + " [9.70661011e-01, 7.27345845e-01, 6.21312044e-02],\n", + " [9.74902793e-01, 7.29490617e-01, 1.24956612e-01],\n", + " [9.78084129e-01, 7.32707775e-01, 4.37695245e-01],\n", + " [9.80911983e-01, 7.31099196e-01, 1.24956612e-01],\n", + " [9.82679392e-01, 7.34852547e-01, 4.99826449e-01],\n", + " [9.83739837e-01, 7.37801609e-01, 1.24956612e-01],\n", + " [9.86567692e-01, 7.39410188e-01, 1.24956612e-01],\n", + " [9.90102510e-01, 7.41286863e-01, 1.87434918e-01],\n", + " [9.90102510e-01, 7.45308311e-01, 2.49913225e-01],\n", + " [9.92223400e-01, 7.49061662e-01, 1.24956612e-01],\n", + " [9.94697773e-01, 7.51742627e-01, 6.24783061e-02],\n", + " [9.97172146e-01, 7.54691689e-01, 1.24956612e-01],\n", + " [9.97172146e-01, 7.58176944e-01, 1.24956612e-01],\n", + " [9.99293036e-01, 7.63002681e-01, 1.24956612e-01],\n", + " [9.99293036e-01, 7.66756032e-01, 6.24783061e-02],\n", + " [9.99293036e-01, 7.69973190e-01, 6.24783061e-02],\n", + " [1.00000000e+00, 7.74530831e-01, 6.24783061e-02],\n", + " [9.98939555e-01, 7.78016086e-01, 6.24783061e-02],\n", + " [9.96111700e-01, 7.79624665e-01, 6.24783061e-02],\n", + " [9.93990809e-01, 7.84718499e-01, 1.24956612e-01],\n", + " [9.92930364e-01, 7.88739946e-01, 6.24783061e-02],\n", + " [9.88688583e-01, 7.93297587e-01, 1.24956612e-01],\n", + " [9.85860728e-01, 7.97319035e-01, 6.24783061e-02],\n", + " [9.82679392e-01, 8.01340483e-01, 6.24783061e-02],\n", + " [9.78791092e-01, 8.04021448e-01, 6.24783061e-02],\n", + " [9.73488865e-01, 8.06702413e-01, 6.24783061e-02],\n", + " [9.68893602e-01, 8.11260054e-01, 6.24783061e-02],\n", + " [9.62530930e-01, 8.12332440e-01, 6.24783061e-02],\n", + " [9.56875221e-01, 8.15013405e-01, 6.24783061e-02],\n", + " [9.50159067e-01, 8.17962466e-01, 6.24783061e-02],\n", + " [9.44856840e-01, 8.17962466e-01, 6.24783061e-02],\n", + " [9.38494168e-01, 8.19571046e-01, 6.24783061e-02],\n", + " [9.30010604e-01, 8.16890080e-01, 1.24956612e-01],\n", + " [9.24354896e-01, 8.13136729e-01, 1.24956612e-01],\n", + " [9.21880523e-01, 8.10723861e-01, 1.24956612e-01],\n", + " [9.20113114e-01, 8.08042895e-01, 1.87434918e-01],\n", + " [9.16578296e-01, 8.06166220e-01, 1.24956612e-01],\n", + " [9.13750442e-01, 8.04557641e-01, 1.87434918e-01],\n", + " [9.16224814e-01, 8.02144772e-01, 1.24956612e-01],\n", + " [9.12336515e-01, 8.02144772e-01, 2.49913225e-01],\n", + " [9.15517851e-01, 8.02680965e-01, 5.00173551e-01],\n", + " [9.10922587e-01, 8.02412869e-01, 2.49566123e-01],\n", + " [9.11629551e-01, 7.99463807e-01, 3.12738632e-01],\n", + " [9.08801697e-01, 7.96782842e-01, 3.12044429e-01],\n", + " [9.12336515e-01, 7.97319035e-01, 4.37695245e-01],\n", + " [9.11983033e-01, 8.00268097e-01, 1.24609511e-01],\n", + " [9.07741251e-01, 7.98391421e-01, 3.12391531e-01],\n", + " [9.05973842e-01, 7.95174263e-01, 2.50260326e-01],\n", + " [9.03145988e-01, 7.93565684e-01, 1.87087817e-01],\n", + " [9.00671615e-01, 7.91420912e-01, 1.24956612e-01],\n", + " [8.98550725e-01, 7.88471850e-01, 6.24783061e-02],\n", + " [8.96076352e-01, 7.83109920e-01, 1.24956612e-01],\n", + " [8.94662425e-01, 7.78820375e-01, 1.24956612e-01],\n", + " [8.90067162e-01, 7.74798928e-01, 6.24783061e-02],\n", + " [8.87946271e-01, 7.71045576e-01, 6.24783061e-02],\n", + " [8.87592789e-01, 7.67828418e-01, 6.24783061e-02],\n", + " [8.87946271e-01, 7.63270777e-01, 1.25303714e-01],\n", + " [8.86885825e-01, 7.59785523e-01, 6.21312044e-02],\n", + " [8.86885825e-01, 7.56300268e-01, 6.24783061e-02],\n", + " [8.88653234e-01, 7.51474531e-01, 1.24956612e-01],\n", + " [8.89713680e-01, 7.47721180e-01, 1.25303714e-01],\n", + " [8.90420643e-01, 7.44504021e-01, 1.24609511e-01],\n", + " [8.90420643e-01, 7.39946381e-01, 3.12738632e-01],\n", + " [8.92541534e-01, 7.34584450e-01, 6.21312044e-02],\n", + " [8.96076352e-01, 7.30563003e-01, 6.24783061e-02],\n", + " [8.98197243e-01, 7.25469169e-01, 6.24783061e-02],\n", + " [8.96429834e-01, 7.28686327e-01, 1.87782020e-01],\n", + " [8.98550725e-01, 7.24128686e-01, 1.87087817e-01],\n", + " [9.01025097e-01, 7.21715818e-01, 1.24956612e-01],\n", + " [9.02792506e-01, 7.19302949e-01, 1.87434918e-01],\n", + " [9.00671615e-01, 7.22520107e-01, 1.87434918e-01],\n", + " [9.03145988e-01, 7.17962466e-01, 1.25303714e-01],\n", + " [9.00671615e-01, 7.20107239e-01, 6.21312044e-02],\n", + " [9.03499470e-01, 7.16890080e-01, 1.87782020e-01],\n", + " [9.06327324e-01, 7.14477212e-01, 1.87434918e-01],\n", + " [9.10569106e-01, 7.11528150e-01, 1.24956612e-01],\n", + " [9.06327324e-01, 7.12600536e-01, 1.24609511e-01],\n", + " [9.10922587e-01, 7.09115282e-01, 1.87434918e-01],\n", + " [9.07741251e-01, 7.11796247e-01, 1.87782020e-01],\n", + " [9.10922587e-01, 7.08579088e-01, 2.49913225e-01],\n", + " [9.08801697e-01, 7.13672922e-01, 1.87087817e-01],\n", + " [9.20820078e-01, 7.18230563e-01, 6.24783061e-02],\n", + " [9.32484977e-01, 7.12868633e-01, 6.24783061e-02],\n", + " [9.37433722e-01, 7.11796247e-01, 6.24783061e-02],\n", + " [9.46270767e-01, 7.20375335e-01, 6.28254078e-02],\n", + " [9.54047367e-01, 7.22252011e-01, 2.29087123e-02],\n", + " [9.75963238e-01, 7.43699732e-01, 2.29087123e-02],\n", + " [9.75609756e-01, 7.78016086e-01, 2.15203054e-02],\n", + " [9.39908095e-01, 8.10991957e-01, 2.15203054e-02],\n", + " [8.83704489e-01, 8.25201072e-01, 2.22145089e-02],\n", + " [8.23259102e-01, 8.20643432e-01, 2.29087123e-02],\n", + " [7.61046306e-01, 7.94638070e-01, 2.39500174e-02],\n", + " [7.08377519e-01, 7.47721180e-01, 2.49913225e-02],\n", + " [6.59243549e-01, 7.11796247e-01, 2.15203054e-02],\n", + " [6.06574761e-01, 6.98659517e-01, 2.11732037e-02],\n", + " [5.62036055e-01, 7.04021448e-01, 2.18674072e-02],\n", + " [5.31990103e-01, 7.22252011e-01, 2.18674072e-02],\n", + " [5.08306822e-01, 7.51206434e-01, 2.46442208e-02],\n", + " [4.78967833e-01, 7.85790885e-01, 2.39500174e-02],\n", + " [4.47154472e-01, 8.22788204e-01, 2.42971191e-02],\n", + " [4.15341110e-01, 8.59249330e-01, 2.46442208e-02],\n", + " [3.87769530e-01, 8.89544236e-01, 2.39500174e-02],\n", + " [3.65500177e-01, 9.12064343e-01, 2.42971191e-02],\n", + " [3.45705196e-01, 9.30831099e-01, 2.42971191e-02],\n", + " [3.29091552e-01, 9.42359249e-01, 2.11732037e-02],\n", + " [3.12831389e-01, 9.53351206e-01, 2.42971191e-02],\n", + " [2.98692117e-01, 9.62198391e-01, 2.42971191e-02],\n", + " [2.85613291e-01, 9.67560322e-01, 2.42971191e-02],\n", + " [2.74301873e-01, 9.70777480e-01, 2.36029157e-02],\n", + " [2.65111347e-01, 9.73190349e-01, 2.15203054e-02],\n", + " [2.55920820e-01, 9.73726542e-01, 2.42971191e-02],\n", + " [2.47437257e-01, 9.72654155e-01, 2.39500174e-02],\n", + " [2.38600212e-01, 9.70241287e-01, 2.39500174e-02],\n", + " [2.30823613e-01, 9.67292225e-01, 2.11732037e-02],\n", + " [2.23400495e-01, 9.61662198e-01, 2.46442208e-02],\n", + " [2.15623895e-01, 9.54423592e-01, 2.39500174e-02],\n", + " [2.07847296e-01, 9.48257373e-01, 2.46442208e-02],\n", + " [2.00070696e-01, 9.42359249e-01, 2.36029157e-02],\n", + " [1.94768469e-01, 9.55764075e-01, 2.11732037e-02],\n", + " [1.68257335e-01, 9.85254692e-01, 2.22145089e-02],\n", + " [1.18769883e-01, 1.00000000e+00, 2.15203054e-02],\n", + " [5.86779781e-02, 9.84450402e-01, 2.25616106e-02],\n", + " [1.62601626e-02, 9.38873995e-01, 2.15203054e-02],\n", + " [4.24178155e-03, 8.67560322e-01, 2.32558140e-02],\n", + " [3.18133616e-03, 7.82573727e-01, 2.46442208e-02],\n", + " [2.12089077e-03, 6.89812332e-01, 2.36029157e-02],\n", + " [7.06963591e-04, 5.89544236e-01, 2.42971191e-02],\n", + " [0.00000000e+00, 4.99195710e-01, 2.11732037e-02],\n", + " [1.76740898e-03, 3.80160858e-01, 2.46442208e-02],\n", + " [1.44927536e-02, 2.54691689e-01, 2.39500174e-02],\n", + " [3.53481796e-02, 1.28418231e-01, 2.42971191e-02],\n", + " [6.78685048e-02, 0.00000000e+00, 2.39500174e-02]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92175338, 0.07678624, 0.97222222],\n", + " [0.84391643, 0.1544619 , 0.97222222],\n", + " [0.77550184, 0.22235399, 0.84722222],\n", + " [0.69848423, 0.29914023, 0.95833333],\n", + " [0.62023761, 0.37711236, 0.98611111],\n", + " [0.54362966, 0.45360213, 0.95833333],\n", + " [0.46538304, 0.53276015, 0.97222222],\n", + " [0.38918476, 0.61102876, 0.95833333],\n", + " [0.30766079, 0.69107619, 1. ],\n", + " [0.23064318, 0.76845538, 0.95833333],\n", + " [0.1544449 , 0.84435221, 0.95833333],\n", + " [0.07660795, 0.92232434, 0.98611111],\n", + " [0. , 1. , 0.97222222]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.80009921, 0.80321285, 0.83246073],\n", + " [0.68700397, 0.69076305, 0.47120419],\n", + " [0.44593254, 0.45381526, 1. ],\n", + " [0.29464286, 0.30378657, 0.61780105],\n", + " [0.19642857, 0.20252438, 0.41884817],\n", + " [0.08333333, 0.08605852, 0.48167539],\n", + " [0. , 0. , 0.35602094]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88482075, 0.88559322, 0.98507463],\n", + " [0.77421815, 0.77093719, 0.98507463],\n", + " [0.65675057, 0.65727817, 0.98507463],\n", + " [0.54385965, 0.54411765, 0.98507463],\n", + " [0.43554539, 0.43170489, 0.98507463],\n", + " [0.33028223, 0.31904287, 0.97014925],\n", + " [0.21205187, 0.20687936, 1. ],\n", + " [0.10297483, 0.09920239, 0.97014925],\n", + " [0. , 0. , 0.91044776]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90441383, 0.90661479, 0.575 ],\n", + " [0.80657858, 0.80505837, 0.58333333],\n", + " [0.63817824, 0.63696498, 1. ],\n", + " [0.48608378, 0.48404669, 0.91666667],\n", + " [0.36069722, 0.35992218, 0.75 ],\n", + " [0.26258083, 0.26264591, 0.59166667],\n", + " [0.16671352, 0.16575875, 0.58333333],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.03158406, 0.92285714, 1. ],\n", + " [0.06365403, 0.84371429, 0.97183099],\n", + " [0.10349854, 0.76514286, 1. ],\n", + " [0.1350826 , 0.69942857, 0.98591549],\n", + " [0.16083576, 0.63085714, 0.97183099],\n", + " [0.19727891, 0.56571429, 1. ],\n", + " [0.24927114, 0.50314286, 0.97183099],\n", + " [0.31389699, 0.44942857, 0.98591549],\n", + " [0.39990282, 0.396 , 1. ],\n", + " [0.49611273, 0.33942857, 0.97183099],\n", + " [0.59183673, 0.28142857, 0.98591549],\n", + " [0.68415938, 0.22171429, 1. ],\n", + " [0.76676385, 0.16457143, 0.95774648],\n", + " [0.83624879, 0.11657143, 0.85915493],\n", + " [0.9212828 , 0.06028571, 0.97183099],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89943609, 0.89965398, 0.8875 ],\n", + " [0.78618421, 0.78575548, 0.9875 ],\n", + " [0.69971805, 0.69867359, 0.7625 ],\n", + " [0.59727444, 0.59602076, 0.875 ],\n", + " [0.50046992, 0.49740484, 0.8625 ],\n", + " [0.41212406, 0.411188 , 0.775 ],\n", + " [0.31531955, 0.31459054, 0.85 ],\n", + " [0.20065789, 0.19982699, 1. ],\n", + " [0.10103383, 0.10034602, 0.8875 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16821192, 0.16409067, 0.97014925],\n", + " [0.33377483, 0.33127254, 1. ],\n", + " [0.50066225, 0.49793921, 0.97014925],\n", + " [0.66754967, 0.66460587, 1. ],\n", + " [0.83245033, 0.83075734, 0.97014925],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.19902518, 0.21813842, 1. ],\n", + " [0.37043054, 0.37494033, 0.73825503],\n", + " [0.48009748, 0.47565632, 0.46979866],\n", + " [0.60357433, 0.59164678, 0.53020134],\n", + " [0.77010561, 0.76634845, 0.80536913],\n", + " [0.89114541, 0.89952267, 0.61073826],\n", + " [1. , 1. , 0.46308725]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8526373 , 0.13913282, 0.91666667],\n", + " [0.70799347, 0.27963776, 0.91666667],\n", + " [0.56824361, 0.41822173, 0.91666667],\n", + " [0.42631865, 0.55927552, 0.91666667],\n", + " [0.28602501, 0.70032931, 0.91666667],\n", + " [0.14953779, 0.84248079, 0.91666667],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91984334, 0.9775641 , 0.85915493],\n", + " [0.8308094 , 0.93269231, 0.97183099],\n", + " [0.7381201 , 0.75641026, 0.98591549],\n", + " [0.6464752 , 0.51923077, 1. ],\n", + " [0.55587467, 0.44230769, 0.97183099],\n", + " [0.46109661, 0.38141026, 1. ],\n", + " [0.37180157, 0.34935897, 0.97183099],\n", + " [0.27832898, 0.30448718, 1. ],\n", + " [0.18720627, 0.18910256, 0.97183099],\n", + " [0.09373368, 0.05128205, 1. ],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15300961, 0.11282051, 1. ],\n", + " [0.287304 , 0.22564103, 0.87142857],\n", + " [0.42134547, 0.37435897, 0.88571429],\n", + " [0.57688417, 0.51794872, 1. ],\n", + " [0.712696 , 0.63076923, 0.88571429],\n", + " [0.86418816, 0.81538462, 1. ],\n", + " [1. , 1. , 0.88571429]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.07977026, 0.07945967, 0.97222222],\n", + " [0.15954052, 0.16567342, 0.95833333],\n", + " [0.23931078, 0.25148987, 0.97222222],\n", + " [0.32450542, 0.33094954, 0.98611111],\n", + " [0.40970006, 0.41716329, 0.95833333],\n", + " [0.48947033, 0.49662296, 0.95833333],\n", + " [0.57434588, 0.58283671, 1. ],\n", + " [0.65954052, 0.66229638, 0.97222222],\n", + " [0.74473516, 0.74811283, 0.95833333],\n", + " [0.82961072, 0.82757251, 0.97222222],\n", + " [0.91480536, 0.91378625, 0.98611111],\n", + " [1. , 1. , 0.97222222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12962963, 0.09155937, 1. ],\n", + " [0.25925926, 0.18407248, 0.98591549],\n", + " [0.38683128, 0.27539342, 1. ],\n", + " [0.51234568, 0.36599905, 0.95774648],\n", + " [0.63786008, 0.45779685, 0.98591549],\n", + " [0.76748971, 0.54911779, 0.98591549],\n", + " [0.89917695, 0.64210777, 1. ],\n", + " [1. , 0.73056748, 0.97183099],\n", + " [0.93209877, 0.81592752, 0.98591549],\n", + " [0.84156379, 0.90724845, 1. ],\n", + " [0.75308642, 1. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89874096, 0.88837209, 0.87142857],\n", + " [0.78542727, 0.76511628, 0.97142857],\n", + " [0.68229306, 0.67209302, 0.88571429],\n", + " [0.5657648 , 0.5627907 , 1. ],\n", + " [0.44923654, 0.43488372, 1. ],\n", + " [0.33297616, 0.33023256, 1. ],\n", + " [0.21618002, 0.22093023, 1. ],\n", + " [0.10018752, 0.09302326, 0.98571429],\n", + " [0. , 0. , 0.87142857]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90331853, 0.94148021, 0.775 ],\n", + " [0.80167233, 0.79518072, 0.8375 ],\n", + " [0.70525216, 0.71772806, 0.8 ],\n", + " [0.6117063 , 0.53184165, 0.7875 ],\n", + " [0.51607003, 0.53700516, 0.7875 ],\n", + " [0.4290567 , 0.40275387, 0.7625 ],\n", + " [0.33263653, 0.33907057, 0.7875 ],\n", + " [0.21766397, 0.21858864, 0.95 ],\n", + " [0.09615887, 0.05335628, 1. ],\n", + " [0. , 0. , 0.7875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89003759, 0.89073634, 0.91428571],\n", + " [0.77866541, 0.77998812, 0.91428571],\n", + " [0.67105263, 0.6716152 , 0.91428571],\n", + " [0.55357143, 0.55374109, 0.97142857],\n", + " [0.44595865, 0.44625891, 0.91428571],\n", + " [0.32847744, 0.32897862, 0.97142857],\n", + " [0.22509398, 0.22505938, 0.88571429],\n", + " [0.12077068, 0.12084323, 0.87142857],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88933121, 0.88826367, 0.97014925],\n", + " [0.77839703, 0.77652733, 0.98507463],\n", + " [0.66613588, 0.66157556, 0.98507463],\n", + " [0.5552017 , 0.54983923, 0.98507463],\n", + " [0.44559448, 0.43971061, 0.98507463],\n", + " [0.33333333, 0.32797428, 1. ],\n", + " [0.22080679, 0.21864952, 0.98507463],\n", + " [0.10934183, 0.10771704, 0.98507463],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90257252, 0.89949324, 0.79120879],\n", + " [0.80706076, 0.80658784, 0.75824176],\n", + " [0.68390805, 0.68412162, 0.98901099],\n", + " [0.58976464, 0.58783784, 0.75824176],\n", + " [0.49151615, 0.4847973 , 0.79120879],\n", + " [0.39709907, 0.3910473 , 0.75824176],\n", + " [0.27285167, 0.26942568, 1. ],\n", + " [0.18007663, 0.17736486, 0.74725275],\n", + " [0.09660646, 0.09628378, 0.67032967],\n", + " [0. , 0. , 0.78021978]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.0950764 , 0.10149821, 0.97222222],\n", + " [0.1901528 , 0.20151931, 0.97222222],\n", + " [0.28862479, 0.30132939, 0.97222222],\n", + " [0.39728353, 0.39839629, 0.95833333],\n", + " [0.50764007, 0.49736231, 0.98611111],\n", + " [0.61205433, 0.59843849, 0.97222222],\n", + " [0.71052632, 0.69845959, 0.97222222],\n", + " [0.80560272, 0.79742562, 0.95833333],\n", + " [0.90237691, 0.89807976, 0.97222222],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08163265, 0.10818308, 0.94366197],\n", + " [0.18367347, 0.2196024 , 0.92957746],\n", + " [0.28571429, 0.32755432, 0.91549296],\n", + " [0.40816327, 0.43966713, 0.94366197],\n", + " [0.53061224, 0.54946833, 0.92957746],\n", + " [0.67346939, 0.65903837, 0.91549296],\n", + " [0.79591837, 0.76907074, 0.94366197],\n", + " [0.93877551, 0.88765603, 1. ],\n", + " [1. , 1. , 0.94366197]]),\n", + " array([[1. , 0.08 , 0. ],\n", + " [0.90946822, 0.5 , 0.875 ],\n", + " [0.81867704, 0.68 , 0.875 ],\n", + " [0.74396887, 0.78 , 0.7625 ],\n", + " [0.65499351, 0.9 , 0.875 ],\n", + " [0.56446174, 1. , 0.8875 ],\n", + " [0.47808042, 1. , 0.85 ],\n", + " [0.3846952 , 0.88 , 0.875 ],\n", + " [0.28093385, 0.88 , 1. ],\n", + " [0.17898833, 0.84 , 1. ],\n", + " [0.08949416, 0.7 , 0.8875 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14366425, 0.11971831, 0.98507463],\n", + " [0.28786656, 0.20774648, 0.97014925],\n", + " [0.43502825, 0.41197183, 0.98507463],\n", + " [0.56497175, 0.52816901, 0.91044776],\n", + " [0.71078827, 0.58802817, 0.97014925],\n", + " [0.85660479, 0.76408451, 1. ],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12486938, 0.12357994, 0.91666667],\n", + " [0.2476489 , 0.24771405, 0.91666667],\n", + " [0.37095089, 0.37129399, 0.91666667],\n", + " [0.49320794, 0.49293433, 0.91666667],\n", + " [0.62852665, 0.62759767, 1. ],\n", + " [0.75182863, 0.7514547 , 0.91666667],\n", + " [0.87304075, 0.87531172, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14258503, 0.1395881 , 0.97014925],\n", + " [0.28517007, 0.2791762 , 1. ],\n", + " [0.42802721, 0.42334096, 0.98507463],\n", + " [0.57061224, 0.56521739, 0.98507463],\n", + " [0.71292517, 0.70709382, 0.98507463],\n", + " [0.8555102 , 0.85125858, 0.97014925],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90088594, 0.8975265 , 1. ],\n", + " [0.80066445, 0.79681979, 0.98591549],\n", + " [0.70459579, 0.68551237, 0.97183099],\n", + " [0.60326689, 0.59717314, 1. ],\n", + " [0.50249169, 0.50353357, 0.98591549],\n", + " [0.39922481, 0.3975265 , 1. ],\n", + " [0.30177187, 0.28798587, 0.97183099],\n", + " [0.19988926, 0.19081272, 0.98591549],\n", + " [0.10077519, 0.09893993, 0.97183099],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.97721128, 0.975458 , 0.95833333],\n", + " [0.95365006, 0.95229865, 0.97222222],\n", + " [0.92854384, 0.92879364, 0.98611111],\n", + " [0.90305137, 0.9073626 , 0.95833333],\n", + " [0.87794515, 0.88385759, 0.98611111],\n", + " [0.85515643, 0.86035258, 0.95833333],\n", + " [0.83120896, 0.8365019 , 0.98611111],\n", + " [0.80571649, 0.81610785, 0.95833333],\n", + " [0.78331402, 0.7974421 , 0.84722222],\n", + " [0.75859405, 0.77808503, 0.95833333],\n", + " [0.73387408, 0.75803664, 0.98611111],\n", + " [0.70876786, 0.73695126, 0.95833333],\n", + " [0.68636539, 0.71552022, 0.98611111],\n", + " [0.66319042, 0.69374352, 0.95833333],\n", + " [0.63924295, 0.67058417, 0.97222222],\n", + " [0.61684048, 0.64707916, 0.97222222],\n", + " [0.59791425, 0.62737643, 0.84722222],\n", + " [0.57396678, 0.6049084 , 0.94444444],\n", + " [0.55156431, 0.58071206, 1. ],\n", + " [0.52954809, 0.55789838, 0.95833333],\n", + " [0.50560062, 0.53543035, 0.97222222],\n", + " [0.47856315, 0.51434497, 0.97222222],\n", + " [0.45616068, 0.49256827, 0.97222222],\n", + " [0.43144071, 0.47010024, 0.97222222],\n", + " [0.40942449, 0.44694089, 0.95833333],\n", + " [0.38624952, 0.42896647, 0.84722222],\n", + " [0.3626883 , 0.4051158 , 0.98611111],\n", + " [0.33989958, 0.38161078, 0.97222222],\n", + " [0.3182696 , 0.35637746, 0.97222222],\n", + " [0.29818463, 0.3314898 , 0.95833333],\n", + " [0.27500966, 0.30729347, 0.97222222],\n", + " [0.25337968, 0.28136882, 0.98611111],\n", + " [0.23213596, 0.2561355 , 0.97222222],\n", + " [0.20625724, 0.23263049, 0.97222222],\n", + " [0.18462727, 0.20636018, 0.97222222],\n", + " [0.1637698 , 0.17974421, 0.97222222],\n", + " [0.13750483, 0.15589354, 0.95833333],\n", + " [0.11201236, 0.12996889, 0.98611111],\n", + " [0.09076864, 0.10438991, 0.95833333],\n", + " [0.06720742, 0.07846526, 0.98611111],\n", + " [0.04441869, 0.0535776 , 0.95833333],\n", + " [0.02162997, 0.02730729, 0.97222222],\n", + " [0. , 0. , 0.97222222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10442909, 0.11861421, 0.87341772],\n", + " [0.19504267, 0.22019965, 0.7721519 ],\n", + " [0.30150345, 0.33763946, 0.88607595],\n", + " [0.42909386, 0.46741045, 1. ],\n", + " [0.54490045, 0.57809748, 0.88607595],\n", + " [0.66273872, 0.6881973 , 0.89873418],\n", + " [0.780577 , 0.79800352, 0.88607595],\n", + " [0.88419342, 0.89342337, 0.7721519 ],\n", + " [1. , 1. , 0.86075949]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87413235, 0.86961986, 0.8988764 ],\n", + " [0.76723739, 0.75683318, 0.7752809 ],\n", + " [0.64044424, 0.62016965, 0.92134831],\n", + " [0.53308653, 0.50518379, 0.76404494],\n", + " [0.42572883, 0.38862708, 0.78651685],\n", + " [0.29477094, 0.25416274, 0.91011236],\n", + " [0.14854234, 0.11530003, 1. ],\n", + " [0. , 0. , 0.91011236]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91420308, 0.08526805, 0.98591549],\n", + " [0.82969152, 0.17306881, 0.98591549],\n", + " [0.7438946 , 0.25960321, 0.98591549],\n", + " [0.65938303, 0.34402702, 0.97183099],\n", + " [0.57326478, 0.42634023, 1. ],\n", + " [0.48746787, 0.51371887, 1. ],\n", + " [0.40552699, 0.60109751, 0.95774648],\n", + " [0.33097686, 0.66779232, 0.85915493],\n", + " [0.25064267, 0.75137189, 0.97183099],\n", + " [0.16773779, 0.83030815, 0.98591549],\n", + " [0.08322622, 0.91557619, 0.98591549],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 0.99622107, 0. ],\n", + " [0.8804878 , 0.99905527, 0.7 ],\n", + " [0.72317073, 1. , 0.91 ],\n", + " [0.55213415, 0.97779877, 1. ],\n", + " [0.43993902, 0.92300425, 0.69 ],\n", + " [0.34207317, 0.82002834, 0.71 ],\n", + " [0.26676829, 0.67831838, 0.68 ],\n", + " [0.20762195, 0.50921115, 0.71 ],\n", + " [0.14634146, 0.34671705, 0.7 ],\n", + " [0.07987805, 0.18422296, 0.7 ],\n", + " [0. , 0. , 0.8 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90095238, 0.89590998, 0.63063063],\n", + " [0.8 , 0.79268557, 0.62162162],\n", + " [0.64380952, 0.63103224, 1. ],\n", + " [0.53714286, 0.52802424, 0.62162162],\n", + " [0.4152381 , 0.41203203, 0.72072072],\n", + " [0.31809524, 0.30729279, 0.63963964],\n", + " [0.20190476, 0.20688163, 0.62162162],\n", + " [0.10666667, 0.10495564, 0.63063063],\n", + " [0. , 0. , 0.63963964]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89692044, 0.07033466, 0.98591549],\n", + " [0.79298546, 0.14152014, 0.98591549],\n", + " [0.69118905, 0.21157119, 0.98591549],\n", + " [0.58853721, 0.28247306, 0.97183099],\n", + " [0.48545766, 0.35422575, 1. ],\n", + " [0.38836612, 0.43221781, 1. ],\n", + " [0.31907613, 0.51956892, 0.97183099],\n", + " [0.25363559, 0.61542825, 0.98591549],\n", + " [0.19118905, 0.71072036, 0.97183099],\n", + " [0.12917023, 0.80714691, 0.98591549],\n", + " [0.06330197, 0.90754396, 1. ],\n", + " [0. , 1. , 0.97183099]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.9227027 , 0.08519481, 1. ],\n", + " [0.84864865, 0.17402597, 1. ],\n", + " [0.78162162, 0.25376623, 0.87142857],\n", + " [0.68486486, 0.33324675, 1. ],\n", + " [0.58594595, 0.41116883, 1. ],\n", + " [0.47405405, 0.48649351, 0.98571429],\n", + " [0.36324324, 0.56363636, 1. ],\n", + " [0.26486486, 0.63558442, 0.91428571],\n", + " [0.19837838, 0.72285714, 0.95714286],\n", + " [0.13621622, 0.81220779, 0.98571429],\n", + " [0.06918919, 0.90467532, 1. ],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14686825, 0.14530551, 0.98507463],\n", + " [0.29319654, 0.28961749, 0.98507463],\n", + " [0.424946 , 0.4212618 , 0.91044776],\n", + " [0.56965443, 0.56582216, 0.97014925],\n", + " [0.71382289, 0.7106309 , 1. ],\n", + " [0.8574514 , 0.85519126, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88333941, 0.88224181, 0.93589744],\n", + " [0.76558513, 0.76322418, 0.92307692],\n", + " [0.65730952, 0.65554156, 0.84615385],\n", + " [0.5501276 , 0.54911839, 0.84615385],\n", + " [0.44148742, 0.43986146, 0.84615385],\n", + " [0.33357638, 0.33217884, 0.83333333],\n", + " [0.23660226, 0.23551637, 0.78205128],\n", + " [0.10864017, 0.10831234, 1. ],\n", + " [0. , 0. , 0.84615385]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87549933, 0.876553 , 0.90410959],\n", + " [0.75166445, 0.75337034, 0.90410959],\n", + " [0.63115846, 0.63230241, 0.89041096],\n", + " [0.50798935, 0.50832672, 0.91780822],\n", + " [0.38482024, 0.38435104, 0.89041096],\n", + " [0.24833555, 0.24900872, 1. ],\n", + " [0.126498 , 0.12714777, 0.89041096],\n", + " [0. , 0. , 0.91780822]]),\n", + " array([[0.93979592, 0.97787398, 0. ],\n", + " [0.95408163, 0.97763348, 0.01236338],\n", + " [0.9622449 , 0.98027898, 0.03601505],\n", + " [0.95918367, 0.97643098, 0.02526429],\n", + " [0.95714286, 0.98075998, 0.03189393],\n", + " [0.95408163, 0.97715248, 0.06450457],\n", + " [0.96530612, 0.97883598, 0.22612435],\n", + " [0.97755102, 0.98003848, 0.70883354],\n", + " [0.96938776, 0.97883598, 0.3228812 ],\n", + " [0.9744898 , 0.98148148, 0.16090306],\n", + " [0.9755102 , 0.97787398, 0.03278982],\n", + " [0.97040816, 0.98124098, 0.03207311],\n", + " [0.98061224, 0.98244348, 0.03189393],\n", + " [0.9744898 , 0.97787398, 0.03278982],\n", + " [0.97040816, 0.98244348, 0.06414621],\n", + " [0.97244898, 0.97763348, 0.03243146],\n", + " [0.96428571, 0.97883598, 0.03189393],\n", + " [0.97244898, 0.97667148, 0.12954668],\n", + " [0.96428571, 0.98075998, 0.09675685],\n", + " [0.96938776, 0.97763348, 0.03243146],\n", + " [0.96428571, 0.97546898, 0.28973302],\n", + " [0.9744898 , 0.97594998, 0.48378427],\n", + " [0.97959184, 0.97835498, 0.19351371],\n", + " [0.96530612, 0.98003848, 0.22612435],\n", + " [0.96938776, 0.97763348, 0.64468733],\n", + " [0.96428571, 0.97546898, 0.80684465],\n", + " [0.9744898 , 0.98027898, 0.06432539],\n", + " [0.9744898 , 0.97763348, 0.03171475],\n", + " [0.98469388, 0.97835498, 0.09693603],\n", + " [0.97040816, 0.97715248, 0.29044974],\n", + " [0.98265306, 0.97715248, 0.03225228],\n", + " [0.9755102 , 0.98003848, 0.06468375],\n", + " [0.95510204, 0.98725349, 0.03207311],\n", + " [0.97040816, 0.97907648, 0.03243146],\n", + " [0.96734694, 0.97667148, 0.03225228],\n", + " [0.97755102, 0.97667148, 0.03171475],\n", + " [0.96938776, 0.97835498, 0.06504211],\n", + " [0.97244898, 0.97546898, 0.03171475],\n", + " [0.97244898, 0.97955748, 0.09729439],\n", + " [0.97040816, 0.97643098, 0.09639849],\n", + " [0.96938776, 0.98027898, 0.09657767],\n", + " [0.96938776, 0.97667148, 0.2908081 ],\n", + " [0.96020408, 0.97474747, 0.16090306],\n", + " [0.96530612, 0.97835498, 0.25801828],\n", + " [0.96428571, 0.97546898, 0.19333453],\n", + " [0.9744898 , 0.97522848, 0.22612435],\n", + " [0.99489796, 0.97907648, 0.1614406 ],\n", + " [0.98571429, 0.98075998, 0.16090306],\n", + " [0.97755102, 0.98388648, 0.80648629],\n", + " [0.9877551 , 0.98364598, 0.35441677],\n", + " [0.99591837, 0.98027898, 0.22576599],\n", + " [0.99285714, 0.98364598, 0.03243146],\n", + " [0.98061224, 0.98124098, 0.09657767],\n", + " [0.98979592, 0.98148148, 0.19369289],\n", + " [0.98061224, 0.97955748, 1. ],\n", + " [0.9744898 , 0.98436748, 0.19369289],\n", + " [0.98265306, 0.97835498, 0.06414621],\n", + " [0.98469388, 0.98244348, 0.1614406 ],\n", + " [0.99591837, 0.98148148, 0.25801828],\n", + " [0.98979592, 0.98508899, 0.19369289],\n", + " [0.99591837, 0.98268398, 0.06450457],\n", + " [0.99081633, 0.98484848, 0.06450457],\n", + " [1. , 0.98268398, 0.06468375],\n", + " [0.98979592, 0.98244348, 0.1284716 ],\n", + " [0.97959184, 0.98436748, 0.09675685],\n", + " [0.99081633, 0.98148148, 0.09675685],\n", + " [0.97755102, 0.98316498, 0.1293675 ],\n", + " [0.99489796, 0.98027898, 0.03207311],\n", + " [0.98469388, 0.98268398, 0.09675685],\n", + " [0.98061224, 0.98003848, 0.16108224],\n", + " [0.97244898, 0.97715248, 0.29062892],\n", + " [0.96020408, 0.97594998, 0.03207311],\n", + " [0.94693878, 0.97306397, 0.03243146],\n", + " [0.95204082, 0.97715248, 0.61225587],\n", + " [0.95408163, 0.97282347, 0.03261064],\n", + " [0.95204082, 0.97667148, 0.48360509],\n", + " [0.94387755, 0.97907648, 0.09693603],\n", + " [0.95204082, 0.97787398, 0.03243146],\n", + " [0.95918367, 0.97594998, 0.06396703],\n", + " [0.94897959, 0.97715248, 0.03225228],\n", + " [0.95714286, 0.97594998, 0.03243146],\n", + " [0.93979592, 0.98075998, 0.09657767],\n", + " [0.94897959, 0.97546898, 0.06522129],\n", + " [0.95408163, 0.97186147, 0.64486651],\n", + " [0.96020408, 0.97787398, 0.06414621],\n", + " [0.96020408, 0.97522848, 0.03278982],\n", + " [0.94897959, 0.97354497, 0.03189393],\n", + " [0.96020408, 0.97402597, 0.12900914],\n", + " [0.94183673, 0.97522848, 0.03243146],\n", + " [0.95204082, 0.97306397, 0.06432539],\n", + " [0.95408163, 0.97546898, 0.38684824],\n", + " [0.94489796, 0.97402597, 0.25819746],\n", + " [0.94387755, 0.97667148, 0.12918832],\n", + " [0.94387755, 0.97402597, 0.16090306],\n", + " [0.93979592, 0.97715248, 0.22576599],\n", + " [0.95510204, 0.97667148, 0.45189034],\n", + " [0.94183673, 0.97643098, 0.12865078],\n", + " [0.95204082, 0.97667148, 0.06486293],\n", + " [0.95918367, 0.97474747, 0.41874216],\n", + " [0.95408163, 0.97835498, 0.12918832],\n", + " [0.95204082, 0.97474747, 0.06450457],\n", + " [0.94897959, 0.97787398, 0.06468375],\n", + " [0.95204082, 0.98027898, 0.09693603],\n", + " [0.94183673, 0.97763348, 0.03207311],\n", + " [0.94693878, 0.97426647, 0.03189393],\n", + " [0.94387755, 0.97715248, 0.06468375],\n", + " [0.95510204, 0.97282347, 0.03225228],\n", + " [0.93979592, 0.97907648, 0.03243146],\n", + " [0.94897959, 0.97426647, 0.03189393],\n", + " [0.94489796, 0.97715248, 0.38702741],\n", + " [0.95204082, 0.97282347, 0.03243146],\n", + " [0.93877551, 0.97546898, 0.23830855],\n", + " [0.91428571, 0.97546898, 0.01272173],\n", + " [0.88877551, 0.97715248, 0.01236338],\n", + " [0.86734694, 0.98316498, 0.01146748],\n", + " [0.84489796, 0.98869649, 0.0112883 ],\n", + " [0.84489796, 0.9963925 , 0.01146748],\n", + " [0.86326531, 1. , 0.0112883 ],\n", + " [0.84489796, 0.9987975 , 0.03691095],\n", + " [0.81938776, 0.98917749, 0.01272173],\n", + " [0.78877551, 0.97065897, 0.01254256],\n", + " [0.76020408, 0.94660895, 0.01254256],\n", + " [0.73265306, 0.91871092, 0.01236338],\n", + " [0.70510204, 0.88263588, 0.01254256],\n", + " [0.67653061, 0.84175084, 0.01272173],\n", + " [0.64387755, 0.8003848 , 0.01254256],\n", + " [0.60816327, 0.75781626, 0.01236338],\n", + " [0.56938776, 0.71212121, 0.01272173],\n", + " [0.53163265, 0.66522367, 0.01254256],\n", + " [0.49489796, 0.62169312, 0.01236338],\n", + " [0.45510204, 0.57142857, 0.01254256],\n", + " [0.42142857, 0.52982203, 0.01092994],\n", + " [0.38877551, 0.47931698, 0.01236338],\n", + " [0.34489796, 0.42448292, 0.01236338],\n", + " [0.30408163, 0.36820587, 0.01290091],\n", + " [0.26020408, 0.31409331, 0.01254256],\n", + " [0.20918367, 0.25877826, 0.01236338],\n", + " [0.16326531, 0.1996152 , 0.01272173],\n", + " [0.12346939, 0.14502165, 0.01236338],\n", + " [0.07755102, 0.08922559, 0.01254256],\n", + " [0.03877551, 0.04569505, 0.01092994],\n", + " [0. , 0. , 0.01236338]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08333333, 0.08589909, 0.95833333],\n", + " [0.16306306, 0.16817594, 0.95833333],\n", + " [0.23603604, 0.24346701, 0.84722222],\n", + " [0.31441441, 0.32626132, 0.95833333],\n", + " [0.39594595, 0.41319534, 0.98611111],\n", + " [0.47612613, 0.49831824, 0.97222222],\n", + " [0.56306306, 0.58085382, 0.95833333],\n", + " [0.65225225, 0.66416559, 1. ],\n", + " [0.73783784, 0.7461837 , 0.95833333],\n", + " [0.82612613, 0.8313066 , 0.98611111],\n", + " [0.91126126, 0.91435964, 0.97222222],\n", + " [1. , 1. , 0.97222222]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.0192199 , 0.94057638, 1. ],\n", + " [0.04126625, 0.87681714, 0.95774648],\n", + " [0.06726964, 0.80642693, 1. ],\n", + " [0.09101187, 0.73960724, 0.90140845],\n", + " [0.09723007, 0.66794185, 0.91549296],\n", + " [0.09779536, 0.59882683, 0.90140845],\n", + " [0.11984172, 0.53098699, 0.88732394],\n", + " [0.16732617, 0.46977812, 0.85915493],\n", + " [0.21763708, 0.40168324, 0.90140845],\n", + " [0.2866026 , 0.33996429, 0.87323944],\n", + " [0.39174675, 0.28589645, 0.95774648],\n", + " [0.50876201, 0.22800306, 0.97183099],\n", + " [0.6308649 , 0.17087478, 0.98591549],\n", + " [0.75296778, 0.11425657, 0.98591549],\n", + " [0.87563595, 0.05738332, 0.98591549],\n", + " [1. , 0. , 0.98591549]]),\n", + " array([[0.5390322 , 0.33616419, 0. ],\n", + " [0.55875906, 0.21832979, 0.00987959],\n", + " [0.59484067, 0.16737438, 0.00987959],\n", + " [0.6317653 , 0.15923567, 0.00957086],\n", + " [0.67391671, 0.15923567, 0.00987959],\n", + " [0.7244984 , 0.17692852, 0.01265823],\n", + " [0.76816726, 0.20169851, 0.01096017],\n", + " [0.80880121, 0.21832979, 0.0108058 ],\n", + " [0.84252234, 0.23602265, 0.0108058 ],\n", + " [0.87337717, 0.24769993, 0.00972522],\n", + " [0.90440061, 0.25442321, 0.00987959],\n", + " [0.93238914, 0.24769993, 0.00987959],\n", + " [0.95767999, 0.22434536, 0.00957086],\n", + " [0.97824987, 0.18577495, 0.00987959],\n", + " [0.99140111, 0.14154282, 0.01018833],\n", + " [1. , 0.09731069, 0.00987959],\n", + " [0.99983139, 0.05307856, 0.00972522],\n", + " [0.99426741, 0.01769285, 0.00972522],\n", + " [0.98297083, 0. , 0.00941649],\n", + " [0.97150565, 0.01061571, 0.00972522],\n", + " [0.9669533 , 0.03963199, 0.00972522],\n", + " [0.96341258, 0.07678698, 0.00972522],\n", + " [0.96054628, 0.10615711, 0.00987959],\n", + " [0.95767999, 0.12774239, 0.00972522],\n", + " [0.95767999, 0.13411182, 0.00941649],\n", + " [0.95767999, 0.12986553, 0.0108058 ],\n", + " [0.96054628, 0.12986553, 0.01065144],\n", + " [0.96054628, 0.12384996, 0.0108058 ],\n", + " [0.96611027, 0.10615711, 0.02624267],\n", + " [0.96341258, 0.10615711, 0.02794072],\n", + " [0.96526724, 0.10120311, 0.02778635],\n", + " [0.9701568 , 0.09023355, 0.02763199],\n", + " [0.97740685, 0.0651097 , 0.05572708],\n", + " [0.98027314, 0.0651097 , 0.02747762],\n", + " [0.98297083, 0.0651097 , 0.05572708],\n", + " [0.98027314, 0.0651097 , 0.08335906],\n", + " [0.98297083, 0.07077141, 0.27801791],\n", + " [0.98179059, 0.06723284, 0.02763199],\n", + " [0.98027314, 0.0651097 , 0.05572708],\n", + " [0.98297083, 0.0651097 , 0.19435011],\n", + " [0.98027314, 0.0651097 , 0.02794072],\n", + " [0.98297083, 0.0651097 , 0.08320469],\n", + " [0.98027314, 0.0651097 , 0.02778635],\n", + " [0.98297083, 0.0651097 , 0.16671812],\n", + " [0.98027314, 0.0651097 , 0.05572708],\n", + " [0.98297083, 0.0651097 , 0.08320469],\n", + " [0.98297083, 0.07077141, 0.1387774 ],\n", + " [0.98297083, 0.0651097 , 0.05588144],\n", + " [0.98027314, 0.0651097 , 0.11083668],\n", + " [0.98297083, 0.0651097 , 0.02794072],\n", + " [0.98145338, 0.06581741, 0.02794072],\n", + " [0.98297083, 0.0651097 , 0.02778635],\n", + " [0.98027314, 0.0651097 , 0.02747762],\n", + " [0.98297083, 0.0651097 , 0.05557271],\n", + " [0.98027314, 0.0651097 , 0.02794072],\n", + " [0.98297083, 0.0651097 , 0.08351343],\n", + " [0.98027314, 0.0651097 , 0.02747762],\n", + " [0.98297083, 0.0651097 , 0.02794072],\n", + " [0.98027314, 0.05909413, 0.05572708],\n", + " [0.98027314, 0.0651097 , 0.05526397],\n", + " [0.98027314, 0.05909413, 0.05588144],\n", + " [0.98027314, 0.0651097 , 0.05541834],\n", + " [0.97740685, 0.05909413, 0.05572708],\n", + " [0.98027314, 0.0651097 , 0.05557271],\n", + " [0.98111617, 0.06192498, 0.05557271],\n", + " [0.98027314, 0.0651097 , 0.02778635],\n", + " [0.98027314, 0.05909413, 0.08335906],\n", + " [0.98027314, 0.0651097 , 0.30564989],\n", + " [0.98027314, 0.05909413, 0.02778635],\n", + " [0.97740685, 0.05909413, 0.08320469],\n", + " [0.97943011, 0.05909413, 0.02778635],\n", + " [0.98027314, 0.0651097 , 0.11129978],\n", + " [0.98027314, 0.05909413, 0.08320469],\n", + " [0.97993593, 0.0626327 , 0.02778635],\n", + " [0.98027314, 0.05909413, 0.08351343],\n", + " [0.98027314, 0.0651097 , 0.05557271],\n", + " [0.98027314, 0.05909413, 0.05557271],\n", + " [0.98027314, 0.0651097 , 0.05557271],\n", + " [0.98027314, 0.05909413, 0.02747762],\n", + " [0.98027314, 0.0651097 , 0.08351343],\n", + " [0.98297083, 0.0651097 , 0.05572708],\n", + " [0.98027314, 0.0651097 , 0.02778635],\n", + " [0.98027314, 0.05909413, 0.02747762],\n", + " [0.98027314, 0.0651097 , 0.02794072],\n", + " [0.98027314, 0.05909413, 0.08335906],\n", + " [0.97740685, 0.05909413, 0.1387774 ],\n", + " [0.9790929 , 0.06086341, 0.05572708],\n", + " [0.98094756, 0.06157113, 0.11114542],\n", + " [0.98027314, 0.0651097 , 0.13908614],\n", + " [0.98027314, 0.05980184, 0.02763199],\n", + " [0.97740685, 0.05909413, 0.24992282],\n", + " [0.9789243 , 0.05732484, 0.02809509],\n", + " [0.97740685, 0.05909413, 0.02763199],\n", + " [0.98027314, 0.05909413, 0.05541834],\n", + " [0.97740685, 0.05909413, 0.05588144],\n", + " [0.97740685, 0.05307856, 0.13893177],\n", + " [0.97740685, 0.05909413, 0.05541834],\n", + " [0.97740685, 0.05307856, 0.02763199],\n", + " [0.9789243 , 0.05803255, 0.02809509],\n", + " [0.97740685, 0.05909413, 0.02763199],\n", + " [0.97740685, 0.05307856, 0.02763199],\n", + " [0.97740685, 0.05909413, 0.02809509],\n", + " [0.97774406, 0.0552017 , 0.02763199],\n", + " [0.97740685, 0.05909413, 0.11129978],\n", + " [0.97740685, 0.05307856, 0.05557271],\n", + " [0.97454055, 0.05307856, 0.11114542],\n", + " [0.97740685, 0.05307856, 0.16671812],\n", + " [0.97454055, 0.05307856, 0.02778635],\n", + " [0.97656382, 0.05201699, 0.05557271],\n", + " [0.97454055, 0.05307856, 0.11099105],\n", + " [0.97740685, 0.05307856, 0.19465885],\n", + " [0.97454055, 0.05307856, 0.02763199],\n", + " [0.97454055, 0.04741684, 0.08335906],\n", + " [0.97454055, 0.05307856, 0.02778635],\n", + " [0.97740685, 0.05307856, 0.05541834],\n", + " [0.97454055, 0.04741684, 0.05588144],\n", + " [0.97454055, 0.05307856, 0.02763199],\n", + " [0.97740685, 0.05307856, 0.16671812],\n", + " [0.97504637, 0.05166313, 0.08335906],\n", + " [0.97740685, 0.05307856, 0.11114542],\n", + " [0.97420334, 0.04953999, 0.05572708],\n", + " [0.97454055, 0.05307856, 0.02763199],\n", + " [0.97622661, 0.05237084, 0.02794072],\n", + " [0.97454055, 0.05307856, 0.02747762],\n", + " [0.97454055, 0.04741684, 0.02778635],\n", + " [0.97454055, 0.05307856, 0.02809509],\n", + " [0.97454055, 0.04741684, 0.02747762],\n", + " [0.97184286, 0.04741684, 0.36137697],\n", + " [0.97504637, 0.04847841, 0.05557271],\n", + " [0.97352892, 0.04706299, 0.27786354],\n", + " [0.97470916, 0.04953999, 0.27801791],\n", + " [0.97740685, 0.05307856, 0.19435011],\n", + " [0.97504637, 0.0502477 , 0.02778635],\n", + " [0.97740685, 0.05307856, 0.11114542],\n", + " [0.97841848, 0.05590941, 0.25023155],\n", + " [0.97740685, 0.05307856, 0.08335906],\n", + " [0.97504637, 0.05095541, 1. ],\n", + " [0.97454055, 0.04741684, 0.16687249],\n", + " [0.97184286, 0.04741684, 0.66687249],\n", + " [0.97454055, 0.04741684, 0.11114542],\n", + " [0.97184286, 0.04741684, 0.11099105],\n", + " [0.96897656, 0.04140127, 0.11145415],\n", + " [0.97032541, 0.04635527, 0.02763199],\n", + " [0.97184286, 0.04741684, 0.02794072],\n", + " [0.97454055, 0.04741684, 0.30549552],\n", + " [0.97521497, 0.05095541, 0.16671812],\n", + " [0.97454055, 0.04741684, 0.02794072],\n", + " [0.97184286, 0.04741684, 0.33343625],\n", + " [0.97454055, 0.04741684, 0.16671812],\n", + " [0.97454055, 0.05307856, 0.08320469],\n", + " [0.97572079, 0.05060156, 0.02794072],\n", + " [0.97454055, 0.05307856, 0.02778635],\n", + " [0.97454055, 0.04741684, 0.02763199],\n", + " [0.97740685, 0.05307856, 0.11099105],\n", + " [0.97454055, 0.05307856, 0.27786354],\n", + " [0.97740685, 0.05307856, 0.05588144],\n", + " [0.97740685, 0.05909413, 0.41648657],\n", + " [0.97875569, 0.0552017 , 0.02809509],\n", + " [0.97740685, 0.05307856, 0.05541834],\n", + " [0.98027314, 0.05909413, 0.02763199],\n", + " [0.97740685, 0.05307856, 0.08335906],\n", + " [0.98027314, 0.05307856, 0.02809509],\n", + " [0.97740685, 0.05307856, 0.02763199],\n", + " [0.97454055, 0.05307856, 0.22229083],\n", + " [0.97740685, 0.05307856, 0.05572708],\n", + " [0.97454055, 0.04741684, 0.16671812],\n", + " [0.97454055, 0.05307856, 0.02763199],\n", + " [0.97740685, 0.05307856, 0.11129978],\n", + " [0.97454055, 0.05307856, 0.11099105],\n", + " [0.97622661, 0.05626327, 0.13908614],\n", + " [0.97740685, 0.05307856, 0.05541834],\n", + " [0.97454055, 0.04741684, 0.05541834],\n", + " [0.97184286, 0.04741684, 0.11129978],\n", + " [0.97454055, 0.04741684, 0.11099105],\n", + " [0.97555218, 0.05060156, 0.05572708],\n", + " [0.97740685, 0.05307856, 0.11129978],\n", + " [0.98044175, 0.0576787 , 0.19435011],\n", + " [0.98297083, 0.05909413, 0.16671812],\n", + " [0.98297083, 0.0651097 , 0.05572708],\n", + " [0.98297083, 0.05909413, 0.02763199],\n", + " [0.98027314, 0.05909413, 0.05557271],\n", + " [0.98297083, 0.05909413, 0.13893177],\n", + " [0.98027314, 0.05909413, 0.05557271],\n", + " [0.97740685, 0.05307856, 0.05557271],\n", + " [0.97454055, 0.04741684, 0.55572708],\n", + " [0.97184286, 0.04741684, 0.02794072],\n", + " [0.96897656, 0.04140127, 0.02763199],\n", + " [0.96611027, 0.04140127, 0.02763199],\n", + " [0.97268589, 0.04706299, 0.02794072],\n", + " [0.97454055, 0.04741684, 0.02778635],\n", + " [0.97184286, 0.04741684, 0.05557271],\n", + " [0.96897656, 0.04741684, 0.16687249],\n", + " [0.96863935, 0.04352442, 0.02763199],\n", + " [0.97184286, 0.04741684, 0.08335906],\n", + " [0.97454055, 0.04741684, 0.16687249],\n", + " [0.97454055, 0.05307856, 0.22213646],\n", + " [0.97454055, 0.04741684, 0.02778635],\n", + " [0.97454055, 0.05307856, 0.05572708],\n", + " [0.97454055, 0.04741684, 0.02763199],\n", + " [0.97454055, 0.05307856, 0.02778635],\n", + " [0.97454055, 0.04741684, 0.05557271],\n", + " [0.97454055, 0.05307856, 0.02778635],\n", + " [0.97454055, 0.04741684, 0.11129978],\n", + " [0.9730231 , 0.04847841, 0.02778635],\n", + " [0.97454055, 0.04741684, 0.05557271],\n", + " [0.97234868, 0.04741684, 0.16671812],\n", + " [0.97066262, 0.04741684, 0.41679531],\n", + " [0.96897656, 0.04741684, 0.02747762],\n", + " [0.97184286, 0.04741684, 0.05588144],\n", + " [0.97454055, 0.04741684, 0.08305032],\n", + " [0.97184286, 0.04741684, 0.13924051],\n", + " [0.97454055, 0.04741684, 0.55557271],\n", + " [0.97538358, 0.05307856, 0.02794072],\n", + " [0.97740685, 0.05307856, 0.02763199],\n", + " [0.97740685, 0.05909413, 0.08351343],\n", + " [0.97740685, 0.05307856, 0.11099105],\n", + " [0.97740685, 0.05909413, 0.02794072],\n", + " [0.97740685, 0.05307856, 0.02778635],\n", + " [0.97538358, 0.0527247 , 0.08320469],\n", + " [0.97740685, 0.05307856, 0.1387774 ],\n", + " [0.97740685, 0.04741684, 0.02794072],\n", + " [0.97555218, 0.0502477 , 0.02794072],\n", + " [0.97740685, 0.05307856, 0.02763199],\n", + " [0.97184286, 0.07678698, 0.16671812],\n", + " [0.96897656, 0.08280255, 0.02778635],\n", + " [0.964087 , 0.10509554, 0.05572708],\n", + " [0.96054628, 0.11818825, 0.02763199],\n", + " [0.95262182, 0.13552725, 0.05572708],\n", + " [0.94655201, 0.14154282, 0.01883297],\n", + " [0.94655201, 0.14755839, 0.01065144],\n", + " [0.94250548, 0.15711253, 0.0108058 ],\n", + " [0.94081942, 0.17126681, 0.0108058 ],\n", + " [0.93795313, 0.1836518 , 0.00941649],\n", + " [0.9310403 , 0.20205237, 0.01065144],\n", + " [0.91552858, 0.22434536, 0.01096017],\n", + " [0.89597033, 0.2537155 , 0.01049707],\n", + " [0.87303996, 0.2915782 , 0.01111454],\n", + " [0.84808633, 0.33050248, 0.01065144],\n", + " [0.8172315 , 0.37756546, 0.01234949],\n", + " [0.79126623, 0.41967445, 0.00941649],\n", + " [0.76378351, 0.46602972, 0.01065144],\n", + " [0.73006238, 0.507431 , 0.01096017],\n", + " [0.69920755, 0.55449398, 0.01065144],\n", + " [0.66835272, 0.59589526, 0.01065144],\n", + " [0.63732929, 0.63694268, 0.0108058 ],\n", + " [0.60360816, 0.68435952, 0.01111454],\n", + " [0.56988703, 0.73142251, 0.0108058 ],\n", + " [0.53616591, 0.77848549, 0.01204075],\n", + " [0.50817737, 0.81988677, 0.00987959],\n", + " [0.47479346, 0.83828733, 0.01049707],\n", + " [0.44073512, 0.8492569 , 0.01018833],\n", + " [0.4071826 , 0.85633404, 0.00972522],\n", + " [0.36705446, 0.85491861, 0.01234949],\n", + " [0.33670545, 0.85527247, 0.01096017],\n", + " [0.30585062, 0.8492569 , 0.0108058 ],\n", + " [0.28190862, 0.84359519, 0.01065144],\n", + " [0.25796662, 0.83757962, 0.0108058 ],\n", + " [0.23840836, 0.83757962, 0.0108058 ],\n", + " [0.21581521, 0.83156405, 0.01404755],\n", + " [0.20182094, 0.83156405, 0.00957086],\n", + " [0.19052436, 0.83156405, 0.01049707],\n", + " [0.17939639, 0.81988677, 0.01065144],\n", + " [0.16995448, 0.80431706, 0.00987959],\n", + " [0.15966953, 0.79617834, 0.01018833],\n", + " [0.14837296, 0.79051663, 0.0108058 ],\n", + " [0.13724498, 0.78450106, 0.0108058 ],\n", + " [0.1288147 , 0.78450106, 0.01096017],\n", + " [0.11751813, 0.77848549, 0.01049707],\n", + " [0.10622155, 0.77848549, 0.01096017],\n", + " [0.09509358, 0.77282378, 0.0108058 ],\n", + " [0.08936098, 0.76680821, 0.01096017],\n", + " [0.083797 , 0.76680821, 0.01234949],\n", + " [0.0809307 , 0.76079264, 0.01049707],\n", + " [0.07823301, 0.76079264, 0.01250386],\n", + " [0.07536672, 0.75548478, 0.01234949],\n", + " [0.07536672, 0.74911536, 0.00941649],\n", + " [0.07250042, 0.75513093, 0.04013584],\n", + " [0.06693644, 0.75513093, 0.00957086],\n", + " [0.0600236 , 0.75017693, 0.00987959],\n", + " [0.05294217, 0.73743808, 0.00972522],\n", + " [0.0480526 , 0.71196037, 0.01234949],\n", + " [0.04737818, 0.6861288 , 0.0108058 ],\n", + " [0.04720958, 0.6606511 , 0.01096017],\n", + " [0.05007587, 0.63694268, 0.0108058 ],\n", + " [0.05294217, 0.61358811, 0.00957086],\n", + " [0.05007587, 0.58386412, 0.00987959],\n", + " [0.0387793 , 0.56617127, 0.00972522],\n", + " [0.03034901, 0.57218684, 0.00972522],\n", + " [0.02309897, 0.60474168, 0.01049707],\n", + " [0.01922104, 0.64897381, 0.01065144],\n", + " [0.01686056, 0.7059448 , 0.00987959],\n", + " [0.01635475, 0.76079264, 0.01003396],\n", + " [0.01348845, 0.8138712 , 0.01003396],\n", + " [0.01079076, 0.86694975, 0.01173202],\n", + " [0.00758725, 0.90835103, 0.01096017],\n", + " [0.00505817, 0.93772116, 0.00957086],\n", + " [0.00219187, 0.96850672, 0.00941649],\n", + " [0. , 1. , 0.00972522]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91932169, 0.92038993, 0.91139241],\n", + " [0.84429599, 0.84646629, 0.86075949],\n", + " [0.76464543, 0.76929326, 0.89873418],\n", + " [0.68961973, 0.69374492, 0.87341772],\n", + " [0.62487153, 0.62659085, 0.7721519 ],\n", + " [0.54727646, 0.55104251, 0.88607595],\n", + " [0.4696814 , 0.47305714, 0.88607595],\n", + " [0.39260021, 0.3975088 , 0.88607595],\n", + " [0.30421377, 0.31004603, 1. ],\n", + " [0.22970195, 0.23178987, 0.89873418],\n", + " [0.15313464, 0.15651232, 0.87341772],\n", + " [0.07605344, 0.07744381, 0.89873418],\n", + " [0. , 0. , 0.87341772]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90531742, 0.90415913, 0.86419753],\n", + " [0.80982094, 0.81374322, 0.85185185],\n", + " [0.7116115 , 0.70886076, 0.88888889],\n", + " [0.60336408, 0.60216998, 0.97530864],\n", + " [0.50623983, 0.51175407, 0.86419753],\n", + " [0.41155724, 0.41952984, 0.86419753],\n", + " [0.29924037, 0.2965642 , 1. ],\n", + " [0.19017906, 0.19529837, 0.97530864],\n", + " [0.09549647, 0.09764919, 0.86419753],\n", + " [0. , 0. , 0.85185185]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90515252, 0.91035857, 0.88405797],\n", + " [0.80748526, 0.81673307, 0.89855072],\n", + " [0.70699821, 0.71115538, 0.92753623],\n", + " [0.60830556, 0.60756972, 0.91304348],\n", + " [0.50961292, 0.5059761 , 0.91304348],\n", + " [0.40579339, 0.4063745 , 0.95652174],\n", + " [0.30992053, 0.31474104, 0.88405797],\n", + " [0.20507562, 0.21115538, 0.95652174],\n", + " [0.10561395, 0.10756972, 0.92753623],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89394969, 0.10206212, 1. ],\n", + " [0.79537729, 0.20281911, 0.98571429],\n", + " [0.69408566, 0.30775255, 1. ],\n", + " [0.60639021, 0.39650222, 0.87142857],\n", + " [0.50577838, 0.49830332, 0.98571429],\n", + " [0.40244731, 0.60114853, 1. ],\n", + " [0.31407206, 0.69015923, 0.87142857],\n", + " [0.20734194, 0.79352649, 1. ],\n", + " [0.10401088, 0.89689376, 1. ],\n", + " [0. , 1. , 0.98571429]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10367893, 0.10566242, 0.85185185],\n", + " [0.22449833, 0.22785153, 0.98765432],\n", + " [0.32859532, 0.33568139, 0.86419753],\n", + " [0.45150502, 0.45814143, 1. ],\n", + " [0.55643813, 0.55973991, 0.85185185],\n", + " [0.66429766, 0.66946627, 0.87654321],\n", + " [0.76588629, 0.77296126, 0.85185185],\n", + " [0.87667224, 0.87862368, 0.87654321],\n", + " [1. , 1. , 0.98765432]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1052364 , 0.10800357, 0.69306931],\n", + " [0.2282664 , 0.23385897, 0.79207921],\n", + " [0.36959837, 0.37935138, 0.88118812],\n", + " [0.52364006, 0.53704255, 1. ],\n", + " [0.6314184 , 0.64504612, 0.7029703 ],\n", + " [0.73817997, 0.75156204, 0.67326733],\n", + " [0.8551093 , 0.86462362, 0.7029703 ],\n", + " [1. , 1. , 0.88118812]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88933121, 0.88826367, 0.97014925],\n", + " [0.77839703, 0.77652733, 0.98507463],\n", + " [0.66613588, 0.66157556, 0.98507463],\n", + " [0.5552017 , 0.54983923, 0.98507463],\n", + " [0.44559448, 0.43971061, 0.98507463],\n", + " [0.33333333, 0.32797428, 1. ],\n", + " [0.22080679, 0.21864952, 0.98507463],\n", + " [0.10934183, 0.10771704, 0.98507463],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8998999 , 0.07954545, 0.97183099],\n", + " [0.8018018 , 0.16477273, 0.98591549],\n", + " [0.7007007 , 0.23295455, 1. ],\n", + " [0.60085085, 0.30681818, 0.98591549],\n", + " [0.50075075, 0.42045455, 0.98591549],\n", + " [0.40365365, 0.52272727, 0.95774648],\n", + " [0.30205205, 0.61363636, 1. ],\n", + " [0.20195195, 0.73295455, 0.98591549],\n", + " [0.1006006 , 0.86931818, 1. ],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08333333, 0.08589909, 0.95833333],\n", + " [0.16306306, 0.16817594, 0.95833333],\n", + " [0.23603604, 0.24346701, 0.84722222],\n", + " [0.31441441, 0.32626132, 0.95833333],\n", + " [0.39594595, 0.41319534, 0.98611111],\n", + " [0.47612613, 0.49831824, 0.97222222],\n", + " [0.56306306, 0.58085382, 0.95833333],\n", + " [0.65225225, 0.66416559, 1. ],\n", + " [0.73783784, 0.7461837 , 0.95833333],\n", + " [0.82612613, 0.8313066 , 0.98611111],\n", + " [0.91126126, 0.91435964, 0.97222222],\n", + " [1. , 1. , 0.97222222]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09622707, 0.84419166, 0.92424242],\n", + " [0.2211838 , 0.71216822, 0.96969697],\n", + " [0.35375562, 0.5887625 , 1. ],\n", + " [0.48840429, 0.4622544 , 1. ],\n", + " [0.62132226, 0.34298518, 0.98484848],\n", + " [0.73970232, 0.23612547, 0.92424242],\n", + " [0.87088958, 0.11651155, 1. ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.03138374, 0.04688973, 0.86419753],\n", + " [0.08131241, 0.09519321, 0.85185185],\n", + " [0.12981455, 0.13972667, 0.75308642],\n", + " [0.18259629, 0.19180019, 0.86419753],\n", + " [0.21112696, 0.24434496, 0.83950617],\n", + " [0.20399429, 0.29948162, 0.86419753],\n", + " [0.17689016, 0.35626767, 0.88888889],\n", + " [0.15406562, 0.41093308, 0.83950617],\n", + " [0.13552068, 0.46347785, 0.88888889],\n", + " [0.13694722, 0.50895382, 0.83950617],\n", + " [0.15121255, 0.55207352, 0.87654321],\n", + " [0.18116976, 0.59731385, 0.87654321],\n", + " [0.2296719 , 0.64373233, 0.86419753],\n", + " [0.30813124, 0.6972196 , 0.97530864],\n", + " [0.42225392, 0.74858624, 1. ],\n", + " [0.54208274, 0.80136664, 0.96296296],\n", + " [0.64621969, 0.84566447, 0.88888889],\n", + " [0.73894437, 0.88407163, 0.86419753],\n", + " [0.82310984, 0.92059378, 0.85185185],\n", + " [0.91012839, 0.9594722 , 0.86419753],\n", + " [1. , 1. , 0.85185185]]),\n", + " array([[0.27722772, 1. , 0. ],\n", + " [0. , 0.8795045 , 1. ],\n", + " [0.04950495, 0.76914414, 1. ],\n", + " [0.07920792, 0.65923423, 1. ],\n", + " [0.12871287, 0.54774775, 1. ],\n", + " [0.17821782, 0.44121622, 1. ],\n", + " [0.07920792, 0.32972973, 1. ],\n", + " [0.24752475, 0.23986486, 1. ],\n", + " [0.62376238, 0.11148649, 1. ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92137592, 0.91666667, 0.74725275],\n", + " [0.84766585, 0.84682765, 0.67032967],\n", + " [0.74078624, 0.73697917, 1. ],\n", + " [0.65847666, 0.65435606, 0.76923077],\n", + " [0.58599509, 0.56889205, 0.76923077],\n", + " [0.50614251, 0.48768939, 0.74725275],\n", + " [0.43243243, 0.41595644, 0.67032967],\n", + " [0.34520885, 0.33072917, 0.78021978],\n", + " [0.25552826, 0.24928977, 0.76923077],\n", + " [0.16830467, 0.16619318, 0.75824176],\n", + " [0.07616708, 0.0842803 , 0.78021978],\n", + " [0. , 0. , 0.76923077]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86811352, 0.86810417, 0.86813187],\n", + " [0.74791319, 0.75021003, 0.78021978],\n", + " [0.63550362, 0.63623635, 0.75824176],\n", + " [0.49693934, 0.49929992, 0.89010989],\n", + " [0.38286032, 0.38392607, 0.76923077],\n", + " [0.26655537, 0.26743209, 0.75824176],\n", + " [0.11574847, 0.11593391, 1. ],\n", + " [0. , 0. , 0.76923077]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9276407 , 0.93355482, 0.875 ],\n", + " [0.86664818, 0.87707641, 0.7625 ],\n", + " [0.79484336, 0.79568106, 0.8625 ],\n", + " [0.73357361, 0.74086379, 0.7625 ],\n", + " [0.66176878, 0.66943522, 0.875 ],\n", + " [0.58913224, 0.59966777, 0.875 ],\n", + " [0.51594123, 0.53156146, 0.875 ],\n", + " [0.44219573, 0.4551495 , 0.875 ],\n", + " [0.36179651, 0.37209302, 1. ],\n", + " [0.29026892, 0.30232558, 0.875 ],\n", + " [0.2184641 , 0.22093023, 0.875 ],\n", + " [0.14582756, 0.14119601, 0.8625 ],\n", + " [0.07208206, 0.06976744, 0.8875 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11267218, 0.88849348, 0.98611111],\n", + " [0.22534435, 0.77758007, 0.95833333],\n", + " [0.33911846, 0.66251483, 1. ],\n", + " [0.45041322, 0.55160142, 0.95833333],\n", + " [0.56363636, 0.43831554, 0.95833333],\n", + " [0.67630854, 0.32562278, 0.98611111],\n", + " [0.79118457, 0.20996441, 0.97222222],\n", + " [0.88677686, 0.113879 , 0.84722222],\n", + " [1. , 0. , 0.95833333]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12690919, 0.12635379, 1. ],\n", + " [0.24687587, 0.24729242, 0.97183099],\n", + " [0.35406831, 0.35740072, 0.85915493],\n", + " [0.47542349, 0.48375451, 0.98591549],\n", + " [0.59844488, 0.60830325, 0.97183099],\n", + " [0.63343516, 0.64259928, 0.28169014],\n", + " [0.75645654, 0.76353791, 0.98591549],\n", + " [0.87892252, 0.88628159, 0.98591549],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90237603, 0.90572687, 0.6969697 ],\n", + " [0.80785124, 0.810279 , 0.71717172],\n", + " [0.7107438 , 0.71483113, 0.70707071],\n", + " [0.57954545, 0.58002937, 1. ],\n", + " [0.48140496, 0.48516887, 0.71717172],\n", + " [0.37551653, 0.37826725, 0.80808081],\n", + " [0.28305785, 0.28546256, 0.6969697 ],\n", + " [0.1875 , 0.189721 , 0.70707071],\n", + " [0.07902893, 0.08017621, 0.81818182],\n", + " [0. , 0. , 0.61616162]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8555311 , 0.10659898, 0.93055556],\n", + " [0.7135388 , 0.20304569, 0.90277778],\n", + " [0.57402312, 0.29949239, 0.91666667],\n", + " [0.43258118, 0.39086294, 0.91666667],\n", + " [0.29003853, 0.56852792, 0.91666667],\n", + " [0.15024766, 0.79695431, 0.91666667],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14975192, 0.14799214, 0.67708333],\n", + " [0.29995489, 0.29879247, 0.69791667],\n", + " [0.47902571, 0.47739399, 0.8125 ],\n", + " [0.63148399, 0.63100253, 0.6875 ],\n", + " [0.85160126, 0.8511654 , 1. ],\n", + " [1. , 1. , 0.67708333]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91905388, 0.90140845, 0.79775281],\n", + " [0.83731932, 0.84507042, 0.78651685],\n", + " [0.75637319, 0.79342723, 0.78651685],\n", + " [0.65413929, 0.66197183, 1. ],\n", + " [0.57424442, 0.5258216 , 0.79775281],\n", + " [0.49408673, 0.45070423, 0.78651685],\n", + " [0.41340342, 0.37558685, 0.78651685],\n", + " [0.33166886, 0.30985915, 0.79775281],\n", + " [0.25045992, 0.24413146, 0.78651685],\n", + " [0.15952694, 0.15492958, 0.88764045],\n", + " [0.07858081, 0.08450704, 0.79775281],\n", + " [0. , 0. , 0.78651685]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11636557, 0.33333333, 0.875 ],\n", + " [0.23166844, 0.73333333, 0.875 ],\n", + " [0.36716259, 0.86666667, 1. ],\n", + " [0.49760893, 1. , 0.9875 ],\n", + " [0.61716259, 0.8 , 0.9 ],\n", + " [0.74920298, 0.86666667, 0.9875 ],\n", + " [0.88469713, 0.73333333, 1. ],\n", + " [1. , 0.8 , 0.875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88519213, 0.88570671, 0.86904762],\n", + " [0.77881912, 0.77910369, 0.77380952],\n", + " [0.67291471, 0.67303103, 0.78571429],\n", + " [0.56841612, 0.56854946, 0.78571429],\n", + " [0.45173383, 0.45133917, 0.85714286],\n", + " [0.34395501, 0.3439406 , 0.79761905],\n", + " [0.23992502, 0.23972421, 0.77380952],\n", + " [0.13448922, 0.13418191, 0.78571429],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85824977, 0.85678601, 0.97014925],\n", + " [0.71558797, 0.71412712, 0.98507463],\n", + " [0.57247037, 0.57063558, 1. ],\n", + " [0.42889699, 0.42797669, 0.97014925],\n", + " [0.2857794 , 0.28531779, 0.98507463],\n", + " [0.14448496, 0.14487927, 0.98507463],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.07623318, 0.08402235, 0.98591549],\n", + " [0.14798206, 0.15597765, 0.85915493],\n", + " [0.24215247, 0.24156425, 0.98591549],\n", + " [0.33183857, 0.32424581, 0.98591549],\n", + " [0.38565022, 0.40960894, 1. ],\n", + " [0.44843049, 0.49385475, 0.98591549],\n", + " [0.52017937, 0.57653631, 0.97183099],\n", + " [0.62780269, 0.66189944, 0.98591549],\n", + " [0.71748879, 0.74458101, 0.98591549],\n", + " [0.8161435 , 0.8301676 , 0.98591549],\n", + " [0.89237668, 0.90592179, 0.85915493],\n", + " [1. , 1. , 0.97183099]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14686825, 0.14530551, 0.98507463],\n", + " [0.29319654, 0.28961749, 0.98507463],\n", + " [0.424946 , 0.4212618 , 0.91044776],\n", + " [0.56965443, 0.56582216, 0.97014925],\n", + " [0.71382289, 0.7106309 , 1. ],\n", + " [0.8574514 , 0.85519126, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13428252, 0.12765957, 1. ],\n", + " [0.25823562, 0.24680851, 0.90277778],\n", + " [0.36795087, 0.36085106, 0.84722222],\n", + " [0.49274149, 0.49191489, 0.91666667],\n", + " [0.61501954, 0.61361702, 0.91666667],\n", + " [0.74008934, 0.73957447, 0.91666667],\n", + " [0.87520938, 0.87234043, 1. ],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.96296296, 0.93545391, 0.97222222],\n", + " [0.88888889, 0.8699791 , 0.95833333],\n", + " [0.85185185, 0.81193406, 0.84722222],\n", + " [0.74074074, 0.74483399, 0.97222222],\n", + " [0.62962963, 0.67750174, 0.97222222],\n", + " [0.59259259, 0.61133039, 0.98611111],\n", + " [0.59259259, 0.54399814, 0.95833333],\n", + " [0.44444444, 0.47736243, 0.97222222],\n", + " [0.33333333, 0.409798 , 0.95833333],\n", + " [0.37037037, 0.34269793, 0.97222222],\n", + " [0.22222222, 0.2739726 , 0.97222222],\n", + " [0.14814815, 0.20455073, 1. ],\n", + " [0.18518519, 0.13791502, 0.94444444],\n", + " [0.07407407, 0.06826097, 0.97222222],\n", + " [0. , 0. , 0.97222222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16385435, 0.16465018, 0.85542169],\n", + " [0.30284192, 0.30720673, 0.73493976],\n", + " [0.46847247, 0.47448711, 0.86746988],\n", + " [0.63721137, 0.64018937, 0.86746988],\n", + " [0.83081705, 0.83166754, 1. ],\n", + " [1. , 1. , 0.87951807]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1104178 , 0.09268707, 0.8625 ],\n", + " [0.23412914, 0.21428571, 1. ],\n", + " [0.34427564, 0.31972789, 0.875 ],\n", + " [0.45496473, 0.43707483, 0.8875 ],\n", + " [0.56348345, 0.55782313, 0.875 ],\n", + " [0.67308736, 0.66156463, 0.8625 ],\n", + " [0.78241997, 0.77465986, 0.875 ],\n", + " [0.88931091, 0.89710884, 0.8625 ],\n", + " [1. , 1. , 0.8875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89736978, 0.89257082, 0.83950617],\n", + " [0.78494069, 0.78460716, 0.87654321],\n", + " [0.67663744, 0.67771245, 0.87654321],\n", + " [0.56936565, 0.57215393, 0.85185185],\n", + " [0.44507478, 0.45002672, 0.98765432],\n", + " [0.32181537, 0.3241582 , 1. ],\n", + " [0.21402785, 0.21619455, 0.86419753],\n", + " [0.10778752, 0.11036879, 0.85185185],\n", + " [0. , 0. , 0.87654321]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13333333, 0.12178189, 0.90277778],\n", + " [0.25941043, 0.24645647, 0.91666667],\n", + " [0.38321995, 0.37199884, 0.91666667],\n", + " [0.49569161, 0.48625976, 0.84722222],\n", + " [0.61904762, 0.61209141, 0.91666667],\n", + " [0.74240363, 0.73763379, 0.90277778],\n", + " [0.86575964, 0.86317616, 0.93055556],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.1658805 , 0.74470588, 1. ],\n", + " [0.29690776, 0.52941176, 0.78571429],\n", + " [0.43238994, 0.35294118, 0.78571429],\n", + " [0.56761006, 0.23529412, 0.78571429],\n", + " [0.7206499 , 0.15647059, 0.85714286],\n", + " [0.86032495, 0.07882353, 0.78571429],\n", + " [1. , 0. , 0.79761905]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.08618368, 0.10447761, 0.98611111],\n", + " [0.16859682, 0.20298507, 0.95833333],\n", + " [0.25181794, 0.29452736, 0.97222222],\n", + " [0.33396176, 0.38606965, 0.97222222],\n", + " [0.41718287, 0.47761194, 0.97222222],\n", + " [0.49905737, 0.56218905, 0.95833333],\n", + " [0.58416375, 0.64577114, 1. ],\n", + " [0.66684622, 0.72139303, 0.95833333],\n", + " [0.74925936, 0.79502488, 0.98611111],\n", + " [0.83032588, 0.86766169, 0.94444444],\n", + " [0.91300835, 0.93233831, 0.98611111],\n", + " [1. , 1. , 0.98611111]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90005522, 0.89772727, 0.85185185],\n", + " [0.77912755, 0.77355876, 1. ],\n", + " [0.65930425, 0.654102 , 1. ],\n", + " [0.55494202, 0.54961197, 0.85185185],\n", + " [0.44837107, 0.44595344, 0.85185185],\n", + " [0.32633904, 0.32732816, 0.98765432],\n", + " [0.22418553, 0.22256098, 0.86419753],\n", + " [0.10546659, 0.10338137, 1. ],\n", + " [0. , 0. , 0.86419753]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91603053, 0.13511675, 0.57894737],\n", + " [0.80916031, 0.27318068, 0.57894737],\n", + " [0.61832061, 0.45817275, 0.78947368],\n", + " [0.42748092, 0.60530492, 0.63157895],\n", + " [0.23664122, 0.76535933, 0.68421053],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88820043, 0.88438134, 1. ],\n", + " [0.79229526, 0.79107505, 0.86419753],\n", + " [0.68292026, 0.68559838, 0.98765432],\n", + " [0.58701509, 0.5862069 , 0.85185185],\n", + " [0.47737069, 0.48073022, 0.98765432],\n", + " [0.38200431, 0.37728195, 0.87654321],\n", + " [0.28609914, 0.28803245, 0.87654321],\n", + " [0.19342672, 0.20081136, 0.83950617],\n", + " [0.09509698, 0.09736308, 0.87654321],\n", + " [0. , 0. , 0.85185185]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.9015984 , 0.07929515, 0.85 ],\n", + " [0.8001998 , 0.1938326 , 0.875 ],\n", + " [0.69855145, 0.30396476, 0.9 ],\n", + " [0.5989011 , 0.40088106, 0.875 ],\n", + " [0.49875125, 0.4845815 , 0.875 ],\n", + " [0.40034965, 0.5814978 , 0.8625 ],\n", + " [0.30044955, 0.6784141 , 0.8625 ],\n", + " [0.2017982 , 0.77973568, 0.875 ],\n", + " [0.11438561, 0.87665198, 0.7625 ],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.06887347, 0.92717155, 0.98591549],\n", + " [0.14201815, 0.84902008, 0.98591549],\n", + " [0.21569674, 0.76844907, 0.98591549],\n", + " [0.30005339, 0.68013549, 0.98591549],\n", + " [0.3966898 , 0.58674087, 0.98591549],\n", + " [0.49546183, 0.4914106 , 0.97183099],\n", + " [0.59530166, 0.39293491, 1. ],\n", + " [0.6983449 , 0.29349141, 0.98591549],\n", + " [0.79871863, 0.19695137, 0.98591549],\n", + " [0.89909237, 0.09774982, 1. ],\n", + " [1. , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87068966, 0.85956298, 0.98484848],\n", + " [0.73354232, 0.71249693, 1. ],\n", + " [0.59012539, 0.56837712, 1. ],\n", + " [0.44278997, 0.42597594, 1. ],\n", + " [0.29702194, 0.28382028, 1. ],\n", + " [0.15125392, 0.14387429, 1. ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.82985822, 0.83132239, 0.98507463],\n", + " [0.66638866, 0.66795367, 0.98507463],\n", + " [0.50125104, 0.50168919, 0.98507463],\n", + " [0.33110926, 0.33301158, 0.98507463],\n", + " [0.16513761, 0.16650579, 1. ],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15594937, 0.16025641, 0.83544304],\n", + " [0.34329114, 0.35227273, 1. ],\n", + " [0.49974684, 0.50903263, 0.82278481],\n", + " [0.65670886, 0.66841492, 0.83544304],\n", + " [0.83037975, 0.84120047, 0.92405063],\n", + " [1. , 1. , 0.83544304]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12106918, 0.12217195, 0.84810127],\n", + " [0.23925577, 0.23755656, 0.82278481],\n", + " [0.38259958, 0.37556561, 1. ],\n", + " [0.50235849, 0.49321267, 0.83544304],\n", + " [0.63128931, 0.62443439, 0.91139241],\n", + " [0.75262055, 0.74434389, 0.83544304],\n", + " [0.88312369, 0.87104072, 0.91139241],\n", + " [1. , 1. , 0.83544304]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9106652 , 0.91666667, 0.8875 ],\n", + " [0.81913139, 0.82564103, 0.875 ],\n", + " [0.73062122, 0.72179487, 0.875 ],\n", + " [0.62699285, 0.61282051, 1. ],\n", + " [0.5371083 , 0.5474359 , 0.875 ],\n", + " [0.44832325, 0.46025641, 0.8625 ],\n", + " [0.35816383, 0.3525641 , 0.8875 ],\n", + " [0.2680044 , 0.25769231, 0.875 ],\n", + " [0.17921935, 0.18589744, 0.8625 ],\n", + " [0.0893348 , 0.10384615, 0.875 ],\n", + " [0. , 0. , 0.8875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.18918919, 0.17648521, 1. ],\n", + " [0.34459459, 0.31891623, 0.8 ],\n", + " [0.47972973, 0.44419587, 0.72222222],\n", + " [0.61486486, 0.601044 , 0.86666667],\n", + " [0.74324324, 0.73204077, 0.74444444],\n", + " [0.86486486, 0.8650261 , 0.73333333],\n", + " [1. , 1. , 0.72222222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1111679 , 0.16666667, 0.98507463],\n", + " [0.22208025, 0.30952381, 0.97014925],\n", + " [0.33299259, 0.45238095, 1. ],\n", + " [0.44441605, 0.64285714, 0.98507463],\n", + " [0.55762842, 0.83333333, 0.98507463],\n", + " [0.66700741, 1. , 0.98507463],\n", + " [0.77970866, 0.97619048, 0.98507463],\n", + " [0.89087657, 0.95238095, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89145001, 0.89066667, 0.85185185],\n", + " [0.78236398, 0.78266667, 0.88888889],\n", + " [0.67354597, 0.66533333, 0.83950617],\n", + " [0.56445993, 0.55466667, 0.87654321],\n", + " [0.45456982, 0.448 , 0.87654321],\n", + " [0.34548378, 0.332 , 0.85185185],\n", + " [0.2358617 , 0.22133333, 0.85185185],\n", + " [0.12570356, 0.12 , 0.87654321],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.2962963 , 0.887449 , 0.97014925],\n", + " [0.55555556, 0.78257739, 0.91044776],\n", + " [0.51851852, 0.67458603, 0.94029851],\n", + " [0.33333333, 0.55987521, 1. ],\n", + " [0.59259259, 0.45140389, 0.95522388],\n", + " [0.85185185, 0.33549316, 1. ],\n", + " [0.92592593, 0.22606192, 0.94029851],\n", + " [1. , 0.11183105, 0.98507463],\n", + " [0.92592593, 0. , 0.95522388]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10986367, 0.10578512, 0.87654321],\n", + " [0.21785619, 0.19834711, 0.86419753],\n", + " [0.32745255, 0.31735537, 0.86419753],\n", + " [0.43785084, 0.43801653, 0.86419753],\n", + " [0.54530874, 0.53719008, 0.86419753],\n", + " [0.65490511, 0.64793388, 0.85185185],\n", + " [0.78134189, 0.79173554, 1. ],\n", + " [0.88906709, 0.89256198, 0.86419753],\n", + " [1. , 1. , 0.86419753]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91304348, 0.14041657, 0.97014925],\n", + " [0.73913043, 0.2864498 , 0.98507463],\n", + " [0.52173913, 0.42990873, 0.98507463],\n", + " [0.39130435, 0.57243155, 0.98507463],\n", + " [0.13043478, 0.71495436, 1. ],\n", + " [0.17391304, 0.85513691, 0.97014925],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.95631641, 0.95151372, 0.84722222],\n", + " [0.90436836, 0.89522233, 0.97222222],\n", + " [0.84533648, 0.83869442, 0.95833333],\n", + " [0.79338843, 0.78122044, 1. ],\n", + " [0.73553719, 0.7256386 , 0.95833333],\n", + " [0.67532468, 0.66958373, 0.95833333],\n", + " [0.61393152, 0.61305582, 0.97222222],\n", + " [0.57969303, 0.56456954, 0.84722222],\n", + " [0.52538371, 0.50875118, 0.95833333],\n", + " [0.46635183, 0.45175024, 0.98611111],\n", + " [0.40968123, 0.39640492, 0.95833333],\n", + " [0.35182999, 0.33940397, 0.98611111],\n", + " [0.29279811, 0.28311258, 0.95833333],\n", + " [0.23494687, 0.22587512, 1. ],\n", + " [0.17473436, 0.17005676, 0.94444444],\n", + " [0.11924439, 0.11352886, 0.97222222],\n", + " [0.06493506, 0.05558184, 0.98611111],\n", + " [0. , 0. , 0.95833333]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12454723, 0.13357401, 0.95833333],\n", + " [0.24825857, 0.26534296, 1. ],\n", + " [0.37419894, 0.39169675, 0.95833333],\n", + " [0.49846754, 0.50541516, 0.98611111],\n", + " [0.62385065, 0.62815884, 0.95833333],\n", + " [0.74533296, 0.74729242, 0.95833333],\n", + " [0.87461688, 0.8700361 , 0.97222222],\n", + " [1. , 1. , 0.98611111]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90951743, 0.0944217 , 0.75308642],\n", + " [0.80093834, 0.20061412, 0.86419753],\n", + " [0.69369973, 0.30962129, 0.86419753],\n", + " [0.5730563 , 0.43091095, 0.98765432],\n", + " [0.44705094, 0.55552712, 0.98765432],\n", + " [0.3424933 , 0.66248721, 0.86419753],\n", + " [0.23324397, 0.76970317, 0.85185185],\n", + " [0.10656836, 0.89406346, 1. ],\n", + " [0. , 1. , 0.85185185]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91245791, 0.91351975, 0.86419753],\n", + " [0.82210999, 0.8279043 , 0.86419753],\n", + " [0.71997755, 0.73018161, 0.98765432],\n", + " [0.62121212, 0.63072932, 1. ],\n", + " [0.53535354, 0.5448256 , 0.85185185],\n", + " [0.44893378, 0.45863361, 0.86419753],\n", + " [0.36251403, 0.37071202, 0.88888889],\n", + " [0.27833895, 0.2848083 , 0.83950617],\n", + " [0.17845118, 0.18449121, 1. ],\n", + " [0.09652076, 0.10031709, 0.85185185],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10586881, 0.1083973 , 0.875 ],\n", + " [0.21403913, 0.21842289, 0.875 ],\n", + " [0.32336018, 0.32914631, 0.875 ],\n", + " [0.42347526, 0.44010235, 0.8875 ],\n", + " [0.52819333, 0.54826704, 0.875 ],\n", + " [0.63981588, 0.65875785, 0.875 ],\n", + " [0.74798619, 0.76506164, 0.8625 ],\n", + " [0.88607595, 0.89137009, 1. ],\n", + " [1. , 1. , 0.8875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1221253 , 0.12259307, 0.85714286],\n", + " [0.24504362, 0.24518614, 0.85714286],\n", + " [0.36743325, 0.3677792 , 0.85714286],\n", + " [0.49193762, 0.49229782, 0.85714286],\n", + " [0.63283109, 0.6322208 , 1. ],\n", + " [0.74544013, 0.74518614, 0.79220779],\n", + " [0.86915147, 0.86842105, 0.85714286],\n", + " [1. , 1. , 0.93506494]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14693878, 0.14700544, 1. ],\n", + " [0.28954082, 0.28675136, 1. ],\n", + " [0.43647959, 0.43557169, 1. ],\n", + " [0.57908163, 0.57713249, 0.98484848],\n", + " [0.71045918, 0.70961887, 0.92424242],\n", + " [0.85739796, 0.8584392 , 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0.47216036, 0.93603936, 0. ],\n", + " [0.43838159, 0.92841328, 0.00827423],\n", + " [0.37936154, 0.91783518, 0.01536643],\n", + " ...,\n", + " [0.91833705, 0.08314883, 0.00839243],\n", + " [0.96139569, 0.0403444 , 0.00827423],\n", + " [1. , 0. , 0.00815603]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.05869242, 0.91642229, 0.38888889],\n", + " [0.1077266 , 0.83108504, 0.38333333],\n", + " [0.14895988, 0.75806452, 0.33888889],\n", + " [0.22548291, 0.64252199, 0.55555556],\n", + " [0.28194651, 0.56392962, 0.38888889],\n", + " [0.45245171, 0.41524927, 0.89444444],\n", + " [0.65527489, 0.26099707, 1. ],\n", + " [0.74368499, 0.1914956 , 0.43888889],\n", + " [0.85995542, 0.10322581, 0.55555556],\n", + " [1. , 0. , 0.66111111]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1115 , 0.11496503, 0.57024793],\n", + " [0.2355 , 0.24307692, 0.65289256],\n", + " [0.379 , 0.39048951, 0.75206612],\n", + " [0.5085 , 0.51692308, 0.66115702],\n", + " [0.708 , 0.71076923, 1. ],\n", + " [0.8385 , 0.83972028, 0.65289256],\n", + " [1. , 1. , 0.83471074]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91496689, 0.91418564, 0.75308642],\n", + " [0.81536424, 0.82311734, 0.85185185],\n", + " [0.70993377, 0.72504378, 0.88888889],\n", + " [0.61033113, 0.62171629, 0.83950617],\n", + " [0.50728477, 0.52014011, 0.87654321],\n", + " [0.42119205, 0.43082312, 0.75308642],\n", + " [0.3181457 , 0.32574431, 0.85185185],\n", + " [0.21907285, 0.22942207, 0.85185185],\n", + " [0.11629139, 0.11908932, 0.86419753],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90172504, 0.9018598 , 0.46308725],\n", + " [0.79822269, 0.79914163, 0.47651007],\n", + " [0.67067433, 0.67267525, 0.59731544],\n", + " [0.56926294, 0.57052933, 0.46979866],\n", + " [0.46785154, 0.46924177, 0.47651007],\n", + " [0.32618923, 0.32732475, 0.66442953],\n", + " [0.21066388, 0.21144492, 0.54362416],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89955993, 0.89710145, 0.87654321],\n", + " [0.80326171, 0.8 , 0.85185185],\n", + " [0.70256278, 0.69130435, 0.87654321],\n", + " [0.59047373, 0.5826087 , 0.97530864],\n", + " [0.47657261, 0.45797101, 1. ],\n", + " [0.38234533, 0.34927536, 0.83950617],\n", + " [0.29640176, 0.26956522, 0.75308642],\n", + " [0.19777375, 0.18405797, 0.86419753],\n", + " [0.10018121, 0.09565217, 0.85185185],\n", + " [0. , 0. , 0.87654321]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.06150943, 0.88525547, 0.97183099],\n", + " [0.1245283 , 0.78540146, 0.90140845],\n", + " [0.22264151, 0.70043796, 0.94366197],\n", + " [0.3245283 , 0.61605839, 0.97183099],\n", + " [0.42943396, 0.52992701, 1. ],\n", + " [0.53320755, 0.44525547, 0.98591549],\n", + " [0.63433962, 0.36116788, 0.98591549],\n", + " [0.73509434, 0.2779562 , 0.97183099],\n", + " [0.83320755, 0.19240876, 0.98591549],\n", + " [0.91698113, 0.09781022, 0.98591549],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87544484, 0.08695652, 1. ],\n", + " [0.77142075, 0.18115942, 0.79775281],\n", + " [0.67369286, 0.26811594, 0.7752809 ],\n", + " [0.57897618, 0.41304348, 0.79775281],\n", + " [0.48042705, 0.57971014, 0.7752809 ],\n", + " [0.38215166, 0.67391304, 0.79775281],\n", + " [0.28223378, 0.77536232, 0.76404494],\n", + " [0.1938133 , 0.88405797, 0.69662921],\n", + " [0.09471667, 0.92753623, 0.7752809 ],\n", + " [0. , 1. , 0.7752809 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88658892, 0.11301775, 0.97183099],\n", + " [0.77142857, 0.22426036, 1. ],\n", + " [0.6548105 , 0.34260355, 0.98591549],\n", + " [0.54169096, 0.4556213 , 0.97183099],\n", + " [0.4271137 , 0.57159763, 1. ],\n", + " [0.31078717, 0.68757396, 0.98591549],\n", + " [0.21253644, 0.78698225, 0.85915493],\n", + " [0.09970845, 0.89881657, 0.97183099],\n", + " [0. , 1. , 0.85915493]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90303359, 0.93186004, 0.52980132],\n", + " [0.79469122, 0.85451197, 0.58940397],\n", + " [0.72345612, 0.80294659, 0.40397351],\n", + " [0.61863489, 0.70165746, 0.58278146],\n", + " [0.468039 , 0.53959484, 0.86754967],\n", + " [0.38407367, 0.44935543, 0.47019868],\n", + " [0.27221018, 0.33517495, 0.65562914],\n", + " [0.10021668, 0.1252302 , 1. ],\n", + " [0. , 0. , 0.58940397]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86805556, 0.8636589 , 0.92424242],\n", + " [0.71924603, 0.71888944, 1. ],\n", + " [0.57142857, 0.57164105, 1. ],\n", + " [0.42509921, 0.42513634, 0.98484848],\n", + " [0.27926587, 0.27838374, 1. ],\n", + " [0.14583333, 0.14476946, 0.92424242],\n", + " [0. , 0. , 0.98484848]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88405797, 0.89355357, 0.83333333],\n", + " [0.7826087 , 0.78435421, 0.84615385],\n", + " [0.69565217, 0.67699014, 0.84615385],\n", + " [0.53623188, 0.55173205, 1. ],\n", + " [0.46376812, 0.4338151 , 0.92307692],\n", + " [0.34782609, 0.3259922 , 0.84615385],\n", + " [0.24637681, 0.21748107, 0.84615385],\n", + " [0.11594203, 0.09795825, 0.92307692],\n", + " [0. , 0. , 0.78205128]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89230769, 0.1337252 , 0.83544304],\n", + " [0.73846154, 0.28385991, 0.91139241],\n", + " [0.62307692, 0.42174871, 0.84810127],\n", + " [0.47692308, 0.55326965, 0.82278481],\n", + " [0.29230769, 0.71589518, 1. ],\n", + " [0.15384615, 0.85378398, 0.83544304],\n", + " [0. , 1. , 0.91139241]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.97680891, 0.11246731, 1. ],\n", + " [0.94526902, 0.224644 , 0.98591549],\n", + " [0.89517625, 0.32984598, 0.97183099],\n", + " [0.83024119, 0.43214182, 0.94366197],\n", + " [0.74721707, 0.52281314, 0.88732394],\n", + " [0.62894249, 0.60650974, 1. ],\n", + " [0.50556586, 0.68904388, 0.98591549],\n", + " [0.37987013, 0.76460331, 0.97183099],\n", + " [0.25046382, 0.84394071, 0.98591549],\n", + " [0.12662338, 0.92153444, 1. ],\n", + " [0. , 1. , 0.97183099]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1083757 , 0.1084507 , 0.85185185],\n", + " [0.22290607, 0.22957746, 0.87654321],\n", + " [0.33128178, 0.34507042, 0.85185185],\n", + " [0.45838908, 0.47605634, 1. ],\n", + " [0.57265186, 0.5943662 , 0.86419753],\n", + " [0.66818303, 0.68028169, 0.75308642],\n", + " [0.78191062, 0.79295775, 0.86419753],\n", + " [0.89055392, 0.8971831 , 0.85185185],\n", + " [1. , 1. , 0.85185185]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10283505, 0.13666229, 0.91044776],\n", + " [0.21340206, 0.28383706, 0.98507463],\n", + " [0.32371134, 0.42444152, 0.97014925],\n", + " [0.43582474, 0.52956636, 0.98507463],\n", + " [0.54845361, 0.62549277, 0.98507463],\n", + " [0.66134021, 0.72010512, 0.98507463],\n", + " [0.7742268 , 0.81603154, 1. ],\n", + " [0.88737113, 0.90801577, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.98653199, 0.92090818, 0.875 ],\n", + " [0.91245791, 0.82659681, 1. ],\n", + " [0.85858586, 0.74575848, 0.8625 ],\n", + " [0.77104377, 0.66167665, 0.8875 ],\n", + " [0.67003367, 0.58008982, 0.875 ],\n", + " [0.58922559, 0.49800399, 0.875 ],\n", + " [0.50505051, 0.41417166, 0.875 ],\n", + " [0.43771044, 0.33033932, 0.875 ],\n", + " [0.35690236, 0.24775449, 0.875 ],\n", + " [0.25589226, 0.16641717, 0.875 ],\n", + " [0.13468013, 0.08333333, 0.875 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08260325, 0.91874694, 0.77777778],\n", + " [0.16739675, 0.83749388, 0.78888889],\n", + " [0.24937422, 0.7670093 , 0.76666667],\n", + " [0.33573217, 0.69309838, 0.78888889],\n", + " [0.42052566, 0.61674009, 0.78888889],\n", + " [0.4965582 , 0.52716593, 0.76666667],\n", + " [0.57478098, 0.43808125, 0.76666667],\n", + " [0.6548811 , 0.35633872, 0.78888889],\n", + " [0.76376721, 0.25648556, 1. ],\n", + " [0.83416771, 0.18502203, 0.67777778],\n", + " [0.9120776 , 0.09789525, 0.75555556],\n", + " [1. , 0. , 0.88888889]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86585026, 0.86891386, 1. ],\n", + " [0.76342889, 0.77153558, 0.75824176],\n", + " [0.65738937, 0.69662921, 0.76923077],\n", + " [0.55246312, 0.6329588 , 0.78021978],\n", + " [0.43417757, 0.53558052, 0.85714286],\n", + " [0.32925132, 0.45318352, 0.78021978],\n", + " [0.22182021, 0.32209738, 0.78021978],\n", + " [0.11828556, 0.19101124, 0.76923077],\n", + " [0. , 0. , 0.86813187]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12321181, 0.12563896, 1. ],\n", + " [0.24596216, 0.25127791, 1. ],\n", + " [0.36917397, 0.37664783, 1. ],\n", + " [0.49238579, 0.50686037, 1. ],\n", + " [0.61513613, 0.63223029, 1. ],\n", + " [0.730503 , 0.76674738, 1. ],\n", + " [0.86894324, 0.88781275, 1. ],\n", + " [1. , 1. , 0.93939394]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12094595, 0.88481968, 0.64285714],\n", + " [0.22972973, 0.78221974, 0.57142857],\n", + " [0.33108108, 0.68157674, 0.57857143],\n", + " [0.47432432, 0.53816047, 0.79285714],\n", + " [0.56216216, 0.44786134, 0.49285714],\n", + " [0.73783784, 0.26977914, 1. ],\n", + " [0.87162162, 0.13055633, 0.77857143],\n", + " [1. , 0. , 0.71428571]]),\n", + " array([[1. , 0. , 0. ],\n", + " [1. , 0.10674656, 0.97183099],\n", + " [0.93023256, 0.21393697, 0.98591549],\n", + " [0.8372093 , 0.32490013, 0.98591549],\n", + " [0.62790698, 0.43919219, 1. ],\n", + " [0.48837209, 0.55614736, 0.98591549],\n", + " [0.34883721, 0.65823347, 0.85915493],\n", + " [0.20930233, 0.77030626, 0.92957746],\n", + " [0.11627907, 0.88459831, 0.94366197],\n", + " [0. , 1. , 0.92957746]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14445008, 0.1446198 , 0.92307692],\n", + " [0.30207805, 0.3010043 , 1. ],\n", + " [0.43385707, 0.43328551, 0.84615385],\n", + " [0.56715661, 0.56700143, 0.85897436],\n", + " [0.69944247, 0.69928264, 0.83333333],\n", + " [0.85352255, 0.85337159, 0.98717949],\n", + " [1. , 1. , 0.94871795]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91051396, 0.94007989, 0.78021978],\n", + " [0.82337595, 0.88015979, 0.76923077],\n", + " [0.7338899 , 0.82023968, 0.76923077],\n", + " [0.65823115, 0.76830892, 0.67032967],\n", + " [0.57031046, 0.70838881, 0.76923077],\n", + " [0.48291156, 0.64980027, 0.75824176],\n", + " [0.36916254, 0.57256991, 0.97802198],\n", + " [0.2794156 , 0.50732357, 0.78021978],\n", + " [0.19462562, 0.38348868, 0.76923077],\n", + " [0.11035742, 0.21571238, 0.76923077],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.82985822, 0.83132239, 0.98507463],\n", + " [0.66638866, 0.66795367, 0.98507463],\n", + " [0.50125104, 0.50168919, 0.98507463],\n", + " [0.33110926, 0.33301158, 0.98507463],\n", + " [0.16513761, 0.16650579, 1. ],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8590604 , 0.14042722, 0.89041096],\n", + " [0.70469799, 0.29351266, 1. ],\n", + " [0.56073826, 0.43314873, 0.90410959],\n", + " [0.41979866, 0.57278481, 0.90410959],\n", + " [0.28120805, 0.7147943 , 0.89041096],\n", + " [0.14295302, 0.85719937, 0.91780822],\n", + " [0. , 1. , 0.90410959]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87358684, 0.87167449, 1. ],\n", + " [0.75976362, 0.75117371, 0.88607595],\n", + " [0.65236382, 0.64788732, 0.89873418],\n", + " [0.53751285, 0.53208138, 0.87341772],\n", + " [0.43011305, 0.43035994, 0.89873418],\n", + " [0.31577595, 0.31924883, 0.87341772],\n", + " [0.20863309, 0.21126761, 0.88607595],\n", + " [0.11408016, 0.12050078, 0.7721519 ],\n", + " [0. , 0. , 0.87341772]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15552632, 0.17119565, 1. ],\n", + " [0.29421053, 0.32608696, 0.91666667],\n", + " [0.43763158, 0.47282609, 0.93055556],\n", + " [0.57631579, 0.61141304, 0.90277778],\n", + " [0.72131579, 0.74728261, 0.93055556],\n", + " [0.85947368, 0.8763587 , 0.90277778],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11142857, 0.88778878, 0.98484848],\n", + " [0.22415584, 0.77887789, 1. ],\n", + " [0.33662338, 0.669967 , 1. ],\n", + " [0.43974026, 0.56765677, 0.92424242],\n", + " [0.55090909, 0.45874587, 0.98484848],\n", + " [0.66337662, 0.34323432, 1. ],\n", + " [0.77558442, 0.2310231 , 1. ],\n", + " [0.88727273, 0.11551155, 1. ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90076531, 0.90322581, 0.98591549],\n", + " [0.8 , 0.79626486, 0.98591549],\n", + " [0.70153061, 0.70288625, 0.97183099],\n", + " [0.60382653, 0.60950764, 0.98591549],\n", + " [0.50204082, 0.51103565, 1. ],\n", + " [0.40382653, 0.41086587, 0.97183099],\n", + " [0.30408163, 0.30560272, 0.98591549],\n", + " [0.20153061, 0.20373514, 1. ],\n", + " [0.10127551, 0.10016978, 0.98591549],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92789374, 0.93026992, 0.7721519 ],\n", + " [0.84364326, 0.84768638, 0.88607595],\n", + " [0.76091082, 0.76542416, 0.87341772],\n", + " [0.67741935, 0.68059126, 0.88607595],\n", + " [0.59089184, 0.59511568, 0.89873418],\n", + " [0.5085389 , 0.51253213, 0.86075949],\n", + " [0.43529412, 0.43798201, 0.7721519 ],\n", + " [0.34990512, 0.35250643, 0.89873418],\n", + " [0.25351044, 0.25642674, 1. ],\n", + " [0.16774194, 0.17030848, 0.89873418],\n", + " [0.08614801, 0.0874036 , 0.86075949],\n", + " [0. , 0. , 0.89873418]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.85332859, 0.1473448 , 1. ],\n", + " [0.70665717, 0.2946896 , 0.98484848],\n", + " [0.57351371, 0.42819746, 0.92424242],\n", + " [0.42684229, 0.57442034, 1. ],\n", + " [0.28017088, 0.72026926, 1. ],\n", + " [0.13314347, 0.86649215, 0.98484848],\n", + " [0. , 1. , 0.92424242]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.07962058, 0.09466667, 0.98591549],\n", + " [0.16096579, 0.19555556, 1. ],\n", + " [0.24144869, 0.29777778, 0.98591549],\n", + " [0.32250647, 0.40044444, 0.97183099],\n", + " [0.40385168, 0.49022222, 0.97183099],\n", + " [0.48433458, 0.56222222, 1. ],\n", + " [0.56050589, 0.63244444, 0.98591549],\n", + " [0.63380282, 0.69911111, 0.98591549],\n", + " [0.70767462, 0.768 , 1. ],\n", + " [0.77809715, 0.83244444, 0.97183099],\n", + " [0.85139408, 0.89155556, 0.98591549],\n", + " [0.92555332, 0.94711111, 0.98591549],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[0. , 0.00231303, 0. ],\n", + " [0.07305936, 0. , 0.97222222],\n", + " [0.15410959, 0.0077101 , 0.98611111],\n", + " [0.22745434, 0.01464919, 0.97222222],\n", + " [0.29252283, 0.01927525, 0.97222222],\n", + " [0.3678653 , 0.02235929, 0.95833333],\n", + " [0.44006849, 0.0308404 , 1. ],\n", + " [0.5119863 , 0.06630686, 0.90277778],\n", + " [0.56934932, 0.13261372, 0.84722222],\n", + " [0.62842466, 0.24441018, 0.875 ],\n", + " [0.69006849, 0.3770239 , 0.98611111],\n", + " [0.73858447, 0.51888975, 0.86111111],\n", + " [0.78510274, 0.68080185, 0.91666667],\n", + " [0.8533105 , 0.84425598, 1. ],\n", + " [0.92579909, 0.95065536, 0.86111111],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12960123, 0.14681892, 1. ],\n", + " [0.24335378, 0.24959217, 0.875 ],\n", + " [0.35787321, 0.36052202, 0.875 ],\n", + " [0.45373211, 0.45350734, 0.7625 ],\n", + " [0.56825153, 0.57096248, 0.875 ],\n", + " [0.68123722, 0.69004894, 0.875 ],\n", + " [0.79064417, 0.79282219, 0.8625 ],\n", + " [0.90490798, 0.91353997, 0.875 ],\n", + " [1. , 1. , 0.7625 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14937193, 0.14018692, 0.94444444],\n", + " [0.27580557, 0.27102804, 0.73333333],\n", + " [0.44756963, 0.43925234, 1. ],\n", + " [0.6116876 , 0.56074766, 1. ],\n", + " [0.74604042, 0.74766355, 0.8 ],\n", + " [0.8806663 , 0.87850467, 0.8 ],\n", + " [1. , 1. , 0.73333333]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12217659, 0.12384717, 0.875 ],\n", + " [0.24435318, 0.2455863 , 0.8625 ],\n", + " [0.36704312, 0.36758893, 0.875 ],\n", + " [0.49332649, 0.49459816, 0.9 ],\n", + " [0.61344969, 0.61528327, 0.8625 ],\n", + " [0.73973306, 0.73860343, 0.8875 ],\n", + " [0.85985626, 0.86166008, 0.8625 ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09632446, 0.09997369, 0.85915493],\n", + " [0.21863118, 0.21652197, 0.97183099],\n", + " [0.33586819, 0.33017627, 0.97183099],\n", + " [0.44803549, 0.44330439, 1. ],\n", + " [0.57034221, 0.56116811, 0.97183099],\n", + " [0.68948035, 0.67640095, 0.98591549],\n", + " [0.78453739, 0.77821626, 0.85915493],\n", + " [0.89797212, 0.89871087, 0.98591549],\n", + " [1. , 1. , 0.85915493]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13713245, 0.13663968, 0.80487805],\n", + " [0.26021337, 0.26012146, 0.74390244],\n", + " [0.43091335, 0.43421053, 1. ],\n", + " [0.56700494, 0.56680162, 0.81707317],\n", + " [0.70335675, 0.70647773, 0.80487805],\n", + " [0.85089774, 0.85222672, 0.87804878],\n", + " [1. , 1. , 0.87804878]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.12345679, 0.88327695, 1. ],\n", + " [0.24074074, 0.76848719, 1. ],\n", + " [0.35802469, 0.65418076, 0.97183099],\n", + " [0.47283951, 0.54253262, 0.97183099],\n", + " [0.58765432, 0.42895118, 1. ],\n", + " [0.70123457, 0.31778637, 1. ],\n", + " [0.8037037 , 0.20976317, 0.95774648],\n", + " [0.91358025, 0.09497342, 1. ],\n", + " [1. , 0. , 0.85915493]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15040757, 0.14968153, 0.98809524],\n", + " [0.25532474, 0.24522293, 0.72619048],\n", + " [0.37233763, 0.36305732, 0.77380952],\n", + " [0.49092821, 0.49681529, 0.78571429],\n", + " [0.60662635, 0.62420382, 0.78571429],\n", + " [0.75414147, 0.7866242 , 1. ],\n", + " [0.88193531, 0.88535032, 0.85714286],\n", + " [1. , 1. , 0.78571429]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89034296, 0.88786394, 0.98591549],\n", + " [0.78113718, 0.77832228, 0.97183099],\n", + " [0.6683213 , 0.66589795, 1. ],\n", + " [0.558213 , 0.55664457, 0.97183099],\n", + " [0.4467509 , 0.44566157, 0.98591549],\n", + " [0.33483755, 0.33467858, 0.98591549],\n", + " [0.22337545, 0.22340732, 0.98591549],\n", + " [0.1101083 , 0.11011819, 1. ],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88871424, 0.88682834, 0.85185185],\n", + " [0.75699466, 0.75558726, 1. ],\n", + " [0.65985539, 0.65763195, 0.75308642],\n", + " [0.5460547 , 0.54541132, 0.86419753],\n", + " [0.43634077, 0.4341417 , 0.83950617],\n", + " [0.33731531, 0.33666191, 0.75308642],\n", + " [0.22571518, 0.22491679, 0.85185185],\n", + " [0.11191449, 0.10699001, 0.87654321],\n", + " [0. , 0. , 0.85185185]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11518047, 0.11066127, 0.98507463],\n", + " [0.235138 , 0.22591093, 0.97014925],\n", + " [0.33970276, 0.32901484, 0.91044776],\n", + " [0.4485138 , 0.44102564, 0.97014925],\n", + " [0.54936306, 0.54278003, 0.91044776],\n", + " [0.66082803, 0.65668016, 0.97014925],\n", + " [0.77707006, 0.77165992, 1. ],\n", + " [0.88375796, 0.88178138, 0.97014925],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 0.23076923, 0. ],\n", + " [0.8891455 , 0.38461538, 0.90410959],\n", + " [0.78008725, 0. , 0.90410959],\n", + " [0.66127791, 0.38461538, 1. ],\n", + " [0.54400821, 0.30769231, 0.95890411],\n", + " [0.44341801, 0.53846154, 0.83561644],\n", + " [0.32768797, 0.76923077, 0.97260274],\n", + " [0.21041827, 1. , 0.95890411],\n", + " [0.09828073, 1. , 0.93150685],\n", + " [0. , 0.61538462, 0.83561644]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91106719, 0.91081081, 0.59322034],\n", + " [0.81884058, 0.81837838, 0.60169492],\n", + " [0.66996047, 0.66648649, 1. ],\n", + " [0.58102767, 0.57675676, 0.60169492],\n", + " [0.48945982, 0.48702703, 0.59322034],\n", + " [0.39986825, 0.39702703, 0.59322034],\n", + " [0.2826087 , 0.28027027, 0.76271186],\n", + " [0.17061924, 0.16810811, 0.76271186],\n", + " [0.09156785, 0.08918919, 0.51694915],\n", + " [0. , 0. , 0.59322034]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8443038 , 0.84266263, 1. ],\n", + " [0.72658228, 0.72339889, 0.75824176],\n", + " [0.60632911, 0.60085729, 0.76923077],\n", + " [0.49113924, 0.48159355, 0.76923077],\n", + " [0.36455696, 0.35955623, 0.76923077],\n", + " [0.24303797, 0.23877963, 0.78021978],\n", + " [0.11898734, 0.11649017, 0.76923077],\n", + " [0. , 0. , 0.74725275]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90253807, 0.90490798, 0.875 ],\n", + " [0.79314721, 0.79754601, 1. ],\n", + " [0.69314721, 0.69018405, 0.8875 ],\n", + " [0.59746193, 0.59509202, 0.875 ],\n", + " [0.50152284, 0.50613497, 0.8625 ],\n", + " [0.40329949, 0.41717791, 0.875 ],\n", + " [0.30583756, 0.30981595, 0.875 ],\n", + " [0.20685279, 0.21472393, 0.8875 ],\n", + " [0.0964467 , 0.10122699, 1. ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87976438, 0.12968406, 0.85897436],\n", + " [0.75848926, 0.25679647, 0.84615385],\n", + " [0.61088011, 0.40080823, 1. ],\n", + " [0.48267498, 0.52204262, 0.84615385],\n", + " [0.35862786, 0.63997061, 0.83333333],\n", + " [0.24532225, 0.75202057, 0.78205128],\n", + " [0.12300762, 0.87692873, 0.84615385],\n", + " [0. , 1. , 0.84615385]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88482759, 0.91802431, 0.8625 ],\n", + " [0.75862069, 0.83191104, 0.8875 ],\n", + " [0.64344828, 0.74579778, 0.8625 ],\n", + " [0.51724138, 0.66382208, 0.9 ],\n", + " [0.39034483, 0.57770882, 0.8625 ],\n", + " [0.31034483, 0.48719938, 0.8625 ],\n", + " [0.24137931, 0.39229377, 0.875 ],\n", + " [0.19517241, 0.3061805 , 0.7625 ],\n", + " [0.11448276, 0.1939488 , 1. ],\n", + " [0.05724138, 0.09490561, 0.875 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.14266193, 0.84558824, 0.98507463],\n", + " [0.28368407, 0.69852941, 0.97014925],\n", + " [0.42661929, 0.55147059, 0.98507463],\n", + " [0.56982782, 0.40441176, 0.98507463],\n", + " [0.71522274, 0.27205882, 1. ],\n", + " [0.85679147, 0.14705882, 0.97014925],\n", + " [1. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12199264, 0.13542795, 0.93055556],\n", + " [0.25870365, 0.28494041, 1. ],\n", + " [0.38126238, 0.40520043, 0.91666667],\n", + " [0.50325502, 0.54279523, 0.91666667],\n", + " [0.62666289, 0.66413868, 0.91666667],\n", + " [0.75035381, 0.77789816, 0.90277778],\n", + " [0.87630909, 0.89057421, 0.91666667],\n", + " [1. , 1. , 0.93055556]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11979167, 0.12317185, 0.84722222],\n", + " [0.26432292, 0.26942413, 1. ],\n", + " [0.40755208, 0.41521938, 1. ],\n", + " [0.55338542, 0.56147166, 1. ],\n", + " [0.70833333, 0.70795247, 1. ],\n", + " [0.85677083, 0.85397623, 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.128 , 0.12765535, 0.93939394],\n", + " [0.248 , 0.24538416, 0.95454545],\n", + " [0.37733333, 0.37562041, 0.95454545],\n", + " [0.508 , 0.5054596 , 0.98484848],\n", + " [0.62533333, 0.62358547, 0.98484848],\n", + " [0.76533333, 0.76493945, 1. ],\n", + " [0.88266667, 0.88246972, 0.92424242],\n", + " [1. , 1. , 0.93939394]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12121212, 0.12217997, 0.85185185],\n", + " [0.25 , 0.24435995, 0.87654321],\n", + " [0.36363636, 0.36704689, 0.85185185],\n", + " [0.47727273, 0.48948035, 0.86419753],\n", + " [0.63257576, 0.63092522, 1. ],\n", + " [0.75757576, 0.75234474, 0.85185185],\n", + " [0.89772727, 0.87528517, 0.87654321],\n", + " [1. , 1. , 0.85185185]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91048593, 0.91094771, 0.85185185],\n", + " [0.82193095, 0.82148693, 0.86419753],\n", + " [0.73209719, 0.72916667, 0.86419753],\n", + " [0.64386189, 0.63643791, 0.86419753],\n", + " [0.53868286, 0.53308824, 1. ],\n", + " [0.43734015, 0.43341503, 0.97530864],\n", + " [0.35709719, 0.35498366, 0.75308642],\n", + " [0.26822251, 0.26674837, 0.85185185],\n", + " [0.17838875, 0.17769608, 0.86419753],\n", + " [0.08887468, 0.08905229, 0.86419753],\n", + " [0. , 0. , 0.85185185]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1048951 , 0.10485592, 0.76923077],\n", + " [0.21888112, 0.21931697, 0.76923077],\n", + " [0.32377622, 0.31803629, 0.76923077],\n", + " [0.43006993, 0.42209178, 0.75824176],\n", + " [0.56993007, 0.55843116, 1. ],\n", + " [0.67692308, 0.66488794, 0.75824176],\n", + " [0.7958042 , 0.78842049, 0.87912088],\n", + " [0.8972028 , 0.89300961, 0.76923077],\n", + " [1. , 1. , 0.78021978]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1403277 , 0.05051302, 1. ],\n", + " [0.27325581, 0.09944751, 0.93055556],\n", + " [0.40142706, 0.1878453 , 0.91666667],\n", + " [0.51902748, 0.33307024, 0.90277778],\n", + " [0.63874207, 0.50907656, 0.91666667],\n", + " [0.75554968, 0.68271507, 0.91666667],\n", + " [0.87896406, 0.85872139, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89375349, 0.90441176, 0.71 ],\n", + " [0.78945901, 0.81617647, 0.7 ],\n", + " [0.68516453, 0.73529412, 0.7 ],\n", + " [0.56525376, 0.6372549 , 0.8 ],\n", + " [0.4601227 , 0.54411765, 0.69 ],\n", + " [0.37116564, 0.47058824, 0.61 ],\n", + " [0.2665923 , 0.36764706, 0.7 ],\n", + " [0.11795873, 0.20098039, 1. ],\n", + " [0. , 0. , 0.8 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91709013, 0.91745283, 0.875 ],\n", + " [0.8422038 , 0.84080189, 0.7625 ],\n", + " [0.75956138, 0.76179245, 0.85 ],\n", + " [0.67424445, 0.67688679, 0.9 ],\n", + " [0.57796202, 0.57665094, 1. ],\n", + " [0.49505215, 0.49174528, 0.8625 ],\n", + " [0.40946777, 0.40566038, 0.8875 ],\n", + " [0.3254881 , 0.32193396, 0.875 ],\n", + " [0.24097352, 0.23938679, 0.875 ],\n", + " [0.15645895, 0.15683962, 0.875 ],\n", + " [0.07461888, 0.07783019, 0.85 ],\n", + " [0. , 0. , 0.775 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8816568 , 0.87946778, 0.92957746],\n", + " [0.75443787, 0.75032612, 0.94366197],\n", + " [0.6183432 , 0.61466214, 1. ],\n", + " [0.49753452, 0.4949126 , 0.92957746],\n", + " [0.36932939, 0.36785807, 0.94366197],\n", + " [0.24408284, 0.24445604, 0.91549296],\n", + " [0.12475345, 0.12418471, 0.92957746],\n", + " [0. , 0. , 0.92957746]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92156863, 0.16892809, 1. ],\n", + " [0.84313725, 0.33808232, 1. ],\n", + " [0.74509804, 0.45251018, 0.66666667],\n", + " [0.58823529, 0.52849389, 0.44444444],\n", + " [0.37254902, 0.63432836, 0.61666667],\n", + " [0.21568627, 0.70081411, 0.38888889],\n", + " [0. , 0.7663953 , 0.38333333],\n", + " [0. , 0.83333333, 0.39444444],\n", + " [0.01960784, 0.89891452, 0.38888889],\n", + " [0.11764706, 1. , 0.60555556]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14471058, 0.13897281, 0.98507463],\n", + " [0.28767465, 0.27492447, 1. ],\n", + " [0.43038922, 0.41540785, 0.97014925],\n", + " [0.57285429, 0.55891239, 1. ],\n", + " [0.71806387, 0.70996979, 0.98507463],\n", + " [0.85778443, 0.85196375, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90751445, 0.10955056, 0.97183099],\n", + " [0.8150289 , 0.2207397 , 0.98591549],\n", + " [0.68786127, 0.33333333, 1. ],\n", + " [0.56647399, 0.44452247, 0.98591549],\n", + " [0.44508671, 0.55430712, 0.97183099],\n", + " [0.31791908, 0.66736891, 0.98591549],\n", + " [0.21387283, 0.77691948, 0.98591549],\n", + " [0.11560694, 0.89115169, 1. ],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1369181 , 0.15015015, 0.84615385],\n", + " [0.26985312, 0.3003003 , 0.84615385],\n", + " [0.43166542, 0.45045045, 1. ],\n", + " [0.56858352, 0.6006006 , 0.83333333],\n", + " [0.7137167 , 0.75075075, 0.93589744],\n", + " [0.85486682, 0.9009009 , 0.84615385],\n", + " [1. , 1. , 0.92307692]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89968107, 0.89993667, 0.98591549],\n", + " [0.79820238, 0.79924003, 0.97183099],\n", + " [0.69585387, 0.69917669, 0.98591549],\n", + " [0.59582488, 0.59848005, 1. ],\n", + " [0.49695564, 0.49588347, 0.98591549],\n", + " [0.39576689, 0.3939202 , 0.98591549],\n", + " [0.29660771, 0.2951235 , 0.98591549],\n", + " [0.19831835, 0.19506016, 0.98591549],\n", + " [0.09944912, 0.09943002, 0.97183099],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0.53657363, 0. , 0. ],\n", + " [0.45572666, 0.05637084, 0.98611111],\n", + " [0.37776708, 0.10784999, 0.95833333],\n", + " [0.29740135, 0.15676683, 0.95833333],\n", + " [0.21270452, 0.20847892, 0.98611111],\n", + " [0.13089509, 0.26484976, 0.98611111],\n", + " [0.06641001, 0.32611228, 0.94444444],\n", + " [0.01828681, 0.39715816, 1. ],\n", + " [0. , 0.46866993, 0.94444444],\n", + " [0.00721848, 0.53692057, 0.88888889],\n", + " [0.05149182, 0.59795015, 0.93055556],\n", + " [0.13233879, 0.65571861, 0.97222222],\n", + " [0.219923 , 0.70696483, 0.95833333],\n", + " [0.31905679, 0.76054041, 0.98611111],\n", + " [0.4307026 , 0.79711158, 0.97222222],\n", + " [0.55582291, 0.83205218, 0.95833333],\n", + " [0.66313763, 0.86186816, 0.84722222],\n", + " [0.7892204 , 0.89634288, 0.97222222],\n", + " [0.91578441, 0.94036804, 0.97222222],\n", + " [1. , 1. , 0.97222222]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.07363292, 0.07086614, 0.63636364],\n", + " [0.13806172, 0.12598425, 0.55454545],\n", + " [0.23362209, 0.22834646, 0.81818182],\n", + " [0.30806714, 0.30708661, 0.62727273],\n", + " [0.39956687, 0.3976378 , 0.73636364],\n", + " [0.47888468, 0.46456693, 0.63636364],\n", + " [0.55711965, 0.53543307, 0.63636364],\n", + " [0.63535463, 0.62204724, 0.62727273],\n", + " [0.71250677, 0.7007874 , 0.63636364],\n", + " [0.792366 , 0.77559055, 0.64545455],\n", + " [0.87384949, 0.86220472, 0.63636364],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14366425, 0.11971831, 0.98507463],\n", + " [0.28786656, 0.20774648, 0.97014925],\n", + " [0.43502825, 0.41197183, 0.98507463],\n", + " [0.56497175, 0.52816901, 0.91044776],\n", + " [0.71078827, 0.58802817, 0.97014925],\n", + " [0.85660479, 0.76408451, 1. ],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87973274, 0.11837121, 0.78571429],\n", + " [0.76020787, 0.23555871, 0.78571429],\n", + " [0.63845583, 0.35440341, 0.78571429],\n", + " [0.52115813, 0.47277462, 0.78571429],\n", + " [0.4060876 , 0.5875947 , 0.77380952],\n", + " [0.28582034, 0.70880682, 0.79761905],\n", + " [0.13363029, 0.86221591, 1. ],\n", + " [0. , 1. , 0.92857143]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09309309, 0.91705375, 1. ],\n", + " [0.22222222, 0.83985844, 0.97183099],\n", + " [0.3963964 , 0.76177837, 0.98591549],\n", + " [0.57957958, 0.66423358, 0.98591549],\n", + " [0.78378378, 0.56093785, 0.98591549],\n", + " [0.99399399, 0.45697854, 0.87323944],\n", + " [1. , 0.34815306, 0.94366197],\n", + " [0.98798799, 0.22915284, 0.91549296],\n", + " [0.94594595, 0.11391285, 0.92957746],\n", + " [0.89189189, 0. , 0.92957746]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11283243, 0.11195929, 1. ],\n", + " [0.22334108, 0.21967769, 0.98507463],\n", + " [0.33643171, 0.34266327, 0.98507463],\n", + " [0.44719855, 0.45801527, 0.98507463],\n", + " [0.5582236 , 0.57336726, 0.97014925],\n", + " [0.67105603, 0.68023749, 0.98507463],\n", + " [0.77485154, 0.7769296 , 0.91044776],\n", + " [0.88794216, 0.89143342, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8588 , 0.85936528, 0.98507463],\n", + " [0.716 , 0.71717486, 0.97014925],\n", + " [0.5692 , 0.56938395, 1. ],\n", + " [0.4264 , 0.42812694, 0.98507463],\n", + " [0.2852 , 0.28593653, 0.98507463],\n", + " [0.1412 , 0.14187928, 0.98507463],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.17321207, 0.16753472, 1. ],\n", + " [0.30963208, 0.29918981, 0.79761905],\n", + " [0.44481191, 0.43084491, 0.78571429],\n", + " [0.57833816, 0.5630787 , 0.77380952],\n", + " [0.70855726, 0.69328704, 0.78571429],\n", + " [0.86233981, 0.85445602, 0.94047619],\n", + " [1. , 1. , 0.8452381 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11007155, 0.11143852, 0.97183099],\n", + " [0.22949917, 0.22314492, 0.98591549],\n", + " [0.33957072, 0.33485133, 0.98591549],\n", + " [0.44964227, 0.44628985, 1. ],\n", + " [0.5690699 , 0.56255023, 0.98591549],\n", + " [0.67914144, 0.66514867, 0.97183099],\n", + " [0.78921299, 0.78114117, 0.98591549],\n", + " [0.88992845, 0.89284758, 1. ],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.0990688 , 0.09188361, 0.89873418],\n", + " [0.19736161, 0.1914242 , 0.86075949],\n", + " [0.30212106, 0.30168453, 0.89873418],\n", + " [0.40041386, 0.40122511, 0.87341772],\n", + " [0.48887739, 0.48545176, 0.7721519 ],\n", + " [0.59363683, 0.58958652, 0.88607595],\n", + " [0.69839628, 0.69678407, 0.89873418],\n", + " [0.79694775, 0.79173047, 0.88607595],\n", + " [0.91257113, 0.90658499, 1. ],\n", + " [1. , 1. , 0.7721519 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11339148, 0.11436797, 0.8019802 ],\n", + " [0.21292971, 0.21198639, 0.69306931],\n", + " [0.35454079, 0.35383407, 0.98019802],\n", + " [0.45356593, 0.45406962, 0.7029703 ],\n", + " [0.55053874, 0.55064119, 0.69306931],\n", + " [0.66495639, 0.66448574, 0.79207921],\n", + " [0.75987686, 0.76158074, 0.69306931],\n", + " [0.85787583, 0.85919916, 0.68316832],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90162272, 0.90258046, 0.45333333],\n", + " [0.78803245, 0.7895042 , 0.54 ],\n", + " [0.68813387, 0.68947521, 0.46666667],\n", + " [0.59178499, 0.59176573, 0.46666667],\n", + " [0.46551724, 0.46506234, 0.6 ],\n", + " [0.35294118, 0.35198608, 0.53333333],\n", + " [0.14148073, 0.14120035, 1. ],\n", + " [0. , 0. , 0.67333333]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90349265, 0.89948968, 0.97183099],\n", + " [0.80330882, 0.79653872, 1. ],\n", + " [0.69577206, 0.69425338, 0.98591549],\n", + " [0.59007353, 0.59196805, 0.98591549],\n", + " [0.48897059, 0.48857333, 0.98591549],\n", + " [0.39797794, 0.40004438, 0.85915493],\n", + " [0.29227941, 0.29798092, 0.95774648],\n", + " [0.20588235, 0.20900821, 0.85915493],\n", + " [0.10661765, 0.10561349, 0.98591549],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14817688, 0.14906348, 1. ],\n", + " [0.29712956, 0.29604579, 0.98484848],\n", + " [0.42746315, 0.42715921, 0.92424242],\n", + " [0.57176106, 0.57284079, 0.98484848],\n", + " [0.72226532, 0.72294485, 1. ],\n", + " [0.8541505 , 0.85379813, 0.92424242],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12048193, 0.10714286, 0.9875 ],\n", + " [0.23274918, 0.22619048, 0.9 ],\n", + " [0.34200438, 0.28571429, 0.85 ],\n", + " [0.44277108, 0.38690476, 0.875 ],\n", + " [0.55284775, 0.47619048, 0.875 ],\n", + " [0.66511501, 0.5952381 , 0.8875 ],\n", + " [0.7694414 , 0.73214286, 0.8625 ],\n", + " [0.89184009, 0.88095238, 1. ],\n", + " [1. , 1. , 0.8875 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89123288, 0.00909091, 0.87654321],\n", + " [0.78356164, 0.01818182, 0.87654321],\n", + " [0.67479452, 0.07272727, 0.83950617],\n", + " [0.5660274 , 0.14545455, 0.86419753],\n", + " [0.45671233, 0.21818182, 0.87654321],\n", + " [0.35068493, 0.42727273, 0.85185185],\n", + " [0.23753425, 0.69090909, 0.87654321],\n", + " [0.12986301, 0.83636364, 0.85185185],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 0.18950437, 0. ],\n", + " [0.91155914, 0.21574344, 0.87341772],\n", + " [0.80887097, 0.28571429, 1. ],\n", + " [0.7188172 , 0.41690962, 0.89873418],\n", + " [0.62930108, 0.56559767, 0.88607595],\n", + " [0.54032258, 0.70262391, 0.88607595],\n", + " [0.45053763, 0.8483965 , 0.88607595],\n", + " [0.35887097, 0.99708455, 0.88607595],\n", + " [0.26747312, 1. , 0.88607595],\n", + " [0.17526882, 0.76093294, 0.88607595],\n", + " [0.08682796, 0.44897959, 0.88607595],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09948394, 0.09249677, 0.97183099],\n", + " [0.19581422, 0.1843467 , 1. ],\n", + " [0.29071101, 0.27619664, 0.98591549],\n", + " [0.38188073, 0.37063389, 0.98591549],\n", + " [0.47161697, 0.46054334, 1. ],\n", + " [0.56049312, 0.54721863, 0.97183099],\n", + " [0.64506881, 0.63195343, 0.97183099],\n", + " [0.71387615, 0.70181113, 0.85915493],\n", + " [0.79042431, 0.78072445, 0.98591549],\n", + " [0.86295872, 0.85705045, 0.98591549],\n", + " [0.93319954, 0.9301423 , 1. ],\n", + " [1. , 1. , 0.97183099]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88194812, 0.04724409, 0.84615385],\n", + " [0.75092642, 0.12755906, 0.92307692],\n", + " [0.62519852, 0.24173228, 0.91025641],\n", + " [0.4862361 , 0.39527559, 1. ],\n", + " [0.37056644, 0.53307087, 0.85897436],\n", + " [0.24483854, 0.68818898, 0.92307692],\n", + " [0.12784542, 0.83622047, 0.84615385],\n", + " [0. , 1. , 0.92307692]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92597968, 0.92989344, 0.98591549],\n", + " [0.85486212, 0.85530006, 0.98591549],\n", + " [0.78035801, 0.78575435, 0.97183099],\n", + " [0.71843251, 0.72378015, 0.85915493],\n", + " [0.64537978, 0.65143017, 0.97183099],\n", + " [0.57329463, 0.57823892, 0.98591549],\n", + " [0.5002419 , 0.50476725, 1. ],\n", + " [0.42960813, 0.431576 , 0.97183099],\n", + " [0.35558781, 0.3589456 , 0.98591549],\n", + " [0.29027576, 0.29444756, 0.85915493],\n", + " [0.21770682, 0.224341 , 0.98591549],\n", + " [0.14513788, 0.14946719, 0.98591549],\n", + " [0.07305273, 0.07655637, 0.97183099],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85108434, 0.84398605, 0.98630137],\n", + " [0.72289157, 0.71963974, 0.83561644],\n", + " [0.58457831, 0.58018594, 0.89041096],\n", + " [0.43180723, 0.42969204, 1. ],\n", + " [0.29108434, 0.29285299, 0.89041096],\n", + " [0.13542169, 0.14148751, 0.98630137],\n", + " [0. , 0. , 0.90410959]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11051693, 0.89400922, 0.77272727],\n", + " [0.21865716, 0.78639198, 0.80681818],\n", + " [0.31729055, 0.69341285, 0.69318182],\n", + " [0.42602496, 0.58660884, 0.78409091],\n", + " [0.5466429 , 0.46218487, 0.92045455],\n", + " [0.65181224, 0.35429656, 0.78409091],\n", + " [0.76351753, 0.24722147, 0.79545455],\n", + " [0.86809269, 0.13580916, 0.80681818],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14154144, 0.14054054, 0.92957746],\n", + " [0.29714009, 0.29702703, 1. ],\n", + " [0.43625788, 0.43567568, 0.94366197],\n", + " [0.58167717, 0.58162162, 0.94366197],\n", + " [0.7198255 , 0.72081081, 0.91549296],\n", + " [0.85555017, 0.86054054, 0.91549296],\n", + " [1. , 1. , 0.94366197]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13428252, 0.12765957, 1. ],\n", + " [0.25823562, 0.24680851, 0.90277778],\n", + " [0.36795087, 0.36085106, 0.84722222],\n", + " [0.49274149, 0.49191489, 0.91666667],\n", + " [0.61501954, 0.61361702, 0.91666667],\n", + " [0.74008934, 0.73957447, 0.91666667],\n", + " [0.87520938, 0.87234043, 1. ],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11789067, 0.87979798, 0.78888889],\n", + " [0.2515185 , 0.74646465, 0.88888889],\n", + " [0.35229155, 0.64646465, 0.67777778],\n", + " [0.46990613, 0.52929293, 0.77777778],\n", + " [0.60077305, 0.4030303 , 0.86666667],\n", + " [0.72004417, 0.28686869, 0.77777778],\n", + " [0.86996135, 0.13636364, 1. ],\n", + " [1. , 0. , 0.88888889]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12706737, 0.13003941, 1. ],\n", + " [0.25252118, 0.25522886, 0.97014925],\n", + " [0.37716821, 0.37859958, 0.98507463],\n", + " [0.50786608, 0.50106093, 0.98507463],\n", + " [0.63816055, 0.62473477, 0.97014925],\n", + " [0.76401775, 0.75386481, 1. ],\n", + " [0.87615974, 0.87117308, 0.91044776],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9009264 , 0.89835165, 1. ],\n", + " [0.80082347, 0.78296703, 0.98591549],\n", + " [0.69917653, 0.69230769, 0.98591549],\n", + " [0.59933093, 0.5989011 , 0.98591549],\n", + " [0.49948533, 0.48626374, 0.98591549],\n", + " [0.39912506, 0.38461538, 1. ],\n", + " [0.3010808 , 0.2967033 , 0.97183099],\n", + " [0.19943387, 0.18406593, 1. ],\n", + " [0.0998456 , 0.08516484, 0.97183099],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12107734, 0.10344828, 0.89041096],\n", + " [0.25772177, 0.22758621, 1. ],\n", + " [0.38028169, 0.35862069, 0.89041096],\n", + " [0.50605387, 0.46896552, 0.91780822],\n", + " [0.62984927, 0.6137931 , 0.90410959],\n", + " [0.75364468, 0.73103448, 0.90410959],\n", + " [0.87546331, 0.89655172, 0.90410959],\n", + " [1. , 1. , 0.89041096]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89838751, 0.90734824, 0.89873418],\n", + " [0.79959048, 0.79233227, 0.87341772],\n", + " [0.71103148, 0.71565495, 0.7721519 ],\n", + " [0.61453801, 0.61341853, 0.87341772],\n", + " [0.51138981, 0.49840256, 0.89873418],\n", + " [0.41284873, 0.41214058, 0.87341772],\n", + " [0.29971845, 0.29392971, 1. ],\n", + " [0.21141541, 0.2172524 , 0.78481013],\n", + " [0.10033274, 0.10223642, 1. ],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.16264547, 0.8392385 , 1. ],\n", + " [0.30059608, 0.70333157, 0.84259259],\n", + " [0.43315356, 0.56848228, 0.83333333],\n", + " [0.56713029, 0.43151772, 0.84259259],\n", + " [0.68833381, 0.31147541, 0.74074074],\n", + " [0.79165484, 0.20888419, 0.63888889],\n", + " [0.89753051, 0.10312004, 0.65740741],\n", + " [1. , 0. , 0.63888889]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88877985, 0.88875526, 0.97014925],\n", + " [0.7775597 , 0.77781118, 0.98507463],\n", + " [0.66404972, 0.66746843, 0.98507463],\n", + " [0.55446516, 0.55562237, 0.98507463],\n", + " [0.44357213, 0.44497895, 0.98507463],\n", + " [0.33333333, 0.33343355, 0.98507463],\n", + " [0.21982336, 0.2230908 , 0.98507463],\n", + " [0.11089303, 0.11064342, 1. ],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11867835, 0.11882547, 0.83333333],\n", + " [0.24072825, 0.2395719 , 0.84615385],\n", + " [0.36547539, 0.36333699, 0.84615385],\n", + " [0.48550236, 0.48408342, 0.84615385],\n", + " [0.62238705, 0.62623491, 1. ],\n", + " [0.74376264, 0.74945115, 0.85897436],\n", + " [0.87660148, 0.8784303 , 0.91025641],\n", + " [1. , 1. , 0.85897436]]),\n", + " array([[9.92181070e-01, 4.05246744e-01, 0.00000000e+00],\n", + " [9.92592593e-01, 3.45808109e-01, 1.78384050e-03],\n", + " [9.91358025e-01, 2.95725555e-01, 1.60020986e-03],\n", + " [9.90946502e-01, 2.42891213e-01, 1.83630640e-03],\n", + " [9.91769547e-01, 1.95927353e-01, 1.86253935e-03],\n", + " [9.93415638e-01, 1.57035406e-01, 1.78384050e-03],\n", + " [9.93004115e-01, 1.22179417e-01, 1.86253935e-03],\n", + " [9.93004115e-01, 9.20931939e-02, 1.83630640e-03],\n", + " [9.98765432e-01, 7.02623372e-02, 1.65267576e-03],\n", + " [1.00000000e+00, 5.09998165e-02, 1.67890871e-03],\n", + " [9.90534979e-01, 3.39387268e-02, 1.65267576e-03],\n", + " [9.71604938e-01, 2.03632361e-02, 1.65267576e-03],\n", + " [9.41975309e-01, 1.24747753e-02, 1.67890871e-03],\n", + " [9.01234568e-01, 1.41258485e-02, 1.65267576e-03],\n", + " [8.50205761e-01, 2.01797835e-02, 1.83630640e-03],\n", + " [7.91358025e-01, 2.77013392e-02, 1.81007345e-03],\n", + " [7.34156379e-01, 3.61401578e-02, 1.70514166e-03],\n", + " [6.71193416e-01, 3.81581361e-02, 1.73137461e-03],\n", + " [6.06995885e-01, 3.66905155e-02, 1.83630640e-03],\n", + " [5.43209877e-01, 3.44890846e-02, 1.81007345e-03],\n", + " [4.80246914e-01, 3.11869382e-02, 1.86253935e-03],\n", + " [4.25925926e-01, 2.82516969e-02, 1.60020986e-03],\n", + " [3.65843621e-01, 2.53164557e-02, 1.78384050e-03],\n", + " [3.04938272e-01, 2.38488351e-02, 1.83630640e-03],\n", + " [2.55555556e-01, 2.27481196e-02, 1.62644281e-03],\n", + " [2.04115226e-01, 2.12804990e-02, 1.78384050e-03],\n", + " [1.62551440e-01, 1.92625206e-02, 1.60020986e-03],\n", + " [1.18930041e-01, 1.83452578e-02, 1.83630640e-03],\n", + " [8.31275720e-02, 1.65107320e-02, 1.83630640e-03],\n", + " [6.54320988e-02, 1.57769217e-02, 1.86253935e-03],\n", + " [5.26748971e-02, 1.43093010e-02, 1.81007345e-03],\n", + " [4.19753086e-02, 1.17409650e-02, 1.83630640e-03],\n", + " [3.16872428e-02, 1.10071547e-02, 1.83630640e-03],\n", + " [2.13991770e-02, 9.35608145e-03, 1.83630640e-03],\n", + " [1.15226337e-02, 8.62227114e-03, 1.86253935e-03],\n", + " [4.93827160e-03, 7.52155568e-03, 1.78384050e-03],\n", + " [4.11522634e-04, 7.52155568e-03, 1.21720881e-02],\n", + " [0.00000000e+00, 1.00898918e-02, 1.00000000e+00],\n", + " [4.11522634e-03, 1.52265639e-02, 1.81007345e-03],\n", + " [1.39917695e-02, 1.98128784e-02, 1.60020986e-03],\n", + " [3.33333333e-02, 2.23812145e-02, 1.83630640e-03],\n", + " [6.29629630e-02, 2.40322877e-02, 1.83630640e-03],\n", + " [9.62962963e-02, 2.62337186e-02, 1.78384050e-03],\n", + " [1.27572016e-01, 2.45826454e-02, 1.60020986e-03],\n", + " [1.62139918e-01, 1.96294258e-02, 1.86253935e-03],\n", + " [1.85185185e-01, 1.17409650e-02, 1.65267576e-03],\n", + " [1.93415638e-01, 5.87048248e-03, 1.65267576e-03],\n", + " [1.90123457e-01, 2.38488351e-03, 1.65267576e-03],\n", + " [1.80658436e-01, 0.00000000e+00, 1.67890871e-03],\n", + " [1.73662551e-01, 6.42084021e-03, 1.65267576e-03],\n", + " [1.83539095e-01, 1.68776371e-02, 1.62644281e-03],\n", + " [2.06584362e-01, 2.58668134e-02, 1.70514166e-03],\n", + " [2.47325103e-01, 2.84351495e-02, 1.73137461e-03],\n", + " [2.92592593e-01, 2.86186021e-02, 1.60020986e-03],\n", + " [3.45679012e-01, 2.86186021e-02, 1.81007345e-03],\n", + " [4.02469136e-01, 2.99027701e-02, 1.86253935e-03],\n", + " [4.57613169e-01, 3.24711062e-02, 1.81007345e-03],\n", + " [5.16049383e-01, 3.46725371e-02, 1.83630640e-03],\n", + " [5.76131687e-01, 3.65070629e-02, 1.83630640e-03],\n", + " [6.35390947e-01, 4.12768299e-02, 1.81007345e-03],\n", + " [6.90123457e-01, 4.69638598e-02, 1.70514166e-03],\n", + " [7.41975309e-01, 4.16437351e-02, 1.70514166e-03],\n", + " [7.84362140e-01, 3.50394423e-02, 1.60020986e-03],\n", + " [8.21810700e-01, 2.69675289e-02, 1.60020986e-03],\n", + " [8.63786008e-01, 1.79783526e-02, 1.65267576e-03],\n", + " [9.09465021e-01, 1.35754907e-02, 1.73137461e-03],\n", + " [9.48559671e-01, 2.34819299e-02, 1.67890871e-03],\n", + " [9.74074074e-01, 4.78811227e-02, 1.65267576e-03],\n", + " [9.81893004e-01, 8.47550908e-02, 1.65267576e-03],\n", + " [9.81069959e-01, 1.33736929e-01, 1.86253935e-03],\n", + " [9.83950617e-01, 1.90423775e-01, 1.81007345e-03],\n", + " [9.88065844e-01, 2.54448725e-01, 1.83630640e-03],\n", + " [9.88477366e-01, 3.23059989e-01, 1.86253935e-03],\n", + " [9.90123457e-01, 3.91854706e-01, 1.83630640e-03],\n", + " [9.89711934e-01, 4.49275362e-01, 1.65267576e-03],\n", + " [9.47736626e-01, 4.94955054e-01, 1.65267576e-03],\n", + " [8.76543210e-01, 5.25591635e-01, 1.65267576e-03],\n", + " [7.88065844e-01, 5.41368556e-01, 1.67890871e-03],\n", + " [6.89300412e-01, 5.49623922e-01, 1.73137461e-03],\n", + " [5.90946502e-01, 5.58796551e-01, 1.67890871e-03],\n", + " [5.26337449e-01, 5.87782058e-01, 1.65267576e-03],\n", + " [4.77777778e-01, 6.26490552e-01, 1.67890871e-03],\n", + " [4.22633745e-01, 6.77490369e-01, 1.81007345e-03],\n", + " [3.62139918e-01, 7.35644836e-01, 1.83630640e-03],\n", + " [2.96707819e-01, 8.00036691e-01, 1.83630640e-03],\n", + " [2.32098765e-01, 8.67547239e-01, 1.81007345e-03],\n", + " [1.76543210e-01, 9.27719684e-01, 1.60020986e-03],\n", + " [1.13580247e-01, 1.00000000e+00, 1.86253935e-03]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90873786, 0.10034014, 0.875 ],\n", + " [0.81608877, 0.18197279, 0.8875 ],\n", + " [0.7220527 , 0.26615646, 0.8625 ],\n", + " [0.63106796, 0.36734694, 0.8875 ],\n", + " [0.54285714, 0.46768707, 0.8625 ],\n", + " [0.45270458, 0.56122449, 0.875 ],\n", + " [0.34951456, 0.65816327, 1. ],\n", + " [0.25742025, 0.73809524, 0.875 ],\n", + " [0.18113731, 0.81462585, 0.7625 ],\n", + " [0.09042996, 0.90986395, 0.85 ],\n", + " [0. , 1. , 0.875 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91578947, 0.080373 , 0.82926829],\n", + " [0.83421053, 0.16363233, 0.87804878],\n", + " [0.75 , 0.24356128, 0.84146341],\n", + " [0.67105263, 0.32371226, 0.84146341],\n", + " [0.57894737, 0.42118117, 1. ],\n", + " [0.5 , 0.5008881 , 0.84146341],\n", + " [0.41842105, 0.58414742, 0.86585366],\n", + " [0.33947368, 0.6651865 , 0.84146341],\n", + " [0.25 , 0.74844583, 0.86585366],\n", + " [0.17105263, 0.82992895, 0.85365854],\n", + " [0.08421053, 0.91230018, 0.84146341],\n", + " [0. , 1. , 0.85365854]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.89919586, 0.10881801, 0.7 ],\n", + " [0.79379667, 0.22232645, 0.73333333],\n", + " [0.68811028, 0.33489681, 0.73333333],\n", + " [0.58328547, 0.44465291, 0.73333333],\n", + " [0.47472717, 0.55159475, 0.73333333],\n", + " [0.32768524, 0.69230769, 1. ],\n", + " [0.21883975, 0.79502814, 0.73333333],\n", + " [0.10913268, 0.89774859, 0.73333333],\n", + " [0. , 1. , 0.73333333]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.204914 , 0.19736053, 1. ],\n", + " [0.36560197, 0.35272945, 0.77647059],\n", + " [0.52481572, 0.51109778, 0.76470588],\n", + " [0.68108108, 0.67186563, 0.78823529],\n", + " [0.83144963, 0.82873425, 0.77647059],\n", + " [1. , 1. , 0.83529412]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88933121, 0.88826367, 0.97014925],\n", + " [0.77839703, 0.77652733, 0.98507463],\n", + " [0.66613588, 0.66157556, 0.98507463],\n", + " [0.5552017 , 0.54983923, 0.98507463],\n", + " [0.44559448, 0.43971061, 0.98507463],\n", + " [0.33333333, 0.32797428, 1. ],\n", + " [0.22080679, 0.21864952, 0.98507463],\n", + " [0.10934183, 0.10771704, 0.98507463],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86133333, 0.94091182, 0.98591549],\n", + " [0.72488889, 0.87822436, 1. ],\n", + " [0.60133333, 0.80533893, 1. ],\n", + " [0.50888889, 0.71925615, 0.97183099],\n", + " [0.43155556, 0.61967606, 1. ],\n", + " [0.35822222, 0.5179964 , 0.97183099],\n", + " [0.28044444, 0.4130174 , 0.98591549],\n", + " [0.20355556, 0.30773845, 0.98591549],\n", + " [0.12755556, 0.19826035, 1. ],\n", + " [0.06266667, 0.09118176, 0.97183099],\n", + " [0. , 0. , 0.85915493]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09865471, 0.09921415, 0.97183099],\n", + " [0.19994724, 0.19941061, 1. ],\n", + " [0.30018465, 0.29862475, 0.98591549],\n", + " [0.40015827, 0.39882122, 0.97183099],\n", + " [0.49881298, 0.49214145, 0.98591549],\n", + " [0.59746769, 0.59724951, 0.97183099],\n", + " [0.70113427, 0.70530452, 1. ],\n", + " [0.80110789, 0.80353635, 1. ],\n", + " [0.89897125, 0.90176817, 0.97183099],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16938776, 0.17280996, 1. ],\n", + " [0.32857143, 0.34298708, 1. ],\n", + " [0.4755102 , 0.50981331, 1. ],\n", + " [0.63469388, 0.66586884, 0.92424242],\n", + " [0.81632653, 0.83413116, 0.98484848],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90549961, 0.89603025, 0.87341772],\n", + " [0.80686806, 0.80907372, 0.89873418],\n", + " [0.71159308, 0.71077505, 0.86075949],\n", + " [0.61399432, 0.61625709, 0.89873418],\n", + " [0.51768655, 0.52362949, 0.88607595],\n", + " [0.40511232, 0.4026465 , 1. ],\n", + " [0.30570617, 0.31758034, 0.91139241],\n", + " [0.19571392, 0.19659735, 1. ],\n", + " [0.09630777, 0.09073724, 0.88607595],\n", + " [0. , 0. , 0.87341772]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12522407, 0.12554745, 0.98507463],\n", + " [0.24814341, 0.24817518, 0.97014925],\n", + " [0.37490397, 0.37372263, 1. ],\n", + " [0.49987196, 0.50072993, 0.98507463],\n", + " [0.62279129, 0.62189781, 0.97014925],\n", + " [0.75006402, 0.75182482, 0.98507463],\n", + " [0.87503201, 0.87591241, 1. ],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91106719, 0.91081081, 0.59322034],\n", + " [0.81884058, 0.81837838, 0.60169492],\n", + " [0.66996047, 0.66648649, 1. ],\n", + " [0.58102767, 0.57675676, 0.60169492],\n", + " [0.48945982, 0.48702703, 0.59322034],\n", + " [0.39986825, 0.39702703, 0.59322034],\n", + " [0.2826087 , 0.28027027, 0.76271186],\n", + " [0.17061924, 0.16810811, 0.76271186],\n", + " [0.09156785, 0.08918919, 0.51694915],\n", + " [0. , 0. , 0.59322034]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88591591, 0.10953058, 0.97183099],\n", + " [0.77124375, 0.22285443, 0.98591549],\n", + " [0.66480447, 0.32811759, 0.98591549],\n", + " [0.54895619, 0.44238976, 1. ],\n", + " [0.43987063, 0.54812707, 0.97183099],\n", + " [0.32755072, 0.6628734 , 0.98591549],\n", + " [0.21875919, 0.77524893, 1. ],\n", + " [0.10761541, 0.88999526, 0.97183099],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89051888, 0.90364026, 0.98611111],\n", + " [0.78212442, 0.79657388, 0.94444444],\n", + " [0.66911165, 0.68522484, 1. ],\n", + " [0.55609889, 0.57173448, 0.97222222],\n", + " [0.44879109, 0.45824411, 0.97222222],\n", + " [0.33795164, 0.34689507, 0.95833333],\n", + " [0.22656887, 0.2248394 , 0.97222222],\n", + " [0.11192611, 0.10492505, 0.98611111],\n", + " [0. , 0. , 0.97222222]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08595989, 0.90207786, 0.8625 ],\n", + " [0.16905444, 0.80702173, 0.85 ],\n", + " [0.252149 , 0.7105326 , 0.9 ],\n", + " [0.36962751, 0.60114641, 1. ],\n", + " [0.48997135, 0.4903272 , 1. ],\n", + " [0.6017192 , 0.38213518, 0.975 ],\n", + " [0.68767908, 0.28707905, 0.875 ],\n", + " [0.77936963, 0.18987342, 0.8875 ],\n", + " [0.89684814, 0.09386195, 0.875 ],\n", + " [1. , 0. , 0.875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89031595, 0.88479263, 0.87341772],\n", + " [0.77754945, 0.77419355, 0.91139241],\n", + " [0.66632417, 0.64516129, 0.88607595],\n", + " [0.53917287, 0.51612903, 1. ],\n", + " [0.44361675, 0.42396313, 0.7721519 ],\n", + " [0.33418957, 0.30414747, 0.87341772],\n", + " [0.22296429, 0.19354839, 0.88607595],\n", + " [0.095813 , 0.09677419, 1. ],\n", + " [0. , 0. , 0.7721519 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87004405, 0.03798141, 0.86419753],\n", + " [0.75682819, 0.09322709, 0.86419753],\n", + " [0.66872247, 0.17237716, 0.87654321],\n", + " [0.60572687, 0.26772908, 0.85185185],\n", + " [0.53436123, 0.36812749, 0.86419753],\n", + " [0.45859031, 0.4690571 , 0.86419753],\n", + " [0.3660793 , 0.59150066, 1. ],\n", + " [0.28722467, 0.70092961, 0.86419753],\n", + " [0.20396476, 0.80371846, 0.85185185],\n", + " [0.10704846, 0.90039841, 0.86419753],\n", + " [0. , 1. , 0.86419753]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14588305, 0.1395655 , 1. ],\n", + " [0.28818616, 0.27781435, 0.97014925],\n", + " [0.43078759, 0.41935484, 0.98507463],\n", + " [0.57547733, 0.55892034, 0.98507463],\n", + " [0.72106205, 0.70046083, 1. ],\n", + " [0.86127685, 0.8439763 , 0.97014925],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86044444, 0.12144638, 0.60185185],\n", + " [0.73777778, 0.24563591, 0.61111111],\n", + " [0.60533333, 0.3840399 , 0.66666667],\n", + " [0.376 , 0.59600998, 1. ],\n", + " [0.26222222, 0.73017456, 0.66666667],\n", + " [0.12533333, 0.87605985, 0.67592593],\n", + " [0. , 1. , 0.61111111]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86870229, 0.13065539, 0.92307692],\n", + " [0.75572519, 0.24651163, 0.84615385],\n", + " [0.61832061, 0.38625793, 1. ],\n", + " [0.49465649, 0.51374207, 0.92307692],\n", + " [0.3648855 , 0.64080338, 0.92307692],\n", + " [0.24580153, 0.75708245, 0.84615385],\n", + " [0.13587786, 0.87336152, 0.84615385],\n", + " [0. , 1. , 0.92307692]]),\n", + " array([[1.33710407e-01, 8.37188612e-01, 0.00000000e+00],\n", + " [1.02488688e-01, 8.06049822e-01, 1.93331465e-03],\n", + " [7.51131222e-02, 7.74911032e-01, 1.96133371e-03],\n", + " [5.00000000e-02, 7.44661922e-01, 1.96133371e-03],\n", + " [2.94117647e-02, 7.17081851e-01, 1.93331465e-03],\n", + " [1.80995475e-02, 6.99288256e-01, 1.96133371e-03],\n", + " [1.49321267e-02, 6.90391459e-01, 1.98935276e-03],\n", + " [1.28959276e-02, 6.80604982e-01, 1.70916223e-03],\n", + " [9.72850679e-03, 6.65480427e-01, 1.96133371e-03],\n", + " [7.23981900e-03, 6.51245552e-01, 1.90529560e-03],\n", + " [5.88235294e-03, 6.44128114e-01, 6.73858224e-02],\n", + " [2.71493213e-03, 6.65480427e-01, 1.00000000e+00],\n", + " [4.52488688e-04, 6.80604982e-01, 1.70916223e-03],\n", + " [0.00000000e+00, 6.95729537e-01, 1.96133371e-03],\n", + " [5.65610860e-03, 7.10854093e-01, 1.96133371e-03],\n", + " [1.96832579e-02, 7.36654804e-01, 1.93331465e-03],\n", + " [4.27601810e-02, 7.69572954e-01, 1.96133371e-03],\n", + " [7.37556561e-02, 8.02491103e-01, 1.96133371e-03],\n", + " [1.10633484e-01, 8.38078292e-01, 1.98935276e-03],\n", + " [1.49321267e-01, 8.68327402e-01, 1.96133371e-03],\n", + " [1.85067873e-01, 8.91459075e-01, 1.93331465e-03],\n", + " [2.19457014e-01, 9.16370107e-01, 1.98935276e-03],\n", + " [2.50452489e-01, 9.35943060e-01, 1.96133371e-03],\n", + " [2.72171946e-01, 9.43060498e-01, 1.76520034e-03],\n", + " [2.91176471e-01, 9.41281139e-01, 1.76520034e-03],\n", + " [3.09049774e-01, 9.50177936e-01, 1.79321939e-03],\n", + " [3.23303167e-01, 9.83096085e-01, 1.76520034e-03],\n", + " [3.37330317e-01, 1.00000000e+00, 1.76520034e-03],\n", + " [3.57013575e-01, 9.91992883e-01, 1.76520034e-03],\n", + " [3.83484163e-01, 9.59074733e-01, 1.79321939e-03],\n", + " [4.16515837e-01, 8.92348754e-01, 1.90529560e-03],\n", + " [4.55203620e-01, 7.87366548e-01, 1.93331465e-03],\n", + " [4.95701357e-01, 6.40569395e-01, 1.96133371e-03],\n", + " [5.33710407e-01, 4.78647687e-01, 1.93331465e-03],\n", + " [5.65837104e-01, 3.29181495e-01, 1.70916223e-03],\n", + " [6.01357466e-01, 1.79715302e-01, 1.76520034e-03],\n", + " [6.41176471e-01, 7.02846975e-02, 1.79321939e-03],\n", + " [6.82579186e-01, 1.69039146e-02, 1.76520034e-03],\n", + " [7.27828054e-01, 0.00000000e+00, 1.93331465e-03],\n", + " [7.68325792e-01, 1.60142349e-02, 1.70916223e-03],\n", + " [8.15610860e-01, 5.78291815e-02, 1.96133371e-03],\n", + " [8.68778281e-01, 1.09430605e-01, 1.93331465e-03],\n", + " [9.31447964e-01, 1.81494662e-01, 1.98935276e-03],\n", + " [1.00000000e+00, 2.69572954e-01, 1.93331465e-03]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.84745763, 0.1525 , 0.72222222],\n", + " [0.69061071, 0.30583333, 0.73333333],\n", + " [0.47968792, 0.51416667, 1. ],\n", + " [0.31853645, 0.68 , 0.73333333],\n", + " [0.1614205 , 0.83333333, 0.73333333],\n", + " [0. , 1. , 0.74444444]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.1138088 , 0.88624339, 0.91549296],\n", + " [0.21760243, 0.78344671, 0.85915493],\n", + " [0.33323217, 0.6670446 , 0.92957746],\n", + " [0.45584219, 0.54535147, 1. ],\n", + " [0.55781487, 0.4425548 , 0.85915493],\n", + " [0.67010622, 0.33106576, 0.92957746],\n", + " [0.78300455, 0.21844293, 0.92957746],\n", + " [0.89165402, 0.1095994 , 0.91549296],\n", + " [1. , 0. , 0.92957746]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.1000535 , 0.90861813, 0.85185185],\n", + " [0.20278224, 0.81624567, 0.88888889],\n", + " [0.30551097, 0.72362556, 0.86419753],\n", + " [0.40342429, 0.63447251, 0.85185185],\n", + " [0.50775816, 0.54160475, 0.86419753],\n", + " [0.5917603 , 0.46433878, 0.75308642],\n", + " [0.68967362, 0.37270926, 0.85185185],\n", + " [0.79026217, 0.26597325, 1. ],\n", + " [0.87693954, 0.17360079, 0.85185185],\n", + " [0.93953986, 0.0936107 , 0.75308642],\n", + " [1. , 0. , 0.85185185]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8966525 , 0.88308977, 1. ],\n", + " [0.79596174, 0.76826722, 0.98591549],\n", + " [0.69899044, 0.66805846, 0.97183099],\n", + " [0.59829968, 0.57202505, 1. ],\n", + " [0.49628055, 0.47599165, 0.98591549],\n", + " [0.39638682, 0.37995825, 0.98591549],\n", + " [0.29702444, 0.28392484, 0.98591549],\n", + " [0.20031881, 0.18997912, 0.97183099],\n", + " [0.09936238, 0.09394572, 1. ],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91652174, 0.0825 , 0.97183099],\n", + " [0.82608696, 0.17045455, 1. ],\n", + " [0.74869565, 0.25272727, 0.97183099],\n", + " [0.66521739, 0.33795455, 0.98591549],\n", + " [0.58 , 0.42409091, 1. ],\n", + " [0.49304348, 0.5075 , 0.97183099],\n", + " [0.40956522, 0.59363636, 1. ],\n", + " [0.33391304, 0.67795455, 0.97183099],\n", + " [0.24521739, 0.76090909, 0.98591549],\n", + " [0.16086957, 0.84477273, 0.98591549],\n", + " [0.08695652, 0.91659091, 0.85915493],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09847716, 0.09154203, 1. ],\n", + " [0.18375635, 0.16915936, 0.89873418],\n", + " [0.26598985, 0.2503868 , 0.88607595],\n", + " [0.34720812, 0.33470861, 0.89873418],\n", + " [0.4284264 , 0.41645178, 0.86075949],\n", + " [0.5071066 , 0.49845281, 0.88607595],\n", + " [0.59137056, 0.58561114, 0.89873418],\n", + " [0.6822335 , 0.67715317, 0.87341772],\n", + " [0.75228426, 0.74548736, 0.88607595],\n", + " [0.83604061, 0.83032491, 0.91139241],\n", + " [0.9213198 , 0.92135121, 0.87341772],\n", + " [1. , 1. , 0.87341772]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91950558, 0.91319857, 0.97183099],\n", + " [0.83629786, 0.82282996, 1. ],\n", + " [0.75309014, 0.73067776, 0.97183099],\n", + " [0.67199276, 0.64090369, 0.98591549],\n", + " [0.58908652, 0.54875149, 1. ],\n", + " [0.50406994, 0.45541023, 0.98591549],\n", + " [0.42056075, 0.36801427, 0.98591549],\n", + " [0.33765451, 0.27586207, 0.98591549],\n", + " [0.25444679, 0.18192628, 0.98591549],\n", + " [0.17304793, 0.08799049, 0.97183099],\n", + " [0.08561954, 0.02021403, 1. ],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10882182, 0.1049936 , 0.86419753],\n", + " [0.21445154, 0.2099872 , 0.85185185],\n", + " [0.32356355, 0.32010243, 0.87654321],\n", + " [0.44486361, 0.44558259, 0.97530864],\n", + " [0.55223447, 0.55569782, 0.86419753],\n", + " [0.66163668, 0.66325224, 0.86419753],\n", + " [0.78583865, 0.78318395, 1. ],\n", + " [0.89320952, 0.88860435, 0.85185185],\n", + " [1. , 1. , 0.86419753]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10660039, 0.07021792, 1. ],\n", + " [0.21181994, 0.14043584, 0.98591549],\n", + " [0.31400166, 0.20096852, 0.95774648],\n", + " [0.40568904, 0.26271186, 0.85915493],\n", + " [0.51090859, 0.32687651, 0.98591549],\n", + " [0.61723281, 0.38498789, 0.98591549],\n", + " [0.72493786, 0.45762712, 1. ],\n", + " [0.82988125, 0.53268765, 0.97183099],\n", + " [0.92239713, 0.68523002, 0.90140845],\n", + " [1. , 1. , 0.88732394]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.83281116, 0.83225806, 1. ],\n", + " [0.66647679, 0.65403226, 1. ],\n", + " [0.49985759, 0.48467742, 1. ],\n", + " [0.33380803, 0.31129032, 1. ],\n", + " [0.16775847, 0.13709677, 1. ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11480519, 0.06835938, 0.59166667],\n", + " [0.24337662, 0.171875 , 0.66666667],\n", + " [0.43896104, 0.35742188, 1. ],\n", + " [0.55038961, 0.46484375, 0.575 ],\n", + " [0.66103896, 0.58203125, 0.58333333],\n", + " [0.77506494, 0.71875 , 0.58333333],\n", + " [0.88753247, 0.85546875, 0.58333333],\n", + " [1. , 1. , 0.58333333]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86426999, 0.13653234, 0.91011236],\n", + " [0.75568599, 0.25662778, 0.78651685],\n", + " [0.63316214, 0.37698834, 0.78651685],\n", + " [0.53411592, 0.47773065, 0.68539326],\n", + " [0.4108584 , 0.59968187, 0.7752809 ],\n", + " [0.25825385, 0.75026511, 1. ],\n", + " [0.11958914, 0.88335101, 0.91011236],\n", + " [0. , 1. , 0.7752809 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12033195, 0.12414837, 0.90277778],\n", + " [0.23236515, 0.23921272, 0.84722222],\n", + " [0.36514523, 0.36613677, 0.91666667],\n", + " [0.48547718, 0.49356548, 0.91666667],\n", + " [0.60580913, 0.62074186, 0.90277778],\n", + " [0.71369295, 0.73681554, 0.84722222],\n", + " [0.85062241, 0.86373959, 0.90277778],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12231819, 0.11845103, 0.875 ],\n", + " [0.24630816, 0.24373576, 0.8875 ],\n", + " [0.3633324 , 0.3690205 , 0.8625 ],\n", + " [0.49038729, 0.49886105, 0.875 ],\n", + " [0.62886598, 0.63553531, 1. ],\n", + " [0.7514628 , 0.75170843, 0.875 ],\n", + " [0.87601003, 0.87015945, 0.8875 ],\n", + " [1. , 1. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11297284, 0.08495146, 0.98507463],\n", + " [0.22264534, 0.17961165, 0.98507463],\n", + " [0.33384108, 0.29126214, 0.98507463],\n", + " [0.4460523 , 0.40776699, 0.98507463],\n", + " [0.5575019 , 0.51456311, 0.98507463],\n", + " [0.66895151, 0.6407767 , 0.98507463],\n", + " [0.7796395 , 0.76699029, 1. ],\n", + " [0.89058137, 0.88834951, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8886619 , 0.88770515, 0.86419753],\n", + " [0.76353422, 0.7615894 , 1. ],\n", + " [0.65372829, 0.65102217, 0.86419753],\n", + " [0.54902962, 0.54563778, 0.85185185],\n", + " [0.42390194, 0.41980996, 0.98765432],\n", + " [0.3319714 , 0.32623092, 0.75308642],\n", + " [0.22318693, 0.21595163, 0.86419753],\n", + " [0.11899898, 0.11229485, 0.86419753],\n", + " [0. , 0. , 0.86419753]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88215962, 0.12964348, 0.97014925],\n", + " [0.76197183, 0.2582897 , 1. ],\n", + " [0.63661972, 0.38344552, 0.98507463],\n", + " [0.51173709, 0.50536026, 0.97014925],\n", + " [0.38403756, 0.62827225, 0.98507463],\n", + " [0.25539906, 0.75442533, 0.98507463],\n", + " [0.12769953, 0.87733732, 1. ],\n", + " [0. , 1. , 0.97014925]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.82269504, 0.16643646, 0.97014925],\n", + " [0.65957447, 0.33517495, 1. ],\n", + " [0.5177305 , 0.49930939, 0.98507463],\n", + " [0.34751773, 0.66620626, 0.98507463],\n", + " [0.14893617, 0.83333333, 0.97014925],\n", + " [0. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87978723, 0.88235294, 0.66666667],\n", + " [0.69893617, 0.69683258, 1. ],\n", + " [0.58989362, 0.58823529, 0.59166667],\n", + " [0.47207447, 0.46757164, 0.65 ],\n", + " [0.35132979, 0.3453997 , 0.675 ],\n", + " [0.24468085, 0.23680241, 0.58333333],\n", + " [0.13803191, 0.12971342, 0.58333333],\n", + " [0. , 0. , 0.74166667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91185582, 0.91067961, 0.85 ],\n", + " [0.8203323 , 0.82006472, 0.875 ],\n", + " [0.71472825, 0.71003236, 1. ],\n", + " [0.62545762, 0.61747573, 0.875 ],\n", + " [0.53534216, 0.52556634, 0.875 ],\n", + " [0.44297381, 0.43300971, 0.8875 ],\n", + " [0.35342157, 0.34239482, 0.8625 ],\n", + " [0.27400732, 0.26213592, 0.7625 ],\n", + " [0.18248381, 0.17087379, 0.875 ],\n", + " [0.09293157, 0.0789644 , 0.8625 ],\n", + " [0. , 0. , 0.8875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08280467, 0.91759554, 0.86585366],\n", + " [0.16427379, 0.84076433, 0.84146341],\n", + " [0.24941569, 0.76035032, 0.86585366],\n", + " [0.33055092, 0.68351911, 0.85365854],\n", + " [0.41803005, 0.59872611, 0.97560976],\n", + " [0.49482471, 0.52030255, 0.82926829],\n", + " [0.57863105, 0.45262739, 1. ],\n", + " [0.66510851, 0.34992038, 0.84146341],\n", + " [0.7672788 , 0.26552548, 0.98780488],\n", + " [0.83806344, 0.20063694, 0.84146341],\n", + " [0.92253756, 0.125 , 0.85365854],\n", + " [1. , 0. , 0.97560976]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92167722, 0.91552303, 0.72093023],\n", + " [0.83662975, 0.83836536, 0.73255814],\n", + " [0.75079114, 0.74717902, 0.77906977],\n", + " [0.63568038, 0.63708448, 1. ],\n", + " [0.55063291, 0.55138762, 0.74418605],\n", + " [0.44778481, 0.45013724, 0.88372093],\n", + " [0.35047468, 0.35346142, 0.8255814 ],\n", + " [0.25830696, 0.26044526, 0.81395349],\n", + " [0.16811709, 0.1704788 , 0.76744186],\n", + " [0.08386076, 0.0863068 , 0.73255814],\n", + " [0. , 0. , 0.74418605]]),\n", + " array([[0.81345566, 1. , 0. ],\n", + " [0.94495413, 0.91027367, 1. ],\n", + " [1. , 0.82951996, 0.95833333],\n", + " [0.88685015, 0.74383131, 0.97222222],\n", + " [0.8440367 , 0.6615074 , 0.98611111],\n", + " [0.77370031, 0.57828623, 0.94444444],\n", + " [0.73394495, 0.49685958, 0.98611111],\n", + " [0.617737 , 0.4149843 , 0.98611111],\n", + " [0.51070336, 0.3328847 , 0.95833333],\n", + " [0.35779817, 0.25056079, 0.97222222],\n", + " [0.25382263, 0.16823688, 0.97222222],\n", + " [0.16207951, 0.08591297, 0.95833333],\n", + " [0. , 0. , 0.98611111]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16824197, 0.16919806, 0.98507463],\n", + " [0.33005671, 0.32715674, 0.98507463],\n", + " [0.4952741 , 0.4927096 , 1. ],\n", + " [0.66616257, 0.66433779, 0.98507463],\n", + " [0.83175803, 0.82381531, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 0.0625 , 0. ],\n", + " [0.88338271, 0. , 0.61068702],\n", + " [0.77673041, 0.1875 , 0.53435115],\n", + " [0.67250202, 0.25 , 0.53435115],\n", + " [0.56881228, 0.1875 , 0.53435115],\n", + " [0.46593051, 0.375 , 0.52671756],\n", + " [0.26986264, 0.5625 , 1. ],\n", + " [0.13493132, 0.8125 , 0.6870229 ],\n", + " [0. , 1. , 0.6870229 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13338997, 0.13373162, 0.6875 ],\n", + " [0.2740017 , 0.27504596, 0.73958333],\n", + " [0.39804588, 0.39797794, 0.63541667],\n", + " [0.53313509, 0.53262868, 0.6875 ],\n", + " [0.66864911, 0.66750919, 0.6875 ],\n", + " [0.81138488, 0.81043199, 0.75 ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.85887208, 0.13259669, 1. ],\n", + " [0.71774415, 0.25414365, 1. ],\n", + " [0.56973865, 0.38674033, 1. ],\n", + " [0.43026135, 0.54696133, 1. ],\n", + " [0.28500688, 0.70718232, 1. ],\n", + " [0.14222834, 0.85082873, 1. ],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90038314, 0.90257404, 0.88888889],\n", + " [0.79166667, 0.79518406, 0.97530864],\n", + " [0.68295019, 0.68779408, 0.98765432],\n", + " [0.57136015, 0.57708276, 1. ],\n", + " [0.47509579, 0.48104069, 0.85185185],\n", + " [0.37931034, 0.38444506, 0.86419753],\n", + " [0.28400383, 0.28978688, 0.85185185],\n", + " [0.18726054, 0.19153058, 0.87654321],\n", + " [0.0914751 , 0.09382784, 0.87654321],\n", + " [0. , 0. , 0.83950617]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11486103, 0.88744344, 0.4964539 ],\n", + " [0.22887124, 0.77262443, 0.4964539 ],\n", + " [0.34231424, 0.65837104, 0.4822695 ],\n", + " [0.45717527, 0.54298643, 0.5035461 ],\n", + " [0.63754963, 0.36255656, 0.77304965],\n", + " [0.86670448, 0.13065611, 1. ],\n", + " [1. , 0. , 0.56737589]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88677303, 0.88751545, 0.97222222],\n", + " [0.77303139, 0.77676143, 0.95833333],\n", + " [0.66083376, 0.66205192, 0.98611111],\n", + " [0.5491508 , 0.54932015, 0.95833333],\n", + " [0.43386516, 0.43584672, 1. ],\n", + " [0.32269686, 0.32509271, 0.94444444],\n", + " [0.22593927, 0.22793572, 0.84722222],\n", + " [0.11580031, 0.11644005, 0.95833333],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.11660951, 0.88236703, 0.98507463],\n", + " [0.23811857, 0.75922377, 0.98507463],\n", + " [0.36501715, 0.63320556, 0.98507463],\n", + " [0.49289564, 0.51054145, 0.98507463],\n", + " [0.62371387, 0.38524197, 0.97014925],\n", + " [0.74865262, 0.25706756, 1. ],\n", + " [0.87359138, 0.12913273, 0.98507463],\n", + " [1. , 0. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.82985822, 0.83132239, 0.98507463],\n", + " [0.66638866, 0.66795367, 0.98507463],\n", + " [0.50125104, 0.50168919, 0.98507463],\n", + " [0.33110926, 0.33301158, 0.98507463],\n", + " [0.16513761, 0.16650579, 1. ],\n", + " [0. , 0. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89179906, 0.88330046, 0.89873418],\n", + " [0.78273937, 0.77021696, 0.87341772],\n", + " [0.68913697, 0.67094017, 0.7721519 ],\n", + " [0.5757836 , 0.56147272, 0.88607595],\n", + " [0.46543581, 0.45266272, 0.87341772],\n", + " [0.35294118, 0.34549638, 0.87341772],\n", + " [0.23958781, 0.23372781, 0.89873418],\n", + " [0.1266638 , 0.12228797, 0.89873418],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89185033, 0.91043203, 0.97183099],\n", + " [0.77703742, 0.81348788, 0.98591549],\n", + " [0.66299334, 0.7028451 , 1. ],\n", + " [0.55484367, 0.59747102, 0.97183099],\n", + " [0.44720656, 0.49209694, 0.97183099],\n", + " [0.33444387, 0.37934668, 1. ],\n", + " [0.22731932, 0.26027397, 0.98591549],\n", + " [0.11327524, 0.1317176 , 0.98591549],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.95009074, 0.09995124, 0.71 ],\n", + " [0.90471869, 0.19795222, 0.7 ],\n", + " [0.86206897, 0.28937104, 0.69 ],\n", + " [0.81669691, 0.38152121, 0.7 ],\n", + " [0.77041742, 0.48878596, 0.8 ],\n", + " [0.70780399, 0.58386153, 0.71 ],\n", + " [0.59165154, 0.66723549, 0.7 ],\n", + " [0.45099819, 0.7574354 , 0.8 ],\n", + " [0.26497278, 0.85884934, 1. ],\n", + " [0.13339383, 0.92881521, 0.68 ],\n", + " [0. , 1. , 0.71 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90669431, 0.91631206, 0.97222222],\n", + " [0.82790284, 0.84491726, 0.84722222],\n", + " [0.73904028, 0.76595745, 0.97222222],\n", + " [0.65195498, 0.68652482, 0.94444444],\n", + " [0.56309242, 0.60425532, 1. ],\n", + " [0.47837678, 0.52671395, 0.95833333],\n", + " [0.3924763 , 0.44964539, 0.98611111],\n", + " [0.30776066, 0.37304965, 0.97222222],\n", + " [0.22867299, 0.28652482, 0.95833333],\n", + " [0.15225118, 0.19054374, 0.95833333],\n", + " [0.07671801, 0.09361702, 0.97222222],\n", + " [0. , 0. , 0.98611111]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9073111 , 0.90712251, 0.78481013],\n", + " [0.78923218, 0.78803419, 1. ],\n", + " [0.69807281, 0.6962963 , 0.78481013],\n", + " [0.59926583, 0.6 , 0.81012658],\n", + " [0.49005812, 0.49002849, 0.93670886],\n", + " [0.39736923, 0.3977208 , 0.78481013],\n", + " [0.29703273, 0.2968661 , 0.83544304],\n", + " [0.19027225, 0.18917379, 0.91139241],\n", + " [0.09513613, 0.09344729, 0.78481013],\n", + " [0. , 0. , 0.81012658]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87990607, 0.86831009, 0.90277778],\n", + " [0.7577994 , 0.7356471 , 0.91666667],\n", + " [0.64441463, 0.61368797, 0.84722222],\n", + " [0.52130158, 0.48394421, 0.90277778],\n", + " [0.39483395, 0.35809277, 0.91666667],\n", + " [0.27675277, 0.24813493, 0.84722222],\n", + " [0.1338477 , 0.11644502, 1. ],\n", + " [0. , 0. , 0.90277778]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1286285 , 0.19135802, 1. ],\n", + " [0.25113182, 0.31481481, 0.98507463],\n", + " [0.38029294, 0.44444444, 0.97014925],\n", + " [0.50679095, 0.5617284 , 1. ],\n", + " [0.63195739, 0.67901235, 0.97014925],\n", + " [0.75099867, 0.79320988, 0.98507463],\n", + " [0.87829561, 0.89197531, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08917407, 0.91238564, 0.85915493],\n", + " [0.19381375, 0.80928923, 0.98591549],\n", + " [0.29680816, 0.70724842, 0.98591549],\n", + " [0.39749918, 0.60626319, 0.98591549],\n", + " [0.50082264, 0.50316678, 0.98591549],\n", + " [0.60184271, 0.40218156, 0.98591549],\n", + " [0.70253373, 0.30154821, 0.98591549],\n", + " [0.80289569, 0.20091485, 1. ],\n", + " [0.90062521, 0.10133709, 0.95774648],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12763242, 0.13199004, 0.98507463],\n", + " [0.22335673, 0.24518904, 0.91044776],\n", + " [0.35098915, 0.37355671, 0.97014925],\n", + " [0.47862157, 0.49807562, 1. ],\n", + " [0.60625399, 0.62259452, 0.97014925],\n", + " [0.73388641, 0.75096219, 0.98507463],\n", + " [0.87236758, 0.8754811 , 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89595202, 0.89603766, 0.95833333],\n", + " [0.79310345, 0.79325226, 0.98611111],\n", + " [0.69055472, 0.69046685, 0.95833333],\n", + " [0.5862069 , 0.58650451, 1. ],\n", + " [0.48365817, 0.48254217, 0.95833333],\n", + " [0.3952024 , 0.39584151, 0.84722222],\n", + " [0.29385307, 0.29580228, 0.94444444],\n", + " [0.205997 , 0.20753237, 0.84722222],\n", + " [0.09985007, 0.10082385, 0.98611111],\n", + " [0. , 0. , 0.95833333]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09301691, 0.90568119, 0.88732394],\n", + " [0.19067103, 0.80750138, 0.92957746],\n", + " [0.29405346, 0.70490899, 0.98591549],\n", + " [0.3867976 , 0.61279647, 0.90140845],\n", + " [0.48690671, 0.51241037, 0.94366197],\n", + " [0.58701582, 0.41312741, 0.97183099],\n", + " [0.69285325, 0.30832874, 1. ],\n", + " [0.79378069, 0.20683949, 0.97183099],\n", + " [0.89634479, 0.1042471 , 1. ],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.86883721, 0.87310276, 0.94366197],\n", + " [0.74046512, 0.74744961, 0.92957746],\n", + " [0.61767442, 0.62403583, 0.91549296],\n", + " [0.48930233, 0.49763623, 0.94366197],\n", + " [0.36744186, 0.3749689 , 0.91549296],\n", + " [0.25116279, 0.25901966, 0.85915493],\n", + " [0.12837209, 0.13386415, 0.92957746],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1095994 , 0.08031746, 0.88607595],\n", + " [0.21768707, 0.16253968, 0.89873418],\n", + " [0.32539683, 0.24285714, 0.86075949],\n", + " [0.43197279, 0.32222222, 0.88607595],\n", + " [0.54270597, 0.4047619 , 0.89873418],\n", + " [0.65381708, 0.48190476, 0.89873418],\n", + " [0.75661376, 0.59047619, 1. ],\n", + " [0.81519274, 0.68190476, 0.7721519 ],\n", + " [0.88284203, 0.78984127, 0.86075949],\n", + " [0.93801965, 0.88730159, 0.7721519 ],\n", + " [1. , 1. , 0.88607595]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92970522, 0.08523857, 1. ],\n", + " [0.861678 , 0.15581511, 0.85915493],\n", + " [0.77777778, 0.24030815, 0.97183099],\n", + " [0.70521542, 0.32455268, 1. ],\n", + " [0.61904762, 0.40780318, 0.97183099],\n", + " [0.53514739, 0.49428429, 1. ],\n", + " [0.44897959, 0.57753479, 0.97183099],\n", + " [0.35827664, 0.66227634, 0.98591549],\n", + " [0.26303855, 0.74751491, 0.97183099],\n", + " [0.17460317, 0.83126243, 0.98591549],\n", + " [0.08390023, 0.9167495 , 1. ],\n", + " [0. , 1. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92917847, 0.92784357, 0.86419753],\n", + " [0.85949008, 0.85816579, 0.85185185],\n", + " [0.78640227, 0.78656018, 0.87654321],\n", + " [0.71501416, 0.71578078, 0.86419753],\n", + " [0.64419263, 0.64637841, 0.86419753],\n", + " [0.5694051 , 0.57339576, 0.87654321],\n", + " [0.50028329, 0.50234095, 0.85185185],\n", + " [0.43002833, 0.43073533, 0.86419753],\n", + " [0.35694051, 0.36023134, 0.86419753],\n", + " [0.28441926, 0.28945194, 0.86419753],\n", + " [0.21189802, 0.22060039, 0.85185185],\n", + " [0.13031161, 0.13522446, 1. ],\n", + " [0.06062323, 0.06141559, 0.86419753],\n", + " [0. , 0. , 0.75308642]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16824197, 0.16919806, 0.98507463],\n", + " [0.33005671, 0.32715674, 0.98507463],\n", + " [0.4952741 , 0.4927096 , 1. ],\n", + " [0.66616257, 0.66433779, 0.98507463],\n", + " [0.83175803, 0.82381531, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89772125, 0.92239859, 1. ],\n", + " [0.79623741, 0.84832451, 0.95833333],\n", + " [0.69607843, 0.77601411, 0.95833333],\n", + " [0.59326974, 0.66313933, 1. ],\n", + " [0.49390567, 0.53791887, 0.95833333],\n", + " [0.40540541, 0.43915344, 0.84722222],\n", + " [0.30418654, 0.31922399, 0.95833333],\n", + " [0.20429253, 0.20458554, 0.95833333],\n", + " [0.10121887, 0.08641975, 1. ],\n", + " [0. , 0. , 0.95833333]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.10322581, 0.87261146, 0.8875 ],\n", + " [0.2283871 , 0.73566879, 1. ],\n", + " [0.33496774, 0.61783439, 0.875 ],\n", + " [0.44722581, 0.49044586, 0.8875 ],\n", + " [0.55509677, 0.37420382, 0.8625 ],\n", + " [0.67096774, 0.24363057, 0.8875 ],\n", + " [0.77754839, 0.13853503, 0.8625 ],\n", + " [0.89187097, 0.06050955, 0.875 ],\n", + " [1. , 0. , 0.875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91610911, 0.912 , 0.98611111],\n", + " [0.83401956, 0.81866667, 0.95833333],\n", + " [0.75193001, 0.73066667, 0.97222222],\n", + " [0.66778178, 0.624 , 0.97222222],\n", + " [0.58569223, 0.528 , 0.97222222],\n", + " [0.50102934, 0.44266667, 0.97222222],\n", + " [0.41842512, 0.36533333, 0.95833333],\n", + " [0.33453423, 0.29333333, 0.97222222],\n", + " [0.24935666, 0.21866667, 1. ],\n", + " [0.16572311, 0.14133333, 0.95833333],\n", + " [0.08183222, 0.06666667, 0.97222222],\n", + " [0. , 0. , 0.97222222]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.83281116, 0.83225806, 1. ],\n", + " [0.66647679, 0.65403226, 1. ],\n", + " [0.49985759, 0.48467742, 1. ],\n", + " [0.33380803, 0.31129032, 1. ],\n", + " [0.16775847, 0.13709677, 1. ],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12008073, 0.11428571, 1. ],\n", + " [0.23309788, 0.22326169, 0.97183099],\n", + " [0.34510595, 0.33249052, 0.98591549],\n", + " [0.45812311, 0.4437421 , 0.98591549],\n", + " [0.5691221 , 0.55474083, 0.98591549],\n", + " [0.67709384, 0.66573957, 0.98591549],\n", + " [0.78607467, 0.77825537, 0.98591549],\n", + " [0.89303734, 0.88900126, 1. ],\n", + " [1. , 1. , 0.97183099]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11337209, 0.1167002 , 1. ],\n", + " [0.22122093, 0.22434608, 0.94444444],\n", + " [0.33255814, 0.33249497, 0.98611111],\n", + " [0.44680233, 0.44668008, 0.98611111],\n", + " [0.55465116, 0.55382294, 0.94444444],\n", + " [0.66715116, 0.66599598, 0.98611111],\n", + " [0.77790698, 0.77665996, 0.97222222],\n", + " [0.8877907 , 0.88581489, 0.97222222],\n", + " [1. , 1. , 0.98611111]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90253807, 0.90490798, 0.875 ],\n", + " [0.79314721, 0.79754601, 1. ],\n", + " [0.69314721, 0.69018405, 0.8875 ],\n", + " [0.59746193, 0.59509202, 0.875 ],\n", + " [0.50152284, 0.50613497, 0.8625 ],\n", + " [0.40329949, 0.41717791, 0.875 ],\n", + " [0.30583756, 0.30981595, 0.875 ],\n", + " [0.20685279, 0.21472393, 0.8875 ],\n", + " [0.0964467 , 0.10122699, 1. ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09852357, 0.05820433, 0.97222222],\n", + " [0.19222033, 0.12074303, 0.95833333],\n", + " [0.28591709, 0.18575851, 0.97222222],\n", + " [0.38472459, 0.26315789, 0.98611111],\n", + " [0.4826803 , 0.35108359, 0.97222222],\n", + " [0.57495741, 0.43343653, 0.97222222],\n", + " [0.66780239, 0.51517028, 0.97222222],\n", + " [0.76604202, 0.60371517, 0.97222222],\n", + " [0.84241908, 0.70278638, 0.84722222],\n", + " [0.92078365, 0.84148607, 0.94444444],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.16398204, 0.19233074, 1. ],\n", + " [0.32532348, 0.39724386, 1. ],\n", + " [0.49062583, 0.58298382, 1. ],\n", + " [0.66147346, 0.72438586, 1. ],\n", + " [0.83337734, 0.86039545, 0.98387097],\n", + " [1. , 1. , 0.98387097]]),\n", + " array([[0.56537102, 1. , 0. ],\n", + " [0.35689046, 0.8934983 , 0.94444444],\n", + " [0.16961131, 0.7860262 , 0.98611111],\n", + " [0. , 0.67515769, 0.95833333],\n", + " [0.03886926, 0.56477438, 1. ],\n", + " [0.2155477 , 0.45487627, 0.94444444],\n", + " [0.3745583 , 0.34497817, 0.97222222],\n", + " [0.55123675, 0.22755944, 0.98611111],\n", + " [0.77031802, 0.11475012, 0.95833333],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87991498, 0.88330632, 0.73333333],\n", + " [0.75956429, 0.76661264, 0.73333333],\n", + " [0.63735388, 0.64667747, 0.73333333],\n", + " [0.52072264, 0.53160454, 0.72222222],\n", + " [0.3987779 , 0.41166937, 0.73333333],\n", + " [0.28081828, 0.2917342 , 0.73333333],\n", + " [0.15967056, 0.16693679, 0.73333333],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10746269, 0.11522634, 0.87341772],\n", + " [0.21818182, 0.22427984, 0.89873418],\n", + " [0.32645862, 0.32921811, 0.87341772],\n", + " [0.43880597, 0.44238683, 0.89873418],\n", + " [0.56065129, 0.56378601, 1. ],\n", + " [0.67354138, 0.67695473, 0.89873418],\n", + " [0.78263229, 0.78600823, 0.88607595],\n", + " [0.8890095 , 0.8909465 , 0.87341772],\n", + " [1. , 1. , 0.89873418]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1707989 , 0.17039534, 0.73333333],\n", + " [0.34205693, 0.34201655, 0.72666667],\n", + " [0.43939394, 0.43824701, 0.41333333],\n", + " [0.67263545, 0.67300031, 1. ],\n", + " [0.85950413, 0.85902544, 0.8 ],\n", + " [1. , 1. , 0.6 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92263056, 0.91887046, 0.86419753],\n", + " [0.84719536, 0.83975796, 0.86419753],\n", + " [0.77756286, 0.76378306, 0.86419753],\n", + " [0.70019342, 0.6869117 , 0.86419753],\n", + " [0.62475822, 0.60779919, 0.86419753],\n", + " [0.55125725, 0.53070372, 0.85185185],\n", + " [0.48355899, 0.46391753, 0.75308642],\n", + " [0.40232108, 0.38502913, 0.86419753],\n", + " [0.33462282, 0.31712237, 0.75308642],\n", + " [0.26499033, 0.2431645 , 0.83950617],\n", + " [0.1934236 , 0.16472434, 0.87654321],\n", + " [0.10058027, 0.08695652, 0.85185185],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89234312, 0.88938423, 0.79775281],\n", + " [0.78641336, 0.78239064, 0.76404494],\n", + " [0.6919977 , 0.68849262, 0.68539326],\n", + " [0.57052389, 0.56673168, 0.8988764 ],\n", + " [0.43005181, 0.42908888, 1. ],\n", + " [0.32124352, 0.32014489, 0.79775281],\n", + " [0.21531376, 0.21426581, 0.78651685],\n", + " [0.10592976, 0.10560045, 0.79775281],\n", + " [0. , 0. , 0.7752809 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.09876543, 0.1125 , 0.88607595],\n", + " [0.17283951, 0.20816327, 0.7721519 ],\n", + " [0.24897119, 0.31862245, 0.86075949],\n", + " [0.33333333, 0.43239796, 0.91139241],\n", + " [0.44650206, 0.54311224, 0.87341772],\n", + " [0.58436214, 0.65306122, 0.89873418],\n", + " [0.74691358, 0.77857143, 1. ],\n", + " [0.87654321, 0.8875 , 0.88607595],\n", + " [1. , 1. , 0.89873418]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.06973768, 0.91664574, 0.88607595],\n", + " [0.13755598, 0.83630429, 0.88607595],\n", + " [0.20665387, 0.75520964, 0.88607595],\n", + " [0.28854766, 0.66432337, 1. ],\n", + " [0.34293026, 0.59477781, 0.7721519 ],\n", + " [0.41202815, 0.51644489, 0.87341772],\n", + " [0.48944338, 0.43861411, 0.89873418],\n", + " [0.56877799, 0.3648004 , 0.87341772],\n", + " [0.64939219, 0.28922922, 0.88607595],\n", + " [0.73192578, 0.21240271, 0.89873418],\n", + " [0.82085733, 0.14034647, 0.87341772],\n", + " [0.91106846, 0.06879237, 0.88607595],\n", + " [1. , 0. , 0.87341772]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.19607843, 0.1969648 , 1. ],\n", + " [0.35553089, 0.35615111, 0.79761905],\n", + " [0.50832408, 0.50920245, 0.77380952],\n", + " [0.66259711, 0.66483694, 0.78571429],\n", + " [0.81982982, 0.821763 , 0.78571429],\n", + " [1. , 1. , 0.92857143]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.92263461, 0.07878788, 0.97183099],\n", + " [0.84997386, 0.14440053, 0.85915493],\n", + " [0.77104025, 0.22424242, 0.98591549],\n", + " [0.7009932 , 0.3027668 , 0.97183099],\n", + " [0.61055933, 0.37839262, 1. ],\n", + " [0.53476215, 0.45638999, 0.98591549],\n", + " [0.46053319, 0.5372859 , 0.98591549],\n", + " [0.37794041, 0.61212121, 0.98591549],\n", + " [0.30527967, 0.69354414, 0.98591549],\n", + " [0.22739153, 0.76969697, 0.97183099],\n", + " [0.15786722, 0.83847167, 0.85915493],\n", + " [0.08363826, 0.9198946 , 0.98591549],\n", + " [0. , 1. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91282953, 0.91537133, 1. ],\n", + " [0.83479789, 0.8373057 , 0.92307692],\n", + " [0.7599297 , 0.76303972, 0.87179487],\n", + " [0.68471002, 0.68290155, 0.92307692],\n", + " [0.61230228, 0.60276339, 0.8974359 ],\n", + " [0.53673111, 0.52746114, 0.88461538],\n", + " [0.45940246, 0.45492228, 0.88461538],\n", + " [0.38137083, 0.3806563 , 0.8974359 ],\n", + " [0.30509666, 0.30189983, 0.91025641],\n", + " [0.23093146, 0.22348877, 0.88461538],\n", + " [0.15711775, 0.1492228 , 0.8974359 ],\n", + " [0.07908612, 0.07426598, 0.91025641],\n", + " [0. , 0. , 0.91025641]]),\n", + " array([[0.02540835, 0. , 0. ],\n", + " [0. , 0.12496662, 1. ],\n", + " [0.02631579, 0.24993324, 0.95833333],\n", + " [0.11751361, 0.35941255, 0.97222222],\n", + " [0.25635209, 0.44432577, 0.98611111],\n", + " [0.40517241, 0.49986649, 0.97222222],\n", + " [0.55626134, 0.55246996, 0.97222222],\n", + " [0.70372051, 0.60507343, 0.95833333],\n", + " [0.84392015, 0.66782377, 0.97222222],\n", + " [0.95326679, 0.76555407, 0.97222222],\n", + " [1. , 0.8753004 , 0.86111111],\n", + " [0.98593466, 1. , 0.94444444]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91563275, 0.91659091, 0.63636364],\n", + " [0.8325062 , 0.83477273, 0.62727273],\n", + " [0.74565757, 0.75 , 0.64545455],\n", + " [0.66129032, 0.665 , 0.63636364],\n", + " [0.57816377, 0.58295455, 0.62727273],\n", + " [0.49379653, 0.49954545, 0.63636364],\n", + " [0.41066998, 0.41636364, 0.63636364],\n", + " [0.32754342, 0.33204545, 0.64545455],\n", + " [0.22084367, 0.22568182, 0.81818182],\n", + " [0.12779156, 0.13181818, 0.71818182],\n", + " [0. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88276671, 0.88243462, 0.91666667],\n", + " [0.76553341, 0.76278639, 0.91666667],\n", + " [0.63305979, 0.62902106, 1. ],\n", + " [0.5017585 , 0.50451284, 0.90277778],\n", + " [0.37514654, 0.38787318, 0.84722222],\n", + " [0.24032825, 0.26220782, 0.91666667],\n", + " [0.11488863, 0.13214534, 0.91666667],\n", + " [0. , 0. , 0.91666667]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.88382391, 0.09782609, 0.52671756],\n", + " [0.67074759, 0.33695652, 0.98473282],\n", + " [0.5009117 , 0.5 , 0.77862595],\n", + " [0.35061214, 0.64130435, 0.6870229 ],\n", + " [0.21906747, 0.77173913, 0.60305344],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12480499, 0.14285714, 1. ],\n", + " [0.25013001, 0.271777 , 0.97014925],\n", + " [0.37545502, 0.39372822, 0.98507463],\n", + " [0.49869995, 0.51219512, 0.98507463],\n", + " [0.62584503, 0.63066202, 0.98507463],\n", + " [0.75091004, 0.75261324, 0.98507463],\n", + " [0.87467499, 0.87804878, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.94349142, 0.94297636, 0.89873418],\n", + " [0.88597376, 0.88966157, 0.87341772],\n", + " [0.82542886, 0.83449235, 0.91139241],\n", + " [0.76992936, 0.77978674, 0.86075949],\n", + " [0.72250252, 0.73133982, 0.7721519 ],\n", + " [0.66801211, 0.6754752 , 0.87341772],\n", + " [0.60847629, 0.61868336, 0.88607595],\n", + " [0.55398587, 0.56977283, 0.78481013],\n", + " [0.49545913, 0.51298099, 0.88607595],\n", + " [0.44500505, 0.45618915, 0.88607595],\n", + " [0.39959637, 0.40055633, 0.87341772],\n", + " [0.34308779, 0.34353268, 0.88607595],\n", + " [0.28960646, 0.28859527, 0.88607595],\n", + " [0.22300706, 0.22577654, 1. ],\n", + " [0.16851665, 0.16944831, 0.88607595],\n", + " [0.11402624, 0.1149745 , 0.88607595],\n", + " [0.05953582, 0.05748725, 0.88607595],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[0.09090909, 0. , 0. ],\n", + " [0. , 0.14289162, 1. ],\n", + " [0. , 0.28361091, 0.97014925],\n", + " [0.27272727, 0.42650253, 0.98507463],\n", + " [0.63636364, 0.5715665 , 0.98507463],\n", + " [1. , 0.71445812, 1. ],\n", + " [0.81818182, 0.85710838, 0.98507463],\n", + " [0.90909091, 1. , 0.98507463]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90708661, 0.90079474, 0.86419753],\n", + " [0.82572178, 0.81446972, 0.75308642],\n", + " [0.73070866, 0.71224993, 0.86419753],\n", + " [0.6351706 , 0.61030419, 0.86419753],\n", + " [0.53963255, 0.50972869, 0.86419753],\n", + " [0.43412073, 0.3959989 , 0.97530864],\n", + " [0.3191601 , 0.28610578, 1. ],\n", + " [0.21154856, 0.19101124, 0.86419753],\n", + " [0.10393701, 0.09372431, 0.86419753],\n", + " [0. , 0. , 0.83950617]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90077178, 0.90071344, 1. ],\n", + " [0.79713341, 0.79667063, 0.97183099],\n", + " [0.69652701, 0.69560048, 0.98591549],\n", + " [0.60915105, 0.60939358, 0.85915493],\n", + " [0.51074972, 0.51129608, 0.97183099],\n", + " [0.40656009, 0.40725327, 0.97183099],\n", + " [0.30733186, 0.30915577, 1. ],\n", + " [0.2053473 , 0.20630202, 0.97183099],\n", + " [0.09867696, 0.0980975 , 1. ],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09821019, 0.90069107, 0.875 ],\n", + " [0.19642038, 0.80163809, 0.875 ],\n", + " [0.29325379, 0.70360891, 0.85 ],\n", + " [0.39284075, 0.60302022, 0.8875 ],\n", + " [0.49150987, 0.50422319, 0.8875 ],\n", + " [0.59063791, 0.40542616, 0.875 ],\n", + " [0.6888481 , 0.30662913, 0.8625 ],\n", + " [0.80082607, 0.1952905 , 1. ],\n", + " [0.90041303, 0.09726133, 0.8625 ],\n", + " [1. , 0. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.23809524, 0.14565757, 0.79120879],\n", + " [0.38095238, 0.27617866, 0.72527473],\n", + " [0.71428571, 0.41290323, 0.73626374],\n", + " [0.71428571, 0.54367246, 0.72527473],\n", + " [0.80952381, 0.68734491, 0.78021978],\n", + " [0.95238095, 0.86774194, 1. ],\n", + " [1. , 1. , 0.71428571]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89869171, 0.90103781, 0.8875 ],\n", + " [0.79872526, 0.80244626, 0.875 ],\n", + " [0.70211338, 0.70644922, 0.8625 ],\n", + " [0.60348876, 0.60711638, 0.875 ],\n", + " [0.49211674, 0.49629355, 1. ],\n", + " [0.39248574, 0.39659007, 0.875 ],\n", + " [0.29352566, 0.29725723, 0.875 ],\n", + " [0.19389467, 0.19644181, 0.8875 ],\n", + " [0.09761825, 0.09859155, 0.8625 ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10938284, 0.10914052, 0.97014925],\n", + " [0.224285 , 0.22401091, 1. ],\n", + " [0.33266433, 0.33260573, 0.97014925],\n", + " [0.44405419, 0.44447476, 0.98507463],\n", + " [0.55644757, 0.5574352 , 1. ],\n", + " [0.66633216, 0.66712142, 0.97014925],\n", + " [0.77772203, 0.7781719 , 0.98507463],\n", + " [0.88861014, 0.88922237, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.1373212 , 0.14682003, 1. ],\n", + " [0.28322497, 0.30040595, 1. ],\n", + " [0.42288687, 0.45196211, 1. ],\n", + " [0.56827048, 0.60216509, 1. ],\n", + " [0.71053316, 0.73477673, 1. ],\n", + " [0.8556567 , 0.86738836, 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14103425, 0.14062887, 0.80722892],\n", + " [0.27938214, 0.27927705, 0.79518072],\n", + " [0.45601075, 0.45605348, 1. ],\n", + " [0.58159839, 0.58256994, 0.74698795],\n", + " [0.72061786, 0.7217133 , 0.77108434],\n", + " [0.86030893, 0.86110423, 0.79518072],\n", + " [1. , 1. , 0.79518072]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90676692, 0.87999087, 1. ],\n", + " [0.79097744, 0.76887976, 0.93055556],\n", + " [0.67218045, 0.66233174, 0.90277778],\n", + " [0.54887218, 0.55395848, 0.91666667],\n", + " [0.41954887, 0.44421629, 0.93055556],\n", + " [0.29172932, 0.32740132, 0.98611111],\n", + " [0.1924812 , 0.21879991, 0.91666667],\n", + " [0.09473684, 0.1076888 , 0.91666667],\n", + " [0. , 0. , 0.91666667]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87074148, 0.8702917 , 1. ],\n", + " [0.78006012, 0.77428491, 0.74725275],\n", + " [0.69839679, 0.68903993, 0.67032967],\n", + " [0.58867735, 0.57887284, 0.87912088],\n", + " [0.48697395, 0.47890116, 0.78021978],\n", + " [0.39178357, 0.38487681, 0.74725275],\n", + " [0.29458918, 0.2883036 , 0.76923077],\n", + " [0.19438878, 0.19031436, 0.78021978],\n", + " [0.09819639, 0.09629 , 0.75824176],\n", + " [0. , 0. , 0.76923077]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90481786, 0.90340741, 0.91139241],\n", + " [0.81668625, 0.81274074, 0.86075949],\n", + " [0.72581277, 0.72088889, 0.89873418],\n", + " [0.63650607, 0.6322963 , 0.88607595],\n", + " [0.54680768, 0.54488889, 0.89873418],\n", + " [0.44731688, 0.44651852, 1. ],\n", + " [0.36036036, 0.3602963 , 0.88607595],\n", + " [0.26400313, 0.2637037 , 1. ],\n", + " [0.17587152, 0.17422222, 0.91139241],\n", + " [0.08852331, 0.08711111, 0.87341772],\n", + " [0. , 0. , 0.88607595]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86020119, 0.14467005, 1. ],\n", + " [0.7173072 , 0.28680203, 1. ],\n", + " [0.57467114, 0.43654822, 1. ],\n", + " [0.42997163, 0.57106599, 1. ],\n", + " [0.28707764, 0.71573604, 1. ],\n", + " [0.1454733 , 0.85786802, 1. ],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.88974907, 0.89177489, 1. ],\n", + " [0.7736252 , 0.78354978, 0.97183099],\n", + " [0.67618793, 0.68831169, 0.85915493],\n", + " [0.565937 , 0.57359307, 0.98591549],\n", + " [0.44847838, 0.45887446, 0.98591549],\n", + " [0.33796049, 0.34199134, 0.98591549],\n", + " [0.22770956, 0.23160173, 0.97183099],\n", + " [0.11078484, 0.11255411, 0.98591549],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08544942, 0.85663082, 0.94285714],\n", + " [0.17573559, 0.70609319, 0.95714286],\n", + " [0.26279726, 0.56630824, 0.94285714],\n", + " [0.36074164, 0.44563919, 0.92857143],\n", + " [0.47722692, 0.35274791, 0.94285714],\n", + " [0.60419186, 0.26642772, 0.94285714],\n", + " [0.73397823, 0.17921147, 0.94285714],\n", + " [0.86255542, 0.09199522, 0.98571429],\n", + " [1. , 0. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.10675497, 0.78021978, 0.91666667],\n", + " [0.22251656, 0.6043956 , 0.91666667],\n", + " [0.34490066, 0.28571429, 1. ],\n", + " [0.45033113, 0.06593407, 0.90277778],\n", + " [0.55496689, 0. , 0.84722222],\n", + " [0.66675497, 0.16483516, 0.91666667],\n", + " [0.76874172, 0.43956044, 0.86111111],\n", + " [0.88662252, 0.72527473, 0.91666667],\n", + " [1. , 0.96703297, 0.93055556]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14412998, 0.14686469, 0.98507463],\n", + " [0.28930818, 0.29372937, 0.97014925],\n", + " [0.43422432, 0.44059406, 1. ],\n", + " [0.57756813, 0.58415842, 0.97014925],\n", + " [0.70938155, 0.71287129, 0.91044776],\n", + " [0.85560797, 0.85973597, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11208678, 0.10976616, 0.98412698],\n", + " [0.22365702, 0.22035763, 0.98412698],\n", + " [0.3357438 , 0.33122421, 0.98412698],\n", + " [0.44628099, 0.44209078, 0.98412698],\n", + " [0.5625 , 0.55488308, 1. ],\n", + " [0.66735537, 0.66519945, 0.96825397],\n", + " [0.77840909, 0.77661623, 0.98412698],\n", + " [0.88894628, 0.88830812, 0.98412698],\n", + " [1. , 1. , 0.98412698]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.09363195, 0.90345438, 0.875 ],\n", + " [0.18537507, 0.71656333, 0.95833333],\n", + " [0.27495953, 0.48361382, 1. ],\n", + " [0.35968699, 0.25863596, 0.95833333],\n", + " [0.44765246, 0.0761736 , 0.97222222],\n", + " [0.54020507, 0. , 0.95833333],\n", + " [0.63734485, 0.00797166, 0.98611111],\n", + " [0.73556395, 0.02834367, 0.95833333],\n", + " [0.83324339, 0.04517272, 0.97222222],\n", + " [0.91985969, 0.06200177, 0.97222222],\n", + " [1. , 0.09211692, 0.98611111]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13866069, 0.15498938, 0.91666667],\n", + " [0.29424944, 0.29299363, 1. ],\n", + " [0.43340802, 0.42887473, 0.91666667],\n", + " [0.57879014, 0.56900212, 0.93055556],\n", + " [0.7154593 , 0.72186837, 0.90277778],\n", + " [0.86109037, 0.85774947, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86044444, 0.12144638, 0.60185185],\n", + " [0.73777778, 0.24563591, 0.61111111],\n", + " [0.60533333, 0.3840399 , 0.66666667],\n", + " [0.376 , 0.59600998, 1. ],\n", + " [0.26222222, 0.73017456, 0.66666667],\n", + " [0.12533333, 0.87605985, 0.67592593],\n", + " [0. , 1. , 0.61111111]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.91712707, 0.08315514, 0.875 ],\n", + " [0.83867403, 0.1644096 , 0.875 ],\n", + " [0.75359116, 0.2482775 , 0.875 ],\n", + " [0.6839779 , 0.31765265, 0.7625 ],\n", + " [0.59889503, 0.40080779, 0.875 ],\n", + " [0.51381215, 0.48562604, 0.875 ],\n", + " [0.43093923, 0.56830601, 0.875 ],\n", + " [0.33149171, 0.66809218, 1. ],\n", + " [0.25303867, 0.74839629, 0.875 ],\n", + " [0.16464088, 0.8372535 , 0.875 ],\n", + " [0.08176796, 0.91708244, 0.875 ],\n", + " [0. , 1. , 0.875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89164905, 0.89003055, 0.875 ],\n", + " [0.78171247, 0.78033879, 0.875 ],\n", + " [0.6717759 , 0.67092474, 0.875 ],\n", + " [0.56342495, 0.56289919, 0.8625 ],\n", + " [0.45454545, 0.45348514, 0.875 ],\n", + " [0.34302326, 0.34296029, 0.9 ],\n", + " [0.21934461, 0.21993891, 0.975 ],\n", + " [0.09513742, 0.09497362, 1. ],\n", + " [0. , 0. , 0.7625 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89900387, 0.92107796, 0.98591549],\n", + " [0.79690094, 0.83253128, 0.97183099],\n", + " [0.6934145 , 0.72762271, 1. ],\n", + " [0.59241837, 0.62367661, 0.98591549],\n", + " [0.49252905, 0.52069297, 0.97183099],\n", + " [0.4039845 , 0.43022137, 0.85915493],\n", + " [0.30381848, 0.32435034, 0.98591549],\n", + " [0.20254566, 0.21751684, 0.97183099],\n", + " [0.10182623, 0.11068335, 0.98591549],\n", + " [0. , 0. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.14348908, 0.83253589, 0.98507463],\n", + " [0.28642521, 0.65550239, 1. ],\n", + " [0.42742604, 0.49282297, 0.97014925],\n", + " [0.57008571, 0.32057416, 0.98507463],\n", + " [0.7124689 , 0.19617225, 0.98507463],\n", + " [0.85595798, 0.11004785, 0.98507463],\n", + " [1. , 0. , 0.98507463]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.86910995, 0.11926606, 0.81 ],\n", + " [0.7556719 , 0.2214577 , 0.69 ],\n", + " [0.62303665, 0.34174312, 0.81 ],\n", + " [0.5104712 , 0.46279307, 0.8 ],\n", + " [0.36823735, 0.61442406, 0.98 ],\n", + " [0.2486911 , 0.73853211, 0.82 ],\n", + " [0.14485166, 0.84607543, 0.7 ],\n", + " [0. , 1. , 1. ]]),\n", + " array([[0.86666667, 0. , 0. ],\n", + " [0.7 , 0.15081071, 0.73333333],\n", + " [1. , 0.33033796, 0.74444444],\n", + " [0.43333333, 0.51553038, 1. ],\n", + " [0.7 , 0.69310412, 0.73333333],\n", + " [0. , 0.82359836, 0.72222222],\n", + " [0.36666667, 1. , 0.74444444]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9025522 , 0.89918699, 0.85 ],\n", + " [0.81722093, 0.81138211, 0.7625 ],\n", + " [0.69914927, 0.70243902, 1. ],\n", + " [0.5968033 , 0.59349593, 0.875 ],\n", + " [0.49574633, 0.49756098, 0.875 ],\n", + " [0.39391596, 0.39512195, 0.875 ],\n", + " [0.2910544 , 0.28780488, 0.875 ],\n", + " [0.18948183, 0.19349593, 0.8875 ],\n", + " [0.08945605, 0.08780488, 0.8625 ],\n", + " [0. , 0. , 0.7625 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90016685, 0.88480392, 0.98571429],\n", + " [0.79810901, 0.76715686, 1. ],\n", + " [0.69549499, 0.66421569, 1. ],\n", + " [0.60567297, 0.57352941, 0.88571429],\n", + " [0.50389321, 0.47058824, 0.98571429],\n", + " [0.39988877, 0.37254902, 0.98571429],\n", + " [0.2942158 , 0.28431373, 0.98571429],\n", + " [0.20439377, 0.20588235, 0.87142857],\n", + " [0.09510567, 0.08823529, 1. ],\n", + " [0. , 0. , 0.87142857]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.15734266, 0.15859031, 0.83333333],\n", + " [0.30150619, 0.3001888 , 0.75833333],\n", + " [0.4112426 , 0.4090623 , 0.58333333],\n", + " [0.58284024, 0.58464443, 0.925 ],\n", + " [0.76923077, 0.77281309, 1. ],\n", + " [0.87708445, 0.87979862, 0.575 ],\n", + " [1. , 1. , 0.675 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90179543, 0.89778535, 0.78888889],\n", + " [0.80522307, 0.79812606, 0.77777778],\n", + " [0.70674646, 0.70187394, 0.78888889],\n", + " [0.61153428, 0.60477002, 0.77777778],\n", + " [0.5008161 , 0.49403748, 0.86666667],\n", + " [0.40533188, 0.39948893, 0.78888889],\n", + " [0.3054951 , 0.29982964, 0.76666667],\n", + " [0.20973885, 0.20868825, 0.77777778],\n", + " [0.085963 , 0.08688245, 1. ],\n", + " [0. , 0. , 0.68888889]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90535642, 0.92314119, 0.97183099],\n", + " [0.83125252, 0.8512949 , 0.85915493],\n", + " [0.74748288, 0.76552492, 0.97183099],\n", + " [0.66290777, 0.67836257, 1. ],\n", + " [0.58034636, 0.59370649, 0.97183099],\n", + " [0.49496577, 0.50654414, 1. ],\n", + " [0.41159887, 0.42133111, 0.98591549],\n", + " [0.33064841, 0.33834586, 0.97183099],\n", + " [0.24808699, 0.25396825, 1. ],\n", + " [0.16673379, 0.17070454, 0.97183099],\n", + " [0.08296416, 0.08437761, 0.98591549],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.08262108, 0.90988584, 0.95774648],\n", + " [0.17094017, 0.81928589, 0.98591549],\n", + " [0.27065527, 0.72431382, 1. ],\n", + " [0.36467236, 0.63104202, 1. ],\n", + " [0.44729345, 0.53995628, 0.97183099],\n", + " [0.53561254, 0.44911343, 0.97183099],\n", + " [0.62962963, 0.37017246, 0.85915493],\n", + " [0.72079772, 0.27908671, 0.97183099],\n", + " [0.82905983, 0.18581491, 1. ],\n", + " [0.93732194, 0.09424338, 0.97183099],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8375 , 0.9146477 , 0.98591549],\n", + " [0.6875 , 0.83196266, 0.97183099],\n", + " [0.5625 , 0.74683263, 0.98591549],\n", + " [0.4625 , 0.66370305, 1. ],\n", + " [0.3375 , 0.58012892, 0.97183099],\n", + " [0.1625 , 0.49655479, 1. ],\n", + " [0. , 0.41342521, 0.97183099],\n", + " [0.025 , 0.32851745, 0.98591549],\n", + " [0.1125 , 0.24427651, 0.98591549],\n", + " [0.15 , 0.17026006, 0.85915493],\n", + " [0.225 , 0.08490776, 0.98591549],\n", + " [0.2625 , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.92330623, 0.92857143, 0.875 ],\n", + " [0.84661247, 0.85064935, 0.875 ],\n", + " [0.78102981, 0.78409091, 0.7625 ],\n", + " [0.70542005, 0.70779221, 0.8625 ],\n", + " [0.62059621, 0.61525974, 1. ],\n", + " [0.54363144, 0.53733766, 0.875 ],\n", + " [0.46666667, 0.46266234, 0.875 ],\n", + " [0.39214092, 0.38636364, 0.875 ],\n", + " [0.31463415, 0.31168831, 0.8875 ],\n", + " [0.23821138, 0.23376623, 0.875 ],\n", + " [0.16341463, 0.16233766, 0.8625 ],\n", + " [0.07696477, 0.0762987 , 1. ],\n", + " [0. , 0. , 0.875 ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91076257, 0.90163934, 0.875 ],\n", + " [0.82287723, 0.79391101, 0.8625 ],\n", + " [0.73201731, 0.70023419, 0.8875 ],\n", + " [0.6430503 , 0.6088993 , 0.875 ],\n", + " [0.55164954, 0.51522248, 0.875 ],\n", + " [0.46106003, 0.41920375, 0.875 ],\n", + " [0.37182261, 0.32552693, 0.875 ],\n", + " [0.26960519, 0.22716628, 1. ],\n", + " [0.17982693, 0.15222482, 0.875 ],\n", + " [0.08869659, 0.08196721, 0.8875 ],\n", + " [0. , 0. , 0.8625 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87873462, 0. , 1. ],\n", + " [0.77403967, 0. , 0.86419753],\n", + " [0.65679136, 0. , 0.96296296],\n", + " [0.5438112 , 0. , 0.92592593],\n", + " [0.44338438, 0. , 0.80246914],\n", + " [0.33467236, 0. , 0.88888889],\n", + " [0.2299774 , 0. , 0.85185185],\n", + " [0.12553352, 0. , 0.86419753],\n", + " [0. , 1. , 0.98765432]]),\n", + " array([[0.02540835, 0. , 0. ],\n", + " [0. , 0.12496662, 1. ],\n", + " [0.02631579, 0.24993324, 0.95833333],\n", + " [0.11751361, 0.35941255, 0.97222222],\n", + " [0.25635209, 0.44432577, 0.98611111],\n", + " [0.40517241, 0.49986649, 0.97222222],\n", + " [0.55626134, 0.55246996, 0.97222222],\n", + " [0.70372051, 0.60507343, 0.95833333],\n", + " [0.84392015, 0.66782377, 0.97222222],\n", + " [0.95326679, 0.76555407, 0.97222222],\n", + " [1. , 0.8753004 , 0.86111111],\n", + " [0.98593466, 1. , 0.94444444]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.14715822, 0.84768908, 0.6875 ],\n", + " [0.29953917, 0.69222689, 0.6875 ],\n", + " [0.44884793, 0.54271709, 0.6875 ],\n", + " [0.66850998, 0.32703081, 1. ],\n", + " [0.84884793, 0.14985994, 0.8125 ],\n", + " [1. , 0. , 0.6875 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.10768478, 0.8967334 , 1. ],\n", + " [0.20264317, 0.80532139, 0.8625 ],\n", + " [0.28781204, 0.72128556, 0.8 ],\n", + " [0.37249143, 0.63303477, 0.8375 ],\n", + " [0.46157611, 0.53767123, 0.8875 ],\n", + " [0.54380813, 0.45495258, 0.775 ],\n", + " [0.63142438, 0.36801897, 0.8375 ],\n", + " [0.72393539, 0.27818757, 0.8625 ],\n", + " [0.81889378, 0.18361433, 0.8875 ],\n", + " [0.90993637, 0.09193888, 0.8875 ],\n", + " [1. , 0. , 0.8625 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.13893654, 0.13689095, 1. ],\n", + " [0.26357919, 0.26102088, 0.91666667],\n", + " [0.38593482, 0.38352668, 0.91666667],\n", + " [0.50943396, 0.50835267, 0.91666667],\n", + " [0.63464837, 0.63271462, 0.90277778],\n", + " [0.74957118, 0.74802784, 0.84722222],\n", + " [0.87421384, 0.87285383, 0.91666667],\n", + " [1. , 1. , 0.91666667]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.87606383, 0.12567463, 0.97014925],\n", + " [0.75106383, 0.25314829, 1. ],\n", + " [0.62340426, 0.38190696, 0.98507463],\n", + " [0.49414894, 0.50809561, 0.98507463],\n", + " [0.36595745, 0.63351324, 0.97014925],\n", + " [0.24946809, 0.74916474, 0.91044776],\n", + " [0.12021277, 0.87586739, 0.97014925],\n", + " [0. , 1. , 1. ]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85641244, 0.85544267, 0.98507463],\n", + " [0.70941628, 0.70798258, 0.97014925],\n", + " [0.56838517, 0.56806967, 1. ],\n", + " [0.42394546, 0.42351234, 0.98507463],\n", + " [0.28845334, 0.28795356, 0.98507463],\n", + " [0.13634427, 0.13642961, 0.98507463],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[9.92181070e-01, 4.05246744e-01, 0.00000000e+00],\n", + " [9.92592593e-01, 3.45808109e-01, 1.78384050e-03],\n", + " [9.91358025e-01, 2.95725555e-01, 1.60020986e-03],\n", + " [9.90946502e-01, 2.42891213e-01, 1.83630640e-03],\n", + " [9.91769547e-01, 1.95927353e-01, 1.86253935e-03],\n", + " [9.93415638e-01, 1.57035406e-01, 1.78384050e-03],\n", + " [9.93004115e-01, 1.22179417e-01, 1.86253935e-03],\n", + " [9.93004115e-01, 9.20931939e-02, 1.83630640e-03],\n", + " [9.98765432e-01, 7.02623372e-02, 1.65267576e-03],\n", + " [1.00000000e+00, 5.09998165e-02, 1.67890871e-03],\n", + " [9.90534979e-01, 3.39387268e-02, 1.65267576e-03],\n", + " [9.71604938e-01, 2.03632361e-02, 1.65267576e-03],\n", + " [9.41975309e-01, 1.24747753e-02, 1.67890871e-03],\n", + " [9.01234568e-01, 1.41258485e-02, 1.65267576e-03],\n", + " [8.50205761e-01, 2.01797835e-02, 1.83630640e-03],\n", + " [7.91358025e-01, 2.77013392e-02, 1.81007345e-03],\n", + " [7.34156379e-01, 3.61401578e-02, 1.70514166e-03],\n", + " [6.71193416e-01, 3.81581361e-02, 1.73137461e-03],\n", + " [6.06995885e-01, 3.66905155e-02, 1.83630640e-03],\n", + " [5.43209877e-01, 3.44890846e-02, 1.81007345e-03],\n", + " [4.80246914e-01, 3.11869382e-02, 1.86253935e-03],\n", + " [4.25925926e-01, 2.82516969e-02, 1.60020986e-03],\n", + " [3.65843621e-01, 2.53164557e-02, 1.78384050e-03],\n", + " [3.04938272e-01, 2.38488351e-02, 1.83630640e-03],\n", + " [2.55555556e-01, 2.27481196e-02, 1.62644281e-03],\n", + " [2.04115226e-01, 2.12804990e-02, 1.78384050e-03],\n", + " [1.62551440e-01, 1.92625206e-02, 1.60020986e-03],\n", + " [1.18930041e-01, 1.83452578e-02, 1.83630640e-03],\n", + " [8.31275720e-02, 1.65107320e-02, 1.83630640e-03],\n", + " [6.54320988e-02, 1.57769217e-02, 1.86253935e-03],\n", + " [5.26748971e-02, 1.43093010e-02, 1.81007345e-03],\n", + " [4.19753086e-02, 1.17409650e-02, 1.83630640e-03],\n", + " [3.16872428e-02, 1.10071547e-02, 1.83630640e-03],\n", + " [2.13991770e-02, 9.35608145e-03, 1.83630640e-03],\n", + " [1.15226337e-02, 8.62227114e-03, 1.86253935e-03],\n", + " [4.93827160e-03, 7.52155568e-03, 1.78384050e-03],\n", + " [4.11522634e-04, 7.52155568e-03, 1.21720881e-02],\n", + " [0.00000000e+00, 1.00898918e-02, 1.00000000e+00],\n", + " [4.11522634e-03, 1.52265639e-02, 1.81007345e-03],\n", + " [1.39917695e-02, 1.98128784e-02, 1.60020986e-03],\n", + " [3.33333333e-02, 2.23812145e-02, 1.83630640e-03],\n", + " [6.29629630e-02, 2.40322877e-02, 1.83630640e-03],\n", + " [9.62962963e-02, 2.62337186e-02, 1.78384050e-03],\n", + " [1.27572016e-01, 2.45826454e-02, 1.60020986e-03],\n", + " [1.62139918e-01, 1.96294258e-02, 1.86253935e-03],\n", + " [1.85185185e-01, 1.17409650e-02, 1.65267576e-03],\n", + " [1.93415638e-01, 5.87048248e-03, 1.65267576e-03],\n", + " [1.90123457e-01, 2.38488351e-03, 1.65267576e-03],\n", + " [1.80658436e-01, 0.00000000e+00, 1.67890871e-03],\n", + " [1.73662551e-01, 6.42084021e-03, 1.65267576e-03],\n", + " [1.83539095e-01, 1.68776371e-02, 1.62644281e-03],\n", + " [2.06584362e-01, 2.58668134e-02, 1.70514166e-03],\n", + " [2.47325103e-01, 2.84351495e-02, 1.73137461e-03],\n", + " [2.92592593e-01, 2.86186021e-02, 1.60020986e-03],\n", + " [3.45679012e-01, 2.86186021e-02, 1.81007345e-03],\n", + " [4.02469136e-01, 2.99027701e-02, 1.86253935e-03],\n", + " [4.57613169e-01, 3.24711062e-02, 1.81007345e-03],\n", + " [5.16049383e-01, 3.46725371e-02, 1.83630640e-03],\n", + " [5.76131687e-01, 3.65070629e-02, 1.83630640e-03],\n", + " [6.35390947e-01, 4.12768299e-02, 1.81007345e-03],\n", + " [6.90123457e-01, 4.69638598e-02, 1.70514166e-03],\n", + " [7.41975309e-01, 4.16437351e-02, 1.70514166e-03],\n", + " [7.84362140e-01, 3.50394423e-02, 1.60020986e-03],\n", + " [8.21810700e-01, 2.69675289e-02, 1.60020986e-03],\n", + " [8.63786008e-01, 1.79783526e-02, 1.65267576e-03],\n", + " [9.09465021e-01, 1.35754907e-02, 1.73137461e-03],\n", + " [9.48559671e-01, 2.34819299e-02, 1.67890871e-03],\n", + " [9.74074074e-01, 4.78811227e-02, 1.65267576e-03],\n", + " [9.81893004e-01, 8.47550908e-02, 1.65267576e-03],\n", + " [9.81069959e-01, 1.33736929e-01, 1.86253935e-03],\n", + " [9.83950617e-01, 1.90423775e-01, 1.81007345e-03],\n", + " [9.88065844e-01, 2.54448725e-01, 1.83630640e-03],\n", + " [9.88477366e-01, 3.23059989e-01, 1.86253935e-03],\n", + " [9.90123457e-01, 3.91854706e-01, 1.83630640e-03],\n", + " [9.89711934e-01, 4.49275362e-01, 1.65267576e-03],\n", + " [9.47736626e-01, 4.94955054e-01, 1.65267576e-03],\n", + " [8.76543210e-01, 5.25591635e-01, 1.65267576e-03],\n", + " [7.88065844e-01, 5.41368556e-01, 1.67890871e-03],\n", + " [6.89300412e-01, 5.49623922e-01, 1.73137461e-03],\n", + " [5.90946502e-01, 5.58796551e-01, 1.67890871e-03],\n", + " [5.26337449e-01, 5.87782058e-01, 1.65267576e-03],\n", + " [4.77777778e-01, 6.26490552e-01, 1.67890871e-03],\n", + " [4.22633745e-01, 6.77490369e-01, 1.81007345e-03],\n", + " [3.62139918e-01, 7.35644836e-01, 1.83630640e-03],\n", + " [2.96707819e-01, 8.00036691e-01, 1.83630640e-03],\n", + " [2.32098765e-01, 8.67547239e-01, 1.81007345e-03],\n", + " [1.76543210e-01, 9.27719684e-01, 1.60020986e-03],\n", + " [1.13580247e-01, 1.00000000e+00, 1.86253935e-03]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.10739615, 0.1119334 , 1. ],\n", + " [0.21884498, 0.22340426, 0.95833333],\n", + " [0.33839919, 0.33533765, 0.97222222],\n", + " [0.44782168, 0.4440333 , 0.97222222],\n", + " [0.56737589, 0.55874191, 0.98611111],\n", + " [0.67173252, 0.66836263, 0.95833333],\n", + " [0.7781155 , 0.77775208, 0.97222222],\n", + " [0.89665653, 0.89176688, 0.98611111],\n", + " [1. , 1. , 0.95833333]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.83870968, 0.18051218, 1. ],\n", + " [0.67741935, 0.34603373, 0.91666667],\n", + " [0.35483871, 0.48573808, 0.91666667],\n", + " [0.27419355, 0.675203 , 0.91666667],\n", + " [0. , 0.81324172, 0.91666667],\n", + " [0.03225806, 1. , 0.91666667]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.07546674, 0.06754221, 0.95774648],\n", + " [0.14462267, 0.14071295, 0.85915493],\n", + " [0.21088614, 0.20825516, 0.85915493],\n", + " [0.28740468, 0.28142589, 0.97183099],\n", + " [0.36497502, 0.37148218, 0.97183099],\n", + " [0.433868 , 0.44090056, 0.85915493],\n", + " [0.51354194, 0.51782364, 0.98591549],\n", + " [0.59347883, 0.59287054, 0.98591549],\n", + " [0.67525638, 0.66228893, 1. ],\n", + " [0.75729687, 0.75046904, 0.98591549],\n", + " [0.83802261, 0.83114447, 0.97183099],\n", + " [0.91953721, 0.91557223, 1. ],\n", + " [1. , 1. , 0.98591549]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.85732041, 0.71428571, 0.91666667],\n", + " [0.71488939, 1. , 0.91666667],\n", + " [0.58563261, 1. , 0.84722222],\n", + " [0.44270445, 0.42857143, 0.90277778],\n", + " [0.30027343, 0.71428571, 0.91666667],\n", + " [0.14491673, 0.42857143, 1. ],\n", + " [0. , 1. , 0.91666667]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12607204, 0.12433989, 0.98507463],\n", + " [0.25557461, 0.25132021, 0.97014925],\n", + " [0.38336192, 0.37566011, 0.98507463],\n", + " [0.51200686, 0.50120019, 0.98507463],\n", + " [0.6406518 , 0.62698032, 1. ],\n", + " [0.75471698, 0.74843975, 0.98507463],\n", + " [0.87049743, 0.87469995, 0.98507463],\n", + " [1. , 1. , 0.98507463]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.11052763, 0.14403292, 0.72527473],\n", + " [0.21730433, 0.24691358, 0.73626374],\n", + " [0.31732933, 0.33950617, 0.67032967],\n", + " [0.4236059 , 0.45884774, 0.72527473],\n", + " [0.52988247, 0.54526749, 0.72527473],\n", + " [0.63490873, 0.62757202, 0.73626374],\n", + " [0.7511878 , 0.75102881, 0.79120879],\n", + " [0.85446362, 0.84979424, 0.69230769],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.12434002, 0.14088983, 1. ],\n", + " [0.2344245 , 0.23305085, 0.8875 ],\n", + " [0.34609293, 0.33368644, 0.875 ],\n", + " [0.45353749, 0.44597458, 0.8625 ],\n", + " [0.56362196, 0.55720339, 0.875 ],\n", + " [0.65733897, 0.65042373, 0.7625 ],\n", + " [0.76636748, 0.76165254, 0.8625 ],\n", + " [0.89017951, 0.89300847, 0.9875 ],\n", + " [1. , 1. , 0.875 ]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.07529208, 0.07518337, 1. ],\n", + " [0.15318044, 0.15281174, 1. ],\n", + " [0.23063609, 0.23013447, 1. ],\n", + " [0.30765902, 0.30776284, 1. ],\n", + " [0.38554738, 0.38569682, 1. ],\n", + " [0.46127218, 0.46210269, 1. ],\n", + " [0.53916054, 0.54003667, 1. ],\n", + " [0.6170489 , 0.61797066, 1. ],\n", + " [0.69363912, 0.69437653, 1. ],\n", + " [0.77022934, 0.77139364, 1. ],\n", + " [0.84681956, 0.84810513, 1. ],\n", + " [0.92340978, 0.924511 , 1. ],\n", + " [1. , 1. , 1. ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.10249237, 0.89552239, 1. ],\n", + " [0.20116989, 0.80099502, 0.97183099],\n", + " [0.30111902, 0.69983416, 0.98591549],\n", + " [0.40081384, 0.61028192, 0.98591549],\n", + " [0.50305188, 0.51243781, 1. ],\n", + " [0.60274669, 0.40961857, 0.98591549],\n", + " [0.70066124, 0.30182421, 0.97183099],\n", + " [0.79984741, 0.20066335, 1. ],\n", + " [0.89877925, 0.10447761, 0.97183099],\n", + " [1. , 0. , 1. ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.85803432, 0.14175655, 0.91666667],\n", + " [0.71346854, 0.28608115, 0.91666667],\n", + " [0.56058242, 0.43939394, 1. ],\n", + " [0.41809672, 0.58217771, 0.90277778],\n", + " [0.28653146, 0.71237802, 0.84722222],\n", + " [0.14352574, 0.8556754 , 0.91666667],\n", + " [0. , 1. , 0.90277778]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.91984334, 0.9775641 , 0.85915493],\n", + " [0.8308094 , 0.93269231, 0.97183099],\n", + " [0.7381201 , 0.75641026, 0.98591549],\n", + " [0.6464752 , 0.51923077, 1. ],\n", + " [0.55587467, 0.44230769, 0.97183099],\n", + " [0.46109661, 0.38141026, 1. ],\n", + " [0.37180157, 0.34935897, 0.97183099],\n", + " [0.27832898, 0.30448718, 1. ],\n", + " [0.18720627, 0.18910256, 0.97183099],\n", + " [0.09373368, 0.05128205, 1. ],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.89972074, 0.89626055, 0.8625 ],\n", + " [0.78446306, 0.77925211, 1. ],\n", + " [0.69840061, 0.68757539, 0.7625 ],\n", + " [0.58415842, 0.55850422, 0.9875 ],\n", + " [0.4843869 , 0.44270205, 0.8875 ],\n", + " [0.38563087, 0.33655006, 0.8625 ],\n", + " [0.2863671 , 0.24366707, 0.8625 ],\n", + " [0.20106626, 0.17370326, 0.7625 ],\n", + " [0.10307185, 0.09650181, 0.8625 ],\n", + " [0. , 0. , 0.8875 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.8638814 , 0.1354871 , 0.78571429],\n", + " [0.71428571, 0.28124217, 0.85714286],\n", + " [0.53773585, 0.45404458, 1. ],\n", + " [0.40161725, 0.590283 , 0.78571429],\n", + " [0.26954178, 0.72652141, 0.77380952],\n", + " [0.13477089, 0.86551465, 0.79761905],\n", + " [0. , 1. , 0.78571429]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.90916737, 0.94017094, 0.95833333],\n", + " [0.81889543, 0.85327635, 0.95833333],\n", + " [0.72694141, 0.75783476, 0.98611111],\n", + " [0.63751051, 0.66809117, 0.97222222],\n", + " [0.54667788, 0.57692308, 0.97222222],\n", + " [0.45360247, 0.48290598, 0.98611111],\n", + " [0.36192879, 0.38319088, 0.97222222],\n", + " [0.27361929, 0.29059829, 0.94444444],\n", + " [0.18222596, 0.19230769, 0.97222222],\n", + " [0.08999159, 0.09116809, 1. ],\n", + " [0. , 0. , 0.94444444]]),\n", + " array([[0. , 0. , 0. ],\n", + " [0.14893617, 0.12458234, 0.98507463],\n", + " [0.28723404, 0.24844869, 0.98507463],\n", + " [0.36170213, 0.37374702, 0.97014925],\n", + " [0.45744681, 0.50071599, 0.98507463],\n", + " [0.61702128, 0.62625298, 1. ],\n", + " [0.74468085, 0.75131265, 0.98507463],\n", + " [0.88297872, 0.87661098, 0.98507463],\n", + " [1. , 1. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.85517241, 0.85358025, 0.98507463],\n", + " [0.71724138, 0.70962963, 0.98507463],\n", + " [0.5862069 , 0.57382716, 0.98507463],\n", + " [0.42758621, 0.42271605, 0.98507463],\n", + " [0.30344828, 0.28691358, 1. ],\n", + " [0.13793103, 0.14049383, 0.98507463],\n", + " [0. , 0. , 0.97014925]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.9091623 , 0.85028249, 1. ],\n", + " [0.81963351, 0.72033898, 0.95774648],\n", + " [0.72774869, 0.62146893, 1. ],\n", + " [0.63298429, 0.52824859, 1. ],\n", + " [0.5434555 , 0.4180791 , 0.95774648],\n", + " [0.46361257, 0.33898305, 0.87323944],\n", + " [0.37382199, 0.27118644, 0.95774648],\n", + " [0.28010471, 0.21186441, 1. ],\n", + " [0.18586387, 0.14971751, 1. ],\n", + " [0.09424084, 0.0819209 , 0.97183099],\n", + " [0. , 0. , 0.98591549]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.8994695 , 0.89759503, 0.98591549],\n", + " [0.80132626, 0.79674166, 0.98591549],\n", + " [0.70185676, 0.6935609 , 0.98591549],\n", + " [0.60291777, 0.60046548, 0.97183099],\n", + " [0.50159151, 0.49650892, 1. ],\n", + " [0.40212202, 0.39953452, 0.98591549],\n", + " [0.29920424, 0.29402638, 0.98591549],\n", + " [0.19973475, 0.19782777, 0.98591549],\n", + " [0.09761273, 0.0969744 , 0.98591549],\n", + " [0. , 0. , 0.97183099]]),\n", + " array([[1. , 1. , 0. ],\n", + " [0.87866978, 0.86832061, 1. ],\n", + " [0.77058976, 0.76526718, 0.91666667],\n", + " [0.65887243, 0.65839695, 0.91666667],\n", + " [0.55079241, 0.54961832, 0.90277778],\n", + " [0.43907508, 0.42938931, 0.93055556],\n", + " [0.3289166 , 0.32824427, 0.91666667],\n", + " [0.22057677, 0.21374046, 0.91666667],\n", + " [0.11041829, 0.10496183, 0.90277778],\n", + " [0. , 0. , 0.93055556]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.06101104, 0.9713644 , 0.875 ],\n", + " [0.11359675, 0.93935991, 0.875 ],\n", + " [0.15979082, 0.90230208, 0.8875 ],\n", + " [0.19726903, 0.86524424, 0.875 ],\n", + " [0.22719349, 0.83267827, 0.85 ],\n", + " [0.25392214, 0.79337451, 0.8875 ],\n", + " [0.27803603, 0.75912409, 1. ],\n", + " [0.29924463, 0.7237507 , 0.9875 ],\n", + " [0.31900058, 0.67770915, 0.9 ],\n", + " [0.34195235, 0.62099944, 0.8625 ],\n", + " [0.37855898, 0.5300393 , 1. ],\n", + " [0.42475305, 0.43851769, 0.875 ],\n", + " [0.47298083, 0.35429534, 0.7625 ],\n", + " [0.5403835 , 0.26558113, 0.85 ],\n", + " [0.60981987, 0.19876474, 0.7625 ],\n", + " [0.69755956, 0.1398091 , 0.8625 ],\n", + " [0.79488669, 0.08927569, 0.8875 ],\n", + " [0.89570017, 0.04211117, 0.8875 ],\n", + " [1. , 0. , 0.875 ]]),\n", + " array([[1. , 0. , 0. ],\n", + " [0.90451389, 0.09230769, 0.875 ],\n", + " [0.81770833, 0.18353576, 0.875 ],\n", + " [0.73784722, 0.26153846, 0.7625 ],\n", + " [0.65046296, 0.35195682, 0.8625 ],\n", + " [0.56076389, 0.44156545, 0.875 ],\n", + " [0.4693287 , 0.53333333, 0.875 ],\n", + " [0.37673611, 0.62537112, 0.875 ],\n", + " [0.28530093, 0.71659919, 0.875 ],\n", + " [0.18229167, 0.81862348, 1. ],\n", + " [0.09259259, 0.90877193, 0.8625 ],\n", + " [0. , 1. , 0.9 ]]),\n", + " array([[0. , 1. , 0. ],\n", + " [0.13981849, 0.8614098 , 1. ],\n", + " [0.26035167, 0.73715651, 0.86419753],\n", + " [0.39619966, 0.6051374 , 0.97530864],\n", + " [0.51162791, 0.48864994, 0.82716049],\n", + " [0.64577425, 0.34946237, 0.96296296],\n", + " [0.76829268, 0.22640382, 0.87654321],\n", + " [0.87975043, 0.11827957, 0.80246914],\n", + " [1. , 0. , 0.85185185]])]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.corpus" + ] + }, { "cell_type": "markdown", "id": "12e4c956-0b49-4d06-9ff0-201cd1f3a27e", @@ -576,7 +11009,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.17" + "version": "3.9.18" } }, "nbformat": 4, From 47d002ab36c837ea4100b454e1b31b3be7d95794 Mon Sep 17 00:00:00 2001 From: rchan Date: Thu, 2 Nov 2023 11:58:52 +0000 Subject: [PATCH 12/22] run with updated code --- paper-examples/UCR_data_support.py | 30 +- paper-examples/examples.ipynb | 10616 ++------------------------- 2 files changed, 450 insertions(+), 10196 deletions(-) diff --git a/paper-examples/UCR_data_support.py b/paper-examples/UCR_data_support.py index be56e48..4ca0480 100644 --- a/paper-examples/UCR_data_support.py +++ b/paper-examples/UCR_data_support.py @@ -7,7 +7,15 @@ DATA_DIR = "/Users/zoos/PycharmProjects/Anomaly_detection/data/" -def compute_best_and_std(data_set, iter, data, signature_maha_knn, anomaly_level=0.001): +def compute_best_and_std( + data_set, + iter, + data, + signature_maha_knn, + depth, + n_neighbours, + anomaly_level=0.001, +): tnfn = {} for d in data_set: tnfn[d] = [] @@ -17,9 +25,23 @@ def compute_best_and_std(data_set, iter, data, signature_maha_knn, anomaly_level data_set_name=d, random_state=random_state, anomaly_level=anomaly_level ) # anomaly detection - signature_maha_knn.fit(data.corpus) - inlier_dists = signature_maha_knn.conformance(data.test_inlier) - outlier_dists = signature_maha_knn.conformance(data.test_outlier) + # Measure the time spent on fit + signature_maha_knn.fit( + knn_library="sklearn", + X_train=data.corpus, + signature_kwargs={ + "augmentation_list": ("addtime",), + "depth": depth, + }, + ) + + # Measure the time spent on conformance + inlier_dists = signature_maha_knn.conformance( + data.test_inlier, n_neighbors=n_neighbours + ) + outlier_dists = signature_maha_knn.conformance( + data.test_outlier, n_neighbors=n_neighbours + ) tnfn[d].append(compute_tn_fn_for_all_thres(inlier_dists, outlier_dists)) diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index de9b124..5106faf 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "b7a56abc", "metadata": {}, "outputs": [], @@ -392,7 +392,7 @@ " },\n", " )\n", " fit_time = time.time() - start_time\n", - " print(\"fit_time: \", fit_time)\n", + " print(f\"fit_time: {fit_time}\")\n", "\n", " # Measure the time spent on conformance\n", " start_time = time.time()\n", @@ -403,7 +403,7 @@ " data.test_outlier, n_neighbors=n_neighbours\n", " )\n", " compute_auc_time = time.time() - start_time\n", - " print(\"compute_auc_time: \", compute_auc_time)\n", + " print(f\"compute_auc_time: {compute_auc_time}\")\n", "\n", " digit_to_inlier_dists[digit] = inlier_dists\n", " digit_to_outlier_dists[digit] = outlier_dists\n", @@ -423,25 +423,75 @@ " depth_to_auc[depth] = auc" ] }, + { + "cell_type": "markdown", + "id": "79e05b28", + "metadata": {}, + "source": [ + "## Can we reproduce distances?\n", + "\n", + "For depth 4, digit 0:" + ] + }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 27, + "id": "a4675b42", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 0 doing signature level 4\n", + "fit_time: 1.786160945892334\n" + ] + } + ], + "source": [ + "digit = 0\n", + "depth = 4\n", + "data.load_pen_digit(digit=digit)\n", + "print(\"doing digit\", digit, \"doing signature level \", depth)\n", + "signature_maha_knn = SignatureMahalanobisKNN()\n", + "# Measure the time spent on fit\n", + "start_time = time.time()\n", + "signature_maha_knn.fit(\n", + " knn_library=\"sklearn\",\n", + " X_train=data.corpus,\n", + " signature_kwargs={\n", + " \"depth\": depth,\n", + " },\n", + ")\n", + "fit_time = time.time() - start_time\n", + "print(f\"fit_time: {fit_time}\")\n", + "\n", + "inlier_dists = signature_maha_knn.conformance(\n", + " data.test_inlier, n_neighbors=n_neighbours\n", + ")\n", + "outlier_dists = signature_maha_knn.conformance(\n", + " data.test_outlier, n_neighbors=n_neighbours\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, "id": "fa3d0039-5d50-4aa8-ac91-f76a83513315", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 0.37542346, 0.6084737 , 0.5330198 , 2.0521839 , 18.178993 ,\n", - " 0.9051934 , 0.66631705, 11.695885 , 0.7718717 , 0.6693719 ,\n", - " 1.4397979 , 0.6041697 , 0.6704992 , 5.289418 , 0.52658904,\n", - " 6.532274 , 1.2970588 , 27.432434 , 1.2141329 , 15.89954 ,\n", - " 0.6093601 , 1.6905133 , 0.64199626, 0.49906355, 0.42805055,\n", - " 0.36041334, 0.41619825, 4.1343365 , 3.3879225 , 0.92946756],\n", - " dtype=float32)" + "array([0.10293763, 0.21655908, 0.17555342, 0.37821957, 2.52220155,\n", + " 0.25794536, 0.19356175, 1.8735614 , 0.21667799, 0.21799781,\n", + " 0.30084204, 0.14079295, 0.19137239, 1.0841934 , 0.20703369,\n", + " 1.16883841, 0.25666209, 4.09705851, 0.28626317, 2.27759731,\n", + " 0.17592573, 0.40444251, 0.22031607, 0.152825 , 0.13235025,\n", + " 0.12575332, 0.14180312, 0.65683611, 0.78451488, 0.23221037])" ] }, - "execution_count": 15, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -491,23 +541,22 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 29, "id": "7b24a162-ab61-42ec-92d0-31067441e1ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([246.81157 , 45.91195 , 23.841997, 101.71473 , 32.23767 ,\n", - " 23.344664, 61.933914, 88.72693 , 274.00122 , 229.67078 ,\n", - " 55.578976, 194.31023 , 124.48786 , 128.36687 , 96.641365,\n", - " 66.92221 , 240.74686 , 238.1418 , 198.62576 , 65.794754,\n", - " 51.987164, 281.74393 , 194.5858 , 243.91685 , 10.673991,\n", - " 34.443893, 125.14485 , 132.93954 , 159.01588 , 112.86924 ],\n", - " dtype=float32)" + "array([22.91785796, 5.13259221, 3.1411223 , 8.72980904, 4.24595201,\n", + " 2.95224877, 5.04656285, 8.58317299, 25.66333466, 21.39243841,\n", + " 6.60518334, 18.39905365, 8.09815035, 8.45932109, 7.80032309,\n", + " 6.29733469, 21.82005658, 20.12689115, 19.32945792, 8.55422835,\n", + " 5.30316279, 25.21674903, 17.62691334, 19.85905925, 1.38845035,\n", + " 4.07114126, 8.38638713, 13.33983856, 15.38123633, 13.02245564])" ] }, - "execution_count": 16, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -595,26 +644,273 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 36, "id": "60165b32-c950-4b0c-9526-3edcb7674e62", "metadata": {}, "outputs": [ { - "ename": "ValueError", - "evalue": "Either X or signatures must be provided", + "name": "stdout", + "output_type": "stream", + "text": [ + "fit_time: 2.3705170154571533\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.34459805488586426\n", + "lead_lag: True inv_rest: True thres_distance: 4000 auc: 0.8366666666666667\n", + "fit_time: 2.4763379096984863\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.39705705642700195\n", + "lead_lag: True inv_rest: True thres_distance: 8000 auc: 0.7566666666666667\n", + "fit_time: 2.4723050594329834\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.361522912979126\n", + "lead_lag: True inv_rest: True thres_distance: 16000 auc: 0.7677777777777778\n", + "fit_time: 2.7211780548095703\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.41321396827697754\n", + "lead_lag: True inv_rest: True thres_distance: 32000 auc: 0.78\n", + "fit_time: 1.8937711715698242\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.29887914657592773\n", + "lead_lag: True inv_rest: False thres_distance: 4000 auc: 0.8444444444444444\n", + "fit_time: 2.1973140239715576\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.32749319076538086\n", + "lead_lag: True inv_rest: False thres_distance: 8000 auc: 0.7622222222222221\n", + "fit_time: 2.0311882495880127\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.3115198612213135\n", + "lead_lag: True inv_rest: False thres_distance: 16000 auc: 0.7611111111111112\n", + "fit_time: 2.1606862545013428\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.3807559013366699\n", + "lead_lag: True inv_rest: False thres_distance: 32000 auc: 0.7777777777777778\n", + "fit_time: 1.74491286277771\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.2918431758880615\n", + "lead_lag: False inv_rest: True thres_distance: 4000 auc: 0.8155555555555556\n", + "fit_time: 1.770664930343628\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.3539090156555176\n", + "lead_lag: False inv_rest: True thres_distance: 8000 auc: 0.7488888888888889\n", + "fit_time: 1.9913699626922607\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.35626983642578125\n", + "lead_lag: False inv_rest: True thres_distance: 16000 auc: 0.7622222222222222\n", + "fit_time: 1.7985730171203613\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 0.2609882354736328\n", + "lead_lag: False inv_rest: True thres_distance: 32000 auc: 0.7511111111111111\n" + ] + }, + { + "ename": "IndexError", + "evalue": "list index out of range", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m:24\u001b[0m\n", - "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:103\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[39mif\u001b[39;00m signatures_train \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 102\u001b[0m \u001b[39mif\u001b[39;00m X_train \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 103\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(X_OR_SIGNATURE_ERROR_MSG)\n\u001b[1;32m 105\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msktime\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mtransformations\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpanel\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39msignature_based\u001b[39;00m \u001b[39mimport\u001b[39;00m (\n\u001b[1;32m 106\u001b[0m SignatureTransformer,\n\u001b[1;32m 107\u001b[0m )\n\u001b[1;32m 109\u001b[0m \u001b[39m# set default kwargs for signature transformer if not provided\u001b[39;00m\n", - "\u001b[0;31mValueError\u001b[0m: Either X or signatures must be provided" + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m:25\u001b[0m\n", + "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:135\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature_transform \u001b[39m=\u001b[39m SignatureTransformer(\n\u001b[1;32m 131\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39msignature_kwargs,\n\u001b[1;32m 132\u001b[0m )\n\u001b[1;32m 134\u001b[0m \u001b[39m# compute signatures\u001b[39;00m\n\u001b[0;32m--> 135\u001b[0m sigs \u001b[39m=\u001b[39m Parallel(n_jobs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_jobs)(\n\u001b[1;32m 136\u001b[0m delayed(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_transform\u001b[39m.\u001b[39;49mfit_transform)(X_train[i])\n\u001b[1;32m 137\u001b[0m \u001b[39mfor\u001b[39;49;00m i \u001b[39min\u001b[39;49;00m \u001b[39mrange\u001b[39;49m(\u001b[39mlen\u001b[39;49m(X_train))\n\u001b[1;32m 138\u001b[0m )\n\u001b[1;32m 139\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignatures_train \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(pd\u001b[39m.\u001b[39mconcat(sigs))\n\u001b[1;32m 140\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1863\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1861\u001b[0m output \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m 1862\u001b[0m \u001b[39mnext\u001b[39m(output)\n\u001b[0;32m-> 1863\u001b[0m \u001b[39mreturn\u001b[39;00m output \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mreturn_generator \u001b[39melse\u001b[39;00m \u001b[39mlist\u001b[39;49m(output)\n\u001b[1;32m 1865\u001b[0m \u001b[39m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m 1866\u001b[0m \u001b[39m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m 1867\u001b[0m \u001b[39m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m 1868\u001b[0m \u001b[39m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m 1869\u001b[0m \u001b[39m# callback.\u001b[39;00m\n\u001b[1;32m 1870\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1792\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1790\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_batches \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 1791\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m-> 1792\u001b[0m res \u001b[39m=\u001b[39m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1793\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_completed_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 1794\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprint_progress()\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:669\u001b[0m, in \u001b[0;36mBaseTransformer.fit_transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 604\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Fit to data, then transform it.\u001b[39;00m\n\u001b[1;32m 605\u001b[0m \n\u001b[1;32m 606\u001b[0m \u001b[39mFits the transformer to X and y and returns a transformed version of X.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 665\u001b[0m \u001b[39m Example: i-th instance of the output is the i-th window running over `X`\u001b[39;00m\n\u001b[1;32m 666\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 667\u001b[0m \u001b[39m# Non-optimized default implementation; override when a better\u001b[39;00m\n\u001b[1;32m 668\u001b[0m \u001b[39m# method is possible for a given algorithm.\u001b[39;00m\n\u001b[0;32m--> 669\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfit(X, y)\u001b[39m.\u001b[39mtransform(X, y)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:486\u001b[0m, in \u001b[0;36mBaseTransformer.fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 484\u001b[0m \u001b[39m# we call the ordinary _fit if no looping/vectorization needed\u001b[39;00m\n\u001b[1;32m 485\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m vectorization_needed:\n\u001b[0;32m--> 486\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fit(X\u001b[39m=\u001b[39;49mX_inner, y\u001b[39m=\u001b[39;49my_inner)\n\u001b[1;32m 487\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 488\u001b[0m \u001b[39m# otherwise we call the vectorized version of fit\u001b[39;00m\n\u001b[1;32m 489\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_vectorize(\u001b[39m\"\u001b[39m\u001b[39mfit\u001b[39m\u001b[39m\"\u001b[39m, X\u001b[39m=\u001b[39mX_inner, y\u001b[39m=\u001b[39my_inner)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_signature_method.py:100\u001b[0m, in \u001b[0;36mSignatureTransformer._fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_fit\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[0;32m--> 100\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_method\u001b[39m.\u001b[39;49mfit(X)\n\u001b[1;32m 101\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/base.py:1152\u001b[0m, in \u001b[0;36m_fit_context..decorator..wrapper\u001b[0;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1145\u001b[0m estimator\u001b[39m.\u001b[39m_validate_params()\n\u001b[1;32m 1147\u001b[0m \u001b[39mwith\u001b[39;00m config_context(\n\u001b[1;32m 1148\u001b[0m skip_parameter_validation\u001b[39m=\u001b[39m(\n\u001b[1;32m 1149\u001b[0m prefer_skip_nested_validation \u001b[39mor\u001b[39;00m global_skip_validation\n\u001b[1;32m 1150\u001b[0m )\n\u001b[1;32m 1151\u001b[0m ):\n\u001b[0;32m-> 1152\u001b[0m \u001b[39mreturn\u001b[39;00m fit_method(estimator, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:423\u001b[0m, in \u001b[0;36mPipeline.fit\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Fit the model.\u001b[39;00m\n\u001b[1;32m 398\u001b[0m \n\u001b[1;32m 399\u001b[0m \u001b[39mFit all the transformers one after the other and transform the\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[39m Pipeline with fitted steps.\u001b[39;00m\n\u001b[1;32m 421\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 422\u001b[0m fit_params_steps \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_fit_params(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mfit_params)\n\u001b[0;32m--> 423\u001b[0m Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fit(X, y, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mfit_params_steps)\n\u001b[1;32m 424\u001b[0m \u001b[39mwith\u001b[39;00m _print_elapsed_time(\u001b[39m\"\u001b[39m\u001b[39mPipeline\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_log_message(\u001b[39mlen\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msteps) \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m)):\n\u001b[1;32m 425\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_final_estimator \u001b[39m!=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m\"\u001b[39m:\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:357\u001b[0m, in \u001b[0;36mPipeline._fit\u001b[0;34m(self, X, y, **fit_params_steps)\u001b[0m\n\u001b[1;32m 354\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_fit\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mfit_params_steps):\n\u001b[1;32m 355\u001b[0m \u001b[39m# shallow copy of steps - this should really be steps_\u001b[39;00m\n\u001b[1;32m 356\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msteps \u001b[39m=\u001b[39m \u001b[39mlist\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msteps)\n\u001b[0;32m--> 357\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_validate_steps()\n\u001b[1;32m 358\u001b[0m \u001b[39m# Setup the memory\u001b[39;00m\n\u001b[1;32m 359\u001b[0m memory \u001b[39m=\u001b[39m check_memory(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmemory)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:238\u001b[0m, in \u001b[0;36mPipeline._validate_steps\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[39mif\u001b[39;00m t \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mor\u001b[39;00m t \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m 237\u001b[0m \u001b[39mcontinue\u001b[39;00m\n\u001b[0;32m--> 238\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mhasattr\u001b[39m(t, \u001b[39m\"\u001b[39m\u001b[39mfit\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39mor\u001b[39;00m \u001b[39mhasattr\u001b[39m(t, \u001b[39m\"\u001b[39m\u001b[39mfit_transform\u001b[39m\u001b[39m\"\u001b[39m)) \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mhasattr\u001b[39;49m(\n\u001b[1;32m 239\u001b[0m t, \u001b[39m\"\u001b[39;49m\u001b[39mtransform\u001b[39;49m\u001b[39m\"\u001b[39;49m\n\u001b[1;32m 240\u001b[0m ):\n\u001b[1;32m 241\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\n\u001b[1;32m 242\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mAll intermediate steps should be \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 243\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mtransformers and implement fit and transform \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 244\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mor be the string \u001b[39m\u001b[39m'\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m'\u001b[39m\u001b[39m \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 245\u001b[0m \u001b[39m\"\u001b[39m\u001b[39m'\u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m (type \u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m%\u001b[39m (t, \u001b[39mtype\u001b[39m(t))\n\u001b[1;32m 246\u001b[0m )\n\u001b[1;32m 248\u001b[0m \u001b[39m# We allow last estimator to be None as an identity transformation\u001b[39;00m\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/utils/_available_if.py:31\u001b[0m, in \u001b[0;36m_AvailableIfDescriptor.__get__\u001b[0;34m(self, obj, owner)\u001b[0m\n\u001b[1;32m 25\u001b[0m attr_err \u001b[39m=\u001b[39m \u001b[39mAttributeError\u001b[39;00m(\n\u001b[1;32m 26\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mThis \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mrepr\u001b[39m(owner\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m)\u001b[39m}\u001b[39;00m\u001b[39m has no attribute \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mrepr\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mattribute_name)\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[1;32m 27\u001b[0m )\n\u001b[1;32m 28\u001b[0m \u001b[39mif\u001b[39;00m obj \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 29\u001b[0m \u001b[39m# delegate only on instances, not the classes.\u001b[39;00m\n\u001b[1;32m 30\u001b[0m \u001b[39m# this is to allow access to the docstrings.\u001b[39;00m\n\u001b[0;32m---> 31\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcheck(obj):\n\u001b[1;32m 32\u001b[0m \u001b[39mraise\u001b[39;00m attr_err\n\u001b[1;32m 33\u001b[0m out \u001b[39m=\u001b[39m MethodType(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfn, obj)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:667\u001b[0m, in \u001b[0;36mPipeline._can_transform\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 666\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_can_transform\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m--> 667\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_final_estimator \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mor\u001b[39;00m \u001b[39mhasattr\u001b[39m(\n\u001b[1;32m 668\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_final_estimator, \u001b[39m\"\u001b[39m\u001b[39mtransform\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 669\u001b[0m )\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:321\u001b[0m, in \u001b[0;36mPipeline._final_estimator\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[39m@property\u001b[39m\n\u001b[1;32m 319\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_final_estimator\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 320\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 321\u001b[0m estimator \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msteps[\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m][\u001b[39m1\u001b[39m]\n\u001b[1;32m 322\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mif\u001b[39;00m estimator \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m estimator\n\u001b[1;32m 323\u001b[0m \u001b[39mexcept\u001b[39;00m (\u001b[39mValueError\u001b[39;00m, \u001b[39mAttributeError\u001b[39;00m, \u001b[39mTypeError\u001b[39;00m):\n\u001b[1;32m 324\u001b[0m \u001b[39m# This condition happens when a call to a method is first calling\u001b[39;00m\n\u001b[1;32m 325\u001b[0m \u001b[39m# `_available_if` and `fit` did not validate `steps` yet. We\u001b[39;00m\n\u001b[1;32m 326\u001b[0m \u001b[39m# return `None` and an `InvalidParameterError` will be raised\u001b[39;00m\n\u001b[1;32m 327\u001b[0m \u001b[39m# right after.\u001b[39;00m\n", + "\u001b[0;31mIndexError\u001b[0m: list index out of range" ] } ], "source": [ "%%time\n", "lead_lag_and_inv_rest_and_thres_distance_to_auc = {}\n", + "depth = 3\n", "for lead_lag in [True, False]:\n", " augmentation_list1 = []\n", " lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag] = {}\n", @@ -628,7 +924,7 @@ " augmentation_list = augmentation_list1\n", "\n", " if (not inv_reset) and (not lead_lag):\n", - " augmentation_list = None\n", + " augmentation_list = ()\n", "\n", " for thres_distance in [4000, 8000, 16000, 32000]:\n", " signature_maha_knn = SignatureMahalanobisKNN()\n", @@ -639,14 +935,14 @@ " start_time = time.time()\n", " signature_maha_knn.fit(\n", " knn_library=\"sklearn\",\n", - " X=data.corpus,\n", + " X_train=data.corpus,\n", " signature_kwargs={\n", " \"augmentation_list\": augmentation_list,\n", - " \"depth\": 3,\n", + " \"depth\": depth,\n", " },\n", " )\n", " fit_time = time.time() - start_time\n", - " print(\"fit_time: \", fit_time)\n", + " print(f\"fit_time: {fit_time}\")\n", "\n", " # Measure the time spent on compute_auc\n", " start_time = time.time()\n", @@ -660,11 +956,11 @@ " inlier_dists,\n", " outlier_dists,\n", " plot=True,\n", - " title=f\"Threshold distance: {thres_distance} (depth={depth})\",\n", + " title=f\"\\nThreshold distance: {thres_distance} | lead_lag: {lead_lag} | inv_reset: {inv_reset} (depth={depth})\",\n", " )\n", " auc = compute_auc_given_dists(inlier_dists, outlier_dists)\n", " compute_auc_time = time.time() - start_time\n", - " print(\"compute_auc_time: \", compute_auc_time)\n", + " print(f\"compute_auc_time: {compute_auc_time}\")\n", "\n", " print(\n", " f\"lead_lag: {lead_lag}\",\n", @@ -672,10156 +968,12 @@ " f\"thres_distance: {thres_distance}\",\n", " f\"auc: {auc}\",\n", " )\n", - " auc = compute_auc_given_dists(\n", - " all_inlier_dists,\n", - " all_outlier_dists,\n", - " plot=True,\n", - " title=f\"Pen Digit (depth={depth})\",\n", - " )\n", + "\n", " lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag][inv_reset][\n", " thres_distance\n", " ] = auc" ] }, - { - "cell_type": "code", - "execution_count": 23, - "id": "8b2f56b6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[array([[0. , 0. , 0. ],\n", - " [0.12361251, 0.1265174 , 0.98484848],\n", - " [0.25176589, 0.25492312, 1. ],\n", - " [0.37083754, 0.37361748, 0.92424242],\n", - " [0.49646821, 0.49986512, 0.96969697],\n", - " [0.6160444 , 0.61586188, 0.92424242],\n", - " [0.74470232, 0.74372808, 1. ],\n", - " [0.87487386, 0.87321284, 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.01311249, 0.97699594, 0.31386861],\n", - " [0.03588682, 0.95453315, 0.2919708 ],\n", - " [0.07729469, 0.88985115, 0.80291971],\n", - " [0.1131815 , 0.85304465, 0.4379562 ],\n", - " [0.12560386, 0.83843031, 0.17274939],\n", - " [0.13802622, 0.82462788, 0.1946472 ],\n", - " [0.16770186, 0.78673884, 0.486618 ],\n", - " [0.1773637 , 0.77050068, 0.24087591],\n", - " [0.1863354 , 0.75832206, 0.19708029],\n", - " [0.19806763, 0.74073072, 0.26520681],\n", - " [0.20979986, 0.72665765, 0.17274939],\n", - " [0.22222222, 0.71258457, 0.19221411],\n", - " [0.30710835, 0.63734777, 1. ],\n", - " [0.32091097, 0.62219215, 0.19221411],\n", - " [0.36922015, 0.57104195, 0.6107056 ],\n", - " [0.38854382, 0.55074425, 0.2919708 ],\n", - " [0.39820566, 0.5391069 , 0.18978102],\n", - " [0.41614907, 0.51096076, 0.44282238],\n", - " [0.436853 , 0.48985115, 0.3406326 ],\n", - " [0.46031746, 0.47198917, 0.243309 ],\n", - " [0.47273982, 0.4579161 , 0.1946472 ],\n", - " [0.48516218, 0.44303112, 0.19221411],\n", - " [0.52242926, 0.40947226, 0.44038929],\n", - " [0.53347136, 0.39566982, 0.1703163 ],\n", - " [0.57971014, 0.35994587, 0.50851582],\n", - " [0.59006211, 0.34695535, 0.1946472 ],\n", - " [0.60179434, 0.33396482, 0.17274939],\n", - " [0.62594893, 0.31935047, 0.243309 ],\n", - " [0.67425811, 0.26792963, 0.68126521],\n", - " [0.68461008, 0.25493911, 0.1703163 ],\n", - " [0.69565217, 0.24194858, 0.21654501],\n", - " [0.72808834, 0.21163735, 0.4379562 ],\n", - " [0.75017253, 0.18592693, 0.34306569],\n", - " [0.77294686, 0.16833559, 0.2189781 ],\n", - " [0.79503106, 0.15074425, 0.243309 ],\n", - " [0.80607315, 0.13775372, 0.1946472 ],\n", - " [0.82953761, 0.12368065, 0.23844282],\n", - " [0.85231194, 0.10960758, 0.19708029],\n", - " [0.87784679, 0.09039242, 0.2189781 ],\n", - " [0.90407177, 0.06982409, 0.29440389],\n", - " [0.92822636, 0.05033829, 0.2189781 ],\n", - " [0.95238095, 0.03193505, 0.24087591],\n", - " [1. , 0. , 0.486618 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10016287, 0.10016353, 0.95833333],\n", - " [0.2019544 , 0.20134914, 0.95833333],\n", - " [0.3029316 , 0.30294358, 0.98611111],\n", - " [0.40553746, 0.40576451, 0.98611111],\n", - " [0.50732899, 0.50735895, 0.97222222],\n", - " [0.60830619, 0.60752249, 0.94444444],\n", - " [0.71091205, 0.71075225, 1. ],\n", - " [0.81107492, 0.81071137, 0.95833333],\n", - " [0.91205212, 0.91169256, 0.97222222],\n", - " [1. , 1. , 0.84722222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09769094, 0.09785714, 0.98591549],\n", - " [0.19937833, 0.19880952, 0.98591549],\n", - " [0.30106572, 0.3002381 , 1. ],\n", - " [0.39831261, 0.39738095, 0.97183099],\n", - " [0.49955595, 0.49880952, 1. ],\n", - " [0.60079929, 0.60047619, 0.98591549],\n", - " [0.69937833, 0.69928571, 0.97183099],\n", - " [0.79973357, 0.79952381, 1. ],\n", - " [0.90008881, 0.8997619 , 0.97183099],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.10130548, 0.90441176, 0.85 ],\n", - " [0.19112272, 0.80441176, 0.7625 ],\n", - " [0.29190601, 0.68676471, 0.8625 ],\n", - " [0.39425587, 0.56911765, 0.875 ],\n", - " [0.48250653, 0.47058824, 0.7625 ],\n", - " [0.58537859, 0.35588235, 0.8625 ],\n", - " [0.67362924, 0.27205882, 0.7625 ],\n", - " [0.7772846 , 0.19117647, 0.875 ],\n", - " [0.88250653, 0.10294118, 0.875 ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11636557, 0.33333333, 0.875 ],\n", - " [0.23166844, 0.73333333, 0.875 ],\n", - " [0.36716259, 0.86666667, 1. ],\n", - " [0.49760893, 1. , 0.9875 ],\n", - " [0.61716259, 0.8 , 0.9 ],\n", - " [0.74920298, 0.86666667, 0.9875 ],\n", - " [0.88469713, 0.73333333, 1. ],\n", - " [1. , 0.8 , 0.875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12187029, 0.8752314 , 1. ],\n", - " [0.24705882, 0.75083302, 1. ],\n", - " [0.37164404, 0.62495372, 1. ],\n", - " [0.4974359 , 0.50092558, 1. ],\n", - " [0.62262443, 0.37541651, 1. ],\n", - " [0.74600302, 0.25138837, 1. ],\n", - " [0.87209653, 0.12699 , 1. ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92123629, 0.92134831, 0.98591549],\n", - " [0.85377202, 0.85495403, 0.85915493],\n", - " [0.77500831, 0.77596187, 0.98591549],\n", - " [0.69657694, 0.6969697 , 0.98591549],\n", - " [0.6184779 , 0.61797753, 0.98591549],\n", - " [0.54104354, 0.54000681, 0.97183099],\n", - " [0.46095048, 0.45965271, 0.98591549],\n", - " [0.38351612, 0.38032005, 1. ],\n", - " [0.30408774, 0.30064692, 0.98591549],\n", - " [0.2369558 , 0.23323119, 0.85915493],\n", - " [0.15952144, 0.15491999, 0.95774648],\n", - " [0.07909605, 0.0783112 , 0.98591549],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11606061, 0.11318619, 0.63063063],\n", - " [0.24242424, 0.23599321, 0.72072072],\n", - " [0.37363636, 0.36785512, 0.72072072],\n", - " [0.48484848, 0.48104131, 0.63963964],\n", - " [0.61606061, 0.61346916, 0.71171171],\n", - " [0.79272727, 0.79230334, 1. ],\n", - " [0.90393939, 0.90548953, 0.62162162],\n", - " [1. , 1. , 0.54954955]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.875 , 0.83475987, 0.88235294],\n", - " [0.71428571, 0.6766524 , 0.82352941],\n", - " [0.64285714, 0.55634807, 0.64705882],\n", - " [0.49107143, 0.43223966, 0.64705882],\n", - " [0.3125 , 0.24488825, 1. ],\n", - " [0.19642857, 0.11959106, 0.64705882],\n", - " [0. , 0. , 0.64705882]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08661417, 0.90934514, 0.98591549],\n", - " [0.19685039, 0.81799114, 0.98591549],\n", - " [0.31496063, 0.72547192, 0.98591549],\n", - " [0.42519685, 0.64646935, 0.85915493],\n", - " [0.44094488, 0.55721277, 0.95774648],\n", - " [0.48818898, 0.46306222, 0.98591549],\n", - " [0.63779528, 0.37147518, 1. ],\n", - " [0.72440945, 0.279189 , 0.98591549],\n", - " [0.77952756, 0.18573759, 0.98591549],\n", - " [0.91338583, 0.09298532, 0.98591549],\n", - " [1. , 0. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87470135, 0.12380416, 1. ],\n", - " [0.75126095, 0.2447946 , 0.97014925],\n", - " [0.6339262 , 0.3629713 , 0.91044776],\n", - " [0.50836209, 0.4895892 , 0.98507463],\n", - " [0.38093974, 0.61733258, 0.97014925],\n", - " [0.25298646, 0.74563872, 0.98507463],\n", - " [0.12874967, 0.86944288, 0.98507463],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90091337, 0.90187891, 0.97183099],\n", - " [0.80293385, 0.80584551, 0.98591549],\n", - " [0.70218655, 0.70563674, 1. ],\n", - " [0.60060891, 0.60542797, 0.98591549],\n", - " [0.50345973, 0.51148225, 0.97183099],\n", - " [0.40354276, 0.41127349, 0.98591549],\n", - " [0.30196513, 0.30688935, 0.98591549],\n", - " [0.2014946 , 0.20876827, 0.98591549],\n", - " [0.10323831, 0.10647182, 0.98591549],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89617656, 0.91666667, 0.85185185],\n", - " [0.79266397, 0.82666667, 0.87654321],\n", - " [0.68915138, 0.74333333, 0.85185185],\n", - " [0.59061237, 0.65291667, 0.86419753],\n", - " [0.46627293, 0.54875 , 1. ],\n", - " [0.36773391, 0.46541667, 0.86419753],\n", - " [0.27447933, 0.3475 , 0.86419753],\n", - " [0.19676717, 0.24333333, 0.75308642],\n", - " [0.10879702, 0.13208333, 0.83950617],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14485981, 0.13969608, 0.90410959],\n", - " [0.29014444, 0.28472407, 0.90410959],\n", - " [0.43118097, 0.42708611, 0.89041096],\n", - " [0.58751062, 0.58651026, 1. ],\n", - " [0.72812234, 0.72673954, 0.89041096],\n", - " [0.8606627 , 0.85897094, 0.83561644],\n", - " [1. , 1. , 0.90410959]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87482806, 0.89054726, 0.98507463],\n", - " [0.74828061, 0.7761194 , 1. ],\n", - " [0.62310867, 0.65174129, 0.98507463],\n", - " [0.49766162, 0.51741294, 0.98507463],\n", - " [0.37248968, 0.38308458, 0.98507463],\n", - " [0.24951857, 0.25373134, 0.97014925],\n", - " [0.12489684, 0.12935323, 0.98507463],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.05254692, 0.95153514, 1. ],\n", - " [0.10616622, 0.89951789, 0.98591549],\n", - " [0.16407507, 0.84242578, 0.98591549],\n", - " [0.22144772, 0.78685613, 0.97183099],\n", - " [0.28150134, 0.72722659, 0.98591549],\n", - " [0.34048257, 0.66734331, 0.98591549],\n", - " [0.39302949, 0.61532606, 0.85915493],\n", - " [0.45469169, 0.55468155, 0.97183099],\n", - " [0.50670241, 0.5044405 , 0.85915493],\n", - " [0.55924933, 0.45166201, 0.98591549],\n", - " [0.61126005, 0.40040599, 0.97183099],\n", - " [0.66112601, 0.35041868, 0.98591549],\n", - " [0.71635389, 0.29307282, 0.98591549],\n", - " [0.78176944, 0.22608475, 0.97183099],\n", - " [0.84235925, 0.16366404, 0.85915493],\n", - " [0.91849866, 0.08652626, 0.98591549],\n", - " [1. , 0. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88880188, 0.11210222, 0.98507463],\n", - " [0.7807361 , 0.22540984, 0.98507463],\n", - " [0.67188724, 0.33654773, 0.97014925],\n", - " [0.5614722 , 0.45154291, 1. ],\n", - " [0.45184025, 0.56726133, 0.98507463],\n", - " [0.33907596, 0.68008679, 0.98507463],\n", - " [0.22317933, 0.78977821, 0.97014925],\n", - " [0.11589663, 0.89079074, 0.91044776],\n", - " [0. , 1. , 0.97014925]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12015177, 0.12409812, 1. ],\n", - " [0.2272344 , 0.22655123, 0.85185185],\n", - " [0.3351602 , 0.33391053, 0.88888889],\n", - " [0.45320405, 0.45656566, 0.97530864],\n", - " [0.57504216, 0.57489177, 0.97530864],\n", - " [0.67959528, 0.67878788, 0.86419753],\n", - " [0.78583474, 0.78989899, 0.88888889],\n", - " [0.89333895, 0.8966811 , 0.85185185],\n", - " [1. , 1. , 0.86419753]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92156863, 0.16892809, 1. ],\n", - " [0.84313725, 0.33808232, 1. ],\n", - " [0.74509804, 0.45251018, 0.66666667],\n", - " [0.58823529, 0.52849389, 0.44444444],\n", - " [0.37254902, 0.63432836, 0.61666667],\n", - " [0.21568627, 0.70081411, 0.38888889],\n", - " [0. , 0.7663953 , 0.38333333],\n", - " [0. , 0.83333333, 0.39444444],\n", - " [0.01960784, 0.89891452, 0.38888889],\n", - " [0.11764706, 1. , 0.60555556]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15355418, 0.15366884, 1. ],\n", - " [0.29399586, 0.29466001, 0.94366197],\n", - " [0.43512767, 0.43565117, 0.92957746],\n", - " [0.57625949, 0.57587399, 0.91549296],\n", - " [0.7173913 , 0.71686516, 0.94366197],\n", - " [0.85852312, 0.85862466, 0.92957746],\n", - " [1. , 1. , 0.91549296]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91375167, 0.91364903, 0.7625 ],\n", - " [0.80453939, 0.80501393, 0.875 ],\n", - " [0.68891856, 0.68895079, 1. ],\n", - " [0.58878505, 0.58960074, 0.85 ],\n", - " [0.49933244, 0.50139276, 0.7625 ],\n", - " [0.40106809, 0.40575673, 0.875 ],\n", - " [0.29372497, 0.29712163, 0.875 ],\n", - " [0.20694259, 0.21077066, 0.7625 ],\n", - " [0.10146862, 0.10584958, 0.875 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.0738202 , 0.1875 , 0.85185185],\n", - " [0.13867651, 0.28125 , 0.75308642],\n", - " [0.21091484, 0.34375 , 0.86419753],\n", - " [0.28368046, 0.34375 , 0.85185185],\n", - " [0.34827313, 0.40625 , 0.75308642],\n", - " [0.42393883, 0.40625 , 0.86419753],\n", - " [0.50962299, 0.5625 , 0.97530864],\n", - " [0.5950435 , 0.59375 , 0.98765432],\n", - " [0.68310045, 0.71875 , 1. ],\n", - " [0.75902979, 0.84375 , 0.85185185],\n", - " [0.83733193, 0.9375 , 0.86419753],\n", - " [0.9243343 , 1. , 0.98765432],\n", - " [1. , 1. , 0.86419753]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12487512, 0.12654867, 0.90410959],\n", - " [0.25224775, 0.24837758, 0.90410959],\n", - " [0.37712288, 0.37168142, 0.89041096],\n", - " [0.51048951, 0.51032448, 1. ],\n", - " [0.63086913, 0.63126844, 0.90410959],\n", - " [0.75524476, 0.75575221, 0.89041096],\n", - " [0.87912088, 0.87728614, 0.91780822],\n", - " [1. , 1. , 0.90410959]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.16264547, 0.8392385 , 1. ],\n", - " [0.30059608, 0.70333157, 0.84259259],\n", - " [0.43315356, 0.56848228, 0.83333333],\n", - " [0.56713029, 0.43151772, 0.84259259],\n", - " [0.68833381, 0.31147541, 0.74074074],\n", - " [0.79165484, 0.20888419, 0.63888889],\n", - " [0.89753051, 0.10312004, 0.65740741],\n", - " [1. , 0. , 0.63888889]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11284047, 0.01290323, 0.84415584],\n", - " [0.21893645, 0.01612903, 0.80519481],\n", - " [0.35019455, 0.20322581, 1. ],\n", - " [0.46018158, 0.25483871, 0.84415584],\n", - " [0.5618677 , 0.33225806, 0.79220779],\n", - " [0.67367056, 0.53225806, 0.84415584],\n", - " [0.77535668, 0.67741935, 0.79220779],\n", - " [0.89805447, 0.83548387, 0.92207792],\n", - " [1. , 1. , 0.79220779]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13545151, 0.14425428, 0.91666667],\n", - " [0.27090301, 0.26650367, 0.91666667],\n", - " [0.40635452, 0.40831296, 0.91666667],\n", - " [0.54586718, 0.55012225, 0.91666667],\n", - " [0.69732441, 0.69315403, 1. ],\n", - " [0.84065934, 0.83618582, 0.91666667],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0.73807662, 0.04898157, 0. ],\n", - " [0.7898749 , 0.11493695, 0.00122874],\n", - " [0.83229085, 0.25703201, 0.00134576],\n", - " [0.86903831, 0.42531523, 0.00138477],\n", - " [0.90402658, 0.57807953, 0.00138477],\n", - " [0.93647381, 0.72162949, 0.00134576],\n", - " [0.96696638, 0.85935984, 0.00136527],\n", - " [0.99354965, 0.98399612, 0.00136527],\n", - " [1. , 1. , 1. ],\n", - " [0.9601251 , 0.81959263, 0.00136527],\n", - " [0.92044566, 0.63773036, 0.00136527],\n", - " [0.8842846 , 0.46605238, 0.00118973],\n", - " [0.83893667, 0.26527643, 0.00136527],\n", - " [0.7898749 , 0.08680892, 0.00122874],\n", - " [0.71813917, 0. , 0.00122874],\n", - " [0.64953088, 0.05674103, 0.00122874],\n", - " [0.59030493, 0.18865179, 0.00118973],\n", - " [0.52501955, 0.35984481, 0.00130676],\n", - " [0.45895231, 0.53782735, 0.00128725],\n", - " [0.38838937, 0.68477207, 0.00120924],\n", - " [0.30942142, 0.76333657, 0.00120924],\n", - " [0.22888976, 0.73617847, 0.00120924],\n", - " [0.14347146, 0.67895247, 0.00128725],\n", - " [0.06333073, 0.61833172, 0.00120924],\n", - " [0. , 0.47623666, 0.00122874]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12961985, 0.28125 , 0.97222222],\n", - " [0.24630412, 0.53125 , 0.86111111],\n", - " [0.38252376, 0.5 , 1. ],\n", - " [0.51742344, 0.5 , 0.98611111],\n", - " [0.63516367, 0.5625 , 0.86111111],\n", - " [0.76795143, 0.71875 , 0.95833333],\n", - " [0.88595565, 0.875 , 0.86111111],\n", - " [1. , 1. , 0.84722222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12338518, 0.12470588, 0.91666667],\n", - " [0.25731611, 0.24705882, 1. ],\n", - " [0.3825468 , 0.38823529, 0.90277778],\n", - " [0.49327709, 0.48470588, 0.84722222],\n", - " [0.62799895, 0.62117647, 0.98611111],\n", - " [0.75270235, 0.75058824, 0.93055556],\n", - " [0.87687846, 0.87529412, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92434783, 0.919375 , 0.77777778],\n", - " [0.86 , 0.85375 , 0.67777778],\n", - " [0.7826087 , 0.78125 , 0.77777778],\n", - " [0.71014493, 0.708125 , 0.77777778],\n", - " [0.63275362, 0.635 , 0.77777778],\n", - " [0.56028986, 0.5625 , 0.76666667],\n", - " [0.48318841, 0.47875 , 0.76666667],\n", - " [0.39623188, 0.395625 , 0.9 ],\n", - " [0.29942029, 0.301875 , 1. ],\n", - " [0.22695652, 0.22875 , 0.77777778],\n", - " [0.15130435, 0.151875 , 0.77777778],\n", - " [0.0773913 , 0.0725 , 0.77777778],\n", - " [0. , 0. , 0.76666667]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13733469, 0.13391813, 0.85714286],\n", - " [0.28585961, 0.28391813, 0.93506494],\n", - " [0.42217701, 0.41988304, 0.85714286],\n", - " [0.56052899, 0.55555556, 0.87012987],\n", - " [0.69125127, 0.69122807, 0.85714286],\n", - " [0.85198372, 0.85146199, 1. ],\n", - " [1. , 1. , 0.94805195]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88619034, 0.90289017, 1. ],\n", - " [0.78565377, 0.80809249, 0.88607595],\n", - " [0.68568201, 0.71445087, 0.88607595],\n", - " [0.58599266, 0.62774566, 0.87341772],\n", - " [0.48263202, 0.52485549, 0.91139241],\n", - " [0.36825755, 0.40346821, 1. ],\n", - " [0.28212369, 0.30520231, 0.7721519 ],\n", - " [0.18554081, 0.19421965, 0.86075949],\n", - " [0.0971477 , 0.0982659 , 0.7721519 ],\n", - " [0. , 0. , 0.87341772]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.98819777, 0.98237256, 0.72477064],\n", - " [0.97639553, 0.9642687 , 0.73394495],\n", - " [0.96491228, 0.95092901, 0.64220183],\n", - " [0.95279107, 0.93520724, 0.64220183],\n", - " [0.94066986, 0.91996189, 0.65137615],\n", - " [0.92950558, 0.9037637 , 0.64220183],\n", - " [0.91929825, 0.88851834, 0.64220183],\n", - " [0.90813397, 0.8737494 , 0.64220183],\n", - " [0.89760766, 0.85898047, 0.63302752],\n", - " [0.88580542, 0.84373511, 0.73394495],\n", - " [0.87368421, 0.82991901, 0.65137615],\n", - " [0.85454545, 0.81086232, 1. ],\n", - " [0.84242424, 0.79752263, 0.65137615],\n", - " [0.82966507, 0.78275369, 0.73394495],\n", - " [0.81594896, 0.76846117, 0.72477064],\n", - " [0.80287081, 0.75512149, 0.65137615],\n", - " [0.78947368, 0.73939971, 0.72477064],\n", - " [0.77607656, 0.72129586, 0.74311927],\n", - " [0.76650718, 0.7060505 , 0.64220183],\n", - " [0.75470494, 0.69414007, 0.63302752],\n", - " [0.73971292, 0.67746546, 0.83486239],\n", - " [0.72759171, 0.66507861, 0.64220183],\n", - " [0.71259968, 0.65269176, 0.73394495],\n", - " [0.6969697 , 0.63792282, 0.72477064],\n", - " [0.68484848, 0.6236303 , 0.64220183],\n", - " [0.67400319, 0.60790853, 0.65137615],\n", - " [0.66092504, 0.587899 , 0.83486239],\n", - " [0.64816587, 0.57265364, 0.72477064],\n", - " [0.63732057, 0.56026679, 0.63302752],\n", - " [0.63189793, 0.55407337, 0.28440367],\n", - " [0.61881978, 0.53978085, 0.81651376],\n", - " [0.60637959, 0.527394 , 0.65137615],\n", - " [0.59170654, 0.51310148, 0.82568807],\n", - " [0.58086124, 0.50166746, 0.63302752],\n", - " [0.56937799, 0.48928061, 0.64220183],\n", - " [0.55789474, 0.47832301, 0.64220183],\n", - " [0.54545455, 0.46831825, 0.65137615],\n", - " [0.53301435, 0.45831348, 0.63302752],\n", - " [0.52089314, 0.44640305, 0.65137615],\n", - " [0.50940989, 0.4340162 , 0.63302752],\n", - " [0.49920255, 0.42067651, 0.64220183],\n", - " [0.48931419, 0.40686041, 0.65137615],\n", - " [0.4800638 , 0.39304431, 0.63302752],\n", - " [0.47145136, 0.38018104, 0.64220183],\n", - " [0.461563 , 0.36827061, 0.66055046],\n", - " [0.45103668, 0.35778942, 0.63302752],\n", - " [0.44051037, 0.34540257, 0.63302752],\n", - " [0.43030303, 0.33396856, 0.64220183],\n", - " [0.41913876, 0.32062887, 0.65137615],\n", - " [0.41020734, 0.30728919, 0.64220183],\n", - " [0.40095694, 0.29347308, 0.65137615],\n", - " [0.3923445 , 0.2801334 , 0.63302752],\n", - " [0.38245614, 0.26679371, 0.72477064],\n", - " [0.37192982, 0.25678895, 0.65137615],\n", - " [0.36172249, 0.24583135, 0.64220183],\n", - " [0.35183413, 0.23439733, 0.63302752],\n", - " [0.34035088, 0.22201048, 0.74311927],\n", - " [0.33110048, 0.21200572, 0.63302752],\n", - " [0.32185008, 0.20152454, 0.64220183],\n", - " [0.31164274, 0.19056694, 0.65137615],\n", - " [0.30239234, 0.17913292, 0.63302752],\n", - " [0.29314195, 0.16912816, 0.64220183],\n", - " [0.28293461, 0.16007623, 0.65137615],\n", - " [0.27113238, 0.1538828 , 0.63302752],\n", - " [0.25837321, 0.14911863, 0.64220183],\n", - " [0.24370016, 0.14244879, 0.73394495],\n", - " [0.23157895, 0.13482611, 0.64220183],\n", - " [0.2185008 , 0.12434493, 0.74311927],\n", - " [0.20701754, 0.11719867, 0.63302752],\n", - " [0.19202552, 0.10957599, 0.74311927],\n", - " [0.17958533, 0.10147689, 0.63302752],\n", - " [0.16523126, 0.09290138, 0.74311927],\n", - " [0.15311005, 0.0852787 , 0.64220183],\n", - " [0.14035088, 0.07813244, 0.63302752],\n", - " [0.12822967, 0.07050977, 0.64220183],\n", - " [0.11515152, 0.06336351, 0.64220183],\n", - " [0.10207337, 0.05669366, 0.64220183],\n", - " [0.08835726, 0.05002382, 0.64220183],\n", - " [0.07496013, 0.04478323, 0.65137615],\n", - " [0.06220096, 0.03668414, 0.65137615],\n", - " [0.04944179, 0.02858504, 0.63302752],\n", - " [0.03572568, 0.02000953, 0.72477064],\n", - " [0.02296651, 0.01333969, 0.64220183],\n", - " [0.01180223, 0.00666984, 0.64220183],\n", - " [0. , 0. , 0.65137615]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89076418, 0.89660303, 0.5 ],\n", - " [0.78105954, 0.78105629, 0.55 ],\n", - " [0.64041256, 0.64046615, 0.66666667],\n", - " [0.54664791, 0.5494669 , 0.45 ],\n", - " [0.33567745, 0.3429209 , 1. ],\n", - " [0.23441163, 0.23555666, 0.5 ],\n", - " [0.15611814, 0.15695512, 0.38333333],\n", - " [0. , 0. , 0.72777778]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89904102, 0.8974359 , 0.9 ],\n", - " [0.80154502, 0.7985348 , 0.85 ],\n", - " [0.70458178, 0.6996337 , 0.875 ],\n", - " [0.60602025, 0.6007326 , 0.875 ],\n", - " [0.5045285 , 0.503663 , 0.8875 ],\n", - " [0.40623335, 0.4029304 , 0.875 ],\n", - " [0.30900373, 0.30769231, 0.8625 ],\n", - " [0.2088439 , 0.21245421, 0.8875 ],\n", - " [0.11214704, 0.11355311, 0.8625 ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89627756, 0.89419007, 1. ],\n", - " [0.79689194, 0.79607541, 0.97183099],\n", - " [0.69497651, 0.6921893 , 1. ],\n", - " [0.59559089, 0.59176606, 0.95774648],\n", - " [0.49403686, 0.49095806, 0.98591549],\n", - " [0.40693892, 0.4043863 , 0.85915493],\n", - " [0.30430069, 0.30165448, 0.98591549],\n", - " [0.20310806, 0.20123124, 0.98591549],\n", - " [0.09866281, 0.09926895, 1. ],\n", - " [0. , 0. , 0.95774648]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14568345, 0.14525586, 0.98507463],\n", - " [0.28642086, 0.28624733, 0.97014925],\n", - " [0.42985612, 0.42963753, 1. ],\n", - " [0.57194245, 0.57302772, 0.97014925],\n", - " [0.7153777 , 0.71588486, 1. ],\n", - " [0.85836331, 0.85794243, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88754468, 0.11363636, 0.98591549],\n", - " [0.7742645 , 0.22494172, 0.98591549],\n", - " [0.66098433, 0.33566434, 0.97183099],\n", - " [0.54935386, 0.44463869, 0.97183099],\n", - " [0.45092109, 0.54137529, 0.87323944],\n", - " [0.33929062, 0.6532634 , 0.97183099],\n", - " [0.22463569, 0.76981352, 0.98591549],\n", - " [0.11135551, 0.88636364, 1. ],\n", - " [0. , 1. , 0.97183099]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.04347826, 0.12502831, 0.84705882],\n", - " [0.06521739, 0.23148358, 0.77647059],\n", - " [0.1 , 0.34609287, 0.77647059],\n", - " [0.23913043, 0.48629672, 1. ],\n", - " [0.41304348, 0.60973952, 0.83529412],\n", - " [0.64347826, 0.75084938, 1. ],\n", - " [0.84782609, 0.85685164, 0.76470588],\n", - " [1. , 1. , 0.98823529]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13333333, 0.12178189, 0.90277778],\n", - " [0.25941043, 0.24645647, 0.91666667],\n", - " [0.38321995, 0.37199884, 0.91666667],\n", - " [0.49569161, 0.48625976, 0.84722222],\n", - " [0.61904762, 0.61209141, 0.91666667],\n", - " [0.74240363, 0.73763379, 0.90277778],\n", - " [0.86575964, 0.86317616, 0.93055556],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85664336, 0.85861846, 0.91549296],\n", - " [0.70745921, 0.71766731, 0.92957746],\n", - " [0.56293706, 0.57628578, 0.94366197],\n", - " [0.42540793, 0.43468905, 0.92957746],\n", - " [0.28787879, 0.29309232, 0.92957746],\n", - " [0.13636364, 0.13922961, 1. ],\n", - " [0. , 0. , 0.92957746]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87453738, 0.86698766, 0.90909091],\n", - " [0.76350851, 0.75082757, 0.80808081],\n", - " [0.66469282, 0.64790852, 0.70707071],\n", - " [0.52553664, 0.50165513, 1. ],\n", - " [0.42227979, 0.40445381, 0.70707071],\n", - " [0.31754256, 0.30544689, 0.71717172],\n", - " [0.20910437, 0.20523623, 0.70707071],\n", - " [0.10658771, 0.10592838, 0.68686869],\n", - " [0. , 0. , 0.72727273]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.160401 , 0.16309013, 0.90277778],\n", - " [0.32105263, 0.31974249, 0.91666667],\n", - " [0.49373434, 0.50214592, 0.93055556],\n", - " [0.65438596, 0.66094421, 0.91666667],\n", - " [0.8273183 , 0.82832618, 1. ],\n", - " [1. , 1. , 0.98611111]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87482806, 0.89054726, 0.98507463],\n", - " [0.74828061, 0.7761194 , 1. ],\n", - " [0.62310867, 0.65174129, 0.98507463],\n", - " [0.49766162, 0.51741294, 0.98507463],\n", - " [0.37248968, 0.38308458, 0.98507463],\n", - " [0.24951857, 0.25373134, 0.97014925],\n", - " [0.12489684, 0.12935323, 0.98507463],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11128818, 0.11242604, 0.92957746],\n", - " [0.22231076, 0.22633136, 0.91549296],\n", - " [0.33306773, 0.33727811, 0.94366197],\n", - " [0.44409031, 0.44970414, 0.92957746],\n", - " [0.56334661, 0.57100592, 1. ],\n", - " [0.67569721, 0.68343195, 0.94366197],\n", - " [0.78565737, 0.79142012, 0.92957746],\n", - " [0.8937583 , 0.8964497 , 0.91549296],\n", - " [1. , 1. , 0.88732394]]),\n", - " array([[0.51428571, 1. , 0. ],\n", - " [0.62857143, 0.89462762, 0.71717172],\n", - " [1. , 0.7477519 , 1. ],\n", - " [0.48571429, 0.62992852, 0.80808081],\n", - " [0.48571429, 0.52778418, 0.71717172],\n", - " [0.48571429, 0.39681808, 0.8989899 ],\n", - " [0.34285714, 0.30827761, 0.61616162],\n", - " [0.31428571, 0.20659442, 0.6969697 ],\n", - " [0.31428571, 0.10099147, 0.72727273],\n", - " [0. , 0. , 0.6969697 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11284047, 0.01290323, 0.84415584],\n", - " [0.21893645, 0.01612903, 0.80519481],\n", - " [0.35019455, 0.20322581, 1. ],\n", - " [0.46018158, 0.25483871, 0.84415584],\n", - " [0.5618677 , 0.33225806, 0.79220779],\n", - " [0.67367056, 0.53225806, 0.84415584],\n", - " [0.77535668, 0.67741935, 0.79220779],\n", - " [0.89805447, 0.83548387, 0.92207792],\n", - " [1. , 1. , 0.79220779]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86013793, 0.85895628, 0.78888889],\n", - " [0.72993103, 0.72637518, 0.73333333],\n", - " [0.59806897, 0.59238364, 0.73333333],\n", - " [0.42482759, 0.42172073, 1. ],\n", - " [0.25737931, 0.25952045, 0.93333333],\n", - " [0.1257931 , 0.12552891, 0.73333333],\n", - " [0. , 0. , 0.73333333]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.83045213, 0.83052147, 0.97014925],\n", - " [0.66289894, 0.66334356, 0.98507463],\n", - " [0.5 , 0.49897751, 0.98507463],\n", - " [0.33244681, 0.33205521, 1. ],\n", - " [0.16755319, 0.16717791, 0.97014925],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11266861, 0.11625148, 0.98507463],\n", - " [0.22427929, 0.23013049, 0.98507463],\n", - " [0.33350965, 0.34519573, 0.97014925],\n", - " [0.4443269 , 0.45670225, 0.98507463],\n", - " [0.55593758, 0.56702254, 0.98507463],\n", - " [0.66675483, 0.6737841 , 0.98507463],\n", - " [0.77810103, 0.78173191, 1. ],\n", - " [0.88971172, 0.89323843, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87790198, 0.12320789, 1. ],\n", - " [0.75408426, 0.24887993, 0.98484848],\n", - " [0.63026655, 0.375 , 1. ],\n", - " [0.5038693 , 0.50134409, 1. ],\n", - " [0.3783319 , 0.62791219, 1. ],\n", - " [0.24935512, 0.75492832, 1. ],\n", - " [0.11951849, 0.88216846, 1. ],\n", - " [0. , 1. , 0.92424242]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90390051, 0.90627763, 0.53435115],\n", - " [0.79423403, 0.79840849, 0.61068702],\n", - " [0.61560204, 0.622458 , 1. ],\n", - " [0.51950254, 0.52608311, 0.51908397],\n", - " [0.40729226, 0.41290893, 0.6259542 ],\n", - " [0.28688525, 0.29266136, 0.67938931],\n", - " [0.19135105, 0.19628647, 0.53435115],\n", - " [0.09581685, 0.09814324, 0.53435115],\n", - " [0. , 0. , 0.53435115]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16517106, 0.16003351, 0.96875 ],\n", - " [0.33062255, 0.32509426, 0.96875 ],\n", - " [0.49579361, 0.49350649, 0.96875 ],\n", - " [0.66825575, 0.6627566 , 1. ],\n", - " [0.83538979, 0.82907415, 0.96875 ],\n", - " [1. , 1. , 0.953125 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.0959041 , 0.09644939, 0.91666667],\n", - " [0.21628372, 0.21701113, 0.91666667],\n", - " [0.31818182, 0.31849497, 0.90277778],\n", - " [0.43456543, 0.43296237, 0.84722222],\n", - " [0.54795205, 0.54583996, 0.91666667],\n", - " [0.65784216, 0.65686275, 0.91666667],\n", - " [0.77922078, 0.77768945, 1. ],\n", - " [0.89010989, 0.88871224, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87470908, 0.87533693, 0.97222222],\n", - " [0.74864236, 0.75134771, 0.97222222],\n", - " [0.62335144, 0.62668464, 0.97222222],\n", - " [0.49767261, 0.50202156, 0.97222222],\n", - " [0.37315749, 0.37668464, 0.97222222],\n", - " [0.25096974, 0.25336927, 0.95833333],\n", - " [0.12684251, 0.1287062 , 0.97222222],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11482112, 0.11618705, 0.89873418],\n", - " [0.2153322 , 0.22158273, 0.88607595],\n", - " [0.32436116, 0.33093525, 0.86075949],\n", - " [0.42316865, 0.42733813, 0.7721519 ],\n", - " [0.54003407, 0.54244604, 0.89873418],\n", - " [0.64804089, 0.64964029, 0.87341772],\n", - " [0.76218058, 0.76438849, 0.87341772],\n", - " [0.8746167 , 0.87410072, 0.89873418],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.928 , 0.06551724, 0.98591549],\n", - " [0.85381818, 0.13275862, 1. ],\n", - " [0.78254545, 0.19950739, 0.98591549],\n", - " [0.71563636, 0.26256158, 0.97183099],\n", - " [0.64727273, 0.3270936 , 0.97183099],\n", - " [0.58763636, 0.38325123, 0.85915493],\n", - " [0.51854545, 0.44581281, 0.97183099],\n", - " [0.44872727, 0.51034483, 1. ],\n", - " [0.37963636, 0.57389163, 0.98591549],\n", - " [0.33090909, 0.62931034, 0.85915493],\n", - " [0.28072727, 0.69359606, 0.95774648],\n", - " [0.23854545, 0.74950739, 0.85915493],\n", - " [0.18254545, 0.8137931 , 0.98591549],\n", - " [0.12072727, 0.87931034, 0.98591549],\n", - " [0.06472727, 0.93448276, 0.85915493],\n", - " [0. , 1. , 0.95774648]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.1000535 , 0.90861813, 0.85185185],\n", - " [0.20278224, 0.81624567, 0.88888889],\n", - " [0.30551097, 0.72362556, 0.86419753],\n", - " [0.40342429, 0.63447251, 0.85185185],\n", - " [0.50775816, 0.54160475, 0.86419753],\n", - " [0.5917603 , 0.46433878, 0.75308642],\n", - " [0.68967362, 0.37270926, 0.85185185],\n", - " [0.79026217, 0.26597325, 1. ],\n", - " [0.87693954, 0.17360079, 0.85185185],\n", - " [0.93953986, 0.0936107 , 0.75308642],\n", - " [1. , 0. , 0.85185185]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89591281, 0.10855263, 1. ],\n", - " [0.79509537, 0.21513158, 1. ],\n", - " [0.69155313, 0.32368421, 1. ],\n", - " [0.60081744, 0.41907895, 0.87142857],\n", - " [0.49945504, 0.52171053, 1. ],\n", - " [0.4 , 0.62302632, 0.98571429],\n", - " [0.29564033, 0.73157895, 1. ],\n", - " [0.20790191, 0.8125 , 0.87142857],\n", - " [0.1027248 , 0.90789474, 1. ],\n", - " [0. , 1. , 0.97142857]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.0312256 , 0.85023041, 0.92957746],\n", - " [0.06713505, 0.70766129, 0.94366197],\n", - " [0.12021858, 0.57517281, 0.91549296],\n", - " [0.19203747, 0.4593894 , 0.94366197],\n", - " [0.29000781, 0.36837558, 0.85915493],\n", - " [0.42935207, 0.30645161, 0.97183099],\n", - " [0.58235753, 0.24193548, 1. ],\n", - " [0.73497268, 0.17108295, 0.98591549],\n", - " [0.88290398, 0.09331797, 0.98591549],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89893914, 0.88740617, 0.875 ],\n", - " [0.80374093, 0.77898249, 0.875 ],\n", - " [0.71580123, 0.68306922, 0.7625 ],\n", - " [0.61418202, 0.58131776, 0.875 ],\n", - " [0.50083752, 0.46872394, 1. ],\n", - " [0.40061418, 0.36864053, 0.85 ],\n", - " [0.29927415, 0.26605505, 0.8875 ],\n", - " [0.20156337, 0.17431193, 0.8875 ],\n", - " [0.09631491, 0.08340284, 0.875 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.0946715 , 0.92010444, 0.95522388],\n", - " [0.19503363, 0.83916449, 0.98507463],\n", - " [0.29591309, 0.75587467, 1. ],\n", - " [0.37144335, 0.67023499, 0.95522388],\n", - " [0.43455768, 0.58328982, 0.94029851],\n", - " [0.50336265, 0.48955614, 1. ],\n", - " [0.57578893, 0.40469974, 0.94029851],\n", - " [0.64769788, 0.32140992, 0.94029851],\n", - " [0.72995344, 0.23603133, 0.95522388],\n", - " [0.81376099, 0.15665796, 0.94029851],\n", - " [0.90481117, 0.07754569, 0.94029851],\n", - " [1. , 0. , 0.94029851]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87419769, 0.12661969, 0.98507463],\n", - " [0.74967908, 0.24960218, 0.97014925],\n", - " [0.63157895, 0.37599454, 1. ],\n", - " [0.50834403, 0.49943169, 0.98507463],\n", - " [0.38510911, 0.62400546, 0.98507463],\n", - " [0.2593068 , 0.74903387, 0.98507463],\n", - " [0.13478819, 0.87383496, 0.98507463],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13116016, 0.13471503, 0.91 ],\n", - " [0.27900411, 0.27875648, 1. ],\n", - " [0.3798768 , 0.37823834, 0.68 ],\n", - " [0.48459959, 0.48393782, 0.72 ],\n", - " [0.58957906, 0.58756477, 0.69 ],\n", - " [0.68942505, 0.69222798, 0.69 ],\n", - " [0.81211499, 0.8134715 , 0.8 ],\n", - " [0.89938398, 0.8984456 , 0.62 ],\n", - " [1. , 1. , 0.68 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.06137184, 0.91177206, 0.76666667],\n", - " [0.12274368, 0.82654336, 0.76666667],\n", - " [0.18411552, 0.73406648, 0.78888889],\n", - " [0.27797834, 0.61934516, 1. ],\n", - " [0.38628159, 0.52836791, 0.77777778],\n", - " [0.50541516, 0.43964009, 0.77777778],\n", - " [0.60649819, 0.35016246, 0.77777778],\n", - " [0.70758123, 0.26018495, 0.76666667],\n", - " [0.79061372, 0.18395401, 0.67777778],\n", - " [0.89530686, 0.09297676, 0.76666667],\n", - " [1. , 0. , 0.8 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89785992, 0.10197817, 1. ],\n", - " [0.80058366, 0.19815825, 0.98591549],\n", - " [0.70071336, 0.29774898, 0.97183099],\n", - " [0.59954604, 0.39938608, 0.98591549],\n", - " [0.5 , 0.49965894, 0.98591549],\n", - " [0.40175097, 0.59856753, 1. ],\n", - " [0.30220493, 0.69884038, 0.97183099],\n", - " [0.20201038, 0.79911323, 0.98591549],\n", - " [0.10149157, 0.89904502, 0.98591549],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91031693, 0.89806212, 0.91428571],\n", - " [0.82063385, 0.78762941, 1. ],\n", - " [0.73027647, 0.67693125, 0.98571429],\n", - " [0.65205664, 0.58401911, 0.87142857],\n", - " [0.56169926, 0.48659411, 0.9 ],\n", - " [0.44976399, 0.38492169, 0.94285714],\n", - " [0.33715442, 0.29652243, 0.88571429],\n", - " [0.2137559 , 0.19033714, 0.97142857],\n", - " [0.10114633, 0.09742501, 0.91428571],\n", - " [0. , 0. , 0.9 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12722989, 0.12621359, 1. ],\n", - " [0.24503534, 0.24271845, 0.92424242],\n", - " [0.37125547, 0.36997226, 1. ],\n", - " [0.49680242, 0.49653259, 1. ],\n", - " [0.62302255, 0.62309293, 1. ],\n", - " [0.74890609, 0.74965326, 1. ],\n", - " [0.87546281, 0.87552011, 1. ],\n", - " [1. , 1. , 0.98484848]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.16876122, 0.82142857, 0.91666667],\n", - " [0.33290587, 0.65 , 0.91666667],\n", - " [0.49705053, 0.48571429, 0.90277778],\n", - " [0.64939728, 0.34285714, 0.84722222],\n", - " [0.8181585 , 0.17142857, 0.91666667],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08724832, 0.10430892, 0.7752809 ],\n", - " [0.1901566 , 0.21497528, 0.79775281],\n", - " [0.3064877 , 0.32258065, 0.78651685],\n", - " [0.42505593, 0.42971509, 0.78651685],\n", - " [0.54138702, 0.53732046, 0.78651685],\n", - " [0.64653244, 0.64516129, 0.78651685],\n", - " [0.78747204, 0.78172828, 1. ],\n", - " [0.89261745, 0.89004003, 0.78651685],\n", - " [1. , 1. , 0.79775281]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.93250359, 0.89351082, 0.97142857],\n", - " [0.87266635, 0.80057048, 0.88571429],\n", - " [0.80469124, 0.69954837, 1. ],\n", - " [0.73623743, 0.60446874, 0.98571429],\n", - " [0.64528483, 0.52151177, 1. ],\n", - " [0.53853518, 0.44877585, 1. ],\n", - " [0.43178554, 0.37794153, 1. ],\n", - " [0.32072762, 0.3075826 , 1. ],\n", - " [0.22211584, 0.24696934, 0.87142857],\n", - " [0.11488751, 0.17161873, 0.97142857],\n", - " [0.03973193, 0.09531733, 0.88571429],\n", - " [0. , 0. , 0.98571429]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85641244, 0.85544267, 0.98507463],\n", - " [0.70941628, 0.70798258, 0.97014925],\n", - " [0.56838517, 0.56806967, 1. ],\n", - " [0.42394546, 0.42351234, 0.98507463],\n", - " [0.28845334, 0.28795356, 0.98507463],\n", - " [0.13634427, 0.13642961, 0.98507463],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91449275, 0.9394166 , 0.59166667],\n", - " [0.82985507, 0.87808527, 0.575 ],\n", - " [0.74550725, 0.81226627, 0.59166667],\n", - " [0.65101449, 0.72849663, 0.65833333],\n", - " [0.50869565, 0.57217651, 1. ],\n", - " [0.42434783, 0.47718773, 0.58333333],\n", - " [0.34144928, 0.38444278, 0.59166667],\n", - " [0.26 , 0.29244577, 0.575 ],\n", - " [0.16608696, 0.18698579, 0.66666667],\n", - " [0.08492754, 0.09498878, 0.575 ],\n", - " [0. , 0. , 0.59166667]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.10954151, 0.86764706, 0.91666667],\n", - " [0.21933086, 0.76470588, 0.91666667],\n", - " [0.32887237, 0.67647059, 0.91666667],\n", - " [0.44039653, 0.55882353, 0.93055556],\n", - " [0.56009913, 0.42647059, 1. ],\n", - " [0.66815366, 0.29411765, 0.90277778],\n", - " [0.77992565, 0.19117647, 0.93055556],\n", - " [0.888228 , 0.11764706, 0.90277778],\n", - " [1. , 0. , 0.93055556]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88925895, 0.8981209 , 0.98591549],\n", - " [0.76519567, 0.79986416, 0.97183099],\n", - " [0.65445462, 0.69979624, 1. ],\n", - " [0.53039134, 0.59769074, 0.97183099],\n", - " [0.41798501, 0.4996604 , 0.98591549],\n", - " [0.29641965, 0.40095087, 1. ],\n", - " [0.20732723, 0.29816618, 0.95774648],\n", - " [0.15237302, 0.20760697, 0.85915493],\n", - " [0.06827644, 0.10572787, 0.97183099],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10995542, 0.0775463 , 0.58333333],\n", - " [0.31352155, 0.19837963, 0.91666667],\n", - " [0.45319465, 0.2875 , 0.65833333],\n", - " [0.57206538, 0.36759259, 0.6 ],\n", - " [0.72659733, 0.47731481, 0.83333333],\n", - " [0.90044577, 0.58958333, 0.825 ],\n", - " [0.97028232, 0.65601852, 0.50833333],\n", - " [1. , 0.75601852, 0.73333333],\n", - " [0.90936107, 0.89907407, 1. ],\n", - " [0.80832095, 1. , 0.675 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9106652 , 0.91666667, 0.8875 ],\n", - " [0.81913139, 0.82564103, 0.875 ],\n", - " [0.73062122, 0.72179487, 0.875 ],\n", - " [0.62699285, 0.61282051, 1. ],\n", - " [0.5371083 , 0.5474359 , 0.875 ],\n", - " [0.44832325, 0.46025641, 0.8625 ],\n", - " [0.35816383, 0.3525641 , 0.8875 ],\n", - " [0.2680044 , 0.25769231, 0.875 ],\n", - " [0.17921935, 0.18589744, 0.8625 ],\n", - " [0.0893348 , 0.10384615, 0.875 ],\n", - " [0. , 0. , 0.8875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11616572, 0.88108614, 1. ],\n", - " [0.23206066, 0.76310861, 1. ],\n", - " [0.3463309 , 0.64794007, 0.98571429],\n", - " [0.4486867 , 0.54868914, 0.88571429],\n", - " [0.56566477, 0.43164794, 0.98571429],\n", - " [0.66558354, 0.33146067, 0.87142857],\n", - " [0.78012456, 0.21722846, 0.97142857],\n", - " [0.88058489, 0.1170412 , 0.87142857],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92243187, 0.94441871, 0.98591549],\n", - " [0.84696017, 0.88906901, 0.98591549],\n", - " [0.77358491, 0.83441408, 0.97183099],\n", - " [0.69601677, 0.77813803, 0.98591549],\n", - " [0.62683438, 0.72255674, 1. ],\n", - " [0.5639413 , 0.66581751, 1. ],\n", - " [0.50314465, 0.60954145, 0.98591549],\n", - " [0.45073375, 0.55349699, 0.97183099],\n", - " [0.39622642, 0.49675776, 0.98591549],\n", - " [0.34591195, 0.44001853, 0.97183099],\n", - " [0.29350105, 0.3832793 , 0.98591549],\n", - " [0.24947589, 0.3258453 , 1. ],\n", - " [0.20754717, 0.27721167, 0.85915493],\n", - " [0.16771488, 0.22163038, 0.95774648],\n", - " [0.12997904, 0.17392311, 0.85915493],\n", - " [0.09224319, 0.1167207 , 0.97183099],\n", - " [0.04192872, 0.05882353, 1. ],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89975213, 0.89925373, 0.97222222],\n", - " [0.79399614, 0.80410448, 1. ],\n", - " [0.69429909, 0.67910448, 0.95833333],\n", - " [0.60258882, 0.59141791, 0.84722222],\n", - " [0.50179014, 0.49626866, 0.95833333],\n", - " [0.41448637, 0.40485075, 0.84722222],\n", - " [0.31065822, 0.30783582, 0.97222222],\n", - " [0.20655467, 0.18656716, 0.95833333],\n", - " [0.10355274, 0.08955224, 0.97222222],\n", - " [0. , 0. , 0.98611111]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10188473, 0.38461538, 0.85185185],\n", - " [0.19011199, 0.78021978, 0.75308642],\n", - " [0.3045616 , 1. , 0.98765432],\n", - " [0.40590003, 0.92307692, 0.86419753],\n", - " [0.50450697, 0.91208791, 0.86419753],\n", - " [0.60010926, 0.89010989, 0.85185185],\n", - " [0.71483201, 0.75824176, 1. ],\n", - " [0.80223983, 0.69230769, 0.75308642],\n", - " [0.90084676, 0.54945055, 0.85185185],\n", - " [1. , 0.47252747, 0.87654321]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14216282, 0.14292301, 0.98507463],\n", - " [0.2855407 , 0.28446289, 0.98507463],\n", - " [0.42648846, 0.42369756, 0.98507463],\n", - " [0.56136087, 0.56569848, 0.98507463],\n", - " [0.70959903, 0.71069617, 0.98507463],\n", - " [0.85783718, 0.8526971 , 0.98507463],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12199264, 0.13542795, 0.93055556],\n", - " [0.25870365, 0.28494041, 1. ],\n", - " [0.38126238, 0.40520043, 0.91666667],\n", - " [0.50325502, 0.54279523, 0.91666667],\n", - " [0.62666289, 0.66413868, 0.91666667],\n", - " [0.75035381, 0.77789816, 0.90277778],\n", - " [0.87630909, 0.89057421, 0.91666667],\n", - " [1. , 1. , 0.93055556]]),\n", - " array([[0.13333333, 0. , 0. ],\n", - " [0.06666667, 0.10958276, 0.98591549],\n", - " [0.4 , 0.22077029, 0.98591549],\n", - " [0.53333333, 0.33402109, 0.98591549],\n", - " [0.53333333, 0.44360385, 0.98591549],\n", - " [0.8 , 0.55479138, 0.97183099],\n", - " [1. , 0.66712517, 1. ],\n", - " [0.86666667, 0.77624943, 0.98591549],\n", - " [0.46666667, 0.88766621, 0.98591549],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16368013, 0.17495987, 0.90410959],\n", - " [0.32789516, 0.34028892, 0.90410959],\n", - " [0.4947847 , 0.50561798, 0.90410959],\n", - " [0.65792993, 0.66292135, 0.90410959],\n", - " [0.82187751, 0.82504013, 0.89041096],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09802877, 0.91176471, 0.78888889],\n", - " [0.19072989, 0.80882353, 0.75555556],\n", - " [0.28875866, 0.72794118, 0.78888889],\n", - " [0.41182738, 0.64705882, 0.98888889],\n", - " [0.50932339, 0.52941176, 0.78888889],\n", - " [0.63345765, 0.41911765, 1. ],\n", - " [0.72935535, 0.32352941, 0.77777778],\n", - " [0.82285562, 0.22058824, 0.76666667],\n", - " [0.90463506, 0.08823529, 0.67777778],\n", - " [1. , 0. , 0.78888889]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11344853, 0.88550186, 0.55 ],\n", - " [0.22238918, 0.77348203, 0.55 ],\n", - " [0.34109692, 0.65254027, 0.59166667],\n", - " [0.45229151, 0.54027261, 0.55 ],\n", - " [0.56799399, 0.42552664, 0.55833333],\n", - " [0.68069121, 0.31449814, 0.54166667],\n", - " [0.79413974, 0.20272615, 0.55 ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12194488, 0.12121212, 0.91666667],\n", - " [0.2574103 , 0.25575758, 1. ],\n", - " [0.38117525, 0.38181818, 0.90277778],\n", - " [0.50468019, 0.50545455, 0.93055556],\n", - " [0.62844514, 0.63030303, 0.91666667],\n", - " [0.75195008, 0.75393939, 0.91666667],\n", - " [0.87597504, 0.87757576, 0.90277778],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8551049 , 0.14726027, 0.90410959],\n", - " [0.71440559, 0.28938356, 0.89041096],\n", - " [0.55832168, 0.45034247, 1. ],\n", - " [0.41538462, 0.59246575, 0.89041096],\n", - " [0.28559441, 0.72089041, 0.83561644],\n", - " [0.14265734, 0.86130137, 0.89041096],\n", - " [0. , 1. , 0.90410959]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11288292, 0.1053818 , 0.88607595],\n", - " [0.22408728, 0.21301775, 0.86075949],\n", - " [0.33780948, 0.32544379, 0.89873418],\n", - " [0.44901385, 0.43702451, 0.87341772],\n", - " [0.56063785, 0.54860524, 0.89873418],\n", - " [0.68443139, 0.67540152, 1. ],\n", - " [0.78136802, 0.77345731, 0.7721519 ],\n", - " [0.88921527, 0.88503804, 0.87341772],\n", - " [1. , 1. , 0.89873418]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08492569, 0.09134731, 1. ],\n", - " [0.17409766, 0.18028441, 0.97183099],\n", - " [0.26326964, 0.27235478, 1. ],\n", - " [0.35244161, 0.36249699, 0.97183099],\n", - " [0.43949045, 0.45336226, 0.98591549],\n", - " [0.52866242, 0.54302242, 0.98591549],\n", - " [0.62420382, 0.63557484, 0.98591549],\n", - " [0.71762208, 0.72644011, 0.98591549],\n", - " [0.80679406, 0.81610027, 0.98591549],\n", - " [0.90233546, 0.90841167, 0.98591549],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89164905, 0.89003055, 0.875 ],\n", - " [0.78171247, 0.78033879, 0.875 ],\n", - " [0.6717759 , 0.67092474, 0.875 ],\n", - " [0.56342495, 0.56289919, 0.8625 ],\n", - " [0.45454545, 0.45348514, 0.875 ],\n", - " [0.34302326, 0.34296029, 0.9 ],\n", - " [0.21934461, 0.21993891, 0.975 ],\n", - " [0.09513742, 0.09497362, 1. ],\n", - " [0. , 0. , 0.7625 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87603306, 0.11446819, 0.98591549],\n", - " [0.74655647, 0.22647998, 1. ],\n", - " [0.64187328, 0.33971997, 0.98591549],\n", - " [0.55096419, 0.45001228, 0.95774648],\n", - " [0.4600551 , 0.54728568, 0.85915493],\n", - " [0.31404959, 0.66077131, 1. ],\n", - " [0.19008264, 0.77425694, 0.98591549],\n", - " [0.1046832 , 0.88749693, 0.98591549],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09632446, 0.09997369, 0.85915493],\n", - " [0.21863118, 0.21652197, 0.97183099],\n", - " [0.33586819, 0.33017627, 0.97183099],\n", - " [0.44803549, 0.44330439, 1. ],\n", - " [0.57034221, 0.56116811, 0.97183099],\n", - " [0.68948035, 0.67640095, 0.98591549],\n", - " [0.78453739, 0.77821626, 0.85915493],\n", - " [0.89797212, 0.89871087, 0.98591549],\n", - " [1. , 1. , 0.85915493]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.81282496, 0.80597015, 1. ],\n", - " [0.67764298, 0.67116797, 0.69651741],\n", - " [0.59965338, 0.59369818, 0.39303483],\n", - " [0.51299827, 0.50698887, 0.44776119],\n", - " [0.45060659, 0.44065387, 0.34825871],\n", - " [0.32235702, 0.30514096, 0.69651741],\n", - " [0.23916811, 0.2283819 , 0.39800995],\n", - " [0.16984402, 0.1596778 , 0.35323383],\n", - " [0. , 0. , 0.84079602]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09215686, 0.09499264, 1. ],\n", - " [0.18235294, 0.18630339, 0.98591549],\n", - " [0.27310924, 0.27540501, 0.97183099],\n", - " [0.36694678, 0.37776141, 1. ],\n", - " [0.45910364, 0.47790869, 0.98591549],\n", - " [0.55182073, 0.56553756, 0.97183099],\n", - " [0.62997199, 0.6377025 , 0.85915493],\n", - " [0.72240896, 0.73637703, 0.98591549],\n", - " [0.81512605, 0.82842415, 0.98591549],\n", - " [0.90756303, 0.91531664, 0.98591549],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11954023, 0.11458594, 0.8452381 ],\n", - " [0.2316092 , 0.22316738, 0.79761905],\n", - " [0.36781609, 0.35951964, 1. ],\n", - " [0.5045977 , 0.49487115, 1. ],\n", - " [0.64195402, 0.62997248, 1. ],\n", - " [0.75977011, 0.74555917, 0.85714286],\n", - " [0.88103448, 0.87140355, 0.92857143],\n", - " [1. , 1. , 0.92857143]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90452962, 0.91005724, 0.75824176],\n", - " [0.80905923, 0.82038703, 0.76923077],\n", - " [0.71428571, 0.73017171, 0.76923077],\n", - " [0.61811847, 0.63750341, 0.78021978],\n", - " [0.51986063, 0.5448351 , 0.75824176],\n", - " [0.40627178, 0.43663123, 0.87912088],\n", - " [0.28083624, 0.31452712, 1. ],\n", - " [0.16724739, 0.20496048, 0.87912088],\n", - " [0.06968641, 0.11147452, 0.75824176],\n", - " [0. , 0. , 0.87912088]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89868825, 0.8994614 , 0.97222222],\n", - " [0.79877198, 0.7989228 , 0.97222222],\n", - " [0.69718113, 0.69928187, 0.97222222],\n", - " [0.59921853, 0.60502693, 0.97222222],\n", - " [0.50153503, 0.50628366, 0.97222222],\n", - " [0.40106056, 0.3967684 , 0.95833333],\n", - " [0.30142339, 0.30071813, 1. ],\n", - " [0.20318169, 0.2010772 , 0.95833333],\n", - " [0.1046609 , 0.09874327, 0.95833333],\n", - " [0. , 0. , 0.98611111]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12967844, 0.12897727, 0.78217822],\n", - " [0.29098577, 0.29034091, 1. ],\n", - " [0.40379547, 0.40340909, 0.69306931],\n", - " [0.53083817, 0.53096591, 0.78217822],\n", - " [0.64575646, 0.64744318, 0.7029703 ],\n", - " [0.75751186, 0.75880682, 0.68316832],\n", - " [0.87084871, 0.87130682, 0.7029703 ],\n", - " [1. , 1. , 0.78217822]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.9375 , 0.08505155, 0.98591549],\n", - " [0.86299435, 0.16899853, 0.98591549],\n", - " [0.78425141, 0.25036819, 1. ],\n", - " [0.70550847, 0.32768778, 0.95774648],\n", - " [0.62535311, 0.4039028 , 1. ],\n", - " [0.55120056, 0.4808542 , 0.97183099],\n", - " [0.47316384, 0.56001473, 1. ],\n", - " [0.39371469, 0.63917526, 0.98591549],\n", - " [0.32485876, 0.70765832, 0.85915493],\n", - " [0.24435028, 0.78755523, 0.97183099],\n", - " [0.1634887 , 0.86782032, 0.97183099],\n", - " [0.07733051, 0.93888071, 0.98591549],\n", - " [0. , 1. , 0.85915493]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8697101 , 0.12604522, 1. ],\n", - " [0.74508497, 0.25147104, 0.98507463],\n", - " [0.62179274, 0.38216166, 0.98507463],\n", - " [0.4985005 , 0.51316197, 0.97014925],\n", - " [0.36987671, 0.63765872, 0.98507463],\n", - " [0.25158281, 0.74914834, 0.91044776],\n", - " [0.1242919 , 0.8733354 , 0.98507463],\n", - " [0. , 1. , 0.97014925]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.01102589, 0.98979592, 0.21935484],\n", - " [0.02636625, 0.97667638, 0.29354839],\n", - " [0.0388303 , 0.96618076, 0.22903226],\n", - " [0.05656759, 0.95014577, 0.3516129 ],\n", - " [0.06855225, 0.93731778, 0.22903226],\n", - " [0.084372 , 0.92536443, 0.32258065],\n", - " [0.0949185 , 0.91516035, 0.22258065],\n", - " [0.10834132, 0.90437318, 0.22903226],\n", - " [0.1198466 , 0.8941691 , 0.22580645],\n", - " [0.13566635, 0.88104956, 0.29032258],\n", - " [0.14860978, 0.87172012, 0.22580645],\n", - " [0.16059444, 0.86122449, 0.22580645],\n", - " [0.17066155, 0.85131195, 0.22580645],\n", - " [0.18264621, 0.84110787, 0.22258065],\n", - " [0.19558965, 0.83002915, 0.26129032],\n", - " [0.21955896, 0.80962099, 0.41935484],\n", - " [0.2325024 , 0.79883382, 0.22580645],\n", - " [0.26366251, 0.77376093, 0.5483871 ],\n", - " [0.27708533, 0.76209913, 0.22580645],\n", - " [0.29050815, 0.74927114, 0.25483871],\n", - " [0.30920422, 0.73381924, 0.32580645],\n", - " [0.31208054, 0.7212828 , 0.25806452],\n", - " [0.32502397, 0.71049563, 0.22580645],\n", - " [0.3451582 , 0.69941691, 0.22580645],\n", - " [0.35522531, 0.68804665, 0.22258065],\n", - " [0.37296261, 0.67609329, 0.22903226],\n", - " [0.38398849, 0.66618076, 0.22258065],\n", - " [0.3978907 , 0.65451895, 0.22580645],\n", - " [0.41754554, 0.6361516 , 0.38709677],\n", - " [0.42905081, 0.62536443, 0.22903226],\n", - " [0.4400767 , 0.6148688 , 0.22580645],\n", - " [0.45206136, 0.60408163, 0.22258065],\n", - " [0.46788111, 0.58950437, 0.29354839],\n", - " [0.47986577, 0.57842566, 0.22580645],\n", - " [0.49616491, 0.5638484 , 0.28709677],\n", - " [0.5071908 , 0.55306122, 0.22903226],\n", - " [0.53259827, 0.53061224, 0.4516129 ],\n", - " [0.55608821, 0.51078717, 0.38709677],\n", - " [0.56615532, 0.49825073, 0.22580645],\n", - " [0.57670182, 0.48658892, 0.22580645],\n", - " [0.58868648, 0.47434402, 0.21935484],\n", - " [0.60306807, 0.46355685, 0.23225806],\n", - " [0.61649089, 0.44664723, 0.29032258],\n", - " [0.63279003, 0.43294461, 0.25483871],\n", - " [0.65340364, 0.41457726, 0.35483871],\n", - " [0.6653883 , 0.4 , 0.25806452],\n", - " [0.68120805, 0.38396501, 0.29354839],\n", - " [0.71332694, 0.35247813, 0.60967742],\n", - " [0.7325024 , 0.33061224, 0.41935484],\n", - " [0.75263663, 0.31020408, 0.38709677],\n", - " [0.76845638, 0.29067055, 0.38709677],\n", - " [0.78619367, 0.27113703, 0.35806452],\n", - " [0.80105465, 0.25510204, 0.29032258],\n", - " [0.81303931, 0.24169096, 0.25806452],\n", - " [0.82358581, 0.22886297, 0.22580645],\n", - " [0.83652924, 0.21690962, 0.22580645],\n", - " [0.84659636, 0.20466472, 0.22258065],\n", - " [0.86529243, 0.18134111, 0.42258065],\n", - " [0.87631831, 0.16909621, 0.22580645],\n", - " [0.8873442 , 0.15714286, 0.22580645],\n", - " [0.90747843, 0.13323615, 0.4483871 ],\n", - " [0.91946309, 0.1180758 , 0.29354839],\n", - " [0.93384468, 0.09883382, 0.38709677],\n", - " [0.9472675 , 0.08804665, 0.22580645],\n", - " [0.95541707, 0.07638484, 0.22580645],\n", - " [0.96260786, 0.06472303, 0.22258065],\n", - " [0.96883988, 0.05364431, 0.22580645],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91173521, 0.8968254 , 0.87341772],\n", - " [0.82372116, 0.8042328 , 0.87341772],\n", - " [0.74648947, 0.71957672, 0.7721519 ],\n", - " [0.64368104, 0.62433862, 1. ],\n", - " [0.55115346, 0.53439153, 0.91139241],\n", - " [0.46288867, 0.44179894, 0.88607595],\n", - " [0.37261785, 0.34920635, 0.87341772],\n", - " [0.28284855, 0.27777778, 0.88607595],\n", - " [0.19257773, 0.18783069, 0.88607595],\n", - " [0.10205617, 0.1005291 , 0.89873418],\n", - " [0. , 0. , 0.98734177]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14301192, 0.14224781, 1. ],\n", - " [0.28060672, 0.28300277, 1. ],\n", - " [0.41928494, 0.42653018, 1. ],\n", - " [0.56554713, 0.57005758, 1. ],\n", - " [0.72372698, 0.71251866, 1. ],\n", - " [0.86457205, 0.85604607, 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87430684, 0.132287 , 0.98484848],\n", - " [0.75547927, 0.24663677, 0.92424242],\n", - " [0.62661738, 0.37892377, 1. ],\n", - " [0.49907579, 0.5044843 , 0.98484848],\n", - " [0.37919197, 0.61883408, 0.92424242],\n", - " [0.24900977, 0.75112108, 1. ],\n", - " [0.12094006, 0.87443946, 0.98484848],\n", - " [0. , 1. , 0.92424242]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10354331, 0.10197869, 1. ],\n", - " [0.20314961, 0.20395738, 0.95833333],\n", - " [0.30314961, 0.30715373, 0.95833333],\n", - " [0.40472441, 0.41065449, 0.98611111],\n", - " [0.50551181, 0.50837139, 0.95833333],\n", - " [0.59645669, 0.59452055, 0.86111111],\n", - " [0.7 , 0.69315068, 0.95833333],\n", - " [0.8003937 , 0.79299848, 0.97222222],\n", - " [0.9003937 , 0.89497717, 0.97222222],\n", - " [1. , 1. , 0.97222222]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.83898305, 0.84104628, 1. ],\n", - " [0.74152542, 0.7444668 , 0.61616162],\n", - " [0.5960452 , 0.6004599 , 0.90909091],\n", - " [0.48399247, 0.48950848, 0.6969697 ],\n", - " [0.36723164, 0.37338316, 0.71717172],\n", - " [0.22363465, 0.2282265 , 0.8989899 ],\n", - " [0.11393597, 0.1167002 , 0.71717172],\n", - " [0. , 0. , 0.71717172]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.23364486, 0.23500612, 1. ],\n", - " [0.45794393, 0.4626683 , 0.94 ],\n", - " [0.59813084, 0.6004896 , 0.59333333],\n", - " [0.70654206, 0.71113831, 0.46666667],\n", - " [0.85420561, 0.85434517, 0.6 ],\n", - " [1. , 1. , 0.60666667]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.94292453, 0.04454148, 0.87341772],\n", - " [0.87924528, 0.09723435, 0.88607595],\n", - " [0.82358491, 0.13275109, 0.88607595],\n", - " [0.75896226, 0.18427948, 0.88607595],\n", - " [0.70188679, 0.22066958, 0.89873418],\n", - " [0.63820755, 0.26055313, 0.88607595],\n", - " [0.56650943, 0.3062591 , 1. ],\n", - " [0.50849057, 0.35283843, 0.7721519 ],\n", - " [0.44858491, 0.39388646, 0.86075949],\n", - " [0.38773585, 0.42649199, 0.88607595],\n", - " [0.32830189, 0.46870451, 0.89873418],\n", - " [0.26462264, 0.51120815, 0.88607595],\n", - " [0.21792453, 0.56040757, 0.89873418],\n", - " [0.18632075, 0.6154294 , 0.88607595],\n", - " [0.16132075, 0.66870451, 0.86075949],\n", - " [0.13443396, 0.72489083, 0.89873418],\n", - " [0.10566038, 0.77962154, 0.88607595],\n", - " [0.08207547, 0.82852984, 0.7721519 ],\n", - " [0.05377358, 0.88471616, 0.87341772],\n", - " [0.02830189, 0.94061135, 0.88607595],\n", - " [0. , 1. , 0.88607595]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12772074, 0.87162162, 0.72619048],\n", - " [0.26406571, 0.73519949, 0.77380952],\n", - " [0.38809035, 0.60875161, 0.72619048],\n", - " [0.5301848 , 0.46846847, 0.78571429],\n", - " [0.68049281, 0.31885457, 0.85714286],\n", - " [0.85913758, 0.14189189, 1. ],\n", - " [1. , 0. , 0.78571429]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90033138, 0.11888112, 0.875 ],\n", - " [0.80168239, 0.2027972 , 0.875 ],\n", - " [0.6997196 , 0.27972028, 0.875 ],\n", - " [0.60183533, 0.39160839, 0.8625 ],\n", - " [0.49987255, 0.51748252, 0.8875 ],\n", - " [0.40020393, 0.59440559, 0.8625 ],\n", - " [0.29926077, 0.70629371, 0.875 ],\n", - " [0.18429773, 0.83916084, 1. ],\n", - " [0.08564874, 0.93006993, 0.8625 ],\n", - " [0. , 1. , 0.7625 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91891892, 0.91747688, 0.95833333],\n", - " [0.84324324, 0.84443917, 0.84722222],\n", - " [0.75675676, 0.76025611, 0.97222222],\n", - " [0.67297297, 0.67725871, 0.95833333],\n", - " [0.58108108, 0.59283851, 0.98611111],\n", - " [0.4972973 , 0.50652122, 0.97222222],\n", - " [0.41351351, 0.42281243, 0.95833333],\n", - " [0.32702703, 0.33696941, 0.98611111],\n", - " [0.24324324, 0.25420915, 0.95833333],\n", - " [0.15675676, 0.16836614, 0.97222222],\n", - " [0.07567568, 0.08252312, 1. ],\n", - " [0. , 0. , 0.94444444]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90151515, 0.88947118, 0.94444444],\n", - " [0.80606061, 0.791091 , 0.86111111],\n", - " [0.67424242, 0.67937113, 0.95833333],\n", - " [0.55757576, 0.56788947, 0.97222222],\n", - " [0.44242424, 0.45545498, 0.95833333],\n", - " [0.33181818, 0.3406384 , 1. ],\n", - " [0.22121212, 0.22868032, 0.94444444],\n", - " [0.10757576, 0.11362554, 1. ],\n", - " [0. , 0. , 0.95833333]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90951743, 0.0944217 , 0.75308642],\n", - " [0.80093834, 0.20061412, 0.86419753],\n", - " [0.69369973, 0.30962129, 0.86419753],\n", - " [0.5730563 , 0.43091095, 0.98765432],\n", - " [0.44705094, 0.55552712, 0.98765432],\n", - " [0.3424933 , 0.66248721, 0.86419753],\n", - " [0.23324397, 0.76970317, 0.85185185],\n", - " [0.10656836, 0.89406346, 1. ],\n", - " [0. , 1. , 0.85185185]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12021247, 0.12688442, 0.87142857],\n", - " [0.25552139, 0.26507538, 1. ],\n", - " [0.37517473, 0.37939698, 0.88571429],\n", - " [0.49482807, 0.49371859, 0.88571429],\n", - " [0.62566396, 0.62562814, 0.98571429],\n", - " [0.74531731, 0.74120603, 0.87142857],\n", - " [0.88034666, 0.87562814, 1. ],\n", - " [1. , 1. , 0.88571429]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89207868, 0.12365591, 0.86419753],\n", - " [0.78495481, 0.23655914, 0.85185185],\n", - " [0.66214779, 0.37096774, 1. ],\n", - " [0.54093567, 0.48924731, 0.97530864],\n", - " [0.43168527, 0.58602151, 0.87654321],\n", - " [0.32402977, 0.67741935, 0.85185185],\n", - " [0.2169059 , 0.77956989, 0.86419753],\n", - " [0.10712387, 0.87634409, 0.87654321],\n", - " [0. , 1. , 0.86419753]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11139896, 0.86465993, 0.79856115],\n", - " [0.2253886 , 0.75505515, 0.64748201],\n", - " [0.33160622, 0.65877757, 0.56834532],\n", - " [0.42487047, 0.5714614 , 0.51798561],\n", - " [0.51036269, 0.48690257, 0.50359712],\n", - " [0.60362694, 0.38901654, 0.56834532],\n", - " [0.68393782, 0.3046875 , 0.49640288],\n", - " [0.81865285, 0.16888787, 0.79856115],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90065862, 0.90753425, 1. ],\n", - " [0.79802415, 0.79794521, 0.98591549],\n", - " [0.69978046, 0.70205479, 0.98591549],\n", - " [0.60373216, 0.62157534, 0.95774648],\n", - " [0.50274424, 0.51369863, 1. ],\n", - " [0.40257958, 0.40410959, 0.97183099],\n", - " [0.30159166, 0.30479452, 1. ],\n", - " [0.201427 , 0.20376712, 0.98591549],\n", - " [0.09906696, 0.09760274, 1. ],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87821483, 0.11592179, 0.91666667],\n", - " [0.75642965, 0.23184358, 0.93055556],\n", - " [0.63035804, 0.37150838, 0.90277778],\n", - " [0.49571357, 0.48882682, 1. ],\n", - " [0.37392839, 0.62849162, 0.91666667],\n", - " [0.24659607, 0.7472067 , 0.93055556],\n", - " [0.12607161, 0.88407821, 0.90277778],\n", - " [0. , 1. , 0.91666667]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89876808, 0.09226933, 0.97183099],\n", - " [0.79753615, 0.19118869, 1. ],\n", - " [0.69898232, 0.28512053, 0.98591549],\n", - " [0.59882164, 0.38320865, 0.98591549],\n", - " [0.49892876, 0.48295927, 0.98591549],\n", - " [0.39903589, 0.58187864, 0.98591549],\n", - " [0.29780396, 0.68661679, 0.98591549],\n", - " [0.1981789 , 0.7921862 , 0.98591549],\n", - " [0.09989288, 0.8960931 , 0.98591549],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8968254 , 0.89921671, 1. ],\n", - " [0.79470899, 0.79843342, 1. ],\n", - " [0.69259259, 0.69608355, 1. ],\n", - " [0.59365079, 0.59582245, 0.98571429],\n", - " [0.50634921, 0.50704961, 0.87142857],\n", - " [0.40687831, 0.40443864, 1. ],\n", - " [0.3037037 , 0.30261097, 1. ],\n", - " [0.2047619 , 0.20339426, 0.98571429],\n", - " [0.1015873 , 0.10208877, 1. ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.76241135, 0.17019667, 1. ],\n", - " [0.58156028, 0.33282905, 0.98507463],\n", - " [0.46453901, 0.50151286, 0.97014925],\n", - " [0.23404255, 0.67145739, 1. ],\n", - " [0.04964539, 0.82980333, 0.98507463],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11183879, 0.11057692, 0.93055556],\n", - " [0.22191436, 0.22115385, 0.90277778],\n", - " [0.33148615, 0.33052885, 0.91666667],\n", - " [0.44206549, 0.44711538, 0.91666667],\n", - " [0.55062972, 0.55769231, 0.90277778],\n", - " [0.64987406, 0.66105769, 0.84722222],\n", - " [0.77103275, 0.77644231, 1. ],\n", - " [0.87858942, 0.88341346, 0.91666667],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11026409, 0.10839786, 0.97183099],\n", - " [0.22025592, 0.2173913 , 0.98591549],\n", - " [0.33297032, 0.3305539 , 0.98591549],\n", - " [0.44541247, 0.44609887, 1. ],\n", - " [0.55676559, 0.55807028, 0.98591549],\n", - " [0.66648516, 0.66646814, 0.97183099],\n", - " [0.77919956, 0.77963073, 1. ],\n", - " [0.89028042, 0.89041096, 0.98591549],\n", - " [1. , 1. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91915593, 0.91686844, 0.85185185],\n", - " [0.83529734, 0.83454399, 0.87654321],\n", - " [0.74897232, 0.74818402, 0.87654321],\n", - " [0.66566183, 0.66343826, 0.86419753],\n", - " [0.58399562, 0.58353511, 0.83950617],\n", - " [0.51274322, 0.51089588, 0.75308642],\n", - " [0.42861058, 0.42211461, 0.86419753],\n", - " [0.34667032, 0.33898305, 0.86419753],\n", - " [0.26171554, 0.25504439, 0.86419753],\n", - " [0.18059742, 0.17191283, 0.85185185],\n", - " [0.09619074, 0.08878128, 0.87654321],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.20615634, 0.20499451, 1. ],\n", - " [0.3564196 , 0.35620198, 0.72527473],\n", - " [0.509113 , 0.50905598, 0.72527473],\n", - " [0.68489267, 0.685236 , 0.85714286],\n", - " [0.83556096, 0.83589462, 0.71428571],\n", - " [1. , 1. , 0.79120879]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09492386, 0.902267 , 0.85185185],\n", - " [0.20558376, 0.78916877, 0.98765432],\n", - " [0.30507614, 0.6884131 , 0.87654321],\n", - " [0.4035533 , 0.59118388, 0.85185185],\n", - " [0.51725888, 0.47732997, 1. ],\n", - " [0.61218274, 0.37808564, 0.86419753],\n", - " [0.70913706, 0.28060453, 0.85185185],\n", - " [0.8 , 0.19521411, 0.75308642],\n", - " [0.9035533 , 0.09874055, 0.85185185],\n", - " [1. , 0. , 0.86419753]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16400426, 0.16579634, 0.98507463],\n", - " [0.33013845, 0.32924282, 0.97014925],\n", - " [0.49574015, 0.50052219, 1. ],\n", - " [0.66453674, 0.66657963, 0.98507463],\n", - " [0.83226837, 0.83342037, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8155922 , 0.91096901, 0.98591549],\n", - " [0.64917541, 0.82046237, 1. ],\n", - " [0.47976012, 0.73290703, 0.98591549],\n", - " [0.31034483, 0.64731923, 0.98591549],\n", - " [0.13643178, 0.5627152 , 0.97183099],\n", - " [0.01349325, 0.47761928, 0.97183099],\n", - " [0. , 0.4021151 , 0.85915493],\n", - " [0.11994003, 0.32341367, 1. ],\n", - " [0.29835082, 0.25356616, 0.97183099],\n", - " [0.47976012, 0.18396458, 0.98591549],\n", - " [0.65367316, 0.11854402, 0.98591549],\n", - " [0.8035982 , 0.05853419, 1. ],\n", - " [0.95952024, 0. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92812142, 0.92900302, 0.75308642],\n", - " [0.84593356, 0.8489426 , 0.83950617],\n", - " [0.76088202, 0.76359517, 0.86419753],\n", - " [0.68900344, 0.69259819, 0.75308642],\n", - " [0.60538373, 0.60876133, 0.85185185],\n", - " [0.50859107, 0.51283988, 1. ],\n", - " [0.42754868, 0.4305136 , 0.85185185],\n", - " [0.33132875, 0.33383686, 1. ],\n", - " [0.24713631, 0.24697885, 0.86419753],\n", - " [0.16380298, 0.16314199, 0.86419753],\n", - " [0.08075601, 0.08006042, 0.86419753],\n", - " [0. , 0. , 0.85185185]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11434854, 0.11373093, 0.84722222],\n", - " [0.24793843, 0.24632455, 0.97222222],\n", - " [0.36558549, 0.36366158, 0.86111111],\n", - " [0.49917537, 0.49653259, 0.95833333],\n", - " [0.61462342, 0.61192788, 0.86111111],\n", - " [0.7482133 , 0.74674064, 0.97222222],\n", - " [0.88235294, 0.88321775, 1. ],\n", - " [1. , 1. , 0.86111111]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.94401042, 0.94427313, 0.85915493],\n", - " [0.87825521, 0.88017621, 0.98591549],\n", - " [0.81510417, 0.81674009, 0.98591549],\n", - " [0.75195312, 0.75242291, 0.97183099],\n", - " [0.68554688, 0.68722467, 1. ],\n", - " [0.62304688, 0.62290749, 0.98591549],\n", - " [0.56054688, 0.55969163, 0.98591549],\n", - " [0.49414062, 0.49625551, 0.97183099],\n", - " [0.44140625, 0.4407489 , 0.85915493],\n", - " [0.37630208, 0.37555066, 0.98591549],\n", - " [0.3125 , 0.31189427, 0.98591549],\n", - " [0.24934896, 0.24735683, 0.97183099],\n", - " [0.19270833, 0.19317181, 0.85915493],\n", - " [0.12825521, 0.12907489, 0.98591549],\n", - " [0.06575521, 0.06387665, 0.98591549],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.84090909, 0.15348451, 1. ],\n", - " [0.71948052, 0.26963496, 0.75824176],\n", - " [0.59545455, 0.38882743, 0.79120879],\n", - " [0.45194805, 0.52488938, 0.87912088],\n", - " [0.32987013, 0.64131637, 0.75824176],\n", - " [0.20584416, 0.75912611, 0.76923077],\n", - " [0.09545455, 0.87914823, 0.76923077],\n", - " [0. , 1. , 0.75824176]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88213024, 0.11742892, 0.73333333],\n", - " [0.71933367, 0.28059333, 1. ],\n", - " [0.60323069, 0.40049444, 0.73333333],\n", - " [0.48308935, 0.52533993, 0.73333333],\n", - " [0.36648157, 0.63658838, 0.73333333],\n", - " [0.24835941, 0.75648949, 0.73333333],\n", - " [0.11862696, 0.88380717, 0.78888889],\n", - " [0. , 1. , 0.73333333]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88578947, 0.92735043, 1. ],\n", - " [0.77631579, 0.78632479, 1. ],\n", - " [0.66210526, 0.71367521, 1. ],\n", - " [0.55842105, 0.57692308, 0.88571429],\n", - " [0.45157895, 0.42735043, 0.95714286],\n", - " [0.33763158, 0.35897436, 0.98571429],\n", - " [0.22263158, 0.20512821, 1. ],\n", - " [0.10947368, 0.07264957, 1. ],\n", - " [0. , 0. , 0.97142857]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85454545, 0.88110255, 0.95384615],\n", - " [0.74545455, 0.75426302, 0.98461538],\n", - " [0.65454545, 0.63116094, 0.95384615],\n", - " [0.51515152, 0.4998832 , 0.98461538],\n", - " [0.38181818, 0.38028498, 0.95384615],\n", - " [0.23030303, 0.25134314, 0.98461538],\n", - " [0.12121212, 0.1298762 , 0.93846154],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.07806081, 0.92176387, 0.86419753],\n", - " [0.18488085, 0.81564723, 1. ],\n", - " [0.26376335, 0.73456615, 0.85185185],\n", - " [0.34880855, 0.64921764, 0.86419753],\n", - " [0.42810189, 0.571266 , 0.87654321],\n", - " [0.50698439, 0.48790896, 0.85185185],\n", - " [0.58915366, 0.40625889, 0.86419753],\n", - " [0.68981101, 0.3086771 , 0.86419753],\n", - " [0.75472473, 0.24096728, 0.75308642],\n", - " [0.84182416, 0.1541963 , 0.86419753],\n", - " [0.91824158, 0.08108108, 0.86419753],\n", - " [1. , 0. , 0.83950617]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88095238, 0.12059369, 0.84615385],\n", - " [0.75678443, 0.24397032, 0.85897436],\n", - " [0.63722478, 0.36270872, 0.84615385],\n", - " [0.51510497, 0.48330241, 0.84615385],\n", - " [0.37403994, 0.62523191, 1. ],\n", - " [0.25576037, 0.7458256 , 0.83333333],\n", - " [0.13364055, 0.86641929, 0.85897436],\n", - " [0. , 1. , 0.91025641]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11457286, 0.11613475, 1. ],\n", - " [0.21306533, 0.21830674, 0.86419753],\n", - " [0.31155779, 0.31715426, 0.86419753],\n", - " [0.41407035, 0.41710993, 0.86419753],\n", - " [0.51557789, 0.51684397, 0.85185185],\n", - " [0.6040201 , 0.60217199, 0.75308642],\n", - " [0.70150754, 0.7016844 , 0.86419753],\n", - " [0.79899497, 0.80097518, 0.86419753],\n", - " [0.89748744, 0.90004433, 0.85185185],\n", - " [1. , 1. , 0.87654321]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90345528, 0.89888777, 0.97183099],\n", - " [0.80182927, 0.79575329, 1. ],\n", - " [0.70223577, 0.69464105, 0.98591549],\n", - " [0.6046748 , 0.59656218, 0.95774648],\n", - " [0.49898374, 0.49368049, 1. ],\n", - " [0.39634146, 0.39054601, 1. ],\n", - " [0.29471545, 0.29019211, 0.97183099],\n", - " [0.19105691, 0.19084934, 0.97183099],\n", - " [0.10162602, 0.10187058, 0.85915493],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08701473, 0.91350357, 1. ],\n", - " [0.16733601, 0.82815735, 0.98591549],\n", - " [0.25033467, 0.74557166, 0.98591549],\n", - " [0.33065596, 0.66551645, 0.98591549],\n", - " [0.40294511, 0.58868185, 0.95774648],\n", - " [0.47925033, 0.52518979, 0.85915493],\n", - " [0.56358768, 0.45594663, 0.98591549],\n", - " [0.64257028, 0.3910743 , 1. ],\n", - " [0.708166 , 0.32850242, 0.98591549],\n", - " [0.76171352, 0.26938118, 0.97183099],\n", - " [0.81659973, 0.20749942, 1. ],\n", - " [0.86746988, 0.14929837, 0.98591549],\n", - " [0.91566265, 0.09546814, 0.98591549],\n", - " [0.95850067, 0.04600874, 0.97183099],\n", - " [1. , 0. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.93935894, 0.9380117 , 0.78481013],\n", - " [0.8749639 , 0.87076023, 0.83544304],\n", - " [0.81230147, 0.80994152, 0.81012658],\n", - " [0.75310424, 0.74853801, 0.7721519 ],\n", - " [0.68899798, 0.68947368, 0.82278481],\n", - " [0.62546925, 0.62397661, 0.83544304],\n", - " [0.56396188, 0.5625731 , 0.79746835],\n", - " [0.50043315, 0.5 , 0.83544304],\n", - " [0.42333237, 0.42222222, 1. ],\n", - " [0.36038117, 0.3619883 , 0.82278481],\n", - " [0.30262778, 0.30409357, 0.7721519 ],\n", - " [0.24487439, 0.24385965, 0.7721519 ],\n", - " [0.18481086, 0.18421053, 0.7721519 ],\n", - " [0.12214843, 0.12397661, 0.83544304],\n", - " [0.05948599, 0.05672515, 0.83544304],\n", - " [0. , 0. , 0.78481013]]),\n", - " array([[5.80154181e-01, 9.22352269e-01, 0.00000000e+00],\n", - " [5.38050998e-01, 9.11504425e-01, 5.00000000e-01],\n", - " [4.96145483e-01, 8.99514702e-01, 4.85915493e-01],\n", - " [4.53251631e-01, 8.86383100e-01, 5.00000000e-01],\n", - " [4.17078474e-01, 8.76677134e-01, 4.29577465e-01],\n", - " [3.74184621e-01, 8.64972880e-01, 4.92957746e-01],\n", - " [3.34651117e-01, 8.53268627e-01, 4.78873239e-01],\n", - " [2.95117612e-01, 8.41849843e-01, 5.00000000e-01],\n", - " [2.56967780e-01, 8.31287468e-01, 4.92957746e-01],\n", - " [2.24747974e-01, 8.22723380e-01, 4.92957746e-01],\n", - " [1.96086183e-01, 8.13588353e-01, 4.85915493e-01],\n", - " [1.70389405e-01, 8.04453326e-01, 5.00000000e-01],\n", - " [1.48448310e-01, 7.99029403e-01, 4.92957746e-01],\n", - " [1.28088555e-01, 7.98172995e-01, 5.00000000e-01],\n", - " [1.10891481e-01, 8.00171282e-01, 4.92957746e-01],\n", - " [9.58687488e-02, 8.06166143e-01, 4.78873239e-01],\n", - " [8.28226922e-02, 8.14730231e-01, 5.00000000e-01],\n", - " [7.15556434e-02, 8.25007137e-01, 4.85915493e-01],\n", - " [6.18699348e-02, 8.36711390e-01, 5.00000000e-01],\n", - " [5.31725637e-02, 8.47559235e-01, 4.85915493e-01],\n", - " [4.52658628e-02, 8.58121610e-01, 4.92957746e-01],\n", - " [3.79521645e-02, 8.68969455e-01, 5.07042254e-01],\n", - " [3.12314687e-02, 8.77533543e-01, 4.92957746e-01],\n", - " [2.54991105e-02, 8.84670283e-01, 4.85915493e-01],\n", - " [2.01620874e-02, 8.91521553e-01, 4.92957746e-01],\n", - " [1.54180668e-02, 8.97801884e-01, 4.92957746e-01],\n", - " [1.16623839e-02, 9.04367685e-01, 4.85915493e-01],\n", - " [8.30203598e-03, 9.10648016e-01, 4.92957746e-01],\n", - " [5.73235817e-03, 9.15786469e-01, 4.92957746e-01],\n", - " [3.55801542e-03, 9.21495861e-01, 5.00000000e-01],\n", - " [2.17434276e-03, 9.26919783e-01, 4.85915493e-01],\n", - " [9.88337616e-04, 9.30345418e-01, 4.92957746e-01],\n", - " [1.97667523e-04, 9.34912932e-01, 5.07042254e-01],\n", - " [0.00000000e+00, 9.38338567e-01, 4.78873239e-01],\n", - " [0.00000000e+00, 9.41764202e-01, 4.92957746e-01],\n", - " [5.93002570e-04, 9.44904368e-01, 4.92957746e-01],\n", - " [1.38367266e-03, 9.48330003e-01, 4.92957746e-01],\n", - " [2.56967780e-03, 9.50613760e-01, 4.92957746e-01],\n", - " [5.13935560e-03, 9.54895804e-01, 1.00000000e+00],\n", - " [7.11603084e-03, 9.57179560e-01, 4.85915493e-01],\n", - " [8.69737102e-03, 9.59177848e-01, 4.92957746e-01],\n", - " [1.10693813e-02, 9.60605196e-01, 5.00000000e-01],\n", - " [1.34413916e-02, 9.61461604e-01, 4.78873239e-01],\n", - " [1.54180668e-02, 9.62603483e-01, 4.92957746e-01],\n", - " [1.75924096e-02, 9.63459892e-01, 4.92957746e-01],\n", - " [1.99644198e-02, 9.64887240e-01, 5.00000000e-01],\n", - " [2.21387626e-02, 9.65458179e-01, 5.00000000e-01],\n", - " [2.45107729e-02, 9.66314587e-01, 4.85915493e-01],\n", - " [2.70804507e-02, 9.67456466e-01, 5.00000000e-01],\n", - " [2.94524610e-02, 9.67741935e-01, 4.85915493e-01],\n", - " [3.20221388e-02, 9.69169283e-01, 4.92957746e-01],\n", - " [3.43941490e-02, 9.70025692e-01, 4.85915493e-01],\n", - " [3.69638268e-02, 9.70882101e-01, 4.92957746e-01],\n", - " [3.97311722e-02, 9.71453040e-01, 5.00000000e-01],\n", - " [4.23008500e-02, 9.72594919e-01, 4.85915493e-01],\n", - " [4.48705278e-02, 9.73165858e-01, 5.00000000e-01],\n", - " [4.76378731e-02, 9.74022267e-01, 4.92957746e-01],\n", - " [5.02075509e-02, 9.74593206e-01, 4.92957746e-01],\n", - " [5.29748962e-02, 9.75449615e-01, 4.92957746e-01],\n", - " [5.61375766e-02, 9.76020554e-01, 4.92957746e-01],\n", - " [5.96955920e-02, 9.76591493e-01, 4.85915493e-01],\n", - " [6.28582724e-02, 9.77162432e-01, 5.07042254e-01],\n", - " [6.58232852e-02, 9.78304311e-01, 4.85915493e-01],\n", - " [6.87882981e-02, 9.78589780e-01, 4.85915493e-01],\n", - " [7.21486460e-02, 9.79446189e-01, 5.00000000e-01],\n", - " [7.51136588e-02, 9.80873537e-01, 4.92957746e-01],\n", - " [7.78810042e-02, 9.81444476e-01, 4.92957746e-01],\n", - " [8.08460170e-02, 9.82015415e-01, 4.92957746e-01],\n", - " [8.36133623e-02, 9.83157294e-01, 5.00000000e-01],\n", - " [8.63807076e-02, 9.84013703e-01, 4.85915493e-01],\n", - " [8.93457205e-02, 9.85155581e-01, 4.85915493e-01],\n", - " [9.25084009e-02, 9.86297459e-01, 4.92957746e-01],\n", - " [9.54734137e-02, 9.87153868e-01, 4.92957746e-01],\n", - " [9.90314291e-02, 9.88295747e-01, 4.92957746e-01],\n", - " [1.02194110e-01, 9.89152155e-01, 4.92957746e-01],\n", - " [1.05554457e-01, 9.90579503e-01, 4.92957746e-01],\n", - " [1.08519470e-01, 9.91435912e-01, 5.00000000e-01],\n", - " [1.11879818e-01, 9.93148730e-01, 4.92957746e-01],\n", - " [1.15240166e-01, 9.94576078e-01, 4.92957746e-01],\n", - " [1.18205179e-01, 9.95717956e-01, 4.85915493e-01],\n", - " [1.21565527e-01, 9.96003426e-01, 4.92957746e-01],\n", - " [1.24530540e-01, 9.97145304e-01, 5.00000000e-01],\n", - " [1.27693220e-01, 9.97716243e-01, 4.92957746e-01],\n", - " [1.31053568e-01, 9.98572652e-01, 4.85915493e-01],\n", - " [1.34413916e-01, 9.99143591e-01, 5.00000000e-01],\n", - " [1.37576596e-01, 9.99429061e-01, 4.85915493e-01],\n", - " [1.39948606e-01, 9.99143591e-01, 4.36619718e-01],\n", - " [1.43111287e-01, 9.99429061e-01, 4.85915493e-01],\n", - " [1.46273967e-01, 1.00000000e+00, 5.00000000e-01],\n", - " [1.49634315e-01, 9.99429061e-01, 4.92957746e-01],\n", - " [1.53587666e-01, 9.99143591e-01, 4.92957746e-01],\n", - " [1.56552678e-01, 9.98858122e-01, 4.78873239e-01],\n", - " [1.59913026e-01, 9.99429061e-01, 4.29577465e-01],\n", - " [1.63273374e-01, 9.99143591e-01, 4.92957746e-01],\n", - " [1.66436055e-01, 9.98572652e-01, 4.29577465e-01],\n", - " [1.70389405e-01, 9.98858122e-01, 4.85915493e-01],\n", - " [1.74145088e-01, 9.98858122e-01, 4.85915493e-01],\n", - " [1.77505436e-01, 9.98858122e-01, 4.29577465e-01],\n", - " [1.81656454e-01, 9.98572652e-01, 5.00000000e-01],\n", - " [1.85016802e-01, 9.98001713e-01, 4.78873239e-01],\n", - " [1.88179482e-01, 9.97430774e-01, 4.29577465e-01],\n", - " [1.92330500e-01, 9.97145304e-01, 4.92957746e-01],\n", - " [1.96086183e-01, 9.96859834e-01, 4.85915493e-01],\n", - " [2.00237201e-01, 9.96859834e-01, 5.07042254e-01],\n", - " [2.04783554e-01, 9.96288895e-01, 5.63380282e-01],\n", - " [2.09132240e-01, 9.96288895e-01, 4.85915493e-01],\n", - " [2.13085590e-01, 9.96003426e-01, 4.85915493e-01],\n", - " [2.16841273e-01, 9.95432486e-01, 4.92957746e-01],\n", - " [2.20596956e-01, 9.94576078e-01, 5.00000000e-01],\n", - " [2.24154971e-01, 9.93434199e-01, 5.00000000e-01],\n", - " [2.28305989e-01, 9.92577790e-01, 4.92957746e-01],\n", - " [2.32852342e-01, 9.91435912e-01, 5.63380282e-01],\n", - " [2.37201028e-01, 9.90864973e-01, 4.92957746e-01],\n", - " [2.41549713e-01, 9.90294034e-01, 4.78873239e-01],\n", - " [2.46096066e-01, 9.89152155e-01, 5.63380282e-01],\n", - " [2.50049417e-01, 9.88295747e-01, 4.92957746e-01],\n", - " [2.54200435e-01, 9.87439338e-01, 5.07042254e-01],\n", - " [2.57758450e-01, 9.86297459e-01, 4.85915493e-01],\n", - " [2.61711801e-01, 9.85441051e-01, 4.92957746e-01],\n", - " [2.65665151e-01, 9.84299172e-01, 4.92957746e-01],\n", - " [2.69420834e-01, 9.83728233e-01, 4.92957746e-01],\n", - " [2.73769520e-01, 9.82586355e-01, 4.85915493e-01],\n", - " [2.77920538e-01, 9.81444476e-01, 5.00000000e-01],\n", - " [2.81873888e-01, 9.80302598e-01, 4.85915493e-01],\n", - " [2.85827239e-01, 9.79160719e-01, 4.92957746e-01],\n", - " [2.89978257e-01, 9.78018841e-01, 5.07042254e-01],\n", - " [2.93733940e-01, 9.76876963e-01, 4.85915493e-01],\n", - " [2.97884958e-01, 9.75735084e-01, 4.85915493e-01],\n", - " [3.02233643e-01, 9.74307736e-01, 5.00000000e-01],\n", - " [3.05989326e-01, 9.73451327e-01, 4.85915493e-01],\n", - " [3.10535679e-01, 9.72594919e-01, 4.92957746e-01],\n", - " [3.14884364e-01, 9.71453040e-01, 5.00000000e-01],\n", - " [3.18640047e-01, 9.70311162e-01, 4.92957746e-01],\n", - " [3.22791065e-01, 9.69169283e-01, 4.85915493e-01],\n", - " [3.26942083e-01, 9.68027405e-01, 4.92957746e-01],\n", - " [3.31883771e-01, 9.66600057e-01, 4.92957746e-01],\n", - " [3.36232457e-01, 9.65458179e-01, 5.00000000e-01],\n", - " [3.40383475e-01, 9.64316300e-01, 4.92957746e-01],\n", - " [3.44929828e-01, 9.62888952e-01, 5.00000000e-01],\n", - " [3.48487843e-01, 9.61747074e-01, 4.78873239e-01],\n", - " [3.52243526e-01, 9.60319726e-01, 4.92957746e-01],\n", - " [3.56987547e-01, 9.58321439e-01, 5.00000000e-01],\n", - " [3.61336232e-01, 9.56608621e-01, 5.00000000e-01],\n", - " [3.65487250e-01, 9.54610334e-01, 4.85915493e-01],\n", - " [3.69638268e-01, 9.52612047e-01, 4.85915493e-01],\n", - " [3.74382289e-01, 9.50613760e-01, 4.92957746e-01],\n", - " [3.78533307e-01, 9.48330003e-01, 4.92957746e-01],\n", - " [3.82684325e-01, 9.46617185e-01, 4.29577465e-01],\n", - " [3.87428346e-01, 9.44333428e-01, 4.85915493e-01],\n", - " [3.92370034e-01, 9.42049672e-01, 4.92957746e-01],\n", - " [3.97114054e-01, 9.39765915e-01, 5.00000000e-01],\n", - " [4.02451077e-01, 9.37767628e-01, 5.00000000e-01],\n", - " [4.07392765e-01, 9.35198401e-01, 4.85915493e-01],\n", - " [4.12136786e-01, 9.32629175e-01, 4.85915493e-01],\n", - " [4.16880806e-01, 9.30059949e-01, 4.92957746e-01],\n", - " [4.21427160e-01, 9.28061661e-01, 4.29577465e-01],\n", - " [4.26764183e-01, 9.25777905e-01, 4.92957746e-01],\n", - " [4.32101206e-01, 9.23494148e-01, 4.85915493e-01],\n", - " [4.37240561e-01, 9.21495861e-01, 4.92957746e-01],\n", - " [4.42775252e-01, 9.19212104e-01, 4.92957746e-01],\n", - " [4.48112275e-01, 9.16357408e-01, 5.00000000e-01],\n", - " [4.53251631e-01, 9.13788182e-01, 4.92957746e-01],\n", - " [4.58588654e-01, 9.11504425e-01, 4.92957746e-01],\n", - " [4.64123345e-01, 9.09506138e-01, 4.92957746e-01],\n", - " [4.69262700e-01, 9.07222381e-01, 4.85915493e-01],\n", - " [4.74204388e-01, 9.04653154e-01, 4.92957746e-01],\n", - " [4.78750741e-01, 9.01798458e-01, 4.92957746e-01],\n", - " [4.84087764e-01, 8.99514702e-01, 4.92957746e-01],\n", - " [4.89227120e-01, 8.96945475e-01, 4.92957746e-01],\n", - " [4.94959478e-01, 8.94376249e-01, 5.00000000e-01],\n", - " [4.99901166e-01, 8.92092492e-01, 4.92957746e-01],\n", - " [5.05238189e-01, 8.89808735e-01, 4.92957746e-01],\n", - " [5.10970548e-01, 8.87524979e-01, 4.92957746e-01],\n", - " [5.16505238e-01, 8.84955752e-01, 4.85915493e-01],\n", - " [5.22237596e-01, 8.82386526e-01, 5.00000000e-01],\n", - " [5.28167622e-01, 8.80102769e-01, 4.92957746e-01],\n", - " [5.33702313e-01, 8.78104482e-01, 4.92957746e-01],\n", - " [5.39237003e-01, 8.75820725e-01, 4.92957746e-01],\n", - " [5.44969362e-01, 8.73536968e-01, 4.92957746e-01],\n", - " [5.50701720e-01, 8.71253212e-01, 4.85915493e-01],\n", - " [5.56236410e-01, 8.69254924e-01, 5.07042254e-01],\n", - " [5.61771101e-01, 8.66971168e-01, 4.85915493e-01],\n", - " [5.67305792e-01, 8.64972880e-01, 4.85915493e-01],\n", - " [5.72642815e-01, 8.62974593e-01, 4.92957746e-01],\n", - " [5.77782170e-01, 8.60976306e-01, 4.29577465e-01],\n", - " [5.84107531e-01, 8.58978019e-01, 4.92957746e-01],\n", - " [5.89642222e-01, 8.56979732e-01, 4.92957746e-01],\n", - " [5.95572247e-01, 8.54981444e-01, 5.00000000e-01],\n", - " [6.01106938e-01, 8.52983157e-01, 4.78873239e-01],\n", - " [6.05653291e-01, 8.50984870e-01, 4.29577465e-01],\n", - " [6.10990314e-01, 8.48701113e-01, 4.92957746e-01],\n", - " [6.16129670e-01, 8.46702826e-01, 4.85915493e-01],\n", - " [6.22059696e-01, 8.44133600e-01, 5.00000000e-01],\n", - " [6.27792054e-01, 8.41564373e-01, 4.85915493e-01],\n", - " [6.33524412e-01, 8.38995147e-01, 4.92957746e-01],\n", - " [6.39059103e-01, 8.36711390e-01, 5.00000000e-01],\n", - " [6.44593793e-01, 8.34142164e-01, 4.92957746e-01],\n", - " [6.50326151e-01, 8.31572937e-01, 4.85915493e-01],\n", - " [6.56256177e-01, 8.29003711e-01, 5.00000000e-01],\n", - " [6.61988535e-01, 8.26149015e-01, 4.92957746e-01],\n", - " [6.67918561e-01, 8.23579789e-01, 4.92957746e-01],\n", - " [6.74046254e-01, 8.20439623e-01, 5.56338028e-01],\n", - " [6.78987942e-01, 8.17584927e-01, 5.00000000e-01],\n", - " [6.84522633e-01, 8.14730231e-01, 4.92957746e-01],\n", - " [6.90254991e-01, 8.12161005e-01, 4.92957746e-01],\n", - " [6.96185017e-01, 8.09591778e-01, 4.92957746e-01],\n", - " [7.01522040e-01, 8.06737083e-01, 4.85915493e-01],\n", - " [7.07056731e-01, 8.04167856e-01, 5.00000000e-01],\n", - " [7.12591421e-01, 8.01313160e-01, 4.92957746e-01],\n", - " [7.18323779e-01, 7.99029403e-01, 4.29577465e-01],\n", - " [7.23463135e-01, 7.96174707e-01, 4.85915493e-01],\n", - " [7.28207156e-01, 7.93890951e-01, 4.29577465e-01],\n", - " [7.33939514e-01, 7.91036255e-01, 4.78873239e-01],\n", - " [7.39671872e-01, 7.88467028e-01, 4.92957746e-01],\n", - " [7.45206563e-01, 7.85897802e-01, 5.00000000e-01],\n", - " [7.50938921e-01, 7.83328576e-01, 4.85915493e-01],\n", - " [7.56473611e-01, 7.81330288e-01, 4.92957746e-01],\n", - " [7.62403637e-01, 7.79046532e-01, 4.92957746e-01],\n", - " [7.67938328e-01, 7.76477305e-01, 5.00000000e-01],\n", - " [7.73275351e-01, 7.73622609e-01, 4.85915493e-01],\n", - " [7.79205377e-01, 7.71338852e-01, 4.92957746e-01],\n", - " [7.84542400e-01, 7.68198687e-01, 5.00000000e-01],\n", - " [7.90077090e-01, 7.65629460e-01, 4.85915493e-01],\n", - " [7.94821111e-01, 7.63060234e-01, 4.29577465e-01],\n", - " [8.00355802e-01, 7.60776477e-01, 4.85915493e-01],\n", - " [8.06088160e-01, 7.57921781e-01, 5.00000000e-01],\n", - " [8.11622850e-01, 7.55352555e-01, 4.85915493e-01],\n", - " [8.17552876e-01, 7.52497859e-01, 5.00000000e-01],\n", - " [8.23285234e-01, 7.49643163e-01, 4.85915493e-01],\n", - " [8.29412927e-01, 7.47359406e-01, 5.00000000e-01],\n", - " [8.35342953e-01, 7.44790180e-01, 4.92957746e-01],\n", - " [8.41668314e-01, 7.41935484e-01, 4.92957746e-01],\n", - " [8.47400672e-01, 7.39080788e-01, 4.92957746e-01],\n", - " [8.53923700e-01, 7.36797031e-01, 4.85915493e-01],\n", - " [8.60051394e-01, 7.34227805e-01, 5.00000000e-01],\n", - " [8.66376754e-01, 7.31373109e-01, 5.00000000e-01],\n", - " [8.71911445e-01, 7.28518413e-01, 4.85915493e-01],\n", - " [8.77248468e-01, 7.26520126e-01, 4.29577465e-01],\n", - " [8.83376161e-01, 7.24521838e-01, 4.78873239e-01],\n", - " [8.89701522e-01, 7.22238082e-01, 4.92957746e-01],\n", - " [8.96026883e-01, 7.19954325e-01, 5.00000000e-01],\n", - " [9.02352244e-01, 7.17385098e-01, 4.85915493e-01],\n", - " [9.08282269e-01, 7.14530403e-01, 4.92957746e-01],\n", - " [9.14607630e-01, 7.12246646e-01, 4.92957746e-01],\n", - " [9.20339988e-01, 7.09677419e-01, 5.00000000e-01],\n", - " [9.26665349e-01, 7.06822723e-01, 4.92957746e-01],\n", - " [9.32793042e-01, 7.04538967e-01, 4.85915493e-01],\n", - " [9.38920735e-01, 7.01969740e-01, 5.00000000e-01],\n", - " [9.45641431e-01, 6.99400514e-01, 5.00000000e-01],\n", - " [9.51373789e-01, 6.96545818e-01, 4.78873239e-01],\n", - " [9.57896818e-01, 6.94262061e-01, 5.00000000e-01],\n", - " [9.64617513e-01, 6.91692835e-01, 4.92957746e-01],\n", - " [9.70547539e-01, 6.88838139e-01, 4.92957746e-01],\n", - " [9.76675232e-01, 6.86554382e-01, 4.92957746e-01],\n", - " [9.82605258e-01, 6.84270625e-01, 4.92957746e-01],\n", - " [9.88732951e-01, 6.81701399e-01, 5.00000000e-01],\n", - " [9.95848982e-01, 6.89409078e-01, 4.85915493e-01],\n", - " [1.00000000e+00, 7.06251784e-01, 4.29577465e-01],\n", - " [9.98418660e-01, 7.33371396e-01, 4.85915493e-01],\n", - " [9.84977268e-01, 7.57065373e-01, 4.92957746e-01],\n", - " [9.63431508e-01, 7.67056808e-01, 4.92957746e-01],\n", - " [9.36548725e-01, 7.67342278e-01, 4.92957746e-01],\n", - " [9.08084602e-01, 7.65914930e-01, 4.92957746e-01],\n", - " [8.78632141e-01, 7.63345704e-01, 4.92957746e-01],\n", - " [8.47598340e-01, 7.61632886e-01, 4.92957746e-01],\n", - " [8.15971536e-01, 7.60205538e-01, 5.00000000e-01],\n", - " [7.86321407e-01, 7.57921781e-01, 4.85915493e-01],\n", - " [7.60229294e-01, 7.54781616e-01, 4.85915493e-01],\n", - " [7.31369836e-01, 7.53354268e-01, 5.00000000e-01],\n", - " [7.06068393e-01, 7.49643163e-01, 4.85915493e-01],\n", - " [6.83731963e-01, 7.45932058e-01, 5.00000000e-01],\n", - " [6.64162878e-01, 7.42791893e-01, 4.85915493e-01],\n", - " [6.47163471e-01, 7.40793605e-01, 4.92957746e-01],\n", - " [6.31547737e-01, 7.36797031e-01, 5.00000000e-01],\n", - " [6.18699348e-01, 7.33942335e-01, 4.85915493e-01],\n", - " [6.07234631e-01, 7.31373109e-01, 4.92957746e-01],\n", - " [5.96362918e-01, 7.29374822e-01, 4.92957746e-01],\n", - " [5.86677209e-01, 7.26520126e-01, 5.00000000e-01],\n", - " [5.78770508e-01, 7.23094490e-01, 4.92957746e-01],\n", - " [5.71061475e-01, 7.21096203e-01, 4.92957746e-01],\n", - " [5.64143111e-01, 7.17385098e-01, 4.92957746e-01],\n", - " [5.59003756e-01, 7.16243220e-01, 4.92957746e-01],\n", - " [5.53864400e-01, 7.13673994e-01, 4.85915493e-01],\n", - " [5.49713382e-01, 7.11390237e-01, 4.92957746e-01],\n", - " [5.45167029e-01, 7.08821011e-01, 5.00000000e-01],\n", - " [5.42597351e-01, 7.07108193e-01, 4.29577465e-01],\n", - " [5.40027673e-01, 7.04824436e-01, 4.85915493e-01],\n", - " [5.37853331e-01, 7.02540679e-01, 4.85915493e-01],\n", - " [5.35876655e-01, 7.00256923e-01, 5.00000000e-01],\n", - " [5.33702313e-01, 6.97973166e-01, 4.85915493e-01],\n", - " [5.32516308e-01, 6.94833000e-01, 5.07042254e-01],\n", - " [5.31923305e-01, 6.91978304e-01, 4.85915493e-01],\n", - " [5.32120973e-01, 6.86268912e-01, 9.85915493e-01],\n", - " [5.32318640e-01, 6.83128747e-01, 4.85915493e-01],\n", - " [5.33306978e-01, 6.79988581e-01, 4.92957746e-01],\n", - " [5.34690650e-01, 6.76277476e-01, 5.00000000e-01],\n", - " [5.36469658e-01, 6.73422780e-01, 5.00000000e-01],\n", - " [5.38841668e-01, 6.70853554e-01, 4.85915493e-01],\n", - " [5.41411346e-01, 6.67713389e-01, 4.92957746e-01],\n", - " [5.44376359e-01, 6.64287753e-01, 4.85915493e-01],\n", - " [5.47934374e-01, 6.61147588e-01, 4.92957746e-01],\n", - " [5.51690057e-01, 6.57721953e-01, 5.00000000e-01],\n", - " [5.55841075e-01, 6.54010848e-01, 5.00000000e-01],\n", - " [5.59992093e-01, 6.50870682e-01, 4.78873239e-01],\n", - " [5.64933781e-01, 6.46874108e-01, 4.92957746e-01],\n", - " [5.70073137e-01, 6.43448473e-01, 4.92957746e-01],\n", - " [5.75014825e-01, 6.40308307e-01, 4.36619718e-01],\n", - " [5.80549516e-01, 6.36311733e-01, 4.78873239e-01],\n", - " [5.86677209e-01, 6.31458750e-01, 5.00000000e-01],\n", - " [5.92409567e-01, 6.26891236e-01, 4.85915493e-01],\n", - " [5.93200237e-01, 6.30602341e-01, 4.29577465e-01],\n", - " [5.85886539e-01, 6.44019412e-01, 4.92957746e-01],\n", - " [5.71259142e-01, 6.51441621e-01, 4.43661972e-01],\n", - " [5.52283060e-01, 6.37739081e-01, 4.64788732e-01],\n", - " [5.22830599e-01, 6.08621182e-01, 5.07042254e-01],\n", - " [4.87843447e-01, 5.65515273e-01, 4.92957746e-01],\n", - " [4.50484285e-01, 5.17841850e-01, 4.78873239e-01],\n", - " [4.09171773e-01, 4.66742792e-01, 5.00000000e-01],\n", - " [3.66277921e-01, 4.12503568e-01, 4.85915493e-01],\n", - " [3.24174738e-01, 3.49700257e-01, 5.00000000e-01],\n", - " [2.79897213e-01, 2.84042250e-01, 4.85915493e-01],\n", - " [2.34038347e-01, 2.15529546e-01, 5.00000000e-01],\n", - " [1.88377150e-01, 1.49871539e-01, 4.92957746e-01],\n", - " [1.45087962e-01, 7.45075649e-02, 4.92957746e-01],\n", - " [1.02787112e-01, 0.00000000e+00, 4.92957746e-01]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13779423, 0.12975779, 0.84615385],\n", - " [0.27585295, 0.25951557, 0.85897436],\n", - " [0.43797937, 0.41176471, 1. ],\n", - " [0.57550912, 0.5432526 , 0.83333333],\n", - " [0.71356784, 0.67301038, 0.84615385],\n", - " [0.86247025, 0.83737024, 0.93589744],\n", - " [1. , 1. , 0.83333333]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.85393258, 0.14061401, 0.91666667],\n", - " [0.69101124, 0.27935318, 0.91666667],\n", - " [0.52247191, 0.42840403, 1. ],\n", - " [0.39325843, 0.56948676, 0.91666667],\n", - " [0.28089888, 0.70822592, 0.91666667],\n", - " [0.12921348, 0.86055777, 1. ],\n", - " [0. , 1. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92513114, 0.92289372, 0.68539326],\n", - " [0.81545064, 0.80976481, 1. ],\n", - " [0.71149261, 0.70586484, 0.91011236],\n", - " [0.62613257, 0.62072045, 0.78651685],\n", - " [0.52598951, 0.52009527, 0.8988764 ],\n", - " [0.43919886, 0.43286692, 0.78651685],\n", - " [0.35431569, 0.34742483, 0.7752809 ],\n", - " [0.26514068, 0.25930336, 0.79775281],\n", - " [0.18121125, 0.17386127, 0.7752809 ],\n", - " [0.09394373, 0.08693063, 0.78651685],\n", - " [0. , 0. , 0.79775281]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.97721128, 0.975458 , 0.95833333],\n", - " [0.95365006, 0.95229865, 0.97222222],\n", - " [0.92854384, 0.92879364, 0.98611111],\n", - " [0.90305137, 0.9073626 , 0.95833333],\n", - " [0.87794515, 0.88385759, 0.98611111],\n", - " [0.85515643, 0.86035258, 0.95833333],\n", - " [0.83120896, 0.8365019 , 0.98611111],\n", - " [0.80571649, 0.81610785, 0.95833333],\n", - " [0.78331402, 0.7974421 , 0.84722222],\n", - " [0.75859405, 0.77808503, 0.95833333],\n", - " [0.73387408, 0.75803664, 0.98611111],\n", - " [0.70876786, 0.73695126, 0.95833333],\n", - " [0.68636539, 0.71552022, 0.98611111],\n", - " [0.66319042, 0.69374352, 0.95833333],\n", - " [0.63924295, 0.67058417, 0.97222222],\n", - " [0.61684048, 0.64707916, 0.97222222],\n", - " [0.59791425, 0.62737643, 0.84722222],\n", - " [0.57396678, 0.6049084 , 0.94444444],\n", - " [0.55156431, 0.58071206, 1. ],\n", - " [0.52954809, 0.55789838, 0.95833333],\n", - " [0.50560062, 0.53543035, 0.97222222],\n", - " [0.47856315, 0.51434497, 0.97222222],\n", - " [0.45616068, 0.49256827, 0.97222222],\n", - " [0.43144071, 0.47010024, 0.97222222],\n", - " [0.40942449, 0.44694089, 0.95833333],\n", - " [0.38624952, 0.42896647, 0.84722222],\n", - " [0.3626883 , 0.4051158 , 0.98611111],\n", - " [0.33989958, 0.38161078, 0.97222222],\n", - " [0.3182696 , 0.35637746, 0.97222222],\n", - " [0.29818463, 0.3314898 , 0.95833333],\n", - " [0.27500966, 0.30729347, 0.97222222],\n", - " [0.25337968, 0.28136882, 0.98611111],\n", - " [0.23213596, 0.2561355 , 0.97222222],\n", - " [0.20625724, 0.23263049, 0.97222222],\n", - " [0.18462727, 0.20636018, 0.97222222],\n", - " [0.1637698 , 0.17974421, 0.97222222],\n", - " [0.13750483, 0.15589354, 0.95833333],\n", - " [0.11201236, 0.12996889, 0.98611111],\n", - " [0.09076864, 0.10438991, 0.95833333],\n", - " [0.06720742, 0.07846526, 0.98611111],\n", - " [0.04441869, 0.0535776 , 0.95833333],\n", - " [0.02162997, 0.02730729, 0.97222222],\n", - " [0. , 0. , 0.97222222]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90399344, 0.88769036, 0.79775281],\n", - " [0.80415755, 0.79758883, 0.78651685],\n", - " [0.67724289, 0.70114213, 1. ],\n", - " [0.57904814, 0.59771574, 0.79775281],\n", - " [0.48550328, 0.4822335 , 0.78651685],\n", - " [0.38785558, 0.38769036, 0.7752809 ],\n", - " [0.28774617, 0.30647208, 0.79775281],\n", - " [0.19119256, 0.21954315, 0.78651685],\n", - " [0.09682713, 0.11357868, 0.7752809 ],\n", - " [0. , 0. , 0.79775281]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11173498, 0.90486486, 0.77647059],\n", - " [0.22431218, 0.80486486, 0.78823529],\n", - " [0.33043234, 0.70162162, 0.76470588],\n", - " [0.43711398, 0.59081081, 0.77647059],\n", - " [0.57664234, 0.44540541, 1. ],\n", - " [0.67770915, 0.3427027 , 0.71764706],\n", - " [0.78747894, 0.23297297, 0.77647059],\n", - " [0.89472207, 0.11837838, 0.78823529],\n", - " [1. , 0. , 0.77647059]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90282968, 0.81818182, 0.88607595],\n", - " [0.80485852, 0.6969697 , 0.88607595],\n", - " [0.70848905, 0.48484848, 0.87341772],\n", - " [0.61105179, 0.39393939, 0.89873418],\n", - " [0.51521623, 0.24242424, 0.87341772],\n", - " [0.41777896, 0. , 0.88607595],\n", - " [0.31847304, 0. , 0.89873418],\n", - " [0.20928991, 0.39393939, 1. ],\n", - " [0.11078484, 0.57575758, 0.89873418],\n", - " [0. , 0.66666667, 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85943775, 0.87030812, 0.88888889],\n", - " [0.73436604, 0.75042017, 0.76666667],\n", - " [0.61445783, 0.63977591, 0.78888889],\n", - " [0.49110729, 0.51876751, 0.76666667],\n", - " [0.37865749, 0.40588235, 0.77777778],\n", - " [0.2713712 , 0.29047619, 0.78888889],\n", - " [0.12621916, 0.13501401, 1. ],\n", - " [0. , 0. , 0.87777778]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89944867, 0.89569991, 0.97183099],\n", - " [0.79732213, 0.7904849 , 0.98591549],\n", - " [0.69703334, 0.68984446, 0.98591549],\n", - " [0.59280651, 0.5873742 , 1. ],\n", - " [0.49120504, 0.4894785 , 0.98591549],\n", - " [0.39012864, 0.3915828 , 0.98591549],\n", - " [0.28852717, 0.29094236, 0.98591549],\n", - " [0.18850092, 0.18664227, 0.98591549],\n", - " [0.08821213, 0.084172 , 0.97183099],\n", - " [0. , 0. , 0.85915493]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12314887, 0.87906977, 0.97014925],\n", - " [0.24993505, 0.75116279, 0.98507463],\n", - " [0.37490257, 0.62093023, 0.98507463],\n", - " [0.49831125, 0.49767442, 0.98507463],\n", - " [0.62535724, 0.36976744, 1. ],\n", - " [0.74876591, 0.24418605, 0.97014925],\n", - " [0.87425305, 0.1255814 , 0.98507463],\n", - " [1. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11481087, 0.12121212, 0.84146341],\n", - " [0.25332978, 0.26136364, 1. ],\n", - " [0.3857219 , 0.39267677, 0.93902439],\n", - " [0.50825786, 0.51388889, 0.87804878],\n", - " [0.62386787, 0.63131313, 0.84146341],\n", - " [0.7637187 , 0.77020202, 1. ],\n", - " [0.88012786, 0.88383838, 0.82926829],\n", - " [1. , 1. , 0.85365854]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15254237, 0.09308176, 0.98591549],\n", - " [0.28248588, 0.18490566, 0.97183099],\n", - " [0.34745763, 0.26540881, 0.85915493],\n", - " [0.43079096, 0.35798742, 0.97183099],\n", - " [0.51694915, 0.45157233, 1. ],\n", - " [0.60451977, 0.54490566, 1. ],\n", - " [0.68220339, 0.64025157, 0.98591549],\n", - " [0.77683616, 0.73333333, 0.98591549],\n", - " [0.85169492, 0.82540881, 0.97183099],\n", - " [0.9180791 , 0.90566038, 0.85915493],\n", - " [1. , 1. , 0.97183099]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08530021, 0.91389375, 0.86419753],\n", - " [0.17184265, 0.82837128, 0.87654321],\n", - " [0.25300207, 0.74751897, 0.85185185],\n", - " [0.33954451, 0.66141273, 0.87654321],\n", - " [0.42070393, 0.58085231, 0.85185185],\n", - " [0.50144928, 0.5 , 0.85185185],\n", - " [0.5863354 , 0.41330998, 0.86419753],\n", - " [0.65755694, 0.34238179, 0.75308642],\n", - " [0.73830228, 0.26123759, 0.86419753],\n", - " [0.83354037, 0.16666667, 1. ],\n", - " [0.91925466, 0.08114419, 0.86419753],\n", - " [1. , 0. , 0.85185185]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11545338, 0.11961722, 0.97014925],\n", - " [0.21762452, 0.20813397, 0.91044776],\n", - " [0.32950192, 0.31100478, 0.97014925],\n", - " [0.44265645, 0.43779904, 0.98507463],\n", - " [0.55632184, 0.55741627, 0.98507463],\n", - " [0.66590038, 0.64593301, 1. ],\n", - " [0.77445722, 0.73684211, 0.98507463],\n", - " [0.88965517, 0.86842105, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92534538, 0.93382353, 0.88732394],\n", - " [0.83953241, 0.86029412, 1. ],\n", - " [0.76301807, 0.74632353, 0.91549296],\n", - " [0.68836344, 0.69485294, 0.90140845],\n", - " [0.61663124, 0.61029412, 0.88732394],\n", - " [0.54038257, 0.54779412, 0.88732394],\n", - " [0.4651966 , 0.45220588, 0.91549296],\n", - " [0.37964931, 0.36764706, 0.98591549],\n", - " [0.30605739, 0.29779412, 0.87323944],\n", - " [0.22715197, 0.23161765, 0.92957746],\n", - " [0.15196599, 0.16176471, 0.85915493],\n", - " [0.07757705, 0.08088235, 0.88732394],\n", - " [0. , 0. , 0.92957746]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11839482, 0.11568938, 0.77647059],\n", - " [0.23703888, 0.24088748, 0.77647059],\n", - " [0.3773679 , 0.37400951, 0.91764706],\n", - " [0.49401795, 0.49286846, 0.76470588],\n", - " [0.64656032, 0.65293185, 1. ],\n", - " [0.76545364, 0.76545166, 0.77647059],\n", - " [0.88210369, 0.88114105, 0.76470588],\n", - " [1. , 1. , 0.77647059]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11521456, 0.11986002, 1. ],\n", - " [0.22782835, 0.23009624, 0.97222222],\n", - " [0.33836151, 0.34383202, 0.95833333],\n", - " [0.4520156 , 0.46631671, 0.97222222],\n", - " [0.56306892, 0.5791776 , 0.97222222],\n", - " [0.67438231, 0.68853893, 0.95833333],\n", - " [0.77061118, 0.78040245, 0.84722222],\n", - " [0.88816645, 0.89501312, 0.98611111],\n", - " [1. , 1. , 0.97222222]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.98026667, 0.98327392, 0.86419753],\n", - " [0.95946667, 0.96682205, 0.87654321],\n", - " [0.93973333, 0.95064437, 0.85185185],\n", - " [0.92 , 0.93391829, 0.87654321],\n", - " [0.90026667, 0.91746641, 0.85185185],\n", - " [0.88106667, 0.90074033, 0.86419753],\n", - " [0.86186667, 0.88428846, 0.86419753],\n", - " [0.84693333, 0.87057856, 0.75308642],\n", - " [0.82773333, 0.85440088, 0.86419753],\n", - " [0.8096 , 0.837949 , 0.83950617],\n", - " [0.79306667, 0.82231971, 0.7654321 ],\n", - " [0.77386667, 0.80504524, 0.85185185],\n", - " [0.75573333, 0.78749657, 0.87654321],\n", - " [0.73653333, 0.7704963 , 0.86419753],\n", - " [0.71786667, 0.75322183, 0.86419753],\n", - " [0.6992 , 0.73594735, 0.86419753],\n", - " [0.6816 , 0.71812449, 0.85185185],\n", - " [0.66026667, 0.69810803, 0.98765432],\n", - " [0.64213333, 0.67781738, 1. ],\n", - " [0.6224 , 0.65917192, 0.85185185],\n", - " [0.6032 , 0.64052646, 0.86419753],\n", - " [0.5872 , 0.62270359, 0.87654321],\n", - " [0.56853333, 0.60460653, 0.83950617],\n", - " [0.54986667, 0.58650946, 0.88888889],\n", - " [0.53226667, 0.56868659, 0.85185185],\n", - " [0.5152 , 0.55086372, 0.86419753],\n", - " [0.4976 , 0.53304086, 0.86419753],\n", - " [0.47946667, 0.51494379, 0.86419753],\n", - " [0.46186667, 0.49794352, 0.87654321],\n", - " [0.44266667, 0.48039485, 0.85185185],\n", - " [0.424 , 0.46339457, 0.87654321],\n", - " [0.40746667, 0.4455717 , 0.85185185],\n", - " [0.39253333, 0.43131341, 0.75308642],\n", - " [0.37226667, 0.41376474, 0.85185185],\n", - " [0.35466667, 0.39594187, 0.86419753],\n", - " [0.33653333, 0.37757061, 0.86419753],\n", - " [0.31733333, 0.35782835, 0.86419753],\n", - " [0.2992 , 0.33890869, 0.86419753],\n", - " [0.2848 , 0.32355361, 0.75308642],\n", - " [0.2672 , 0.30573074, 0.86419753],\n", - " [0.2512 , 0.28598848, 0.86419753],\n", - " [0.23093333, 0.26487524, 0.97530864],\n", - " [0.21653333, 0.24897176, 0.75308642],\n", - " [0.19946667, 0.2303263 , 0.85185185],\n", - " [0.18293333, 0.21140664, 0.87654321],\n", - " [0.1648 , 0.19221278, 0.86419753],\n", - " [0.14773333, 0.17274472, 0.86419753],\n", - " [0.13066667, 0.15382506, 0.85185185],\n", - " [0.11466667, 0.1346312 , 0.86419753],\n", - " [0.096 , 0.11242117, 1. ],\n", - " [0.07946667, 0.09295311, 0.86419753],\n", - " [0.06346667, 0.07403345, 0.85185185],\n", - " [0.04746667, 0.054017 , 0.86419753],\n", - " [0.03306667, 0.03729092, 0.75308642],\n", - " [0.01653333, 0.01864546, 0.83950617],\n", - " [0. , 0. , 0.87654321]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.05260333, 0.13806487, 0.89041096],\n", - " [0.15727322, 0.26919878, 0.90410959],\n", - " [0.30220075, 0.40033269, 1. ],\n", - " [0.4417606 , 0.51899085, 0.90410959],\n", - " [0.58507783, 0.64014416, 0.90410959],\n", - " [0.72141707, 0.75602994, 0.89041096],\n", - " [0.86151369, 0.87912393, 0.91780822],\n", - " [1. , 1. , 0.90410959]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90921087, 0.93075684, 0.875 ],\n", - " [0.81710214, 0.86151369, 0.8875 ],\n", - " [0.72578517, 0.79388084, 0.8625 ],\n", - " [0.64713645, 0.7310789 , 0.7625 ],\n", - " [0.55634732, 0.64573269, 0.875 ],\n", - " [0.46634996, 0.54267311, 0.8625 ],\n", - " [0.37529691, 0.44122383, 0.875 ],\n", - " [0.28503563, 0.33816425, 0.875 ],\n", - " [0.1942465 , 0.23027375, 0.875 ],\n", - " [0.09026128, 0.10628019, 1. ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.02151364, 0.91272189, 0.77777778],\n", - " [0.07760277, 0.84201183, 0.82716049],\n", - " [0.14252785, 0.7816568 , 0.85185185],\n", - " [0.20591625, 0.72248521, 0.86419753],\n", - " [0.27660392, 0.66627219, 0.86419753],\n", - " [0.34959662, 0.6147929 , 0.87654321],\n", - " [0.42451018, 0.56183432, 0.86419753],\n", - " [0.51363811, 0.49940828, 0.85185185],\n", - " [0.62005378, 0.41863905, 0.86419753],\n", - " [0.72685363, 0.33254438, 0.86419753],\n", - " [0.86438725, 0.2204142 , 1. ],\n", - " [0.953131 , 0.11005917, 0.85185185],\n", - " [1. , 0. , 0.79012346]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11078717, 0.91412349, 0.97222222],\n", - " [0.22643343, 0.83818311, 0.97222222],\n", - " [0.33041788, 0.75159688, 0.97222222],\n", - " [0.42662779, 0.66879584, 0.94444444],\n", - " [0.52089407, 0.58552165, 0.97222222],\n", - " [0.60155491, 0.49893542, 1. ],\n", - " [0.67930029, 0.41968299, 0.97222222],\n", - " [0.74344023, 0.3354625 , 0.95833333],\n", - " [0.80660836, 0.25384433, 0.97222222],\n", - " [0.8707483 , 0.16702153, 0.98611111],\n", - " [0.93586006, 0.08682281, 0.95833333],\n", - " [1. , 0. , 0.97222222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12092906, 0.14975845, 0.953125 ],\n", - " [0.24816965, 0.28019324, 0.984375 ],\n", - " [0.37414794, 0.41545894, 0.96875 ],\n", - " [0.50290331, 0.51690821, 1. ],\n", - " [0.62989144, 0.66666667, 1. ],\n", - " [0.75511235, 0.78743961, 1. ],\n", - " [0.87755617, 0.89371981, 0.96875 ],\n", - " [1. , 1. , 0.96875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14429791, 0.15139442, 0.98507463],\n", - " [0.2906646 , 0.29880478, 0.98507463],\n", - " [0.43392811, 0.43957503, 1. ],\n", - " [0.57900181, 0.58167331, 0.97014925],\n", - " [0.72019653, 0.72377158, 0.97014925],\n", - " [0.85285751, 0.85922975, 0.91044776],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08083333, 0.08108108, 0.95774648],\n", - " [0.15444444, 0.15015015, 0.87323944],\n", - " [0.23888889, 0.24024024, 0.97183099],\n", - " [0.3225 , 0.32132132, 0.98591549],\n", - " [0.41 , 0.40540541, 1. ],\n", - " [0.49444444, 0.48648649, 0.97183099],\n", - " [0.57805556, 0.57057057, 0.97183099],\n", - " [0.66555556, 0.65165165, 1. ],\n", - " [0.75305556, 0.72972973, 1. ],\n", - " [0.83833333, 0.84084084, 0.95774648],\n", - " [0.9125 , 0.91591592, 0.85915493],\n", - " [1. , 1. , 0.97183099]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13843236, 0.13931034, 0.95522388],\n", - " [0.28318584, 0.28505747, 1. ],\n", - " [0.42414665, 0.42574713, 0.98507463],\n", - " [0.56731985, 0.56873563, 0.98507463],\n", - " [0.71333755, 0.71356322, 0.98507463],\n", - " [0.85493047, 0.8537931 , 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9012987 , 0.90759754, 0.58333333],\n", - " [0.80285714, 0.83778234, 0.58333333],\n", - " [0.67662338, 0.71047228, 0.75833333],\n", - " [0.54961039, 0.60985626, 0.74166667],\n", - " [0.38103896, 0.44558522, 1. ],\n", - " [0.20961039, 0.2587269 , 1. ],\n", - " [0.11558442, 0.15605749, 0.575 ],\n", - " [0. , 0. , 0.675 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11849711, 0.11510791, 1. ],\n", - " [0.21728849, 0.23021583, 0.88571429],\n", - " [0.33499737, 0.37410072, 0.97142857],\n", - " [0.43483973, 0.48561151, 0.9 ],\n", - " [0.54913295, 0.60791367, 1. ],\n", - " [0.6660536 , 0.70863309, 1. ],\n", - " [0.78271151, 0.80215827, 0.95714286],\n", - " [0.89963216, 0.90647482, 0.98571429],\n", - " [1. , 1. , 0.87142857]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8843599 , 0.88255699, 0.87341772],\n", - " [0.78713768, 0.78691774, 0.89873418],\n", - " [0.67542271, 0.67542121, 0.88607595],\n", - " [0.55253623, 0.55153617, 1. ],\n", - " [0.43025362, 0.43409316, 0.91139241],\n", - " [0.3227657 , 0.32259663, 1. ],\n", - " [0.20591787, 0.20317146, 0.88607595],\n", - " [0.1053744 , 0.10455897, 0.87341772],\n", - " [0. , 0. , 0.89873418]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89562842, 0.89632701, 0.97222222],\n", - " [0.79590164, 0.79265403, 0.95833333],\n", - " [0.69726776, 0.69312796, 0.97222222],\n", - " [0.59234973, 0.5936019 , 1. ],\n", - " [0.4931694 , 0.49170616, 0.94444444],\n", - " [0.38989071, 0.38803318, 0.97222222],\n", - " [0.30136612, 0.30331754, 0.86111111],\n", - " [0.19726776, 0.19964455, 0.95833333],\n", - " [0.0989071 , 0.1007109 , 0.97222222],\n", - " [0. , 0. , 0.97222222]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88354577, 0.88541667, 1. ],\n", - " [0.77230591, 0.77380952, 0.97183099],\n", - " [0.67555041, 0.67633929, 0.85915493],\n", - " [0.5631518 , 0.56473214, 0.97183099],\n", - " [0.45307068, 0.45337302, 0.97183099],\n", - " [0.34125145, 0.34102183, 1. ],\n", - " [0.22827346, 0.2281746 , 0.97183099],\n", - " [0.11355736, 0.11383929, 1. ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13505435, 0.13846154, 0.85897436],\n", - " [0.27853261, 0.28923077, 0.84615385],\n", - " [0.41440217, 0.42153846, 0.83333333],\n", - " [0.55842391, 0.56 , 0.85897436],\n", - " [0.69429348, 0.69846154, 0.84615385],\n", - " [0.8388587 , 0.84307692, 0.83333333],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92218137, 0.91220347, 0.97222222],\n", - " [0.84129902, 0.82660797, 0.98611111],\n", - " [0.76164216, 0.739056 , 0.95833333],\n", - " [0.68198529, 0.65028124, 0.97222222],\n", - " [0.60355392, 0.56419663, 0.95833333],\n", - " [0.51776961, 0.4793348 , 0.97222222],\n", - " [0.42463235, 0.39471753, 1. ],\n", - " [0.33578431, 0.31352409, 0.95833333],\n", - " [0.24019608, 0.23208608, 0.98611111],\n", - " [0.14522059, 0.14795794, 0.95833333],\n", - " [0.06311275, 0.07581316, 0.86111111],\n", - " [0. , 0. , 0.86111111]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90829932, 0.90315789, 0.8625 ],\n", - " [0.8155102 , 0.81684211, 0.8875 ],\n", - " [0.72653061, 0.72631579, 0.875 ],\n", - " [0.64217687, 0.61473684, 0.8625 ],\n", - " [0.55646259, 0.53684211, 0.875 ],\n", - " [0.46666667, 0.46315789, 0.875 ],\n", - " [0.3755102 , 0.38105263, 0.875 ],\n", - " [0.27346939, 0.28842105, 1. ],\n", - " [0.18367347, 0.20210526, 0.875 ],\n", - " [0.09170068, 0.09894737, 0.8875 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.0730897 , 0.15336323, 0.98412698],\n", - " [0.14950166, 0.30627803, 0.98412698],\n", - " [0.23225612, 0.44932735, 0.98412698],\n", - " [0.32890365, 0.57130045, 0.98412698],\n", - " [0.43219571, 0.66636771, 0.98412698],\n", - " [0.54032014, 0.75650224, 0.98412698],\n", - " [0.65206886, 0.82735426, 0.98412698],\n", - " [0.76834793, 0.88609865, 0.98412698],\n", - " [0.88160677, 0.9426009 , 0.98412698],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89518519, 0.09816164, 0.95454545],\n", - " [0.7962963 , 0.19667014, 0.95454545],\n", - " [0.69407407, 0.30107527, 0.95454545],\n", - " [0.59259259, 0.39889005, 0.96969697],\n", - " [0.49407407, 0.49705168, 0.95454545],\n", - " [0.39407407, 0.60006937, 0.93939394],\n", - " [0.30259259, 0.69961845, 0.92424242],\n", - " [0.2037037 , 0.79188345, 0.92424242],\n", - " [0.10518519, 0.89594173, 0.95454545],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16117436, 0.15540363, 0.69072165],\n", - " [0.31755542, 0.30712595, 0.68041237],\n", - " [0.47693229, 0.46331843, 0.67010309],\n", - " [0.69862193, 0.68971864, 1. ],\n", - " [0.84961055, 0.84380752, 0.67010309],\n", - " [1. , 1. , 0.69072165]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12153918, 0.12887305, 0.98507463],\n", - " [0.247771 , 0.25582671, 0.98507463],\n", - " [0.36461755, 0.36989306, 0.91044776],\n", - " [0.49225716, 0.49629833, 0.97014925],\n", - " [0.6194275 , 0.62270359, 0.98507463],\n", - " [0.74659784, 0.74910886, 0.98507463],\n", - " [0.87236039, 0.87359474, 0.97014925],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09700064, 0.90128449, 0.875 ],\n", - " [0.21059349, 0.79019981, 0.9875 ],\n", - " [0.31844288, 0.67673644, 1. ],\n", - " [0.41608168, 0.57611798, 0.875 ],\n", - " [0.52776005, 0.46717412, 0.9875 ],\n", - " [0.6094448 , 0.38058991, 0.7625 ],\n", - " [0.70963625, 0.28235014, 0.875 ],\n", - " [0.79897894, 0.19838249, 0.7625 ],\n", - " [0.89917039, 0.09871551, 0.8625 ],\n", - " [1. , 0. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09530634, 0.09535604, 0.97183099],\n", - " [0.18487997, 0.18637771, 0.98591549],\n", - " [0.27337872, 0.27616099, 0.97183099],\n", - " [0.35865281, 0.3622291 , 0.87323944],\n", - " [0.45252598, 0.45510836, 0.95774648],\n", - " [0.54317449, 0.54582043, 1. ],\n", - " [0.62916517, 0.63157895, 0.85915493],\n", - " [0.72053028, 0.72291022, 0.97183099],\n", - " [0.8172698 , 0.81950464, 1. ],\n", - " [0.9082766 , 0.90959752, 0.95774648],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11010597, 0.91390728, 0.89873418],\n", - " [0.21555958, 0.82119205, 0.87341772],\n", - " [0.32618248, 0.72847682, 0.89873418],\n", - " [0.43680538, 0.62251656, 0.89873418],\n", - " [0.56164384, 0.48344371, 1. ],\n", - " [0.66787284, 0.35761589, 0.87341772],\n", - " [0.78030499, 0.2384106 , 0.89873418],\n", - " [0.88963556, 0.10596026, 0.88607595],\n", - " [1. , 0. , 0.88607595]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90500864, 0.89541716, 0.8875 ],\n", - " [0.82210708, 0.80023502, 0.85 ],\n", - " [0.74265976, 0.7106933 , 0.7625 ],\n", - " [0.62867012, 0.60987074, 0.875 ],\n", - " [0.52158895, 0.51374853, 0.875 ],\n", - " [0.39896373, 0.39882491, 1. ],\n", - " [0.2970639 , 0.2972973 , 0.8875 ],\n", - " [0.19861831, 0.19835488, 0.8625 ],\n", - " [0.10189983, 0.10105758, 0.875 ],\n", - " [0. , 0. , 0.8875 ]]),\n", - " array([[0.93979592, 0.97787398, 0. ],\n", - " [0.95408163, 0.97763348, 0.01236338],\n", - " [0.9622449 , 0.98027898, 0.03601505],\n", - " [0.95918367, 0.97643098, 0.02526429],\n", - " [0.95714286, 0.98075998, 0.03189393],\n", - " [0.95408163, 0.97715248, 0.06450457],\n", - " [0.96530612, 0.97883598, 0.22612435],\n", - " [0.97755102, 0.98003848, 0.70883354],\n", - " [0.96938776, 0.97883598, 0.3228812 ],\n", - " [0.9744898 , 0.98148148, 0.16090306],\n", - " [0.9755102 , 0.97787398, 0.03278982],\n", - " [0.97040816, 0.98124098, 0.03207311],\n", - " [0.98061224, 0.98244348, 0.03189393],\n", - " [0.9744898 , 0.97787398, 0.03278982],\n", - " [0.97040816, 0.98244348, 0.06414621],\n", - " [0.97244898, 0.97763348, 0.03243146],\n", - " [0.96428571, 0.97883598, 0.03189393],\n", - " [0.97244898, 0.97667148, 0.12954668],\n", - " [0.96428571, 0.98075998, 0.09675685],\n", - " [0.96938776, 0.97763348, 0.03243146],\n", - " [0.96428571, 0.97546898, 0.28973302],\n", - " [0.9744898 , 0.97594998, 0.48378427],\n", - " [0.97959184, 0.97835498, 0.19351371],\n", - " [0.96530612, 0.98003848, 0.22612435],\n", - " [0.96938776, 0.97763348, 0.64468733],\n", - " [0.96428571, 0.97546898, 0.80684465],\n", - " [0.9744898 , 0.98027898, 0.06432539],\n", - " [0.9744898 , 0.97763348, 0.03171475],\n", - " [0.98469388, 0.97835498, 0.09693603],\n", - " [0.97040816, 0.97715248, 0.29044974],\n", - " [0.98265306, 0.97715248, 0.03225228],\n", - " [0.9755102 , 0.98003848, 0.06468375],\n", - " [0.95510204, 0.98725349, 0.03207311],\n", - " [0.97040816, 0.97907648, 0.03243146],\n", - " [0.96734694, 0.97667148, 0.03225228],\n", - " [0.97755102, 0.97667148, 0.03171475],\n", - " [0.96938776, 0.97835498, 0.06504211],\n", - " [0.97244898, 0.97546898, 0.03171475],\n", - " [0.97244898, 0.97955748, 0.09729439],\n", - " [0.97040816, 0.97643098, 0.09639849],\n", - " [0.96938776, 0.98027898, 0.09657767],\n", - " [0.96938776, 0.97667148, 0.2908081 ],\n", - " [0.96020408, 0.97474747, 0.16090306],\n", - " [0.96530612, 0.97835498, 0.25801828],\n", - " [0.96428571, 0.97546898, 0.19333453],\n", - " [0.9744898 , 0.97522848, 0.22612435],\n", - " [0.99489796, 0.97907648, 0.1614406 ],\n", - " [0.98571429, 0.98075998, 0.16090306],\n", - " [0.97755102, 0.98388648, 0.80648629],\n", - " [0.9877551 , 0.98364598, 0.35441677],\n", - " [0.99591837, 0.98027898, 0.22576599],\n", - " [0.99285714, 0.98364598, 0.03243146],\n", - " [0.98061224, 0.98124098, 0.09657767],\n", - " [0.98979592, 0.98148148, 0.19369289],\n", - " [0.98061224, 0.97955748, 1. ],\n", - " [0.9744898 , 0.98436748, 0.19369289],\n", - " [0.98265306, 0.97835498, 0.06414621],\n", - " [0.98469388, 0.98244348, 0.1614406 ],\n", - " [0.99591837, 0.98148148, 0.25801828],\n", - " [0.98979592, 0.98508899, 0.19369289],\n", - " [0.99591837, 0.98268398, 0.06450457],\n", - " [0.99081633, 0.98484848, 0.06450457],\n", - " [1. , 0.98268398, 0.06468375],\n", - " [0.98979592, 0.98244348, 0.1284716 ],\n", - " [0.97959184, 0.98436748, 0.09675685],\n", - " [0.99081633, 0.98148148, 0.09675685],\n", - " [0.97755102, 0.98316498, 0.1293675 ],\n", - " [0.99489796, 0.98027898, 0.03207311],\n", - " [0.98469388, 0.98268398, 0.09675685],\n", - " [0.98061224, 0.98003848, 0.16108224],\n", - " [0.97244898, 0.97715248, 0.29062892],\n", - " [0.96020408, 0.97594998, 0.03207311],\n", - " [0.94693878, 0.97306397, 0.03243146],\n", - " [0.95204082, 0.97715248, 0.61225587],\n", - " [0.95408163, 0.97282347, 0.03261064],\n", - " [0.95204082, 0.97667148, 0.48360509],\n", - " [0.94387755, 0.97907648, 0.09693603],\n", - " [0.95204082, 0.97787398, 0.03243146],\n", - " [0.95918367, 0.97594998, 0.06396703],\n", - " [0.94897959, 0.97715248, 0.03225228],\n", - " [0.95714286, 0.97594998, 0.03243146],\n", - " [0.93979592, 0.98075998, 0.09657767],\n", - " [0.94897959, 0.97546898, 0.06522129],\n", - " [0.95408163, 0.97186147, 0.64486651],\n", - " [0.96020408, 0.97787398, 0.06414621],\n", - " [0.96020408, 0.97522848, 0.03278982],\n", - " [0.94897959, 0.97354497, 0.03189393],\n", - " [0.96020408, 0.97402597, 0.12900914],\n", - " [0.94183673, 0.97522848, 0.03243146],\n", - " [0.95204082, 0.97306397, 0.06432539],\n", - " [0.95408163, 0.97546898, 0.38684824],\n", - " [0.94489796, 0.97402597, 0.25819746],\n", - " [0.94387755, 0.97667148, 0.12918832],\n", - " [0.94387755, 0.97402597, 0.16090306],\n", - " [0.93979592, 0.97715248, 0.22576599],\n", - " [0.95510204, 0.97667148, 0.45189034],\n", - " [0.94183673, 0.97643098, 0.12865078],\n", - " [0.95204082, 0.97667148, 0.06486293],\n", - " [0.95918367, 0.97474747, 0.41874216],\n", - " [0.95408163, 0.97835498, 0.12918832],\n", - " [0.95204082, 0.97474747, 0.06450457],\n", - " [0.94897959, 0.97787398, 0.06468375],\n", - " [0.95204082, 0.98027898, 0.09693603],\n", - " [0.94183673, 0.97763348, 0.03207311],\n", - " [0.94693878, 0.97426647, 0.03189393],\n", - " [0.94387755, 0.97715248, 0.06468375],\n", - " [0.95510204, 0.97282347, 0.03225228],\n", - " [0.93979592, 0.97907648, 0.03243146],\n", - " [0.94897959, 0.97426647, 0.03189393],\n", - " [0.94489796, 0.97715248, 0.38702741],\n", - " [0.95204082, 0.97282347, 0.03243146],\n", - " [0.93877551, 0.97546898, 0.23830855],\n", - " [0.91428571, 0.97546898, 0.01272173],\n", - " [0.88877551, 0.97715248, 0.01236338],\n", - " [0.86734694, 0.98316498, 0.01146748],\n", - " [0.84489796, 0.98869649, 0.0112883 ],\n", - " [0.84489796, 0.9963925 , 0.01146748],\n", - " [0.86326531, 1. , 0.0112883 ],\n", - " [0.84489796, 0.9987975 , 0.03691095],\n", - " [0.81938776, 0.98917749, 0.01272173],\n", - " [0.78877551, 0.97065897, 0.01254256],\n", - " [0.76020408, 0.94660895, 0.01254256],\n", - " [0.73265306, 0.91871092, 0.01236338],\n", - " [0.70510204, 0.88263588, 0.01254256],\n", - " [0.67653061, 0.84175084, 0.01272173],\n", - " [0.64387755, 0.8003848 , 0.01254256],\n", - " [0.60816327, 0.75781626, 0.01236338],\n", - " [0.56938776, 0.71212121, 0.01272173],\n", - " [0.53163265, 0.66522367, 0.01254256],\n", - " [0.49489796, 0.62169312, 0.01236338],\n", - " [0.45510204, 0.57142857, 0.01254256],\n", - " [0.42142857, 0.52982203, 0.01092994],\n", - " [0.38877551, 0.47931698, 0.01236338],\n", - " [0.34489796, 0.42448292, 0.01236338],\n", - " [0.30408163, 0.36820587, 0.01290091],\n", - " [0.26020408, 0.31409331, 0.01254256],\n", - " [0.20918367, 0.25877826, 0.01236338],\n", - " [0.16326531, 0.1996152 , 0.01272173],\n", - " [0.12346939, 0.14502165, 0.01236338],\n", - " [0.07755102, 0.08922559, 0.01254256],\n", - " [0.03877551, 0.04569505, 0.01092994],\n", - " [0. , 0. , 0.01236338]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1303781 , 0.15514019, 0.91025641],\n", - " [0.25110821, 0.3046729 , 0.84615385],\n", - " [0.38852673, 0.46728972, 1. ],\n", - " [0.51160365, 0.59252336, 0.84615385],\n", - " [0.63624511, 0.69158879, 0.84615385],\n", - " [0.75619296, 0.79439252, 0.85897436],\n", - " [0.88187744, 0.90093458, 0.83333333],\n", - " [1. , 1. , 0.84615385]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86635945, 0.11473121, 0.84146341],\n", - " [0.77419355, 0.20781941, 0.74390244],\n", - " [0.65437788, 0.31347452, 0.82926829],\n", - " [0.52995392, 0.44333256, 1. ],\n", - " [0.42857143, 0.55783104, 0.85365854],\n", - " [0.32258065, 0.66395159, 0.82926829],\n", - " [0.20737327, 0.78007912, 0.87804878],\n", - " [0.11520737, 0.88666512, 0.85365854],\n", - " [0. , 1. , 0.84146341]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12522407, 0.12554745, 0.98507463],\n", - " [0.24814341, 0.24817518, 0.97014925],\n", - " [0.37490397, 0.37372263, 1. ],\n", - " [0.49987196, 0.50072993, 0.98507463],\n", - " [0.62279129, 0.62189781, 0.97014925],\n", - " [0.75006402, 0.75182482, 0.98507463],\n", - " [0.87503201, 0.87591241, 1. ],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10034058, 0.09915966, 0.98591549],\n", - " [0.20696882, 0.20504202, 0.98591549],\n", - " [0.30599948, 0.29747899, 0.97183099],\n", - " [0.41131779, 0.40168067, 0.98591549],\n", - " [0.49331936, 0.48571429, 0.85915493],\n", - " [0.59732774, 0.60336134, 0.98591549],\n", - " [0.70159811, 0.69747899, 0.98591549],\n", - " [0.79905685, 0.78991597, 0.97183099],\n", - " [0.89651559, 0.89411765, 0.98591549],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.0754902 , 0.9233916 , 0.97222222],\n", - " [0.15326797, 0.84678319, 0.95833333],\n", - " [0.22712418, 0.77277798, 0.95833333],\n", - " [0.30653595, 0.69245073, 1. ],\n", - " [0.38267974, 0.61547044, 0.97222222],\n", - " [0.45915033, 0.5396058 , 0.95833333],\n", - " [0.53627451, 0.46336928, 0.98611111],\n", - " [0.6127451 , 0.38638899, 0.97222222],\n", - " [0.68986928, 0.30903682, 0.95833333],\n", - " [0.76699346, 0.23131276, 0.98611111],\n", - " [0.84379085, 0.15693566, 0.95833333],\n", - " [0.92058824, 0.0792116 , 0.95833333],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90215924, 0.09635974, 0.50833333],\n", - " [0.78609987, 0.21493576, 0.58333333],\n", - " [0.67139001, 0.33217345, 0.575 ],\n", - " [0.55870445, 0.44780514, 0.58333333],\n", - " [0.44197031, 0.56691649, 0.58333333],\n", - " [0.32591093, 0.68335118, 0.59166667],\n", - " [0.20917679, 0.80192719, 0.575 ],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.19902518, 0.21813842, 1. ],\n", - " [0.37043054, 0.37494033, 0.73825503],\n", - " [0.48009748, 0.47565632, 0.46979866],\n", - " [0.60357433, 0.59164678, 0.53020134],\n", - " [0.77010561, 0.76634845, 0.80536913],\n", - " [0.89114541, 0.89952267, 0.61073826],\n", - " [1. , 1. , 0.46308725]]),\n", - " array([[0.01182894, 0. , 0. ],\n", - " [0. , 0.10011312, 0.97222222],\n", - " [0.03548681, 0.19852941, 0.98611111],\n", - " [0.0955414 , 0.28450226, 0.94444444],\n", - " [0.17515924, 0.3594457 , 0.98611111],\n", - " [0.26979072, 0.41798643, 0.95833333],\n", - " [0.35395814, 0.45701357, 0.84722222],\n", - " [0.45177434, 0.49519231, 0.95833333],\n", - " [0.53867152, 0.52658371, 0.84722222],\n", - " [0.64240218, 0.56165158, 0.95833333],\n", - " [0.74840764, 0.59983032, 1. ],\n", - " [0.84167425, 0.64988688, 0.95833333],\n", - " [0.91856233, 0.71973982, 0.97222222],\n", - " [0.98089172, 0.80656109, 0.97222222],\n", - " [1. , 0.89847285, 0.875 ],\n", - " [0.99499545, 1. , 0.94444444]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92142328, 0.9245424 , 0.98591549],\n", - " [0.84581171, 0.85095256, 0.97183099],\n", - " [0.76575241, 0.77325364, 0.98591549],\n", - " [0.68865827, 0.70003736, 0.98591549],\n", - " [0.60896961, 0.6242062 , 1. ],\n", - " [0.53150482, 0.55024281, 0.98591549],\n", - " [0.45515196, 0.47254389, 0.98591549],\n", - " [0.3795404 , 0.39223011, 0.98591549],\n", - " [0.30355819, 0.31378409, 0.98591549],\n", - " [0.22646405, 0.23459096, 0.98591549],\n", - " [0.153447 , 0.1580127 , 0.97183099],\n", - " [0.0767235 , 0.07919313, 1. ],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08695652, 0.94240715, 0.75308642],\n", - " [0.1826087 , 0.88316878, 0.83950617],\n", - " [0.28695652, 0.82628115, 0.87654321],\n", - " [0.48695652, 0.76680771, 1. ],\n", - " [0.65217391, 0.7157969 , 0.86419753],\n", - " [0.72173913, 0.66995769, 0.85185185],\n", - " [0.83478261, 0.61988717, 0.85185185],\n", - " [0.93913043, 0.55594734, 0.87654321],\n", - " [1. , 0.45886225, 0.98765432],\n", - " [0.89565217, 0.36600846, 0.86419753],\n", - " [0.7826087 , 0.26962858, 0.86419753],\n", - " [0.72173913, 0.16690174, 0.87654321],\n", - " [0.70434783, 0.07287259, 0.85185185],\n", - " [0.70434783, 0. , 0.75308642]]),\n", - " array([[0.96470588, 1. , 0. ],\n", - " [0.98431373, 0.94561572, 0.875 ],\n", - " [1. , 0.89362722, 0.8625 ],\n", - " [0.94509804, 0.83972209, 0.875 ],\n", - " [0.9254902 , 0.78581696, 0.8875 ],\n", - " [0.90196078, 0.73287015, 0.8625 ],\n", - " [0.8627451 , 0.68040249, 0.8875 ],\n", - " [0.81568627, 0.62577863, 0.8875 ],\n", - " [0.75686275, 0.56756109, 0.8625 ],\n", - " [0.68627451, 0.50646862, 0.875 ],\n", - " [0.59215686, 0.4425012 , 0.8875 ],\n", - " [0.51372549, 0.38021083, 0.875 ],\n", - " [0.43529412, 0.3186392 , 0.8625 ],\n", - " [0.34509804, 0.24676569, 1. ],\n", - " [0.25882353, 0.1825587 , 0.8625 ],\n", - " [0.16862745, 0.11859128, 0.875 ],\n", - " [0.07843137, 0.06276953, 0.7625 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10401003, 0.1039865 , 0.98591549],\n", - " [0.20864662, 0.20839485, 0.97183099],\n", - " [0.30388471, 0.29761654, 0.85915493],\n", - " [0.410401 , 0.39991563, 0.97183099],\n", - " [0.51754386, 0.50727695, 1. ],\n", - " [0.60463659, 0.59755326, 0.85915493],\n", - " [0.70238095, 0.70132883, 0.95774648],\n", - " [0.79010025, 0.79160515, 0.85915493],\n", - " [0.89598997, 0.89748998, 0.98591549],\n", - " [1. , 1. , 0.97183099]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12607204, 0.12433989, 0.98507463],\n", - " [0.25557461, 0.25132021, 0.97014925],\n", - " [0.38336192, 0.37566011, 0.98507463],\n", - " [0.51200686, 0.50120019, 0.98507463],\n", - " [0.6406518 , 0.62698032, 1. ],\n", - " [0.75471698, 0.74843975, 0.98507463],\n", - " [0.87049743, 0.87469995, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11562897, 0.99578652, 0.88732394],\n", - " [0.227446 , 0.98291199, 0.90140845],\n", - " [0.31766201, 0.96067416, 0.88732394],\n", - " [0.39135959, 0.92485955, 0.94366197],\n", - " [0.45489199, 0.87874532, 0.98591549],\n", - " [0.50825921, 0.82420412, 0.97183099],\n", - " [0.54637865, 0.76755618, 0.98591549],\n", - " [0.58831004, 0.70201311, 0.98591549],\n", - " [0.63532402, 0.62710674, 1. ],\n", - " [0.68360864, 0.54775281, 0.98591549],\n", - " [0.73189327, 0.46839888, 0.98591549],\n", - " [0.78144854, 0.3883427 , 0.97183099],\n", - " [0.83100381, 0.30781835, 0.98591549],\n", - " [0.87674714, 0.22846442, 0.98591549],\n", - " [0.91486658, 0.15941011, 0.85915493],\n", - " [0.96188056, 0.08052434, 0.98591549],\n", - " [1. , 0. , 0.97183099]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.0857014 , 0.9123977 , 0.77777778],\n", - " [0.19079838, 0.80327372, 0.96296296],\n", - " [0.28101037, 0.71445893, 0.77777778],\n", - " [0.38926477, 0.60775993, 0.97530864],\n", - " [0.50202977, 0.49772658, 0.97530864],\n", - " [0.61208841, 0.38648075, 1. ],\n", - " [0.71853857, 0.27796302, 0.96296296],\n", - " [0.8037889 , 0.19248257, 0.75308642],\n", - " [0.91249436, 0.08608669, 0.97530864],\n", - " [1. , 0. , 0.7654321 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10288858, 0.09943002, 0.69306931],\n", - " [0.20412655, 0.20012666, 0.68316832],\n", - " [0.30866575, 0.30525649, 0.7029703 ],\n", - " [0.41155433, 0.40785307, 0.69306931],\n", - " [0.54277854, 0.53704877, 0.88118812],\n", - " [0.64566713, 0.64091197, 0.69306931],\n", - " [0.74828061, 0.74794174, 0.69306931],\n", - " [0.89628611, 0.90120329, 1. ],\n", - " [1. , 1. , 0.68316832]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90769231, 0.91040089, 0.84931507],\n", - " [0.8021978 , 0.8058378 , 0.94520548],\n", - " [0.71428571, 0.71623868, 0.89041096],\n", - " [0.61538462, 0.61333826, 0.87671233],\n", - " [0.5032967 , 0.50748199, 0.95890411],\n", - " [0.3978022 , 0.40458156, 0.91780822],\n", - " [0.29450549, 0.29872529, 0.95890411],\n", - " [0.2043956 , 0.20912618, 0.84931507],\n", - " [0.1032967 , 0.10604101, 0.91780822],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85447761, 0.90103189, 1. ],\n", - " [0.72910448, 0.81355535, 0.87142857],\n", - " [0.58656716, 0.71693246, 1. ],\n", - " [0.44104478, 0.61984053, 0.97142857],\n", - " [0.30671642, 0.5325985 , 0.87142857],\n", - " [0.19701493, 0.42636023, 1. ],\n", - " [0.14328358, 0.31754221, 0.98571429],\n", - " [0.09626866, 0.2206848 , 0.88571429],\n", - " [0.05074627, 0.11045966, 0.98571429],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88820043, 0.88438134, 1. ],\n", - " [0.79229526, 0.79107505, 0.86419753],\n", - " [0.68292026, 0.68559838, 0.98765432],\n", - " [0.58701509, 0.5862069 , 0.85185185],\n", - " [0.47737069, 0.48073022, 0.98765432],\n", - " [0.38200431, 0.37728195, 0.87654321],\n", - " [0.28609914, 0.28803245, 0.87654321],\n", - " [0.19342672, 0.20081136, 0.83950617],\n", - " [0.09509698, 0.09736308, 0.87654321],\n", - " [0. , 0. , 0.85185185]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91606847, 0.90762125, 0.8875 ],\n", - " [0.83296521, 0.81755196, 0.875 ],\n", - " [0.74765323, 0.72979215, 0.875 ],\n", - " [0.65323026, 0.62586605, 1. ],\n", - " [0.57261182, 0.5404157 , 0.85 ],\n", - " [0.50027609, 0.4665127 , 0.7625 ],\n", - " [0.41579238, 0.36951501, 0.875 ],\n", - " [0.33296521, 0.26789838, 0.875 ],\n", - " [0.24986195, 0.18475751, 0.8875 ],\n", - " [0.1667587 , 0.08775982, 0.8625 ],\n", - " [0.08393153, 0.03002309, 0.8625 ],\n", - " [0. , 0. , 0.8875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.13684211, 0.90286885, 1. ],\n", - " [0.26315789, 0.80840164, 1. ],\n", - " [0.36842105, 0.71741803, 0.95774648],\n", - " [0.42105263, 0.62151639, 1. ],\n", - " [0.45263158, 0.52766393, 1. ],\n", - " [0.45263158, 0.44282787, 0.98591549],\n", - " [0.49473684, 0.36086066, 0.97183099],\n", - " [0.61052632, 0.2727459 , 1. ],\n", - " [0.73684211, 0.18606557, 0.95774648],\n", - " [0.89473684, 0.0932377 , 1. ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08838568, 0.90770332, 0.97222222],\n", - " [0.18115413, 0.81278321, 0.97222222],\n", - " [0.27611395, 0.71571667, 0.97222222],\n", - " [0.36961286, 0.61769616, 0.95833333],\n", - " [0.46749452, 0.51419032, 1. ],\n", - " [0.56245435, 0.41354639, 0.95833333],\n", - " [0.65960555, 0.31027904, 0.97222222],\n", - " [0.75748722, 0.20581922, 0.97222222],\n", - " [0.87582177, 0.10302886, 0.97222222],\n", - " [1. , 0. , 0.97222222]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87419769, 0.12661969, 0.98507463],\n", - " [0.74967908, 0.24960218, 0.97014925],\n", - " [0.63157895, 0.37599454, 1. ],\n", - " [0.50834403, 0.49943169, 0.98507463],\n", - " [0.38510911, 0.62400546, 0.98507463],\n", - " [0.2593068 , 0.74903387, 0.98507463],\n", - " [0.13478819, 0.87383496, 0.98507463],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.06985605, 0.07512953, 0.69306931],\n", - " [0.1257409 , 0.17227979, 0.78217822],\n", - " [0.16892464, 0.2613342 , 0.71287129],\n", - " [0.21718882, 0.33257772, 0.61386139],\n", - " [0.2938188 , 0.39604922, 0.66336634],\n", - " [0.40304826, 0.47797927, 0.9009901 ],\n", - " [0.47502117, 0.54145078, 0.67326733],\n", - " [0.56054191, 0.60330311, 0.7029703 ],\n", - " [0.69983065, 0.69170984, 1. ],\n", - " [0.7811177 , 0.75744819, 0.68316832],\n", - " [0.85097375, 0.83678756, 0.69306931],\n", - " [0.92082981, 0.91645078, 0.69306931],\n", - " [1. , 1. , 0.69306931]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14454776, 0.13888889, 0.98507463],\n", - " [0.28909552, 0.28253968, 0.98507463],\n", - " [0.42011834, 0.41904762, 0.91044776],\n", - " [0.56213018, 0.56507937, 0.97014925],\n", - " [0.7097774 , 0.71111111, 1. ],\n", - " [0.8548887 , 0.85238095, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88547665, 0.88594099, 1. ],\n", - " [0.77415227, 0.77287379, 1. ],\n", - " [0.67370441, 0.67344409, 0.87142857],\n", - " [0.55918106, 0.56062485, 0.98571429],\n", - " [0.44273832, 0.44359038, 1. ],\n", - " [0.32885477, 0.32853955, 1. ],\n", - " [0.22840691, 0.22836598, 0.87142857],\n", - " [0.11516315, 0.11480288, 0.98571429],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90077178, 0.90071344, 1. ],\n", - " [0.79713341, 0.79667063, 0.97183099],\n", - " [0.69652701, 0.69560048, 0.98591549],\n", - " [0.60915105, 0.60939358, 0.85915493],\n", - " [0.51074972, 0.51129608, 0.97183099],\n", - " [0.40656009, 0.40725327, 0.97183099],\n", - " [0.30733186, 0.30915577, 1. ],\n", - " [0.2053473 , 0.20630202, 0.97183099],\n", - " [0.09867696, 0.0980975 , 1. ],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10070452, 0.10668103, 0.77380952],\n", - " [0.20679652, 0.21659483, 0.78571429],\n", - " [0.31123083, 0.32516164, 0.78571429],\n", - " [0.42353916, 0.44423491, 0.85714286],\n", - " [0.53087443, 0.55010776, 0.78571429],\n", - " [0.63945296, 0.65517241, 0.79761905],\n", - " [0.75093245, 0.76050647, 0.78571429],\n", - " [0.86033983, 0.86584052, 0.77380952],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12094595, 0.88481968, 0.64285714],\n", - " [0.22972973, 0.78221974, 0.57142857],\n", - " [0.33108108, 0.68157674, 0.57857143],\n", - " [0.47432432, 0.53816047, 0.79285714],\n", - " [0.56216216, 0.44786134, 0.49285714],\n", - " [0.73783784, 0.26977914, 1. ],\n", - " [0.87162162, 0.13055633, 0.77857143],\n", - " [1. , 0. , 0.71428571]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12235511, 0.87933025, 0.84615385],\n", - " [0.24471021, 0.76270208, 0.84615385],\n", - " [0.37749157, 0.63625866, 0.92307692],\n", - " [0.49800675, 0.51847575, 0.84615385],\n", - " [0.61821527, 0.39896074, 0.84615385],\n", - " [0.7598896 , 0.25808314, 1. ],\n", - " [0.88071144, 0.12586605, 0.84615385],\n", - " [1. , 0. , 0.85897436]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88912868, 0.88344988, 1. ],\n", - " [0.78014567, 0.76923077, 0.97183099],\n", - " [0.66765579, 0.65501166, 1. ],\n", - " [0.5578635 , 0.54778555, 0.97183099],\n", - " [0.4448341 , 0.43356643, 0.98591549],\n", - " [0.33207445, 0.33100233, 1. ],\n", - " [0.22093337, 0.22144522, 1. ],\n", - " [0.10952252, 0.10955711, 0.97183099],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12446675, 0.84671533, 0.98507463],\n", - " [0.24968632, 0.75912409, 0.98507463],\n", - " [0.37340025, 0.62043796, 0.98507463],\n", - " [0.49887077, 0.50364964, 1. ],\n", - " [0.62434128, 0.37226277, 0.98507463],\n", - " [0.75056462, 0.26277372, 0.98507463],\n", - " [0.87377666, 0.12408759, 0.97014925],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0.90909091, 1. , 0. ],\n", - " [1. , 0.84618814, 0.98630137],\n", - " [0.77272727, 0.7068658 , 0.90410959],\n", - " [0.63636364, 0.56977263, 0.89041096],\n", - " [0.36363636, 0.41596077, 1. ],\n", - " [0.45454545, 0.27797593, 0.90410959],\n", - " [0.36363636, 0.14132858, 0.89041096],\n", - " [0. , 0. , 0.91780822]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10122699, 0.11042642, 0.98591549],\n", - " [0.18711656, 0.21888095, 1. ],\n", - " [0.26380368, 0.33029332, 0.98591549],\n", - " [0.33128834, 0.44614247, 0.97183099],\n", - " [0.40797546, 0.55533646, 0.98591549],\n", - " [0.52147239, 0.66428395, 0.98591549],\n", - " [0.62269939, 0.77939364, 0.98591549],\n", - " [0.78527607, 0.89351738, 0.98591549],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87549744, 0.12984496, 1. ],\n", - " [0.74900512, 0.25484496, 1. ],\n", - " [0.64212621, 0.35658915, 0.8625 ],\n", - " [0.54434338, 0.45736434, 0.775 ],\n", - " [0.43746447, 0.56492248, 0.875 ],\n", - " [0.32603752, 0.67344961, 0.875 ],\n", - " [0.21972712, 0.78003876, 0.8625 ],\n", - " [0.10801592, 0.8875969 , 0.8875 ],\n", - " [0. , 1. , 0.8625 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91743917, 0.08354922, 0.97183099],\n", - " [0.83198146, 0.16968912, 1. ],\n", - " [0.74797219, 0.25388601, 0.98591549],\n", - " [0.66541136, 0.33678756, 0.97183099],\n", - " [0.58140209, 0.42033679, 0.98591549],\n", - " [0.49913094, 0.50194301, 0.98591549],\n", - " [0.41338355, 0.58873057, 1. ],\n", - " [0.33140209, 0.67163212, 0.97183099],\n", - " [0.24681344, 0.75453368, 0.98591549],\n", - " [0.16512167, 0.83549223, 1. ],\n", - " [0.08285052, 0.91904145, 0.97183099],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92225032, 0.1052374 , 0.98591549],\n", - " [0.83754741, 0.21096427, 1. ],\n", - " [0.7528445 , 0.31179638, 0.97183099],\n", - " [0.64538559, 0.41385218, 0.98591549],\n", - " [0.52907712, 0.51419481, 1. ],\n", - " [0.43552465, 0.60058737, 0.85915493],\n", - " [0.32996207, 0.69921684, 0.97183099],\n", - " [0.21871049, 0.79882526, 0.98591549],\n", - " [0.10366625, 0.89965737, 0.98591549],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85259516, 0.96371134, 0.77777778],\n", - " [0.683391 , 0.89525773, 0.9 ],\n", - " [0.52975779, 0.79051546, 0.87777778],\n", - " [0.36712803, 0.63917526, 1. ],\n", - " [0.2532872 , 0.48948454, 0.8 ],\n", - " [0.16262976, 0.33443299, 0.74444444],\n", - " [0.08062284, 0.17030928, 0.72222222],\n", - " [0. , 0. , 0.74444444]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14765101, 0.13244867, 0.86111111],\n", - " [0.27516779, 0.27115674, 0.875 ],\n", - " [0.42281879, 0.41462193, 0.91666667],\n", - " [0.57718121, 0.55783676, 0.93055556],\n", - " [0.72483221, 0.71382073, 1. ],\n", - " [0.88255034, 0.8575363 , 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87644092, 0.87342882, 1. ],\n", - " [0.75324207, 0.75007308, 1. ],\n", - " [0.62644092, 0.62262496, 1. ],\n", - " [0.50576369, 0.50160772, 1. ],\n", - " [0.37824207, 0.37562116, 1. ],\n", - " [0.25252161, 0.25197311, 1. ],\n", - " [0.12752161, 0.1271558 , 1. ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12169312, 0.12145073, 0.93055556],\n", - " [0.25396825, 0.25459318, 1. ],\n", - " [0.37830688, 0.37675972, 0.91666667],\n", - " [0.4973545 , 0.49773324, 0.90277778],\n", - " [0.62037037, 0.620377 , 0.93055556],\n", - " [0.75529101, 0.75471248, 1. ],\n", - " [0.87962963, 0.87640181, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91076257, 0.90163934, 0.875 ],\n", - " [0.82287723, 0.79391101, 0.8625 ],\n", - " [0.73201731, 0.70023419, 0.8875 ],\n", - " [0.6430503 , 0.6088993 , 0.875 ],\n", - " [0.55164954, 0.51522248, 0.875 ],\n", - " [0.46106003, 0.41920375, 0.875 ],\n", - " [0.37182261, 0.32552693, 0.875 ],\n", - " [0.26960519, 0.22716628, 1. ],\n", - " [0.17982693, 0.15222482, 0.875 ],\n", - " [0.08869659, 0.08196721, 0.8875 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89590255, 0.88209983, 0.91666667],\n", - " [0.79955703, 0.77423982, 0.84722222],\n", - " [0.6910299 , 0.66150316, 0.91666667],\n", - " [0.58065707, 0.55048766, 0.91666667],\n", - " [0.47065338, 0.44176707, 0.90277778],\n", - " [0.36581764, 0.34136546, 0.84722222],\n", - " [0.24031008, 0.22317843, 1. ],\n", - " [0.12513843, 0.11560528, 0.90277778],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92137592, 0.91666667, 0.74725275],\n", - " [0.84766585, 0.84682765, 0.67032967],\n", - " [0.74078624, 0.73697917, 1. ],\n", - " [0.65847666, 0.65435606, 0.76923077],\n", - " [0.58599509, 0.56889205, 0.76923077],\n", - " [0.50614251, 0.48768939, 0.74725275],\n", - " [0.43243243, 0.41595644, 0.67032967],\n", - " [0.34520885, 0.33072917, 0.78021978],\n", - " [0.25552826, 0.24928977, 0.76923077],\n", - " [0.16830467, 0.16619318, 0.75824176],\n", - " [0.07616708, 0.0842803 , 0.78021978],\n", - " [0. , 0. , 0.76923077]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88945796, 0.11057174, 0.87341772],\n", - " [0.77720871, 0.22168285, 0.88607595],\n", - " [0.65300896, 0.346548 , 1. ],\n", - " [0.55569782, 0.44606257, 0.78481013],\n", - " [0.446863 , 0.55582524, 0.87341772],\n", - " [0.33504055, 0.66855448, 0.89873418],\n", - " [0.2240717 , 0.77696872, 0.87341772],\n", - " [0.11139565, 0.88915858, 0.88607595],\n", - " [0. , 1. , 0.88607595]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88776306, 0.89086294, 0.88888889],\n", - " [0.79111458, 0.79695431, 0.78888889],\n", - " [0.69264744, 0.70050761, 0.77777778],\n", - " [0.60820992, 0.6142132 , 0.67777778],\n", - " [0.51415952, 0.51903553, 0.76666667],\n", - " [0.41699143, 0.42893401, 0.78888889],\n", - " [0.31982333, 0.33883249, 0.76666667],\n", - " [0.22213562, 0.23857868, 0.77777778],\n", - " [0.0971681 , 0.10025381, 1. ],\n", - " [0. , 0. , 0.77777778]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87319885, 0.88933333, 0.55279503],\n", - " [0.76421273, 0.77866667, 0.50310559],\n", - " [0.6463191 , 0.64533333, 0.55279503],\n", - " [0.44982971, 0.44533333, 0.86335404],\n", - " [0.23133351, 0.22266667, 1. ],\n", - " [0.11789363, 0.112 , 0.50310559],\n", - " [0. , 0. , 0.54658385]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92609971, 0.07053034, 0.86419753],\n", - " [0.85571848, 0.14160744, 0.86419753],\n", - " [0.78709677, 0.21377802, 0.86419753],\n", - " [0.71554252, 0.28430837, 0.86419753],\n", - " [0.64633431, 0.35347184, 0.86419753],\n", - " [0.57478006, 0.42017496, 0.85185185],\n", - " [0.50674487, 0.48715145, 0.86419753],\n", - " [0.42521994, 0.56670312, 0.98765432],\n", - " [0.34134897, 0.6470749 , 1. ],\n", - " [0.27096774, 0.71623838, 0.86419753],\n", - " [0.20234604, 0.78540186, 0.86419753],\n", - " [0.13020528, 0.86194642, 0.97530864],\n", - " [0.06392962, 0.93083652, 0.86419753],\n", - " [0. , 1. , 0.86419753]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12216495, 0.875 , 0.98507463],\n", - " [0.25180412, 0.74305556, 1. ],\n", - " [0.37706186, 0.60069444, 0.98507463],\n", - " [0.50128866, 0.47916667, 0.98507463],\n", - " [0.62319588, 0.35069444, 0.97014925],\n", - " [0.74690722, 0.23263889, 0.98507463],\n", - " [0.8742268 , 0.11458333, 1. ],\n", - " [1. , 0. , 0.97014925]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13523957, 0.14097136, 1. ],\n", - " [0.27820711, 0.28368618, 1. ],\n", - " [0.42272025, 0.42665006, 1. ],\n", - " [0.56568779, 0.56936488, 1. ],\n", - " [0.70942813, 0.71108344, 1. ],\n", - " [0.85471406, 0.85603985, 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14223331, 0.15036803, 0.98507463],\n", - " [0.28758578, 0.29810726, 0.97014925],\n", - " [0.42919526, 0.44426919, 1. ],\n", - " [0.57267623, 0.58885384, 0.97014925],\n", - " [0.71334997, 0.72607781, 0.98507463],\n", - " [0.86119775, 0.8659306 , 1. ],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8388497 , 0.98436214, 0.875 ],\n", - " [0.67715681, 0.96817558, 0.8875 ],\n", - " [0.5002713 , 0.95198903, 1. ],\n", - " [0.35973956, 0.91879287, 0.875 ],\n", - " [0.23114487, 0.87078189, 0.875 ],\n", - " [0.14324471, 0.8090535 , 0.7875 ],\n", - " [0.0759631 , 0.73223594, 0.8375 ],\n", - " [0.03798155, 0.64224966, 0.8875 ],\n", - " [0.03581118, 0.55198903, 0.875 ],\n", - " [0.03147043, 0.45843621, 0.8625 ],\n", - " [0.02333152, 0.36433471, 0.875 ],\n", - " [0.017363 , 0.27215364, 0.875 ],\n", - " [0.01193706, 0.17668038, 0.875 ],\n", - " [0.00488334, 0.09410151, 0.7625 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8874352 , 0.10502283, 0.81818182],\n", - " [0.79066897, 0.20273973, 0.6969697 ],\n", - " [0.69143421, 0.30319635, 0.71717172],\n", - " [0.58331276, 0.4109589 , 0.78787879],\n", - " [0.48160948, 0.51324201, 0.72727273],\n", - " [0.38262157, 0.61187215, 0.70707071],\n", - " [0.25623303, 0.74155251, 0.8989899 ],\n", - " [0.140706 , 0.85753425, 0.81818182],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87940208, 0.90277778, 0.91666667],\n", - " [0.75728401, 0.80555556, 0.91666667],\n", - " [0.63136559, 0.73611111, 0.93055556],\n", - " [0.51102103, 0.65277778, 0.90277778],\n", - " [0.37724854, 0.48611111, 1. ],\n", - " [0.25462376, 0.33333333, 0.93055556],\n", - " [0.13326577, 0.18055556, 0.90277778],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.78651685, 0.86210293, 0.97014925],\n", - " [0.58426966, 0.72395962, 1. ],\n", - " [0.39325843, 0.58827875, 0.98507463],\n", - " [0.28089888, 0.46614134, 0.97014925],\n", - " [0.21348315, 0.34892884, 0.97014925],\n", - " [0.13483146, 0.23023886, 0.98507463],\n", - " [0.05617978, 0.11647377, 0.92537313],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.21848739, 0.85865169, 0.75833333],\n", - " [0.44537815, 0.67325843, 1. ],\n", - " [0.57983193, 0.56494382, 0.58333333],\n", - " [0.68067227, 0.46089888, 0.56666667],\n", - " [0.66386555, 0.34921348, 0.59166667],\n", - " [0.73529412, 0.24179775, 0.58333333],\n", - " [0.8697479 , 0.13505618, 0.58333333],\n", - " [1. , 0. , 0.75 ]]),\n", - " array([[1. , 0.86547085, 0. ],\n", - " [0.90095847, 0.89686099, 0.8625 ],\n", - " [0.81203408, 0.91479821, 0.775 ],\n", - " [0.71379127, 0.95964126, 0.875 ],\n", - " [0.59904153, 1. , 1. ],\n", - " [0.49840256, 0.87892377, 0.8625 ],\n", - " [0.39882854, 0.72197309, 0.875 ],\n", - " [0.29792332, 0.5426009 , 0.8875 ],\n", - " [0.20101171, 0.3632287 , 0.8625 ],\n", - " [0.09984026, 0.17040359, 0.8875 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11358473, 0.11722413, 0.98591549],\n", - " [0.24216265, 0.22882151, 1. ],\n", - " [0.37755566, 0.32979056, 0.95774648],\n", - " [0.49750114, 0.4195061 , 0.85915493],\n", - " [0.62017265, 0.51172241, 0.85915493],\n", - " [0.75329396, 0.61863082, 0.97183099],\n", - " [0.84507042, 0.74210691, 0.98591549],\n", - " [0.92912313, 0.86902157, 0.98591549],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92313788, 0.90489914, 0.98611111],\n", - " [0.84812467, 0.81556196, 0.95833333],\n", - " [0.77126255, 0.73775216, 0.97222222],\n", - " [0.6967776 , 0.65417867, 0.95833333],\n", - " [0.61938722, 0.56195965, 1. ],\n", - " [0.54358162, 0.4870317 , 0.94444444],\n", - " [0.46698362, 0.43227666, 0.98611111],\n", - " [0.38880085, 0.37175793, 0.97222222],\n", - " [0.31220285, 0.31123919, 0.97222222],\n", - " [0.23454834, 0.24495677, 0.95833333],\n", - " [0.15662969, 0.16426513, 0.98611111],\n", - " [0.07686212, 0.0778098 , 0.98611111],\n", - " [0. , 0. , 0.94444444]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.23504722, 0.76533742, 1. ],\n", - " [0.42462399, 0.57592025, 0.78571429],\n", - " [0.62854145, 0.37154908, 0.85714286],\n", - " [0.81532004, 0.18443252, 0.79761905],\n", - " [1. , 0. , 0.77380952]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11025093, 0.0619883 , 0.875 ],\n", - " [0.22156967, 0.17660819, 0.875 ],\n", - " [0.32728243, 0.32397661, 0.875 ],\n", - " [0.43619861, 0.44093567, 0.8625 ],\n", - " [0.54618259, 0.5122807 , 0.8875 ],\n", - " [0.67351842, 0.62222222, 1. ],\n", - " [0.78270155, 0.75438596, 0.8875 ],\n", - " [0.89054992, 0.89824561, 0.85 ],\n", - " [1. , 1. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14278729, 0.14273356, 0.91666667],\n", - " [0.28361858, 0.28402537, 0.91666667],\n", - " [0.42689487, 0.42387543, 0.91666667],\n", - " [0.5794621 , 0.57756632, 1. ],\n", - " [0.71882641, 0.71597463, 0.91666667],\n", - " [0.86161369, 0.85870819, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1455518 , 0.13947001, 1. ],\n", - " [0.28631757, 0.27894003, 1. ],\n", - " [0.43186937, 0.41980474, 1. ],\n", - " [0.57263514, 0.55927476, 1. ],\n", - " [0.71818694, 0.69874477, 1. ],\n", - " [0.8589527 , 0.86052999, 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12225948, 0.16 , 0.91666667],\n", - " [0.24632448, 0.44 , 0.93055556],\n", - " [0.36652051, 0.68 , 0.90277778],\n", - " [0.49987103, 0.76 , 1. ],\n", - " [0.63322156, 0.72 , 1. ],\n", - " [0.75548104, 0.72 , 0.91666667],\n", - " [0.87774052, 0.84 , 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14014442, 0.16620499, 0.97014925],\n", - " [0.28617277, 0.32686981, 0.98507463],\n", - " [0.4263172 , 0.47922438, 1. ],\n", - " [0.57341535, 0.60941828, 0.98507463],\n", - " [0.71409468, 0.73407202, 0.98507463],\n", - " [0.85771597, 0.85872576, 0.97014925],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10849577, 0.09481601, 0.94444444],\n", - " [0.22177271, 0.18802041, 1. ],\n", - " [0.32879735, 0.28095622, 0.95833333],\n", - " [0.43692534, 0.37550363, 0.97222222],\n", - " [0.54836337, 0.46978243, 0.98611111],\n", - " [0.65575579, 0.56003223, 0.95833333],\n", - " [0.75652814, 0.66022025, 0.97222222],\n", - " [0.83891136, 0.77706151, 0.95833333],\n", - " [0.91982346, 0.89041096, 0.98611111],\n", - " [1. , 1. , 0.95833333]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90623557, 0.90636288, 0.7625 ],\n", - " [0.79630485, 0.79744373, 0.875 ],\n", - " [0.68452656, 0.68657961, 0.8875 ],\n", - " [0.57321016, 0.57515977, 0.875 ],\n", - " [0.46558891, 0.46707419, 0.875 ],\n", - " [0.33856813, 0.34009447, 1. ],\n", - " [0.23140878, 0.23228675, 0.875 ],\n", - " [0.12332564, 0.12253404, 0.8625 ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1156306 , 0.11653117, 0.98507463],\n", - " [0.22307496, 0.22086721, 0.98507463],\n", - " [0.33384497, 0.32926829, 0.98507463],\n", - " [0.44614991, 0.44715447, 0.97014925],\n", - " [0.54873369, 0.55284553, 0.91044776],\n", - " [0.66001535, 0.66124661, 0.98507463],\n", - " [0.77385521, 0.77642276, 0.97014925],\n", - " [0.88257866, 0.88753388, 0.98507463],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86095965, 0.24509804, 0.90410959],\n", - " [0.72028353, 0.47058824, 0.89041096],\n", - " [0.5648855 , 0.70588235, 1. ],\n", - " [0.42666303, 1. , 0.89041096],\n", - " [0.282988 , 1. , 0.91780822],\n", - " [0.14367503, 0.70588235, 0.90410959],\n", - " [0. , 0.21568627, 0.90410959]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89742294, 0.09586466, 0.57983193],\n", - " [0.79661445, 0.18421053, 0.58823529],\n", - " [0.69302678, 0.28383459, 0.59663866],\n", - " [0.58943911, 0.39097744, 0.58823529],\n", - " [0.48938858, 0.4962406 , 0.58823529],\n", - " [0.38782213, 0.60338346, 0.58823529],\n", - " [0.28802425, 0.70864662, 0.57983193],\n", - " [0.17180394, 0.81954887, 0.68067227],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.17153285, 0.85333333, 0.98507463],\n", - " [0.33829309, 0.68 , 0.98507463],\n", - " [0.50421112, 0.51111111, 1. ],\n", - " [0.66928692, 0.34444444, 0.97014925],\n", - " [0.83436272, 0.16777778, 0.98507463],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.0858328 , 0.08700834, 0.97530864],\n", - " [0.14901085, 0.15256257, 0.75308642],\n", - " [0.23420549, 0.23837902, 0.98765432],\n", - " [0.31876197, 0.32578466, 0.97530864],\n", - " [0.40427569, 0.41716329, 1. ],\n", - " [0.48947033, 0.50337704, 0.98765432],\n", - " [0.57211232, 0.5856178 , 0.97530864],\n", - " [0.65698787, 0.67143425, 0.98765432],\n", - " [0.74473516, 0.76162098, 1. ],\n", - " [0.82514359, 0.84306714, 0.97530864],\n", - " [0.91033823, 0.92491061, 0.98765432],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12091837, 0.12007505, 0.77777778],\n", - " [0.26020408, 0.26025194, 1. ],\n", - " [0.40816327, 0.4087376 , 1. ],\n", - " [0.52295918, 0.52345216, 0.78888889],\n", - " [0.64438776, 0.64620745, 0.87777778],\n", - " [0.76122449, 0.7619941 , 0.77777778],\n", - " [0.86989796, 0.86974002, 0.78888889],\n", - " [1. , 1. , 0.86666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88588667, 0.87341772, 1. ],\n", - " [0.77544596, 0.74864376, 0.97183099],\n", - " [0.66343127, 0.61301989, 0.98591549],\n", - " [0.54905561, 0.49728752, 1. ],\n", - " [0.43546695, 0.39240506, 1. ],\n", - " [0.32214061, 0.28571429, 0.97183099],\n", - " [0.2250787 , 0.20072333, 0.85915493],\n", - " [0.11437566, 0.10126582, 0.97183099],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88276671, 0.88243462, 0.91666667],\n", - " [0.76553341, 0.76278639, 0.91666667],\n", - " [0.63305979, 0.62902106, 1. ],\n", - " [0.5017585 , 0.50451284, 0.90277778],\n", - " [0.37514654, 0.38787318, 0.84722222],\n", - " [0.24032825, 0.26220782, 0.91666667],\n", - " [0.11488863, 0.13214534, 0.91666667],\n", - " [0. , 0. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90600882, 0.90483619, 0.78888889],\n", - " [0.79713341, 0.78627145, 0.88888889],\n", - " [0.70341786, 0.69110764, 0.77777778],\n", - " [0.60970232, 0.5975039 , 0.77777778],\n", - " [0.5146086 , 0.50702028, 0.78888889],\n", - " [0.40656009, 0.39937598, 0.87777778],\n", - " [0.31256891, 0.30577223, 0.76666667],\n", - " [0.21664829, 0.21372855, 0.78888889],\n", - " [0.12348401, 0.12168487, 0.77777778],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90016685, 0.88480392, 0.98571429],\n", - " [0.79810901, 0.76715686, 1. ],\n", - " [0.69549499, 0.66421569, 1. ],\n", - " [0.60567297, 0.57352941, 0.88571429],\n", - " [0.50389321, 0.47058824, 0.98571429],\n", - " [0.39988877, 0.37254902, 0.98571429],\n", - " [0.2942158 , 0.28431373, 0.98571429],\n", - " [0.20439377, 0.20588235, 0.87142857],\n", - " [0.09510567, 0.08823529, 1. ],\n", - " [0. , 0. , 0.87142857]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11771147, 0.10663507, 0.85185185],\n", - " [0.25485902, 0.23815166, 0.98765432],\n", - " [0.37448672, 0.35308057, 0.86419753],\n", - " [0.51355051, 0.49407583, 1. ],\n", - " [0.62934574, 0.60900474, 0.85185185],\n", - " [0.74979469, 0.72985782, 0.87654321],\n", - " [0.88256228, 0.87322275, 0.97530864],\n", - " [1. , 1. , 0.85185185]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91282189, 0.92619926, 0.68316832],\n", - " [0.8251073 , 0.85055351, 0.69306931],\n", - " [0.73658798, 0.7804428 , 0.71287129],\n", - " [0.64994635, 0.70110701, 0.68316832],\n", - " [0.57483906, 0.62730627, 0.6039604 ],\n", - " [0.48712446, 0.53690037, 0.68316832],\n", - " [0.39002146, 0.43357934, 0.78217822],\n", - " [0.30069742, 0.33394834, 0.7029703 ],\n", - " [0.21378755, 0.23431734, 0.69306931],\n", - " [0.08798283, 0.09594096, 1. ],\n", - " [0. , 0. , 0.68316832]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12146379, 0.74074074, 0.90277778],\n", - " [0.2470802 , 0.44444444, 0.93055556],\n", - " [0.36880353, 0.37037037, 0.90277778],\n", - " [0.5037633 , 0.33333333, 1. ],\n", - " [0.6273034 , 0.14814815, 0.91666667],\n", - " [0.75266026, 0. , 0.93055556],\n", - " [0.87620036, 0. , 0.90277778],\n", - " [1. , 0. , 0.93055556]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08532974, 0.10072595, 0.875 ],\n", - " [0.18734859, 0.22323049, 1. ],\n", - " [0.2756393 , 0.32849365, 0.875 ],\n", - " [0.36769852, 0.43284936, 0.8875 ],\n", - " [0.45733513, 0.52631579, 0.8625 ],\n", - " [0.5461642 , 0.62431942, 0.875 ],\n", - " [0.63580081, 0.7168784 , 0.8875 ],\n", - " [0.72570659, 0.78584392, 0.8875 ],\n", - " [0.81588156, 0.85753176, 0.8625 ],\n", - " [0.90794078, 0.9246824 , 0.875 ],\n", - " [1. , 1. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.18 , 0.14519962, 0.97014925],\n", - " [0.325 , 0.2901616 , 0.98507463],\n", - " [0.455 , 0.43536122, 0.98507463],\n", - " [0.595 , 0.58032319, 1. ],\n", - " [0.705 , 0.72172053, 0.97014925],\n", - " [0.835 , 0.85289924, 0.91044776],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8905007 , 0.89092277, 0.89873418],\n", - " [0.78380908, 0.77683049, 0.88607595],\n", - " [0.672438 , 0.67151454, 0.88607595],\n", - " [0.54749649, 0.54638917, 1. ],\n", - " [0.44080487, 0.4390672 , 0.88607595],\n", - " [0.32990173, 0.32848546, 0.88607595],\n", - " [0.22040243, 0.21965898, 0.88607595],\n", - " [0.10903135, 0.10882648, 0.89873418],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87565938, 0.87650086, 0.98507463],\n", - " [0.75307712, 0.75643225, 0.97014925],\n", - " [0.62572218, 0.62950257, 1. ],\n", - " [0.5001256 , 0.50428816, 0.98507463],\n", - " [0.37528259, 0.37392796, 0.98507463],\n", - " [0.25244913, 0.25214408, 0.97014925],\n", - " [0.12635016, 0.12692967, 0.98507463],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91994178, 0.09620253, 1. ],\n", - " [0.84716157, 0.17974684, 0.91139241],\n", - " [0.77438137, 0.26467204, 0.87341772],\n", - " [0.70305677, 0.35005754, 0.89873418],\n", - " [0.62299854, 0.43222094, 0.87341772],\n", - " [0.5371179 , 0.51438435, 0.87341772],\n", - " [0.45269287, 0.5976985 , 0.88607595],\n", - " [0.36972344, 0.66996548, 0.7721519 ],\n", - " [0.27802038, 0.75166858, 0.87341772],\n", - " [0.18049491, 0.83613349, 0.91139241],\n", - " [0.09024745, 0.91829689, 0.87341772],\n", - " [0. , 1. , 0.88607595]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88923627, 0.88978345, 0.84810127],\n", - " [0.77981242, 0.78095502, 0.83544304],\n", - " [0.67128182, 0.67157135, 0.82278481],\n", - " [0.57257704, 0.57245974, 0.7721519 ],\n", - " [0.46538633, 0.46557468, 0.82278481],\n", - " [0.35685574, 0.35674625, 0.83544304],\n", - " [0.22778026, 0.22598556, 1. ],\n", - " [0.11210362, 0.10882843, 0.89873418],\n", - " [0. , 0. , 0.84810127]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86993769, 0.12693284, 0.98507463],\n", - " [0.73987539, 0.2499423 , 0.98507463],\n", - " [0.62305296, 0.37687514, 0.98507463],\n", - " [0.49376947, 0.49988461, 0.98507463],\n", - " [0.37694704, 0.62681745, 0.97014925],\n", - " [0.24688474, 0.74867297, 0.98507463],\n", - " [0.11682243, 0.87699054, 1. ],\n", - " [0. , 1. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88156336, 0.88254172, 0.88888889],\n", - " [0.77615476, 0.78080873, 0.76666667],\n", - " [0.67114094, 0.67394095, 0.78888889],\n", - " [0.56573233, 0.56675225, 0.77777778],\n", - " [0.46032373, 0.47047497, 0.76666667],\n", - " [0.32885906, 0.33697047, 1. ],\n", - " [0.22345045, 0.22978177, 0.78888889],\n", - " [0.10501382, 0.11232349, 0.88888889],\n", - " [0. , 0. , 0.77777778]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10882648, 0.08256881, 0.95833333],\n", - " [0.22291876, 0.20183486, 0.97222222],\n", - " [0.31945838, 0.30275229, 0.84722222],\n", - " [0.43229689, 0.43119266, 0.97222222],\n", - " [0.54363089, 0.52293578, 0.95833333],\n", - " [0.65872618, 0.6146789 , 0.97222222],\n", - " [0.77031093, 0.67889908, 0.95833333],\n", - " [0.88515547, 0.8440367 , 1. ],\n", - " [1. , 1. , 0.97222222]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08613905, 0.91552578, 0.98591549],\n", - " [0.16965457, 0.83338188, 0.98591549],\n", - " [0.25491911, 0.74803379, 0.98591549],\n", - " [0.33799738, 0.66501602, 0.98591549],\n", - " [0.42326192, 0.57966793, 0.98591549],\n", - " [0.50940096, 0.49373726, 1. ],\n", - " [0.59160472, 0.41071949, 0.97183099],\n", - " [0.66375164, 0.33877075, 0.85915493],\n", - " [0.74682991, 0.25575299, 0.97183099],\n", - " [0.83384346, 0.16894844, 1. ],\n", - " [0.91473546, 0.08680454, 0.97183099],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12492492, 0.12566955, 0.98765432],\n", - " [0.23153153, 0.23320972, 0.83950617],\n", - " [0.35465465, 0.35805521, 1. ],\n", - " [0.44804805, 0.45282241, 0.75308642],\n", - " [0.55585586, 0.56159868, 0.86419753],\n", - " [0.66066066, 0.66625464, 0.83950617],\n", - " [0.77087087, 0.77214668, 0.87654321],\n", - " [0.87747748, 0.87886279, 0.86419753],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09876543, 0.10189573, 0.98591549],\n", - " [0.20042028, 0.2014218 , 1. ],\n", - " [0.29944838, 0.30331754, 0.95774648],\n", - " [0.39952719, 0.40047393, 1. ],\n", - " [0.49960599, 0.50236967, 0.98591549],\n", - " [0.59994747, 0.59952607, 0.97183099],\n", - " [0.70028894, 0.70616114, 1. ],\n", - " [0.80194379, 0.8056872 , 0.98591549],\n", - " [0.90254794, 0.9028436 , 1. ],\n", - " [1. , 1. , 0.95774648]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90854161, 0.8968347 , 0.75 ],\n", - " [0.78769569, 0.76436108, 0.97826087],\n", - " [0.69761055, 0.65416178, 0.75 ],\n", - " [0.60148311, 0.53692849, 0.7826087 ],\n", - " [0.50947542, 0.45838218, 0.75 ],\n", - " [0.41636913, 0.38218054, 0.76086957],\n", - " [0.32243889, 0.29777257, 0.75 ],\n", - " [0.20021972, 0.18405627, 1. ],\n", - " [0.09475419, 0.08675264, 0.85869565],\n", - " [0. , 0. , 0.77173913]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90268676, 0.09867629, 0.8625 ],\n", - " [0.80439056, 0.19815483, 0.875 ],\n", - " [0.70478375, 0.29963899, 0.8875 ],\n", - " [0.60648755, 0.39911753, 0.875 ],\n", - " [0.4921363 , 0.51263538, 1. ],\n", - " [0.39580603, 0.60689932, 0.8625 ],\n", - " [0.29423329, 0.70758123, 0.8875 ],\n", - " [0.19724771, 0.80505415, 0.875 ],\n", - " [0.09895151, 0.90332932, 0.8625 ],\n", - " [0. , 1. , 0.8875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.02861314, 0.97211464, 0.78021978],\n", - " [0.05839416, 0.94113091, 0.75824176],\n", - " [0.0870073 , 0.91092177, 0.76923077],\n", - " [0.1249635 , 0.87141751, 0.98901099],\n", - " [0.15416058, 0.83888459, 0.78021978],\n", - " [0.18248175, 0.80945004, 0.75824176],\n", - " [0.21547445, 0.77459334, 0.87912088],\n", - " [0.24817518, 0.74051123, 0.87912088],\n", - " [0.28262774, 0.70487994, 0.87912088],\n", - " [0.31678832, 0.67079783, 0.86813187],\n", - " [0.34656934, 0.64136328, 0.76923077],\n", - " [0.37576642, 0.61192874, 0.76923077],\n", - " [0.40525547, 0.580945 , 0.78021978],\n", - " [0.4350365 , 0.55073586, 0.75824176],\n", - " [0.46481752, 0.5228505 , 0.76923077],\n", - " [0.49343066, 0.49419055, 0.76923077],\n", - " [0.52350365, 0.4655306 , 0.78021978],\n", - " [0.55270073, 0.43841983, 0.76923077],\n", - " [0.58248175, 0.40898528, 0.76923077],\n", - " [0.61109489, 0.38187452, 0.76923077],\n", - " [0.64467153, 0.348567 , 0.87912088],\n", - " [0.67824818, 0.31603408, 0.87912088],\n", - " [0.70948905, 0.28505035, 0.87912088],\n", - " [0.73810219, 0.25793958, 0.76923077],\n", - " [0.76642336, 0.22927963, 0.78021978],\n", - " [0.79766423, 0.19984508, 0.85714286],\n", - " [0.82715328, 0.17118513, 0.78021978],\n", - " [0.86423358, 0.13632843, 1. ],\n", - " [0.89255474, 0.10921766, 0.76923077],\n", - " [0.92029197, 0.0813323 , 0.74725275],\n", - " [0.94364964, 0.0580945 , 0.67032967],\n", - " [0.97080292, 0.02943455, 0.75824176],\n", - " [1. , 0. , 0.78021978]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90257252, 0.89949324, 0.79120879],\n", - " [0.80706076, 0.80658784, 0.75824176],\n", - " [0.68390805, 0.68412162, 0.98901099],\n", - " [0.58976464, 0.58783784, 0.75824176],\n", - " [0.49151615, 0.4847973 , 0.79120879],\n", - " [0.39709907, 0.3910473 , 0.75824176],\n", - " [0.27285167, 0.26942568, 1. ],\n", - " [0.18007663, 0.17736486, 0.74725275],\n", - " [0.09660646, 0.09628378, 0.67032967],\n", - " [0. , 0. , 0.78021978]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13449275, 0.13301663, 0.98765432],\n", - " [0.2342029 , 0.2327791 , 0.75308642],\n", - " [0.36695652, 0.3655318 , 0.97530864],\n", - " [0.50492754, 0.50092373, 0.98765432],\n", - " [0.63072464, 0.63288467, 1. ],\n", - " [0.76521739, 0.76405384, 0.97530864],\n", - " [0.90086957, 0.90129322, 0.98765432],\n", - " [1. , 1. , 0.75308642]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87085834, 0.8773913 , 0.90277778],\n", - " [0.75006522, 0.75826087, 0.91666667],\n", - " [0.62222802, 0.62782609, 0.91666667],\n", - " [0.49986955, 0.5 , 0.91666667],\n", - " [0.37307592, 0.37391304, 0.91666667],\n", - " [0.25384816, 0.26 , 0.91666667],\n", - " [0.11896687, 0.12956522, 1. ],\n", - " [0. , 0. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90481786, 0.90340741, 0.91139241],\n", - " [0.81668625, 0.81274074, 0.86075949],\n", - " [0.72581277, 0.72088889, 0.89873418],\n", - " [0.63650607, 0.6322963 , 0.88607595],\n", - " [0.54680768, 0.54488889, 0.89873418],\n", - " [0.44731688, 0.44651852, 1. ],\n", - " [0.36036036, 0.3602963 , 0.88607595],\n", - " [0.26400313, 0.2637037 , 1. ],\n", - " [0.17587152, 0.17422222, 0.91139241],\n", - " [0.08852331, 0.08711111, 0.87341772],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.13200723, 0.88497217, 0.85714286],\n", - " [0.26220615, 0.76808905, 0.84415584],\n", - " [0.37251356, 0.65491651, 0.79220779],\n", - " [0.49439421, 0.52912801, 0.85714286],\n", - " [0.6358047 , 0.3825603 , 1. ],\n", - " [0.75768535, 0.25269017, 0.87012987],\n", - " [0.88137432, 0.12356215, 0.85714286],\n", - " [1. , 0. , 0.85714286]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12503151, 0.11764706, 1. ],\n", - " [0.23140913, 0.22875817, 0.85185185],\n", - " [0.3408117 , 0.33986928, 0.87654321],\n", - " [0.44844971, 0.45751634, 0.86419753],\n", - " [0.55432317, 0.5620915 , 0.86419753],\n", - " [0.66498614, 0.66666667, 0.87654321],\n", - " [0.78497605, 0.81045752, 0.96296296],\n", - " [0.89412654, 0.90849673, 0.87654321],\n", - " [1. , 1. , 0.85185185]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89951691, 0.90607424, 0.7625 ],\n", - " [0.78164251, 0.79836895, 0.8625 ],\n", - " [0.66135266, 0.68869516, 0.8875 ],\n", - " [0.54444444, 0.58239595, 0.8625 ],\n", - " [0.43381643, 0.46878515, 0.8875 ],\n", - " [0.31497585, 0.34111361, 1. ],\n", - " [0.20821256, 0.22581552, 0.8875 ],\n", - " [0.1057971 , 0.11473566, 0.85 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8994695 , 0.89759503, 0.98591549],\n", - " [0.80132626, 0.79674166, 0.98591549],\n", - " [0.70185676, 0.6935609 , 0.98591549],\n", - " [0.60291777, 0.60046548, 0.97183099],\n", - " [0.50159151, 0.49650892, 1. ],\n", - " [0.40212202, 0.39953452, 0.98591549],\n", - " [0.29920424, 0.29402638, 0.98591549],\n", - " [0.19973475, 0.19782777, 0.98591549],\n", - " [0.09761273, 0.0969744 , 0.98591549],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86006084, 0.860252 , 0.85714286],\n", - " [0.69578444, 0.69730813, 1. ],\n", - " [0.54019991, 0.54266896, 0.94805195],\n", - " [0.40243372, 0.40292096, 0.84415584],\n", - " [0.27509778, 0.27634593, 0.79220779],\n", - " [0.13733159, 0.13659794, 0.85714286],\n", - " [0. , 0. , 0.84415584]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.85458613, 0.14687567, 0.98571429],\n", - " [0.70469799, 0.29568392, 0.98571429],\n", - " [0.57941834, 0.42301911, 0.87142857],\n", - " [0.45637584, 0.55228688, 0.87142857],\n", - " [0.3064877 , 0.69980674, 0.98571429],\n", - " [0.15659955, 0.85076229, 1. ],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91930541, 0. , 0.75308642],\n", - " [0.8299285 , 0.51515152, 0.83950617],\n", - " [0.74055158, 0.51515152, 0.87654321],\n", - " [0.65117467, 0.51515152, 0.85185185],\n", - " [0.55745659, 0.51515152, 0.87654321],\n", - " [0.46807967, 0.51515152, 0.86419753],\n", - " [0.37436159, 0.51515152, 0.85185185],\n", - " [0.28498468, 1. , 0.87654321],\n", - " [0.19560776, 1. , 0.85185185],\n", - " [0.10214505, 1. , 0.86419753],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91784573, 0.08055266, 0.87323944],\n", - " [0.8224555 , 0.17440042, 0.97183099],\n", - " [0.72797809, 0.26903024, 0.98591549],\n", - " [0.63441351, 0.36470282, 0.98591549],\n", - " [0.55043359, 0.44838373, 0.85915493],\n", - " [0.45595618, 0.54249218, 0.95774648],\n", - " [0.35965313, 0.63842544, 0.98591549],\n", - " [0.27567321, 0.72288843, 0.87323944],\n", - " [0.18165221, 0.81725756, 0.98591549],\n", - " [0.09082611, 0.90901981, 0.97183099],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86902655, 0.12535211, 1. ],\n", - " [0.74690265, 0.24812207, 0.97014925],\n", - " [0.61946903, 0.37488263, 1. ],\n", - " [0.49026549, 0.50093897, 0.98507463],\n", - " [0.36814159, 0.62394366, 0.98507463],\n", - " [0.24778761, 0.74906103, 0.97014925],\n", - " [0.12389381, 0.87394366, 1. ],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8857288 , 0.87096774, 0.8875 ],\n", - " [0.77475876, 0.76129032, 0.875 ],\n", - " [0.66404266, 0.64193548, 0.875 ],\n", - " [0.55485018, 0.53870968, 0.8625 ],\n", - " [0.44210259, 0.43548387, 0.8875 ],\n", - " [0.31538852, 0.31612903, 1. ],\n", - " [0.21965465, 0.22903226, 0.7625 ],\n", - " [0.10893855, 0.13548387, 0.8625 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92769148, 0.07264472, 0.84722222],\n", - " [0.84413498, 0.15323496, 0.95833333],\n", - " [0.75977504, 0.23723042, 0.97222222],\n", - " [0.67300482, 0.32236095, 1. ],\n", - " [0.59078736, 0.40068104, 0.94444444],\n", - " [0.50535619, 0.48240636, 0.97222222],\n", - " [0.4196572 , 0.56413167, 1. ],\n", - " [0.33556508, 0.64812713, 0.95833333],\n", - " [0.25147295, 0.73439274, 0.98611111],\n", - " [0.16711302, 0.82065834, 0.95833333],\n", - " [0.08302089, 0.90805902, 0.98611111],\n", - " [0. , 1. , 0.95833333]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.83310947, 0.16734034, 1. ],\n", - " [0.6692411 , 0.33225546, 0.98507463],\n", - " [0.49932841, 0.50080841, 0.98507463],\n", - " [0.33344527, 0.66855295, 0.98507463],\n", - " [0.16655473, 0.83306386, 0.98507463],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90694239, 0.09647651, 0.98591549],\n", - " [0.81585426, 0.18624161, 0.98591549],\n", - " [0.7282127 , 0.27600671, 0.98591549],\n", - " [0.63860167, 0.36465324, 1. ],\n", - " [0.54751354, 0.45441834, 0.98591549],\n", - " [0.45642541, 0.54502237, 0.98591549],\n", - " [0.36681438, 0.63422819, 0.97183099],\n", - " [0.27572624, 0.72455257, 0.98591549],\n", - " [0.18463811, 0.81487696, 0.98591549],\n", - " [0.09256524, 0.90715884, 1. ],\n", - " [0. , 1. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8719346 , 0.87076393, 1. ],\n", - " [0.75095368, 0.75071798, 0.97014925],\n", - " [0.62615804, 0.62894888, 0.98507463],\n", - " [0.50108992, 0.50430787, 0.98507463],\n", - " [0.37574932, 0.3750718 , 0.98507463],\n", - " [0.24686649, 0.24641011, 1. ],\n", - " [0.12561308, 0.12349225, 0.97014925],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1171875 , 0.11153119, 0.98591549],\n", - " [0.22526042, 0.22448015, 1. ],\n", - " [0.33203125, 0.33175803, 0.97183099],\n", - " [0.44921875, 0.44305293, 0.98591549],\n", - " [0.55859375, 0.55529301, 1. ],\n", - " [0.67057292, 0.6665879 , 0.98591549],\n", - " [0.77604167, 0.77599244, 0.97183099],\n", - " [0.88802083, 0.88775992, 0.98591549],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88561525, 0.11497105, 1. ],\n", - " [0.77192374, 0.22746071, 0.97183099],\n", - " [0.6592721 , 0.33995037, 1. ],\n", - " [0.54696707, 0.45437 , 0.94366197],\n", - " [0.45233969, 0.55059278, 0.87323944],\n", - " [0.3407279 , 0.66087676, 0.98591549],\n", - " [0.22426343, 0.77695065, 1. ],\n", - " [0.11091854, 0.8891646 , 0.98591549],\n", - " [0. , 1. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91450777, 0.92163009, 0.8875 ],\n", - " [0.82279793, 0.84639498, 0.8875 ],\n", - " [0.73860104, 0.76489028, 0.8625 ],\n", - " [0.64585492, 0.68652038, 0.8875 ],\n", - " [0.56165803, 0.60815047, 0.8625 ],\n", - " [0.46917098, 0.52351097, 0.8875 ],\n", - " [0.38212435, 0.46081505, 0.8625 ],\n", - " [0.28367876, 0.37617555, 1. ],\n", - " [0.18134715, 0.25705329, 1. ],\n", - " [0.09015544, 0.12225705, 0.8875 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91088833, 0.10162602, 0.88607595],\n", - " [0.82066277, 0.20325203, 0.88607595],\n", - " [0.7315511 , 0.29268293, 0.89873418],\n", - " [0.64104706, 0.38211382, 0.89873418],\n", - " [0.55277082, 0.47560976, 0.86075949],\n", - " [0.4619883 , 0.56910569, 0.91139241],\n", - " [0.36090226, 0.66666667, 1. ],\n", - " [0.26984127, 0.75203252, 0.88607595],\n", - " [0.18156502, 0.83739837, 0.88607595],\n", - " [0.09161793, 0.90650407, 0.87341772],\n", - " [0. , 1. , 0.89873418]]),\n", - " array([[0. , 0.8368336 , 0. ],\n", - " [0.11335722, 0.93699515, 0.89873418],\n", - " [0.22569089, 1. , 0.88607595],\n", - " [0.35363357, 0.99030695, 1. ],\n", - " [0.46264074, 0.8723748 , 0.88607595],\n", - " [0.56704197, 0.68012924, 0.88607595],\n", - " [0.67349028, 0.453958 , 0.89873418],\n", - " [0.78019447, 0.26171244, 0.88607595],\n", - " [0.89124872, 0.12439418, 0.88607595],\n", - " [1. , 0. , 0.87341772]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09876543, 0.10189573, 0.98591549],\n", - " [0.20042028, 0.2014218 , 1. ],\n", - " [0.29944838, 0.30331754, 0.95774648],\n", - " [0.39952719, 0.40047393, 1. ],\n", - " [0.49960599, 0.50236967, 0.98591549],\n", - " [0.59994747, 0.59952607, 0.97183099],\n", - " [0.70028894, 0.70616114, 1. ],\n", - " [0.80194379, 0.8056872 , 0.98591549],\n", - " [0.90254794, 0.9028436 , 1. ],\n", - " [1. , 1. , 0.95774648]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89282178, 0.47619048, 0.91666667],\n", - " [0.78415842, 0.76190476, 1. ],\n", - " [0.67277228, 0.76190476, 0.91666667],\n", - " [0.56138614, 1. , 0.93055556],\n", - " [0.43985149, 0.85714286, 1. ],\n", - " [0.31559406, 0.76190476, 0.90277778],\n", - " [0.21460396, 0.71428571, 0.91666667],\n", - " [0.11633663, 0.71428571, 0.91666667],\n", - " [0. , 0.52380952, 0.93055556]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16842105, 0.17538555, 1. ],\n", - " [0.34035088, 0.34623526, 0.98630137],\n", - " [0.51428571, 0.51285153, 0.97260274],\n", - " [0.67468672, 0.66918657, 0.90410959],\n", - " [0.83057644, 0.83035984, 0.90410959],\n", - " [1. , 1. , 0.98630137]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11912034, 0.11916708, 0.86419753],\n", - " [0.23824068, 0.23532363, 0.86419753],\n", - " [0.35736103, 0.35173106, 0.85185185],\n", - " [0.49908369, 0.49121927, 1. ],\n", - " [0.63103238, 0.62418465, 0.97530864],\n", - " [0.75259621, 0.74460612, 0.87654321],\n", - " [0.86805131, 0.86251882, 0.85185185],\n", - " [1. , 1. , 0.97530864]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11085973, 0.11615487, 0.92424242],\n", - " [0.24384113, 0.25233645, 1. ],\n", - " [0.37405732, 0.3858478 , 0.98484848],\n", - " [0.48919055, 0.49933244, 0.92424242],\n", - " [0.61789844, 0.62616822, 1. ],\n", - " [0.74912016, 0.75300401, 1. ],\n", - " [0.8743087 , 0.87316422, 1. ],\n", - " [1. , 1. , 0.98484848]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.115727 , 0.11044705, 0.98507463],\n", - " [0.22848665, 0.22137222, 0.98507463],\n", - " [0.33531157, 0.33229739, 1. ],\n", - " [0.4421365 , 0.44489601, 0.98507463],\n", - " [0.55192878, 0.5543868 , 0.97014925],\n", - " [0.66765579, 0.66363854, 0.98507463],\n", - " [0.78041543, 0.77671528, 1. ],\n", - " [0.88724036, 0.88811858, 0.97014925],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89961176, 0.90430622, 0.98591549],\n", - " [0.79922352, 0.81339713, 0.98591549],\n", - " [0.70022185, 0.715311 , 0.98591549],\n", - " [0.59844703, 0.61363636, 1. ],\n", - " [0.5 , 0.51196172, 0.97183099],\n", - " [0.39794786, 0.40909091, 1. ],\n", - " [0.29811425, 0.30502392, 0.98591549],\n", - " [0.19994454, 0.19856459, 0.97183099],\n", - " [0.09872435, 0.09808612, 1. ],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89634748, 0.88903326, 0.79761905],\n", - " [0.79022705, 0.77988565, 0.77380952],\n", - " [0.69299112, 0.68035343, 0.72619048],\n", - " [0.58588351, 0.57016632, 0.77380952],\n", - " [0.4792695 , 0.46049896, 0.78571429],\n", - " [0.33711747, 0.32380457, 1. ],\n", - " [0.22408687, 0.21673597, 0.79761905],\n", - " [0.11105627, 0.10758836, 0.78571429],\n", - " [0. , 0. , 0.78571429]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13 , 0.12199112, 0.98765432],\n", - " [0.2425 , 0.23229727, 0.86419753],\n", - " [0.3475 , 0.34050012, 0.86419753],\n", - " [0.475 , 0.46249124, 1. ],\n", - " [0.585 , 0.56905819, 0.85185185],\n", - " [0.6875 , 0.67889694, 0.87654321],\n", - " [0.7925 , 0.78569759, 0.86419753],\n", - " [0.9 , 0.89483524, 0.86419753],\n", - " [1. , 1. , 0.85185185]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.84266834, 0.96865792, 0.82926829],\n", - " [0.67526746, 0.939191 , 0.86585366],\n", - " [0.50723726, 0.91079561, 0.85365854],\n", - " [0.33920705, 0.87945352, 0.84146341],\n", - " [0.18187539, 0.83927136, 0.82926829],\n", - " [0.06670862, 0.77685508, 0.7804878 ],\n", - " [0.01384519, 0.69193678, 0.75609756],\n", - " [0. , 0.5898741 , 0.76829268],\n", - " [0.02454374, 0.48566836, 0.7804878 ],\n", - " [0.04468219, 0.36967586, 0.85365854],\n", - " [0.04531152, 0.25448701, 0.85365854],\n", - " [0.05601007, 0.13822663, 0.84146341],\n", - " [0.05601007, 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14516129, 0.14243673, 1. ],\n", - " [0.28990902, 0.28457916, 0.98507463],\n", - " [0.43382961, 0.4267216 , 0.98507463],\n", - " [0.57733664, 0.56886404, 0.97014925],\n", - " [0.71588089, 0.71041789, 0.98507463],\n", - " [0.85897436, 0.85726898, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08260325, 0.91874694, 0.77777778],\n", - " [0.16739675, 0.83749388, 0.78888889],\n", - " [0.24937422, 0.7670093 , 0.76666667],\n", - " [0.33573217, 0.69309838, 0.78888889],\n", - " [0.42052566, 0.61674009, 0.78888889],\n", - " [0.4965582 , 0.52716593, 0.76666667],\n", - " [0.57478098, 0.43808125, 0.76666667],\n", - " [0.6548811 , 0.35633872, 0.78888889],\n", - " [0.76376721, 0.25648556, 1. ],\n", - " [0.83416771, 0.18502203, 0.67777778],\n", - " [0.9120776 , 0.09789525, 0.75555556],\n", - " [1. , 0. , 0.88888889]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.17448043, 0.17320169, 0.92307692],\n", - " [0.36104398, 0.35881523, 1. ],\n", - " [0.51909135, 0.51932299, 0.84615385],\n", - " [0.67182214, 0.67052186, 0.83333333],\n", - " [0.82745288, 0.82708039, 0.85897436],\n", - " [1. , 1. , 0.92307692]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12133228, 0.13953488, 0.91666667],\n", - " [0.24636532, 0.27906977, 0.91666667],\n", - " [0.36954798, 0.39534884, 0.91666667],\n", - " [0.49088025, 0.5 , 0.90277778],\n", - " [0.61644198, 0.62790698, 0.93055556],\n", - " [0.73988898, 0.73255814, 0.91666667],\n", - " [0.87549564, 0.88372093, 1. ],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12781955, 0.91399109, 0.5785124 ],\n", - " [0.2481203 , 0.82423248, 0.59504132],\n", - " [0.37593985, 0.73048981, 0.6446281 ],\n", - " [0.5037594 , 0.6444809 , 0.5785124 ],\n", - " [0.62406015, 0.54698852, 0.66115702],\n", - " [0.7518797 , 0.40239044, 1. ],\n", - " [0.7518797 , 0.29294586, 0.74380165],\n", - " [0.87969925, 0.20717131, 0.5785124 ],\n", - " [1. , 0.08600891, 0.81818182],\n", - " [1. , 0. , 0.58677686]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.94736842, 0.87674531, 0.9 ],\n", - " [0.86466165, 0.77106403, 0.79 ],\n", - " [0.7443609 , 0.6747713 , 0.71 ],\n", - " [0.66917293, 0.56571979, 0.8 ],\n", - " [0.4962406 , 0.44246509, 0.89 ],\n", - " [0.2481203 , 0.30548869, 1. ],\n", - " [0. , 0.20871449, 0.71 ],\n", - " [0.01503759, 0.11169957, 0.7 ],\n", - " [0.09774436, 0. , 0.8 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88895366, 0.88815394, 0.97222222],\n", - " [0.77674147, 0.77510523, 1. ],\n", - " [0.66569513, 0.66506314, 0.95833333],\n", - " [0.55639755, 0.55802766, 0.97222222],\n", - " [0.44622559, 0.44918821, 0.95833333],\n", - " [0.33226465, 0.33553818, 0.98611111],\n", - " [0.2212183 , 0.2230908 , 0.97222222],\n", - " [0.11221218, 0.11184606, 0.97222222],\n", - " [0. , 0. , 0.97222222]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86507206, 0.954047 , 0.60169492],\n", - " [0.72401104, 0.8386423 , 0.6779661 ],\n", - " [0.57988347, 0.66318538, 0.75423729],\n", - " [0.46366145, 0.52950392, 0.60169492],\n", - " [0.26617602, 0.30391645, 1. ],\n", - " [0.13308801, 0.15195822, 0.68644068],\n", - " [0. , 0. , 0.68644068]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1299435 , 0.13474026, 0.92424242],\n", - " [0.27791229, 0.29707792, 1. ],\n", - " [0.42157654, 0.45941558, 1. ],\n", - " [0.56497175, 0.59415584, 1. ],\n", - " [0.71294054, 0.73051948, 1. ],\n", - " [0.85633575, 0.86525974, 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.17650334, 0.17418351, 0.97260274],\n", - " [0.35022272, 0.34888543, 1. ],\n", - " [0.51057906, 0.50311042, 0.90410959],\n", - " [0.66982183, 0.66977709, 0.90410959],\n", - " [0.82516704, 0.82529808, 0.90410959],\n", - " [1. , 1. , 0.97260274]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90554791, 0.05406204, 0.97222222],\n", - " [0.80926181, 0.10664697, 0.98611111],\n", - " [0.70701513, 0.1633678 , 0.98611111],\n", - " [0.61256304, 0.22304284, 0.95833333],\n", - " [0.53278313, 0.29039882, 0.97222222],\n", - " [0.46217331, 0.36011817, 0.97222222],\n", - " [0.39431453, 0.43840473, 0.98611111],\n", - " [0.33975241, 0.51816839, 0.94444444],\n", - " [0.2783127 , 0.59763663, 1. ],\n", - " [0.22283356, 0.67710487, 0.97222222],\n", - " [0.16964695, 0.75864106, 0.95833333],\n", - " [0.11370931, 0.8437223 , 0.97222222],\n", - " [0.0522696 , 0.92703102, 0.97222222],\n", - " [0. , 1. , 0.84722222]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.51492537, 0.92191313, 0.77777778],\n", - " [0.73880597, 0.84309419, 0.76666667],\n", - " [0.96268657, 0.74280137, 1. ],\n", - " [1. , 0.66105417, 0.78888889],\n", - " [0.96268657, 0.58223524, 0.77777778],\n", - " [0.91791045, 0.50268424, 0.76666667],\n", - " [0.85820896, 0.4114202 , 0.91111111],\n", - " [0.79850746, 0.33235725, 0.75555556],\n", - " [0.75373134, 0.25207418, 0.78888889],\n", - " [0.69402985, 0.17179112, 0.77777778],\n", - " [0.65671642, 0.08223524, 0.88888889],\n", - " [0.58955224, 0. , 0.78888889]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90277404, 0.90537084, 0.85185185],\n", - " [0.80123889, 0.8056266 , 0.87654321],\n", - " [0.70401293, 0.71355499, 0.86419753],\n", - " [0.60463237, 0.60358056, 0.87654321],\n", - " [0.50605979, 0.50127877, 0.86419753],\n", - " [0.40883383, 0.40920716, 0.85185185],\n", - " [0.31079989, 0.31202046, 0.86419753],\n", - " [0.21088069, 0.21227621, 0.87654321],\n", - " [0.11553999, 0.11253197, 0.83950617],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91644562, 0.91833333, 0.87654321],\n", - " [0.83454907, 0.83541667, 0.86419753],\n", - " [0.75066313, 0.75166667, 0.87654321],\n", - " [0.66909814, 0.67041667, 0.85185185],\n", - " [0.58819629, 0.59 , 0.85185185],\n", - " [0.50431034, 0.50875 , 0.86419753],\n", - " [0.42208223, 0.42708333, 0.86419753],\n", - " [0.32625995, 0.33 , 1. ],\n", - " [0.23408488, 0.23833333, 0.97530864],\n", - " [0.15119363, 0.15458333, 0.86419753],\n", - " [0.07062334, 0.07083333, 0.86419753],\n", - " [0. , 0. , 0.75308642]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16398964, 0.16256158, 1. ],\n", - " [0.29637306, 0.29228243, 0.8 ],\n", - " [0.41062176, 0.40722496, 0.71 ],\n", - " [0.52512953, 0.52052545, 0.69 ],\n", - " [0.63937824, 0.63546798, 0.7 ],\n", - " [0.75518135, 0.75533662, 0.71 ],\n", - " [0.8857513 , 0.88341544, 0.8 ],\n", - " [1. , 1. , 0.7 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85601188, 0.8575983 , 1. ],\n", - " [0.71400297, 0.71572795, 0.98507463],\n", - " [0.57298367, 0.5727949 , 0.97014925],\n", - " [0.42998516, 0.4303932 , 1. ],\n", - " [0.28698664, 0.2869288 , 0.97014925],\n", - " [0.14448293, 0.14293305, 1. ],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.79546599, 0.22012579, 1. ],\n", - " [0.68816121, 0.33962264, 0.54615385],\n", - " [0.53098237, 0.49685535, 0.76153846],\n", - " [0.42241814, 0.59748428, 0.53846154],\n", - " [0.31486146, 0.71698113, 0.53846154],\n", - " [0.1302267 , 0.87421384, 0.92307692],\n", - " [0. , 1. , 0.62307692]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87784309, 0.87480438, 0.90410959],\n", - " [0.75210836, 0.74960876, 0.91780822],\n", - " [0.630207 , 0.62441315, 0.89041096],\n", - " [0.49348326, 0.48826291, 1. ],\n", - " [0.37004856, 0.36306729, 0.90410959],\n", - " [0.24559162, 0.23787167, 0.89041096],\n", - " [0.1216458 , 0.12050078, 0.91780822],\n", - " [0. , 0. , 0.89041096]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09758551, 0.15602606, 0.92222222],\n", - " [0.18175721, 0.29348534, 0.82222222],\n", - " [0.27800134, 0.43452769, 0.85555556],\n", - " [0.37391013, 0.53745928, 0.73333333],\n", - " [0.46981891, 0.62312704, 0.68888889],\n", - " [0.58718981, 0.70977199, 0.77777778],\n", - " [0.74279007, 0.81889251, 1. ],\n", - " [0.86049631, 0.90228013, 0.77777778],\n", - " [1. , 1. , 0.9 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16693214, 0.1671882 , 1. ],\n", - " [0.33418286, 0.33348234, 1. ],\n", - " [0.49824785, 0.49754135, 1. ],\n", - " [0.66772858, 0.6656236 , 1. ],\n", - " [0.83434215, 0.83236477, 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13866069, 0.15498938, 0.91666667],\n", - " [0.29424944, 0.29299363, 1. ],\n", - " [0.43340802, 0.42887473, 0.91666667],\n", - " [0.57879014, 0.56900212, 0.93055556],\n", - " [0.7154593 , 0.72186837, 0.90277778],\n", - " [0.86109037, 0.85774947, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13690312, 0.16226415, 1. ],\n", - " [0.26028153, 0.29433962, 0.91666667],\n", - " [0.39000828, 0.46415094, 0.91666667],\n", - " [0.51697488, 0.58490566, 0.91666667],\n", - " [0.64449351, 0.69056604, 0.93055556],\n", - " [0.7673199 , 0.86037736, 0.91666667],\n", - " [0.88683412, 0.96226415, 0.90277778],\n", - " [1. , 1. , 0.84722222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14438944, 0.14377289, 0.97014925],\n", - " [0.28025303, 0.28113553, 0.91044776],\n", - " [0.42986799, 0.43131868, 1. ],\n", - " [0.57975798, 0.58241758, 0.98507463],\n", - " [0.72222222, 0.72527473, 0.95522388],\n", - " [0.86221122, 0.86446886, 0.92537313],\n", - " [1. , 1. , 0.92537313]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.16226415, 0.8384 , 0.89041096],\n", - " [0.31059507, 0.68906667, 0.83561644],\n", - " [0.4862119 , 0.51573333, 0.90410959],\n", - " [0.66966618, 0.33493333, 0.89041096],\n", - " [0.82699565, 0.17333333, 1. ],\n", - " [1. , 0. , 0.90410959]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11443038, 0.12075472, 1. ],\n", - " [0.22759494, 0.23962264, 0.98507463],\n", - " [0.33873418, 0.34528302, 0.97014925],\n", - " [0.44860759, 0.47358491, 0.98507463],\n", - " [0.56 , 0.57358491, 0.98507463],\n", - " [0.6721519 , 0.67924528, 0.98507463],\n", - " [0.78405063, 0.80943396, 1. ],\n", - " [0.89316456, 0.9 , 0.97014925],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8741226 , 0.87664114, 0.94366197],\n", - " [0.75198877, 0.75519694, 0.91549296],\n", - " [0.6284511 , 0.63129103, 0.92957746],\n", - " [0.50444548, 0.50738512, 0.94366197],\n", - " [0.38090781, 0.38293217, 0.92957746],\n", - " [0.25409453, 0.2571116 , 0.92957746],\n", - " [0.12306972, 0.12527352, 1. ],\n", - " [0. , 0. , 0.92957746]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1203376 , 0.11774461, 0.90277778],\n", - " [0.25564933, 0.25870647, 1. ],\n", - " [0.37544242, 0.39137645, 0.91666667],\n", - " [0.51075415, 0.53565506, 1. ],\n", - " [0.62918595, 0.65339967, 0.91666667],\n", - " [0.75333515, 0.76451078, 0.93055556],\n", - " [0.87802886, 0.88059701, 0.90277778],\n", - " [1. , 1. , 0.93055556]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12348668, 0.12221095, 0.87804878],\n", - " [0.24455206, 0.24137931, 0.82926829],\n", - " [0.38256659, 0.38057809, 1. ],\n", - " [0.50121065, 0.4994929 , 0.82926829],\n", - " [0.63922518, 0.63894523, 1. ],\n", - " [0.76029056, 0.75887424, 0.84146341],\n", - " [0.87893462, 0.87981744, 0.86585366],\n", - " [1. , 1. , 0.85365854]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09476534, 0.90813397, 1. ],\n", - " [0.18592058, 0.81578947, 0.98591549],\n", - " [0.27436823, 0.7222488 , 0.98591549],\n", - " [0.36552347, 0.6284689 , 0.98591549],\n", - " [0.4467509 , 0.5492823 , 0.85915493],\n", - " [0.53429603, 0.45645933, 0.97183099],\n", - " [0.61281588, 0.36363636, 0.97183099],\n", - " [0.68592058, 0.28157895, 0.85915493],\n", - " [0.7734657 , 0.18755981, 1. ],\n", - " [0.89259928, 0.09497608, 0.98591549],\n", - " [1. , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88640815, 0.88275862, 1. ],\n", - " [0.77634156, 0.76827586, 0.95833333],\n", - " [0.66666667, 0.65310345, 0.95833333],\n", - " [0.55346651, 0.5362069 , 0.97222222],\n", - " [0.44457501, 0.42275862, 0.97222222],\n", - " [0.33333333, 0.30793103, 0.98611111],\n", - " [0.21699961, 0.19931034, 0.95833333],\n", - " [0.11594203, 0.1062069 , 0.84722222],\n", - " [0. , 0. , 0.95833333]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89111593, 0.88541667, 0.85365854],\n", - " [0.78060672, 0.77083333, 0.86585366],\n", - " [0.66982665, 0.65451389, 0.86585366],\n", - " [0.56040087, 0.54166667, 0.84146341],\n", - " [0.45287107, 0.4375 , 0.86585366],\n", - " [0.34588299, 0.33159722, 0.82926829],\n", - " [0.23510293, 0.22395833, 0.85365854],\n", - " [0.12784399, 0.12152778, 0.85365854],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.0923913 , 0.9196409 , 0.63888889],\n", - " [0.0923913 , 0.85395227, 0.56481481],\n", - " [0.18478261, 0.77381213, 0.65740741],\n", - " [0.18478261, 0.68622728, 0.73148148],\n", - " [0.27173913, 0.59864243, 0.73148148],\n", - " [0.36413043, 0.51828334, 0.66666667],\n", - " [0.54347826, 0.39785417, 1. ],\n", - " [0.63586957, 0.29559886, 0.84259259],\n", - " [0.72826087, 0.20078826, 0.82407407],\n", - " [0.81521739, 0.10225531, 0.83333333],\n", - " [1. , 0. , 0.83333333]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.83921016, 0.83811262, 0.91549296],\n", - " [0.67606958, 0.67335766, 0.92957746],\n", - " [0.51104843, 0.50834202, 0.92957746],\n", - " [0.34508698, 0.34410845, 0.92957746],\n", - " [0.18053597, 0.17935349, 0.94366197],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09046214, 0.08468873, 0.95833333],\n", - " [0.20648968, 0.15647785, 0.98611111],\n", - " [0.31563422, 0.20386988, 0.84722222],\n", - " [0.4473943 , 0.25182277, 0.97222222],\n", - " [0.5840708 , 0.29781268, 0.97222222],\n", - " [0.71583088, 0.34548514, 0.95833333],\n", - " [0.82645034, 0.40437465, 0.95833333],\n", - " [0.91445428, 0.47504206, 0.98611111],\n", - " [0.96951819, 0.54879417, 0.84722222],\n", - " [1. , 0.64890634, 0.95833333],\n", - " [0.99410029, 0.76135726, 0.98611111],\n", - " [0.97689282, 0.87521032, 0.94444444],\n", - " [0.95231072, 1. , 1. ]]),\n", - " array([[1. , 0.3 , 0. ],\n", - " [0.89031912, 0.2 , 0.984375 ],\n", - " [0.77607938, 0.2 , 0.984375 ],\n", - " [0.66237597, 0. , 0.984375 ],\n", - " [0.55457227, 0.1 , 0.984375 ],\n", - " [0.44220971, 0.3 , 0.984375 ],\n", - " [0.33172432, 0.6 , 0.96875 ],\n", - " [0.21909359, 0.6 , 1. ],\n", - " [0.11021722, 1. , 0.96875 ],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10846995, 0.03846154, 0.98591549],\n", - " [0.21830601, 0.07051282, 0.98591549],\n", - " [0.32650273, 0.10897436, 0.97183099],\n", - " [0.43579235, 0.16025641, 0.98591549],\n", - " [0.5489071 , 0.30448718, 0.98591549],\n", - " [0.66229508, 0.48076923, 1. ],\n", - " [0.77295082, 0.65384615, 0.97183099],\n", - " [0.88360656, 0.83012821, 0.98591549],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88127854, 0.11935921, 0.84615385],\n", - " [0.75913242, 0.23668773, 0.84615385],\n", - " [0.63013699, 0.36732852, 0.91025641],\n", - " [0.51255708, 0.48713899, 0.85897436],\n", - " [0.39269406, 0.60740072, 0.84615385],\n", - " [0.2716895 , 0.72901625, 0.85897436],\n", - " [0.14269406, 0.85785199, 0.91025641],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.14477612, 0.74930362, 1. ],\n", - " [0.28532338, 0.5097493 , 0.97014925],\n", - " [0.43283582, 0.28133705, 1. ],\n", - " [0.5761194 , 0.08077994, 0.97014925],\n", - " [0.72039801, 0. , 0.98507463],\n", - " [0.86641791, 0.03064067, 1. ],\n", - " [1. , 0.05571031, 0.91044776]]),\n", - " array([[1. , 0.0625 , 0. ],\n", - " [0.88338271, 0. , 0.61068702],\n", - " [0.77673041, 0.1875 , 0.53435115],\n", - " [0.67250202, 0.25 , 0.53435115],\n", - " [0.56881228, 0.1875 , 0.53435115],\n", - " [0.46593051, 0.375 , 0.52671756],\n", - " [0.26986264, 0.5625 , 1. ],\n", - " [0.13493132, 0.8125 , 0.6870229 ],\n", - " [0. , 1. , 0.6870229 ]]),\n", - " array([[1. , 0.4516129 , 0. ],\n", - " [0.96747738, 0.36856555, 0.79012346],\n", - " [0.92449095, 0.33081675, 0.82716049],\n", - " [0.87754525, 0.30885381, 0.85185185],\n", - " [0.82664027, 0.2889499 , 0.86419753],\n", - " [0.77516968, 0.26835964, 0.86419753],\n", - " [0.72285068, 0.25463281, 0.87654321],\n", - " [0.66855204, 0.24021963, 0.86419753],\n", - " [0.61340498, 0.22443377, 0.85185185],\n", - " [0.55627828, 0.20727522, 0.88888889],\n", - " [0.50084842, 0.19492107, 0.83950617],\n", - " [0.44739819, 0.18256692, 0.87654321],\n", - " [0.39649321, 0.17227179, 0.85185185],\n", - " [0.34756787, 0.16060398, 0.86419753],\n", - " [0.30090498, 0.15305422, 0.87654321],\n", - " [0.25735294, 0.13452299, 0.86419753],\n", - " [0.22143665, 0.09608785, 0.86419753],\n", - " [0.19117647, 0.05284832, 0.86419753],\n", - " [0.15865385, 0.00960879, 1. ],\n", - " [0.12895928, 0. , 0.85185185],\n", - " [0.09615385, 0.03088538, 0.86419753],\n", - " [0.06617647, 0.08647907, 0.85185185],\n", - " [0.04100679, 0.1674674 , 0.87654321],\n", - " [0.02856335, 0.2676733 , 0.86419753],\n", - " [0.02432127, 0.37542896, 0.85185185],\n", - " [0.01979638, 0.49485244, 0.86419753],\n", - " [0.0155543 , 0.62251201, 0.87654321],\n", - " [0.01074661, 0.74742622, 0.85185185],\n", - " [0.0053733 , 0.87508579, 0.86419753],\n", - " [0. , 1. , 0.87654321]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89447486, 0.89591386, 0.80898876],\n", - " [0.79243405, 0.7923799 , 0.76404494],\n", - " [0.67297163, 0.67145224, 0.91011236],\n", - " [0.57192633, 0.56985091, 0.78651685],\n", - " [0.45047287, 0.44864716, 0.88764045],\n", - " [0.34843206, 0.3451132 , 0.78651685],\n", - " [0.22399204, 0.22197681, 0.91011236],\n", - " [0.09059233, 0.09110988, 1. ],\n", - " [0. , 0. , 0.68539326]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.07497714, 0.09354005, 0.7625 ],\n", - " [0.1722036 , 0.2124031 , 0.975 ],\n", - " [0.25083816, 0.30284238, 0.7625 ],\n", - " [0.33008229, 0.38242894, 0.7625 ],\n", - " [0.43523316, 0.48062016, 0.975 ],\n", - " [0.5184395 , 0.55710594, 0.775 ],\n", - " [0.62511429, 0.65529716, 0.9875 ],\n", - " [0.70649192, 0.73023256, 0.7625 ],\n", - " [0.81316672, 0.82739018, 0.9875 ],\n", - " [0.91923194, 0.92661499, 1. ],\n", - " [1. , 1. , 0.7625 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87470135, 0.12380416, 1. ],\n", - " [0.75126095, 0.2447946 , 0.97014925],\n", - " [0.6339262 , 0.3629713 , 0.91044776],\n", - " [0.50836209, 0.4895892 , 0.98507463],\n", - " [0.38093974, 0.61733258, 0.97014925],\n", - " [0.25298646, 0.74563872, 0.98507463],\n", - " [0.12874967, 0.86944288, 0.98507463],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88743039, 0.88480663, 0.98507463],\n", - " [0.77684964, 0.77541436, 0.97014925],\n", - " [0.66865553, 0.66381215, 1. ],\n", - " [0.55608592, 0.55331492, 0.98507463],\n", - " [0.4451074 , 0.44254144, 0.97014925],\n", - " [0.33571997, 0.33093923, 0.98507463],\n", - " [0.22434368, 0.2218232 , 1. ],\n", - " [0.11018298, 0.10883978, 0.98507463],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14588305, 0.1395655 , 1. ],\n", - " [0.28818616, 0.27781435, 0.97014925],\n", - " [0.43078759, 0.41935484, 0.98507463],\n", - " [0.57547733, 0.55892034, 0.98507463],\n", - " [0.72106205, 0.70046083, 1. ],\n", - " [0.86127685, 0.8439763 , 0.97014925],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86649215, 0.13206181, 0.78823529],\n", - " [0.73298429, 0.2648479 , 0.77647059],\n", - " [0.59685864, 0.39666828, 0.76470588],\n", - " [0.42670157, 0.56711733, 1. ],\n", - " [0.27748691, 0.72163206, 0.90588235],\n", - " [0.13612565, 0.86576533, 0.85882353],\n", - " [0. , 1. , 0.77647059]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10826873, 0.10446344, 0.94366197],\n", - " [0.21524548, 0.21367521, 0.92957746],\n", - " [0.31757106, 0.31623932, 0.88732394],\n", - " [0.43152455, 0.42545109, 0.97183099],\n", - " [0.54315245, 0.54226021, 0.97183099],\n", - " [0.65865633, 0.65242165, 1. ],\n", - " [0.77416021, 0.76923077, 1. ],\n", - " [0.88552972, 0.88793922, 0.97183099],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0.55557847, 0.33853702, 0. ],\n", - " [0.59826768, 0.29549509, 0.0020017 ],\n", - " [0.61889049, 0.27319358, 0.00116766],\n", - " [0.63910085, 0.25223015, 0.00118434],\n", - " [0.66240462, 0.22725245, 0.00131779],\n", - " [0.68735822, 0.20049063, 0.00131779],\n", - " [0.70983708, 0.17662801, 0.00118434],\n", - " [0.74840173, 0.14295272, 0.00181821],\n", - " [0.77892349, 0.1206512 , 0.00135115],\n", - " [0.84697876, 0.07850134, 0.00281906],\n", - " [0.90843473, 0.04281891, 0.00268562],\n", - " [0.94060631, 0.0249777 , 0.00150128],\n", - " [0.98803877, 0.00356824, 0.00265225],\n", - " [1. , 0.00958965, 0.00125106],\n", - " [0.9919571 , 0.01516503, 0.0024354 ],\n", - " [0.98577026, 0.00646744, 0.00106757],\n", - " [0.98247061, 0. , 0.00143455],\n", - " [0.9632914 , 0.0073595 , 0.00333617],\n", - " [0.94823675, 0.01873327, 0.00118434],\n", - " [0.92905754, 0.029438 , 0.0011343 ],\n", - " [0.90657868, 0.04281891, 0.00118434],\n", - " [0.88409981, 0.05553078, 0.00116766],\n", - " [0.84553516, 0.07627119, 0.0020017 ],\n", - " [0.80263972, 0.09968778, 0.00233532],\n", - " [0.77273665, 0.11663693, 0.0016514 ],\n", - " [0.74530831, 0.13470116, 0.00150128],\n", - " [0.70694989, 0.16703836, 0.00233532],\n", - " [0.66426067, 0.21008029, 0.00285242],\n", - " [0.63641988, 0.23728814, 0.00183489],\n", - " [0.597649 , 0.27408564, 0.00250213],\n", - " [0.55599093, 0.31400535, 0.00265225],\n", - " [0.51350794, 0.35660125, 0.00266894],\n", - " [0.4809239 , 0.39250669, 0.00216851],\n", - " [0.45968241, 0.41413916, 0.00135115],\n", - " [0.43184162, 0.44446922, 0.00183489],\n", - " [0.41451846, 0.46431757, 0.00116766],\n", - " [0.39802021, 0.48438894, 0.00118434],\n", - " [0.38296556, 0.50646744, 0.00115098],\n", - " [0.34543205, 0.56043711, 0.00298587],\n", - " [0.32171582, 0.59299732, 0.00186825],\n", - " [0.30707362, 0.61418376, 0.0011343 ],\n", - " [0.23757476, 0.70963426, 0.0040034 ],\n", - " [0.17302537, 0.78099911, 0.00351966],\n", - " [0.14415343, 0.80798394, 0.0020017 ],\n", - " [0.11198185, 0.83920607, 0.00300255],\n", - " [0.09362755, 0.85191793, 0.00248545],\n", - " [0.0866158 , 0.85793934, 0.00186825],\n", - " [0.08166632, 0.86351472, 0.0016514 ],\n", - " [0.07877913, 0.86574487, 0.0014846 ],\n", - " [0.07382966, 0.86797502, 0.00468732],\n", - " [0.07073623, 0.86864407, 0.08362108],\n", - " [0.07259229, 0.86819804, 0.00598842],\n", - " [0.07135492, 0.8706512 , 1. ],\n", - " [0.07238606, 0.86864407, 0.00895761],\n", - " [0.07094246, 0.87154326, 0.08410482],\n", - " [0.07238606, 0.86864407, 0.00303591],\n", - " [0.06949887, 0.86953613, 0.36332549],\n", - " [0.07259229, 0.86819804, 0.00295251],\n", - " [0.07135492, 0.87109723, 0.06907538],\n", - " [0.07238606, 0.8690901 , 0.00301923],\n", - " [0.07073623, 0.87310437, 0.15319688],\n", - " [0.06743658, 0.88983051, 0.00290247],\n", - " [0.05898123, 0.90321142, 0.00126774],\n", - " [0.04681378, 0.91971454, 0.00116766],\n", - " [0.03134667, 0.93956289, 0.00116766],\n", - " [0.01546711, 0.9647636 , 0.00118434],\n", - " [0. , 1. , 0.00115098]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.83478009, 0.16591115, 1. ],\n", - " [0.6646412 , 0.33544878, 0.98507463],\n", - " [0.49826389, 0.50135993, 0.97014925],\n", - " [0.34085648, 0.66001813, 0.91044776],\n", - " [0.171875 , 0.82864914, 0.98507463],\n", - " [0. , 1. , 0.97014925]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11291224, 0.1025 , 0.95774648],\n", - " [0.21352711, 0.21777778, 0.97183099],\n", - " [0.32643935, 0.33944444, 1. ],\n", - " [0.43152599, 0.44138889, 0.85915493],\n", - " [0.54723309, 0.55527778, 0.97183099],\n", - " [0.66741196, 0.67361111, 1. ],\n", - " [0.78088317, 0.78583333, 0.97183099],\n", - " [0.89938513, 0.90138889, 0.97183099],\n", - " [1. , 1. , 0.85915493]]),\n", - " array([[0.29007634, 0. , 0. ],\n", - " [0.21374046, 0.09984609, 0.50387597],\n", - " [0.10687023, 0.19584456, 0.48062016],\n", - " [0.00763359, 0.31377453, 0.58914729],\n", - " [0. , 0.4107349 , 0.48062016],\n", - " [0.02290076, 0.50673336, 0.48062016],\n", - " [0.2519084 , 0.63524432, 0.62790698],\n", - " [0.85496183, 0.80088496, 0.8372093 ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15813028, 0.15571708, 1. ],\n", - " [0.30084535, 0.29326251, 0.90410959],\n", - " [0.44256589, 0.43388314, 0.90410959],\n", - " [0.58229736, 0.57170814, 0.89041096],\n", - " [0.72650423, 0.71764048, 0.91780822],\n", - " [0.86176032, 0.85826111, 0.90410959],\n", - " [1. , 1. , 0.90410959]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90099938, 0.90231171, 0.88607595],\n", - " [0.80293567, 0.80275913, 0.88607595],\n", - " [0.70487196, 0.70469799, 0.88607595],\n", - " [0.60493442, 0.60514541, 0.89873418],\n", - " [0.50780762, 0.50894855, 0.87341772],\n", - " [0.408807 , 0.40976883, 0.88607595],\n", - " [0.29793879, 0.29828486, 1. ],\n", - " [0.19706433, 0.19873229, 0.89873418],\n", - " [0.09962523, 0.09992543, 0.87341772],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13313609, 0.13158516, 0.90277778],\n", - " [0.27218935, 0.2605717 , 0.93055556],\n", - " [0.39053254, 0.38625089, 0.91666667],\n", - " [0.52366864, 0.52043468, 1. ],\n", - " [0.64497041, 0.64186156, 0.91666667],\n", - " [0.76923077, 0.76234349, 0.91666667],\n", - " [0.8816568 , 0.88188046, 0.91666667],\n", - " [1. , 1. , 0.90277778]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89259259, 0.11350796, 0.8625 ],\n", - " [0.8 , 0.20852594, 0.7625 ],\n", - " [0.68518519, 0.32280431, 0.8875 ],\n", - " [0.56888889, 0.43888033, 0.875 ],\n", - " [0.45925926, 0.55059065, 0.85 ],\n", - " [0.36444444, 0.64560863, 0.7625 ],\n", - " [0.23185185, 0.7742681 , 1. ],\n", - " [0.11481481, 0.88854648, 0.875 ],\n", - " [0. , 1. , 0.8875 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91712707, 0.08315514, 0.875 ],\n", - " [0.83867403, 0.1644096 , 0.875 ],\n", - " [0.75359116, 0.2482775 , 0.875 ],\n", - " [0.6839779 , 0.31765265, 0.7625 ],\n", - " [0.59889503, 0.40080779, 0.875 ],\n", - " [0.51381215, 0.48562604, 0.875 ],\n", - " [0.43093923, 0.56830601, 0.875 ],\n", - " [0.33149171, 0.66809218, 1. ],\n", - " [0.25303867, 0.74839629, 0.875 ],\n", - " [0.16464088, 0.8372535 , 0.875 ],\n", - " [0.08176796, 0.91708244, 0.875 ],\n", - " [0. , 1. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10736424, 0.12337662, 0.88607595],\n", - " [0.22266303, 0.25324675, 0.89873418],\n", - " [0.33027523, 0.35064935, 0.87341772],\n", - " [0.43020084, 0.45454545, 0.7721519 ],\n", - " [0.54103645, 0.55194805, 0.87341772],\n", - " [0.64716092, 0.67532468, 0.87341772],\n", - " [0.75998016, 0.80519481, 0.91139241],\n", - " [0.88817258, 0.90909091, 1. ],\n", - " [1. , 1. , 0.89873418]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89120178, 0.89985591, 0.875 ],\n", - " [0.76325284, 0.78314121, 1. ],\n", - " [0.65473217, 0.68299712, 0.875 ],\n", - " [0.54537885, 0.57204611, 0.875 ],\n", - " [0.4346378 , 0.4574928 , 0.875 ],\n", - " [0.32722731, 0.34365994, 0.8625 ],\n", - " [0.21842909, 0.22766571, 0.8875 ],\n", - " [0.1110186 , 0.11455331, 0.8625 ],\n", - " [0. , 0. , 0.8875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1171831 , 0.1095176 , 1. ],\n", - " [0.22985915, 0.2398957 , 1. ],\n", - " [0.34732394, 0.34810952, 1. ],\n", - " [0.46 , 0.45632334, 0.97142857],\n", - " [0.55859155, 0.56584094, 0.87142857],\n", - " [0.67126761, 0.67405476, 1. ],\n", - " [0.77464789, 0.78226858, 0.87142857],\n", - " [0.88253521, 0.89178618, 0.98571429],\n", - " [1. , 1. , 0.98571429]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.25 , 0.11624297, 1. ],\n", - " [0.45 , 0.22375315, 1. ],\n", - " [0.6 , 0.34193674, 0.96875 ],\n", - " [0.7 , 0.44944692, 0.984375 ],\n", - " [0.9 , 0.56957112, 0.984375 ],\n", - " [0.95 , 0.67746944, 0.953125 ],\n", - " [0.95 , 0.78497962, 0.953125 ],\n", - " [1. , 0.89268387, 0.953125 ],\n", - " [0.9 , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92313788, 0.90489914, 0.98611111],\n", - " [0.84812467, 0.81556196, 0.95833333],\n", - " [0.77126255, 0.73775216, 0.97222222],\n", - " [0.6967776 , 0.65417867, 0.95833333],\n", - " [0.61938722, 0.56195965, 1. ],\n", - " [0.54358162, 0.4870317 , 0.94444444],\n", - " [0.46698362, 0.43227666, 0.98611111],\n", - " [0.38880085, 0.37175793, 0.97222222],\n", - " [0.31220285, 0.31123919, 0.97222222],\n", - " [0.23454834, 0.24495677, 0.95833333],\n", - " [0.15662969, 0.16426513, 0.98611111],\n", - " [0.07686212, 0.0778098 , 0.98611111],\n", - " [0. , 0. , 0.94444444]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87902716, 0.12082159, 0.98507463],\n", - " [0.75268478, 0.24848973, 0.98507463],\n", - " [0.62634239, 0.36931132, 0.98507463],\n", - " [0.5 , 0.4901329 , 1. ],\n", - " [0.37365761, 0.61739831, 0.97014925],\n", - " [0.25268478, 0.74506645, 0.98507463],\n", - " [0.12634239, 0.8727346 , 0.98507463],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.05468026, 0.04773791, 0.875 ],\n", - " [0.10704356, 0.09765991, 0.875 ],\n", - " [0.1570899 , 0.14633385, 0.8625 ],\n", - " [0.20296571, 0.19937598, 0.875 ],\n", - " [0.2557924 , 0.25429017, 1. ],\n", - " [0.30722892, 0.30577223, 0.8875 ],\n", - " [0.35681186, 0.35631825, 0.8625 ],\n", - " [0.40871177, 0.40686427, 0.8875 ],\n", - " [0.46478221, 0.46365055, 1. ],\n", - " [0.51529194, 0.51419657, 0.875 ],\n", - " [0.56719184, 0.56474259, 0.875 ],\n", - " [0.61584801, 0.61185647, 0.8625 ],\n", - " [0.66774791, 0.6599064 , 0.8875 ],\n", - " [0.71269694, 0.70982839, 0.875 ],\n", - " [0.76088971, 0.7575663 , 0.875 ],\n", - " [0.81278962, 0.80561622, 0.8625 ],\n", - " [0.85912882, 0.85335413, 0.875 ],\n", - " [0.90361446, 0.90171607, 0.875 ],\n", - " [0.95088044, 0.95070203, 0.8875 ],\n", - " [1. , 1. , 0.8625 ]]),\n", - " array([[1. , 0.09090909, 0. ],\n", - " [0.88365727, 0.54545455, 1. ],\n", - " [0.77388448, 1. , 1. ],\n", - " [0.66329045, 0.72727273, 0.98571429],\n", - " [0.55899261, 0.45454545, 0.87142857],\n", - " [0.44894607, 0.45454545, 1. ],\n", - " [0.33397208, 0.27272727, 1. ],\n", - " [0.22447304, 0. , 0.98571429],\n", - " [0.11004654, 0. , 1. ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89365122, 0.89690722, 0.87341772],\n", - " [0.78569515, 0.7812142 , 0.88607595],\n", - " [0.67398875, 0.66895762, 0.89873418],\n", - " [0.5657648 , 0.55441008, 0.88607595],\n", - " [0.45754085, 0.45475372, 0.88607595],\n", - " [0.33351192, 0.32531501, 1. ],\n", - " [0.22153764, 0.21993127, 0.89873418],\n", - " [0.11197428, 0.10538373, 0.88607595],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.83310947, 0.16734034, 1. ],\n", - " [0.6692411 , 0.33225546, 0.98507463],\n", - " [0.49932841, 0.50080841, 0.98507463],\n", - " [0.33344527, 0.66855295, 0.98507463],\n", - " [0.16655473, 0.83306386, 0.98507463],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.04642758, 0.02919708, 0.49586777],\n", - " [0.09285516, 0.06131387, 0.49311295],\n", - " [0.15429525, 0.10364964, 0.66115702],\n", - " [0.20155685, 0.14306569, 0.50413223],\n", - " [0.24826244, 0.18686131, 0.48760331],\n", - " [0.29524604, 0.22919708, 0.49586777],\n", - " [0.34278565, 0.27737226, 0.49862259],\n", - " [0.39143731, 0.32262774, 0.50137741],\n", - " [0.43842091, 0.36642336, 0.49586777],\n", - " [0.48457048, 0.41167883, 0.49311295],\n", - " [0.53183208, 0.45839416, 0.49586777],\n", - " [0.57853767, 0.49927007, 0.49862259],\n", - " [0.62496525, 0.54452555, 0.49586777],\n", - " [0.67083681, 0.60145985, 0.49311295],\n", - " [0.764804 , 0.7080292 , 0.9862259 ],\n", - " [0.85988324, 0.8189781 , 1. ],\n", - " [0.90631081, 0.87737226, 0.49586777],\n", - " [0.95273839, 0.93722628, 0.48760331],\n", - " [1. , 1. , 0.50413223]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8052017 , 0.09638554, 0.98591549],\n", - " [0.62845011, 0.17570281, 0.85915493],\n", - " [0.46921444, 0.25527108, 0.85915493],\n", - " [0.30997877, 0.33057229, 0.85915493],\n", - " [0.18577495, 0.41842369, 0.87323944],\n", - " [0.12420382, 0.52309237, 0.94366197],\n", - " [0.08864119, 0.64006024, 0.98591549],\n", - " [0.06581741, 0.76029116, 0.97183099],\n", - " [0.0403397 , 0.88002008, 0.98591549],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.68845121, 0.07122371, 0.97183099],\n", - " [0.38137869, 0.14244742, 0.98591549],\n", - " [0.13428827, 0.22848948, 0.98591549],\n", - " [0.0080573 , 0.31859465, 0.88732394],\n", - " [0. , 0.40989484, 0.95774648],\n", - " [0.04297225, 0.49545889, 0.97183099],\n", - " [0.09131603, 0.57767686, 1. ],\n", - " [0.13876455, 0.65463671, 0.97183099],\n", - " [0.18173679, 0.73111855, 1. ],\n", - " [0.23187108, 0.81070746, 0.95774648],\n", - " [0.29364369, 0.90081262, 1. ],\n", - " [0.36794987, 1. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.94292453, 0.04454148, 0.87341772],\n", - " [0.87924528, 0.09723435, 0.88607595],\n", - " [0.82358491, 0.13275109, 0.88607595],\n", - " [0.75896226, 0.18427948, 0.88607595],\n", - " [0.70188679, 0.22066958, 0.89873418],\n", - " [0.63820755, 0.26055313, 0.88607595],\n", - " [0.56650943, 0.3062591 , 1. ],\n", - " [0.50849057, 0.35283843, 0.7721519 ],\n", - " [0.44858491, 0.39388646, 0.86075949],\n", - " [0.38773585, 0.42649199, 0.88607595],\n", - " [0.32830189, 0.46870451, 0.89873418],\n", - " [0.26462264, 0.51120815, 0.88607595],\n", - " [0.21792453, 0.56040757, 0.89873418],\n", - " [0.18632075, 0.6154294 , 0.88607595],\n", - " [0.16132075, 0.66870451, 0.86075949],\n", - " [0.13443396, 0.72489083, 0.89873418],\n", - " [0.10566038, 0.77962154, 0.88607595],\n", - " [0.08207547, 0.82852984, 0.7721519 ],\n", - " [0.05377358, 0.88471616, 0.87341772],\n", - " [0.02830189, 0.94061135, 0.88607595],\n", - " [0. , 1. , 0.88607595]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10866373, 0.11042065, 1. ],\n", - " [0.22026432, 0.22179732, 1. ],\n", - " [0.32892805, 0.33365201, 1. ],\n", - " [0.43318649, 0.44407266, 1. ],\n", - " [0.54478708, 0.55544933, 1. ],\n", - " [0.65638767, 0.666826 , 1. ],\n", - " [0.76651982, 0.77844168, 1. ],\n", - " [0.88105727, 0.88910134, 0.98484848],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09164312, 0.0915357 , 0.92307692],\n", - " [0.18368995, 0.18389854, 0.8974359 ],\n", - " [0.27048849, 0.27102288, 0.8974359 ],\n", - " [0.35809447, 0.35787152, 0.87179487],\n", - " [0.45094873, 0.44995864, 0.91025641],\n", - " [0.54178442, 0.54121864, 0.91025641],\n", - " [0.6439241 , 0.64433416, 1. ],\n", - " [0.73274122, 0.73338848, 0.92307692],\n", - " [0.82034719, 0.82078853, 0.87179487],\n", - " [0.91239403, 0.91315136, 0.92307692],\n", - " [1. , 1. , 0.88461538]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.16833612, 0.84359862, 1. ],\n", - " [0.3344463 , 0.68650519, 1. ],\n", - " [0.50083472, 0.51695502, 1. ],\n", - " [0.66694491, 0.34117647, 1. ],\n", - " [0.83416806, 0.16539792, 1. ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89912281, 0.89830508, 0.875 ],\n", - " [0.79927761, 0.78644068, 0.8625 ],\n", - " [0.70975232, 0.69830508, 0.775 ],\n", - " [0.61068111, 0.59661017, 0.875 ],\n", - " [0.50928793, 0.48813559, 0.8625 ],\n", - " [0.42027864, 0.41016949, 0.7625 ],\n", - " [0.30417957, 0.31186441, 1. ],\n", - " [0.20485036, 0.20677966, 0.8625 ],\n", - " [0.10113519, 0.10169492, 0.8875 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92248377, 0.07721893, 0.875 ],\n", - " [0.84780844, 0.15207101, 0.875 ],\n", - " [0.76988636, 0.22781065, 0.875 ],\n", - " [0.69358766, 0.30532544, 0.8875 ],\n", - " [0.60795455, 0.39260355, 1. ],\n", - " [0.53043831, 0.46775148, 0.875 ],\n", - " [0.44439935, 0.55532544, 0.9875 ],\n", - " [0.36810065, 0.6316568 , 0.875 ],\n", - " [0.29261364, 0.70591716, 0.8625 ],\n", - " [0.22727273, 0.77189349, 0.7625 ],\n", - " [0.15097403, 0.84940828, 0.8875 ],\n", - " [0.07305195, 0.92633136, 0.875 ],\n", - " [0. , 1. , 0.85 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.84960422, 0.85021603, 1. ],\n", - " [0.7005277 , 0.69899184, 1. ],\n", - " [0.55145119, 0.55280845, 1. ],\n", - " [0.40897098, 0.40902544, 1. ],\n", - " [0.26649077, 0.26836294, 0.98484848],\n", - " [0.13720317, 0.14042247, 0.92424242],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08991228, 0.09179894, 0.97183099],\n", - " [0.17909357, 0.18386243, 1. ],\n", - " [0.25438596, 0.26243386, 0.85915493],\n", - " [0.33625731, 0.34973545, 0.95774648],\n", - " [0.42032164, 0.43915344, 0.98591549],\n", - " [0.49342105, 0.51560847, 0.85915493],\n", - " [0.57894737, 0.60502646, 0.98591549],\n", - " [0.6630117 , 0.69417989, 1. ],\n", - " [0.73976608, 0.77777778, 0.98591549],\n", - " [0.81359649, 0.85767196, 0.97183099],\n", - " [0.90423977, 0.93121693, 0.98591549],\n", - " [1. , 1. , 0.97183099]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89095574, 0.11177885, 0.73493976],\n", - " [0.76908275, 0.23036859, 0.79518072],\n", - " [0.64849262, 0.34855769, 0.78313253],\n", - " [0.52501604, 0.47636218, 0.80722892],\n", - " [0.39576652, 0.60376603, 0.85542169],\n", - " [0.27100706, 0.72836538, 0.80722892],\n", - " [0.15426555, 0.84735577, 0.79518072],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15966754, 0.16248109, 0.90277778],\n", - " [0.33070866, 0.33797277, 1. ],\n", - " [0.49343832, 0.50226929, 0.93055556],\n", - " [0.65398075, 0.65960666, 0.91666667],\n", - " [0.83333333, 0.83721634, 0.98611111],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90549961, 0.89603025, 0.87341772],\n", - " [0.80686806, 0.80907372, 0.89873418],\n", - " [0.71159308, 0.71077505, 0.86075949],\n", - " [0.61399432, 0.61625709, 0.89873418],\n", - " [0.51768655, 0.52362949, 0.88607595],\n", - " [0.40511232, 0.4026465 , 1. ],\n", - " [0.30570617, 0.31758034, 0.91139241],\n", - " [0.19571392, 0.19659735, 1. ],\n", - " [0.09630777, 0.09073724, 0.88607595],\n", - " [0. , 0. , 0.87341772]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88753056, 0.11025887, 0.98591549],\n", - " [0.78728606, 0.22267498, 1. ],\n", - " [0.70171149, 0.33293384, 0.98591549],\n", - " [0.56479218, 0.44271333, 0.98591549],\n", - " [0.43765281, 0.55417066, 0.97183099],\n", - " [0.3594132 , 0.665628 , 0.98591549],\n", - " [0.24694377, 0.77612656, 0.98591549],\n", - " [0.12224939, 0.88878236, 1. ],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90076336, 0.90233978, 0.88888889],\n", - " [0.82442748, 0.81993896, 0.77777778],\n", - " [0.70992366, 0.71236012, 1. ],\n", - " [0.63358779, 0.62614446, 0.78888889],\n", - " [0.54961832, 0.53229908, 0.87777778],\n", - " [0.48854962, 0.44811801, 0.77777778],\n", - " [0.39694656, 0.35147508, 0.88888889],\n", - " [0.30534351, 0.25457782, 0.88888889],\n", - " [0.19083969, 0.1698881 , 0.77777778],\n", - " [0.08396947, 0.08519837, 0.77777778],\n", - " [0. , 0. , 0.77777778]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14285714, 0.14230769, 0.91666667],\n", - " [0.28390269, 0.28365385, 0.90277778],\n", - " [0.42650104, 0.42788462, 0.91666667],\n", - " [0.57401656, 0.57019231, 0.93055556],\n", - " [0.72722567, 0.725 , 1. ],\n", - " [0.87034161, 0.86826923, 0.90277778],\n", - " [1. , 1. , 0.84722222]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90901537, 0.13140567, 1. ],\n", - " [0.82841712, 0.22301746, 0.75 ],\n", - " [0.74906523, 0.31090753, 0.77173913],\n", - " [0.67760698, 0.38963642, 0.68478261],\n", - " [0.59867054, 0.47695391, 0.77173913],\n", - " [0.51599501, 0.56799313, 0.76086957],\n", - " [0.42958039, 0.66332665, 0.77173913],\n", - " [0.33901122, 0.75150301, 0.75 ],\n", - " [0.23930204, 0.83338105, 0.75 ],\n", - " [0.12712921, 0.91468652, 0.76086957],\n", - " [0. , 1. , 0.77173913]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10206752, 0.10437236, 0.91044776],\n", - " [0.21408008, 0.22143865, 0.98507463],\n", - " [0.32583093, 0.3370945 , 0.97014925],\n", - " [0.4378435 , 0.45557123, 0.98507463],\n", - " [0.54959435, 0.56840621, 0.98507463],\n", - " [0.66213033, 0.67277856, 1. ],\n", - " [0.77466632, 0.78138223, 0.97014925],\n", - " [0.88694059, 0.89280677, 1. ],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87961985, 0.87734488, 1. ],\n", - " [0.7687434 , 0.76479076, 1. ],\n", - " [0.65681098, 0.65488215, 0.91428571],\n", - " [0.54593453, 0.54280904, 0.92857143],\n", - " [0.43822598, 0.43650794, 0.94285714],\n", - " [0.32523759, 0.32467532, 0.94285714],\n", - " [0.21119324, 0.21164021, 0.95714286],\n", - " [0.09714889, 0.0981241 , 0.92857143],\n", - " [0. , 0. , 0.87142857]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12513062, 0.11428571, 0.98507463],\n", - " [0.24973877, 0.24761905, 1. ],\n", - " [0.37643678, 0.39047619, 0.98507463],\n", - " [0.49895507, 0.48571429, 0.98507463],\n", - " [0.62460815, 0.63809524, 0.98507463],\n", - " [0.74973877, 0.76190476, 0.98507463],\n", - " [0.87408568, 0.88571429, 0.97014925],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1171831 , 0.1095176 , 1. ],\n", - " [0.22985915, 0.2398957 , 1. ],\n", - " [0.34732394, 0.34810952, 1. ],\n", - " [0.46 , 0.45632334, 0.97142857],\n", - " [0.55859155, 0.56584094, 0.87142857],\n", - " [0.67126761, 0.67405476, 1. ],\n", - " [0.77464789, 0.78226858, 0.87142857],\n", - " [0.88253521, 0.89178618, 0.98571429],\n", - " [1. , 1. , 0.98571429]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9108299 , 0.90959925, 0.68686869],\n", - " [0.83313714, 0.83224604, 0.61616162],\n", - " [0.71600942, 0.71528425, 0.90909091],\n", - " [0.61124191, 0.61090401, 0.81818182],\n", - " [0.48263685, 0.48229264, 1. ],\n", - " [0.36462625, 0.36439888, 0.91919192],\n", - " [0.27310182, 0.27353215, 0.70707071],\n", - " [0.18363743, 0.18313141, 0.6969697 ],\n", - " [0.09270159, 0.09273066, 0.70707071],\n", - " [0. , 0. , 0.70707071]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12324127, 0.12348668, 0.98507463],\n", - " [0.24882751, 0.24697337, 0.98507463],\n", - " [0.3741532 , 0.37288136, 0.98507463],\n", - " [0.4994789 , 0.49636804, 0.98507463],\n", - " [0.62428348, 0.61985472, 0.98507463],\n", - " [0.74960917, 0.74576271, 0.97014925],\n", - " [0.87493486, 0.87409201, 1. ],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92743702, 0.93573668, 0.97183099],\n", - " [0.85651698, 0.86677116, 1. ],\n", - " [0.78559693, 0.78996865, 0.97183099],\n", - " [0.71221249, 0.71316614, 1. ],\n", - " [0.63882804, 0.63793103, 0.98591549],\n", - " [0.56626506, 0.56269592, 0.98591549],\n", - " [0.49589266, 0.48746082, 0.98591549],\n", - " [0.42387733, 0.4153605 , 0.97183099],\n", - " [0.34884995, 0.34952978, 1. ],\n", - " [0.27847755, 0.28840125, 0.97183099],\n", - " [0.21686747, 0.22413793, 0.85915493],\n", - " [0.14375685, 0.14733542, 0.98591549],\n", - " [0.07228916, 0.07836991, 0.98591549],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.03042376, 0.9676259 , 0.85915493],\n", - " [0.05976096, 0.93021583, 0.97183099],\n", - " [0.09127128, 0.89100719, 0.98591549],\n", - " [0.12459254, 0.85107914, 1. ],\n", - " [0.15574067, 0.81330935, 0.97183099],\n", - " [0.18580225, 0.77517986, 0.98591549],\n", - " [0.21876132, 0.73417266, 1. ],\n", - " [0.24918508, 0.69568345, 0.98591549],\n", - " [0.27852227, 0.65899281, 0.97183099],\n", - " [0.30967041, 0.62086331, 0.98591549],\n", - " [0.34118073, 0.58417266, 1. ],\n", - " [0.37269105, 0.54964029, 0.97183099],\n", - " [0.403477 , 0.51906475, 1. ],\n", - " [0.43534951, 0.49208633, 0.97183099],\n", - " [0.47048171, 0.46294964, 0.98591549],\n", - " [0.51104672, 0.42841727, 1. ],\n", - " [0.56175299, 0.38741007, 0.97183099],\n", - " [0.62115176, 0.3352518 , 1. ],\n", - " [0.68055053, 0.27913669, 0.97183099],\n", - " [0.74176023, 0.21870504, 1. ],\n", - " [0.80441869, 0.15503597, 0.98591549],\n", - " [0.86707715, 0.09676259, 0.98591549],\n", - " [0.93444404, 0.04280576, 0.98591549],\n", - " [1. , 0. , 0.98591549]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09113924, 0.90918214, 0.88607595],\n", - " [0.16708861, 0.83115906, 0.7721519 ],\n", - " [0.25417722, 0.73933768, 0.88607595],\n", - " [0.35443038, 0.63447065, 1. ],\n", - " [0.44303797, 0.54290015, 0.88607595],\n", - " [0.53468354, 0.45208229, 0.88607595],\n", - " [0.62835443, 0.35875564, 0.89873418],\n", - " [0.72 , 0.26818866, 0.88607595],\n", - " [0.81063291, 0.18038133, 0.87341772],\n", - " [0.90835443, 0.08780733, 0.91139241],\n", - " [1. , 0. , 0.87341772]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11183533, 0.88659794, 0.91666667],\n", - " [0.20377358, 0.79843583, 0.75 ],\n", - " [0.32281304, 0.67365802, 1. ],\n", - " [0.42092624, 0.57483114, 0.83333333],\n", - " [0.51423671, 0.48524707, 0.76190476],\n", - " [0.6102916 , 0.39033061, 0.78571429],\n", - " [0.70120069, 0.30181301, 0.75 ],\n", - " [0.79073756, 0.21507288, 0.76190476],\n", - " [0.89296741, 0.10842517, 0.85714286],\n", - " [1. , 0. , 0.92857143]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.07493857, 0.9235348 , 0.97183099],\n", - " [0.14864865, 0.84478022, 1. ],\n", - " [0.22727273, 0.76831502, 0.97183099],\n", - " [0.30712531, 0.68978938, 1. ],\n", - " [0.38329238, 0.61446886, 0.98591549],\n", - " [0.46437346, 0.54235348, 0.98591549],\n", - " [0.53194103, 0.4720696 , 0.97183099],\n", - " [0.5982801 , 0.40132784, 1. ],\n", - " [0.66584767, 0.3331044 , 0.97183099],\n", - " [0.73587224, 0.2657967 , 1. ],\n", - " [0.8046683 , 0.19894689, 0.98591549],\n", - " [0.87223587, 0.1334707 , 0.97183099],\n", - " [0.93611794, 0.066163 , 0.98591549],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11971472, 0.12044456, 0.85897436],\n", - " [0.24859908, 0.25096924, 0.91025641],\n", - " [0.36933265, 0.37425691, 0.85897436],\n", - " [0.51197147, 0.51744637, 1. ],\n", - " [0.63066735, 0.63711553, 0.83333333],\n", - " [0.74325013, 0.74877229, 0.78205128],\n", - " [0.86500255, 0.8666322 , 0.83333333],\n", - " [1. , 1. , 0.93589744]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16577279, 0.16811847, 0.85714286],\n", - " [0.32179425, 0.32084785, 0.78571429],\n", - " [0.51828376, 0.51655052, 1. ],\n", - " [0.66991711, 0.67044135, 0.78571429],\n", - " [0.84641638, 0.84843206, 0.92857143],\n", - " [1. , 1. , 0.77380952]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1 , 0.1134482 , 0.83544304],\n", - " [0.225 , 0.23249049, 0.83544304],\n", - " [0.325 , 0.3624972 , 0.91139241],\n", - " [0.475 , 0.48869993, 0.91139241],\n", - " [0.61666667, 0.60908481, 0.84810127],\n", - " [0.75 , 0.73707765, 0.89873418],\n", - " [0.86666667, 0.87200716, 1. ],\n", - " [1. , 1. , 0.91139241]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.918897 , 0.06410256, 0.98591549],\n", - " [0.85158151, 0.13230769, 0.98591549],\n", - " [0.78426602, 0.19641026, 0.97183099],\n", - " [0.72992701, 0.26487179, 0.98591549],\n", - " [0.66261152, 0.33333333, 0.98591549],\n", - " [0.594485 , 0.40153846, 0.98591549],\n", - " [0.54095702, 0.46564103, 1. ],\n", - " [0.47283049, 0.53410256, 1. ],\n", - " [0.405515 , 0.6025641 , 0.98591549],\n", - " [0.35117599, 0.66666667, 0.95774648],\n", - " [0.27007299, 0.73487179, 1. ],\n", - " [0.2027575 , 0.80333333, 0.98591549],\n", - " [0.13544201, 0.8674359 , 0.97183099],\n", - " [0.06731549, 0.93153846, 1. ],\n", - " [0. , 1. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90535642, 0.92314119, 0.97183099],\n", - " [0.83125252, 0.8512949 , 0.85915493],\n", - " [0.74748288, 0.76552492, 0.97183099],\n", - " [0.66290777, 0.67836257, 1. ],\n", - " [0.58034636, 0.59370649, 0.97183099],\n", - " [0.49496577, 0.50654414, 1. ],\n", - " [0.41159887, 0.42133111, 0.98591549],\n", - " [0.33064841, 0.33834586, 0.97183099],\n", - " [0.24808699, 0.25396825, 1. ],\n", - " [0.16673379, 0.17070454, 0.97183099],\n", - " [0.08296416, 0.08437761, 0.98591549],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87714988, 0.87810384, 0.90410959],\n", - " [0.74348894, 0.74467018, 0.98630137],\n", - " [0.62113022, 0.62202157, 0.91780822],\n", - " [0.4987715 , 0.49937296, 0.89041096],\n", - " [0.37641278, 0.37772761, 0.91780822],\n", - " [0.25503686, 0.25507901, 0.90410959],\n", - " [0.13316953, 0.13343366, 0.89041096],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11818182, 0.15018315, 0.91666667],\n", - " [0.2507177 , 0.29517705, 0.91666667],\n", - " [0.39330144, 0.43650794, 0.91666667],\n", - " [0.54545455, 0.59126984, 1. ],\n", - " [0.69090909, 0.73015873, 0.91666667],\n", - " [0.8430622 , 0.86630037, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11592289, 0.88461538, 0.91044776],\n", - " [0.24161605, 0.75721154, 0.97014925],\n", - " [0.36783734, 0.63341346, 1. ],\n", - " [0.49247425, 0.50841346, 0.97014925],\n", - " [0.62080803, 0.37740385, 1. ],\n", - " [0.74729337, 0.25120192, 0.97014925],\n", - " [0.87193029, 0.12860577, 0.98507463],\n", - " [1. , 0. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86141414, 0.86026436, 0.89041096],\n", - " [0.72242424, 0.72133801, 0.91780822],\n", - " [0.56929293, 0.56757486, 0.98630137],\n", - " [0.43070707, 0.42837874, 0.90410959],\n", - " [0.29131313, 0.29295927, 0.89041096],\n", - " [0.1389899 , 0.13703804, 1. ],\n", - " [0. , 0. , 0.90410959]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08984375, 0.85667656, 0.98507463],\n", - " [0.17617188, 0.72106825, 0.97014925],\n", - " [0.2640625 , 0.58991098, 0.98507463],\n", - " [0.378125 , 0.47596439, 1. ],\n", - " [0.5046875 , 0.37418398, 0.98507463],\n", - " [0.63632813, 0.26884273, 0.98507463],\n", - " [0.76640625, 0.1735905 , 0.97014925],\n", - " [0.88203125, 0.09376855, 0.91044776],\n", - " [1. , 0. , 0.97014925]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10547945, 0.10156028, 0.95774648],\n", - " [0.21598174, 0.21219858, 1. ],\n", - " [0.31232877, 0.30808511, 0.85915493],\n", - " [0.43105023, 0.42297872, 0.97183099],\n", - " [0.53424658, 0.52283688, 0.85915493],\n", - " [0.65251142, 0.64141844, 0.97183099],\n", - " [0.7716895 , 0.7670922 , 0.98591549],\n", - " [0.88356164, 0.88198582, 0.91549296],\n", - " [1. , 1. , 0.94366197]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89241223, 0.10612639, 0.875 ],\n", - " [0.77916195, 0.21900627, 0.875 ],\n", - " [0.67157418, 0.32633864, 0.8625 ],\n", - " [0.5605889 , 0.43777135, 0.875 ],\n", - " [0.44960362, 0.5458273 , 0.8875 ],\n", - " [0.33069083, 0.66931983, 1. ],\n", - " [0.21857305, 0.78147612, 0.8875 ],\n", - " [0.11098528, 0.88904969, 0.875 ],\n", - " [0. , 1. , 0.875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8843599 , 0.88255699, 0.87341772],\n", - " [0.78713768, 0.78691774, 0.89873418],\n", - " [0.67542271, 0.67542121, 0.88607595],\n", - " [0.55253623, 0.55153617, 1. ],\n", - " [0.43025362, 0.43409316, 0.91139241],\n", - " [0.3227657 , 0.32259663, 1. ],\n", - " [0.20591787, 0.20317146, 0.88607595],\n", - " [0.1053744 , 0.10455897, 0.87341772],\n", - " [0. , 0. , 0.89873418]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.05128205, 0.11339735, 1. ],\n", - " [0.12820513, 0.22176497, 0.97014925],\n", - " [0.25641026, 0.33561957, 0.98507463],\n", - " [0.35897436, 0.44947417, 1. ],\n", - " [0.48717949, 0.55989941, 0.97014925],\n", - " [0.58974359, 0.66209419, 0.91044776],\n", - " [0.74358974, 0.77640604, 0.98507463],\n", - " [0.87179487, 0.88728852, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[0.86896713, 0.50993049, 0. ],\n", - " [0.89228258, 0.5571003 , 0.00143794],\n", - " [0.9107018 , 0.59334657, 0.001329 ],\n", - " [0.92609 , 0.63157895, 0.00137258],\n", - " [0.93774773, 0.67428004, 0.00143794],\n", - " [0.94497552, 0.71747766, 0.00139437],\n", - " [0.95220331, 0.76911619, 0.00165581],\n", - " [0.9568664 , 0.816286 , 0.00152509],\n", - " [0.96059688, 0.86146971, 0.00152509],\n", - " [0.9645605 , 0.90317776, 0.00152509],\n", - " [0.96782467, 0.9285005 , 0.00145973],\n", - " [0.97062252, 0.94637537, 0.00139437],\n", - " [0.97551877, 0.96176763, 0.00152509],\n", - " [0.98134763, 0.97318769, 0.00143794],\n", - " [0.98671019, 0.98460775, 0.00139437],\n", - " [0.99090697, 0.99006951, 0.00137258],\n", - " [0.99347167, 0.98659384, 0.00143794],\n", - " [0.99580322, 0.99006951, 0.00429203],\n", - " [0.99766845, 0.99304866, 0.00145973],\n", - " [1. , 0.98460775, 0.0080176 ],\n", - " [0.99836792, 0.99255214, 0.00782152],\n", - " [0.99323852, 0.98311817, 0.00396523],\n", - " [0.99020751, 0.98411122, 0.00389987],\n", - " [0.99347167, 0.98510427, 0.0078651 ],\n", - " [0.99137328, 0.98609732, 0.33721868],\n", - " [0.99347167, 0.98510427, 0.22357786],\n", - " [0.99557006, 0.9836147 , 1. ],\n", - " [0.99347167, 0.98560079, 0.34116212],\n", - " [0.99580322, 0.98510427, 0.41179546],\n", - " [0.99370483, 0.98560079, 0.5804048 ],\n", - " [0.99580322, 0.98411122, 0.4000305 ],\n", - " [0.99393798, 0.98659384, 0.67055927],\n", - " [0.99183959, 0.98609732, 0.2980675 ],\n", - " [0.99463744, 0.98560079, 0.11767141],\n", - " [0.99673584, 0.9836147 , 0.19996078],\n", - " [0.99323852, 0.98560079, 0.04710342],\n", - " [0.99626953, 0.98411122, 0.01176496],\n", - " [0.99417114, 0.98510427, 0.09015447],\n", - " [0.99207274, 0.98560079, 0.14904464],\n", - " [0.99463744, 0.98560079, 0.41963877],\n", - " [0.99673584, 0.9836147 , 0.20000436],\n", - " [0.99277221, 0.98560079, 0.21176932],\n", - " [0.9948706 , 0.98609732, 0.58036123],\n", - " [0.99673584, 0.9836147 , 0.22355607],\n", - " [0.99440429, 0.98510427, 0.16078782],\n", - " [0.9923059 , 0.98411122, 0.06666812],\n", - " [0.99463744, 0.98560079, 0.57256149],\n", - " [0.9923059 , 0.98560079, 0.46275518],\n", - " [0.99463744, 0.98510427, 0.42353864],\n", - " [0.99300536, 0.98907646, 0.05882481],\n", - " [0.98997435, 1. , 0.00394344],\n", - " [0.97598508, 0.9448858 , 0.00392165],\n", - " [0.96222896, 0.84558093, 0.00389987],\n", - " [0.94637445, 0.74230387, 0.00392165],\n", - " [0.94590814, 0.68222443, 0.00392165],\n", - " [0.96899044, 0.75819265, 0.00394344],\n", - " [0.96409419, 0.74925521, 0.00392165],\n", - " [0.94194451, 0.69860973, 0.00228763],\n", - " [0.91862905, 0.64001986, 0.0015033 ],\n", - " [0.88948473, 0.5714995 , 0.00152509],\n", - " [0.85614362, 0.48957299, 0.00152509],\n", - " [0.82140359, 0.41161867, 0.00152509],\n", - " [0.79179296, 0.35153923, 0.001329 ],\n", - " [0.75915132, 0.28202582, 0.00152509],\n", - " [0.72604337, 0.22293942, 0.00152509],\n", - " [0.68967125, 0.19463754, 0.00152509],\n", - " [0.65376545, 0.17030785, 0.0015033 ],\n", - " [0.61832595, 0.14548163, 0.00152509],\n", - " [0.57822336, 0.12065541, 0.00176474],\n", - " [0.54371648, 0.0958292 , 0.00152509],\n", - " [0.50920961, 0.07199603, 0.0015033 ],\n", - " [0.4758685 , 0.04518371, 0.0015033 ],\n", - " [0.44112847, 0.02730884, 0.00154687],\n", - " [0.4070879 , 0.01390268, 0.0015033 ],\n", - " [0.37701096, 0.00546177, 0.001329 ],\n", - " [0.340872 , 0. , 0.00154687],\n", - " [0.30146887, 0.00446872, 0.0015033 ],\n", - " [0.25623689, 0.02135055, 0.00152509],\n", - " [0.20540919, 0.03972195, 0.0015033 ],\n", - " [0.15877827, 0.06951341, 0.001329 ],\n", - " [0.10048962, 0.10724926, 0.00154687],\n", - " [0.04383306, 0.17080437, 0.0015033 ],\n", - " [0. , 0.25173784, 0.001329 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09489796, 0.09597315, 0.85915493],\n", - " [0.21020408, 0.21006711, 0.98591549],\n", - " [0.31530612, 0.32326622, 1. ],\n", - " [0.4255102 , 0.43422819, 0.97183099],\n", - " [0.54183673, 0.54876957, 0.98591549],\n", - " [0.65714286, 0.66129754, 0.98591549],\n", - " [0.77142857, 0.77427293, 0.98591549],\n", - " [0.88469388, 0.88680089, 0.98591549],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11211644, 0.88765987, 1. ],\n", - " [0.22029898, 0.77773937, 0.97183099],\n", - " [0.33044847, 0.6657449 , 0.98591549],\n", - " [0.44138474, 0.55478742, 0.98591549],\n", - " [0.55192762, 0.44348427, 0.98591549],\n", - " [0.66404406, 0.33045282, 0.98591549],\n", - " [0.77104642, 0.22122364, 0.97183099],\n", - " [0.88316286, 0.10750086, 0.98591549],\n", - " [1. , 0. , 0.98591549]]),\n", - " array([[0.37808642, 0.28623976, 0. ],\n", - " [0.3287037 , 0.2499582 , 0.00157598],\n", - " [0.27777778, 0.2110015 , 0.00180851],\n", - " [0.23611111, 0.17371677, 0.00183434],\n", - " [0.21759259, 0.13960876, 0.00178267],\n", - " [0.19135802, 0.10901187, 0.00180851],\n", - " [0.16820988, 0.08276208, 0.00180851],\n", - " [0.13580247, 0.06119378, 0.00180851],\n", - " [0.10802469, 0.04681491, 0.00180851],\n", - " [0.12808642, 0.03644875, 0.00157598],\n", - " [0.13734568, 0.02541381, 0.00162765],\n", - " [0.12654321, 0.0172212 , 0.00162765],\n", - " [0.10030864, 0.01187092, 0.00160182],\n", - " [0.06790123, 0.00919579, 0.00165349],\n", - " [0.10648148, 0.00819261, 0.00534801],\n", - " [0.1404321 , 0.00652065, 0.00183434],\n", - " [0.16203704, 0.00518308, 0.00178267],\n", - " [0.18364198, 0.00384551, 0.00178267],\n", - " [0.19598765, 0.00468149, 0.00364285],\n", - " [0.20987654, 0.0043471 , 0.01482974],\n", - " [0.19598765, 0.00501588, 0.04658193],\n", - " [0.20833333, 0.0041799 , 0.01397716],\n", - " [0.19444444, 0.00367831, 0.39996383],\n", - " [0.22067901, 0.00334392, 0.00470211],\n", - " [0.19907407, 0.0045143 , 0.01384798],\n", - " [0.21141975, 0.00267514, 0.0231747 ],\n", - " [0.20216049, 0.0041799 , 0.06975663],\n", - " [0.21759259, 0.0041799 , 1. ],\n", - " [0.20061728, 0.0043471 , 0.00927505],\n", - " [0.20987654, 0.00769102, 0.26517853],\n", - " [0.20061728, 0.00501588, 0.00462461],\n", - " [0.18518519, 0.00401271, 0.03715186],\n", - " [0.2037037 , 0.0045143 , 0.00477962],\n", - " [0.19753086, 0.00284233, 0.27429856],\n", - " [0.20679012, 0.00468149, 0.00930088],\n", - " [0.19290123, 0.00585186, 0.09760761],\n", - " [0.2037037 , 0.0043471 , 0.00467628],\n", - " [0.18364198, 0.00551747, 0.07394202],\n", - " [0.15895062, 0.00468149, 0.00180851],\n", - " [0.13271605, 0.00401271, 0.00180851],\n", - " [0.09104938, 0.00501588, 0.00180851],\n", - " [0.0617284 , 0.00367831, 0.00180851],\n", - " [0.02314815, 0.00167196, 0.00178267],\n", - " [0.00771605, 0. , 0.00180851],\n", - " [0.00154321, 0.00384551, 0.00183434],\n", - " [0. , 0.01454606, 0.00157598],\n", - " [0.01388889, 0.03644875, 0.00178267],\n", - " [0.04166667, 0.06738004, 0.00178267],\n", - " [0.07561728, 0.1036616 , 0.00183434],\n", - " [0.12808642, 0.14178231, 0.00178267],\n", - " [0.18518519, 0.18007022, 0.00157598],\n", - " [0.25308642, 0.22772112, 0.00180851],\n", - " [0.32561728, 0.27771276, 0.00178267],\n", - " [0.39969136, 0.33238589, 0.00183434],\n", - " [0.47376543, 0.38388229, 0.00178267],\n", - " [0.54166667, 0.43404113, 0.00180851],\n", - " [0.61265432, 0.48369838, 0.00183434],\n", - " [0.67438272, 0.52917572, 0.00180851],\n", - " [0.69907407, 0.57548905, 0.00180851],\n", - " [0.65432099, 0.62113359, 0.00178267],\n", - " [0.55555556, 0.67129243, 0.00180851],\n", - " [0.44444444, 0.72512958, 0.00183434],\n", - " [0.39969136, 0.78063869, 0.00180851],\n", - " [0.47839506, 0.83481023, 0.00178267],\n", - " [0.6558642 , 0.8878114 , 0.00180851],\n", - " [0.83641975, 0.94248453, 0.00183434],\n", - " [1. , 1. , 0.00180851]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89916506, 0.90027933, 0.76666667],\n", - " [0.77970456, 0.78128492, 0.9 ],\n", - " [0.67244701, 0.6773743 , 0.78888889],\n", - " [0.56968529, 0.57458101, 0.76666667],\n", - " [0.46820809, 0.47346369, 0.77777778],\n", - " [0.34168272, 0.35335196, 0.88888889],\n", - " [0.20873475, 0.22150838, 1. ],\n", - " [0.10276172, 0.11871508, 0.77777778],\n", - " [0. , 0. , 0.88888889]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90171804, 0.89302326, 0.85915493],\n", - " [0.78928752, 0.8 , 0.97183099],\n", - " [0.67812026, 0.71627907, 0.98591549],\n", - " [0.56392117, 0.59534884, 1. ],\n", - " [0.451238 , 0.49302326, 0.97183099],\n", - " [0.3403234 , 0.38139535, 0.98591549],\n", - " [0.22612431, 0.24651163, 1. ],\n", - " [0.11318848, 0.13023256, 0.97183099],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89517876, 0.92907801, 0.8625 ],\n", - " [0.77139762, 0.8108747 , 1. ],\n", - " [0.66088841, 0.69030733, 0.8875 ],\n", - " [0.55444204, 0.58156028, 0.875 ],\n", - " [0.42930661, 0.45390071, 1. ],\n", - " [0.32204767, 0.34042553, 0.875 ],\n", - " [0.2156013 , 0.22458629, 0.875 ],\n", - " [0.10780065, 0.11347518, 0.875 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8526373 , 0.13913282, 0.91666667],\n", - " [0.70799347, 0.27963776, 0.91666667],\n", - " [0.56824361, 0.41822173, 0.91666667],\n", - " [0.42631865, 0.55927552, 0.91666667],\n", - " [0.28602501, 0.70032931, 0.91666667],\n", - " [0.14953779, 0.84248079, 0.91666667],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90478628, 0.90769231, 0.7721519 ],\n", - " [0.77860251, 0.80512821, 1. ],\n", - " [0.66547223, 0.66153846, 0.88607595],\n", - " [0.55490146, 0.52307692, 0.89873418],\n", - " [0.4463783 , 0.39487179, 0.86075949],\n", - " [0.33452777, 0.31282051, 0.89873418],\n", - " [0.22216534, 0.21538462, 0.89873418],\n", - " [0.11389813, 0.1025641 , 0.86075949],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.13227045, 0.86840253, 0.97014925],\n", - " [0.26424565, 0.73539761, 0.98507463],\n", - " [0.39326838, 0.60380014, 0.98507463],\n", - " [0.51992914, 0.4799437 , 0.98507463],\n", - " [0.64363744, 0.35749472, 1. ],\n", - " [0.76616475, 0.23363828, 0.97014925],\n", - " [0.8768822 , 0.12385644, 0.91044776],\n", - " [1. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12532774, 0.11647255, 0.98507463],\n", - " [0.25144206, 0.25291181, 1. ],\n", - " [0.37414788, 0.3843594 , 0.97014925],\n", - " [0.50052438, 0.49916805, 1. ],\n", - " [0.62532774, 0.61730449, 0.97014925],\n", - " [0.7501311 , 0.75207987, 1. ],\n", - " [0.87519664, 0.87354409, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12655547, 0.87096774, 0.6875 ],\n", - " [0.30791634, 0.67741935, 1. ],\n", - " [0.43155944, 0.56682028, 0.6875 ],\n", - " [0.55599682, 0.43778802, 0.67708333],\n", - " [0.69473127, 0.29493088, 0.76041667],\n", - " [0.82922955, 0.16589862, 0.75 ],\n", - " [1. , 0. , 0.9375 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88892519, 0.88787879, 1. ],\n", - " [0.79157138, 0.79134199, 0.8875 ],\n", - " [0.69519765, 0.6952381 , 0.85 ],\n", - " [0.59719046, 0.5965368 , 0.8875 ],\n", - " [0.49885658, 0.4987013 , 0.875 ],\n", - " [0.38908853, 0.39134199, 1. ],\n", - " [0.29010127, 0.29480519, 0.8875 ],\n", - " [0.1950343 , 0.2017316 , 0.85 ],\n", - " [0.09735381, 0.1008658 , 0.8875 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86659719, 0.85674393, 1. ],\n", - " [0.76498176, 0.75006981, 0.74311927],\n", - " [0.69359041, 0.67104161, 0.55963303],\n", - " [0.57894737, 0.54984641, 0.8440367 ],\n", - " [0.46013549, 0.43730801, 0.82568807],\n", - " [0.37571652, 0.35101927, 0.6146789 ],\n", - " [0.28295987, 0.26836079, 0.60550459],\n", - " [0.18394997, 0.17173974, 0.70642202],\n", - " [0.09223554, 0.08852276, 0.60550459],\n", - " [0. , 0. , 0.64220183]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85517241, 0.85358025, 0.98507463],\n", - " [0.71724138, 0.70962963, 0.98507463],\n", - " [0.5862069 , 0.57382716, 0.98507463],\n", - " [0.42758621, 0.42271605, 0.98507463],\n", - " [0.30344828, 0.28691358, 1. ],\n", - " [0.13793103, 0.14049383, 0.98507463],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12962963, 0.09155937, 1. ],\n", - " [0.25925926, 0.18407248, 0.98591549],\n", - " [0.38683128, 0.27539342, 1. ],\n", - " [0.51234568, 0.36599905, 0.95774648],\n", - " [0.63786008, 0.45779685, 0.98591549],\n", - " [0.76748971, 0.54911779, 0.98591549],\n", - " [0.89917695, 0.64210777, 1. ],\n", - " [1. , 0.73056748, 0.97183099],\n", - " [0.93209877, 0.81592752, 0.98591549],\n", - " [0.84156379, 0.90724845, 1. ],\n", - " [0.75308642, 1. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88812714, 0.11279826, 1. ],\n", - " [0.77126831, 0.23318872, 0.98571429],\n", - " [0.65783733, 0.35140998, 0.92857143],\n", - " [0.5344344 , 0.48318872, 0.92857143],\n", - " [0.40729199, 0.62255965, 0.95714286],\n", - " [0.27890309, 0.76193059, 0.92857143],\n", - " [0.14178872, 0.88882863, 0.95714286],\n", - " [0. , 1. , 0.92857143]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89225182, 0.10917979, 0.8875 ],\n", - " [0.76937046, 0.23275394, 1. ],\n", - " [0.66162228, 0.34139055, 0.8625 ],\n", - " [0.53571429, 0.46740902, 1. ],\n", - " [0.42675545, 0.57631722, 0.875 ],\n", - " [0.31476998, 0.68929929, 0.8875 ],\n", - " [0.20762712, 0.79603476, 0.85 ],\n", - " [0.11016949, 0.89163498, 0.775 ],\n", - " [0. , 1. , 0.8625 ]]),\n", - " array([[9.61117002e-01, 8.14209115e-01, 0.00000000e+00],\n", - " [9.62884411e-01, 7.95710456e-01, 2.11732037e-02],\n", - " [9.51572994e-01, 7.94369973e-01, 2.42971191e-02],\n", - " [9.41322022e-01, 8.01876676e-01, 2.42971191e-02],\n", - " [9.33191941e-01, 8.07238606e-01, 2.39500174e-02],\n", - " [9.22234005e-01, 8.10455764e-01, 2.46442208e-02],\n", - " [9.11629551e-01, 8.09115282e-01, 2.39500174e-02],\n", - " [9.03145988e-01, 8.05093834e-01, 2.46442208e-02],\n", - " [8.96783316e-01, 7.87667560e-01, 6.52551198e-02],\n", - " [8.91834571e-01, 7.71313673e-01, 6.24783061e-02],\n", - " [8.89713680e-01, 7.57640751e-01, 6.24783061e-02],\n", - " [8.90774125e-01, 7.47721180e-01, 6.24783061e-02],\n", - " [8.91481089e-01, 7.42091153e-01, 6.24783061e-02],\n", - " [8.93955461e-01, 7.38873995e-01, 6.24783061e-02],\n", - " [8.95015907e-01, 7.35656836e-01, 3.74869837e-01],\n", - " [8.97843761e-01, 7.33512064e-01, 1.24956612e-01],\n", - " [8.94662425e-01, 7.34852547e-01, 2.49913225e-01],\n", - " [8.97843761e-01, 7.33243968e-01, 2.49913225e-01],\n", - " [8.98904206e-01, 7.30026810e-01, 1.87434918e-01],\n", - " [9.01732061e-01, 7.28686327e-01, 3.74869837e-01],\n", - " [9.03499470e-01, 7.26273458e-01, 1.87434918e-01],\n", - " [9.05973842e-01, 7.24396783e-01, 1.87434918e-01],\n", - " [9.09155179e-01, 7.21715818e-01, 2.49913225e-01],\n", - " [9.12336515e-01, 7.20107239e-01, 1.87434918e-01],\n", - " [9.15517851e-01, 7.18230563e-01, 2.49913225e-01],\n", - " [9.18345705e-01, 7.16353887e-01, 2.50260326e-01],\n", - " [9.18345705e-01, 7.20911528e-01, 1.24609511e-01],\n", - " [9.20466596e-01, 7.18498660e-01, 3.74869837e-01],\n", - " [9.17285260e-01, 7.21447721e-01, 6.24783061e-02],\n", - " [9.17992223e-01, 7.17962466e-01, 1.87434918e-01],\n", - " [9.24354896e-01, 7.17426273e-01, 1.24956612e-01],\n", - " [9.27536232e-01, 7.18230563e-01, 6.24783061e-02],\n", - " [9.31071050e-01, 7.16085791e-01, 6.24783061e-02],\n", - " [9.32838459e-01, 7.12868633e-01, 6.24783061e-02],\n", - " [9.36373277e-01, 7.11796247e-01, 4.99826449e-01],\n", - " [9.40615058e-01, 7.12600536e-01, 1.24956612e-01],\n", - " [9.42028986e-01, 7.15281501e-01, 1.87434918e-01],\n", - " [9.46977731e-01, 7.15013405e-01, 4.99826449e-01],\n", - " [9.53693885e-01, 7.14209115e-01, 3.12391531e-01],\n", - " [9.57935666e-01, 7.14745308e-01, 1.87434918e-01],\n", - " [9.60410039e-01, 7.17158177e-01, 2.50260326e-01],\n", - " [9.63237893e-01, 7.20911528e-01, 1.87087817e-01],\n", - " [9.66419229e-01, 7.20375335e-01, 1.87434918e-01],\n", - " [9.69954047e-01, 7.22520107e-01, 1.87434918e-01],\n", - " [9.73842347e-01, 7.21983914e-01, 2.49913225e-01],\n", - " [9.76316720e-01, 7.24396783e-01, 6.24783061e-02],\n", - " [9.80205019e-01, 7.26541555e-01, 6.25130163e-01],\n", - " [9.82679392e-01, 7.28686327e-01, 1.24609511e-01],\n", - " [9.84800283e-01, 7.32975871e-01, 1.25303714e-01],\n", - " [9.87274655e-01, 7.35388740e-01, 6.24783061e-02],\n", - " [9.89749028e-01, 7.37265416e-01, 6.24783061e-02],\n", - " [9.92930364e-01, 7.38873995e-01, 6.21312044e-02],\n", - " [9.94697773e-01, 7.43699732e-01, 1.24956612e-01],\n", - " [9.97172146e-01, 7.45844504e-01, 6.28254078e-02],\n", - " [9.98232591e-01, 7.50402145e-01, 6.24783061e-02],\n", - " [9.97879109e-01, 7.54423592e-01, 6.24783061e-02],\n", - " [9.97879109e-01, 7.58713137e-01, 6.24783061e-02],\n", - " [9.97879109e-01, 7.64075067e-01, 6.24783061e-02],\n", - " [9.97879109e-01, 7.68096515e-01, 6.21312044e-02],\n", - " [9.96818664e-01, 7.71849866e-01, 6.28254078e-02],\n", - " [9.94697773e-01, 7.73994638e-01, 6.21312044e-02],\n", - " [9.94344291e-01, 7.79624665e-01, 6.28254078e-02],\n", - " [9.93990809e-01, 7.84450402e-01, 6.21312044e-02],\n", - " [9.93990809e-01, 7.89544236e-01, 6.28254078e-02],\n", - " [9.93990809e-01, 7.94906166e-01, 6.24783061e-02],\n", - " [9.91869919e-01, 7.99463807e-01, 6.24783061e-02],\n", - " [9.88688583e-01, 8.03753351e-01, 6.24783061e-02],\n", - " [9.84446801e-01, 8.06702413e-01, 6.24783061e-02],\n", - " [9.81618947e-01, 8.09919571e-01, 6.24783061e-02],\n", - " [9.78791092e-01, 8.12600536e-01, 6.24783061e-02],\n", - " [9.74902793e-01, 8.13941019e-01, 1.24956612e-01],\n", - " [9.71721456e-01, 8.16353887e-01, 1.87434918e-01],\n", - " [9.68186638e-01, 8.17158177e-01, 6.24783061e-02],\n", - " [9.64651820e-01, 8.18498660e-01, 6.24783061e-02],\n", - " [9.60410039e-01, 8.20107239e-01, 1.24956612e-01],\n", - " [9.64651820e-01, 8.16890080e-01, 3.74869837e-01],\n", - " [9.69600566e-01, 8.15281501e-01, 1.24956612e-01],\n", - " [9.73842347e-01, 8.13136729e-01, 6.24783061e-02],\n", - " [9.77730647e-01, 8.12332440e-01, 6.24783061e-02],\n", - " [9.82325910e-01, 8.09919571e-01, 6.24783061e-02],\n", - " [9.88335101e-01, 8.06434316e-01, 6.24783061e-02],\n", - " [9.90809473e-01, 8.03753351e-01, 6.24783061e-02],\n", - " [9.92930364e-01, 7.99195710e-01, 6.24783061e-02],\n", - " [9.95404737e-01, 7.97050938e-01, 6.24783061e-02],\n", - " [9.98232591e-01, 7.94638070e-01, 1.24609511e-01],\n", - " [9.93990809e-01, 7.98659517e-01, 1.87782020e-01],\n", - " [9.89042064e-01, 8.05093834e-01, 6.24783061e-02],\n", - " [9.84800283e-01, 8.08847185e-01, 6.24783061e-02],\n", - " [9.81618947e-01, 8.11528150e-01, 6.24783061e-02],\n", - " [9.78084129e-01, 8.13136729e-01, 6.24783061e-02],\n", - " [9.74902793e-01, 8.14209115e-01, 6.24783061e-02],\n", - " [9.77730647e-01, 8.12600536e-01, 1.87434918e-01],\n", - " [9.74195829e-01, 8.15013405e-01, 2.49913225e-01],\n", - " [9.71014493e-01, 8.16621984e-01, 8.12217980e-01],\n", - " [9.68186638e-01, 8.18498660e-01, 3.74869837e-01],\n", - " [9.63944857e-01, 8.19571046e-01, 1.87434918e-01],\n", - " [9.60763521e-01, 8.19302949e-01, 2.49913225e-01],\n", - " [9.63237893e-01, 8.21983914e-01, 6.24783061e-02],\n", - " [9.59703075e-01, 8.21179625e-01, 1.87434918e-01],\n", - " [9.56168257e-01, 8.21983914e-01, 2.49913225e-01],\n", - " [9.54400848e-01, 8.24396783e-01, 8.12217980e-01],\n", - " [9.58642630e-01, 8.23324397e-01, 1.24956612e-01],\n", - " [9.54754330e-01, 8.22788204e-01, 1.24956612e-01],\n", - " [9.57935666e-01, 8.21983914e-01, 1.00000000e+00],\n", - " [9.61117002e-01, 8.21715818e-01, 1.87434918e-01],\n", - " [9.56875221e-01, 8.23324397e-01, 3.12391531e-01],\n", - " [9.54400848e-01, 8.21447721e-01, 3.12044429e-01],\n", - " [9.50866030e-01, 8.21447721e-01, 1.24956612e-01],\n", - " [9.46270767e-01, 8.23592493e-01, 6.28254078e-02],\n", - " [9.43796394e-01, 8.20643432e-01, 1.24609511e-01],\n", - " [9.40261577e-01, 8.20911528e-01, 1.87434918e-01],\n", - " [9.35666313e-01, 8.20375335e-01, 6.24783061e-02],\n", - " [9.32131495e-01, 8.18498660e-01, 6.24783061e-02],\n", - " [9.28950159e-01, 8.17158177e-01, 6.24783061e-02],\n", - " [9.32484977e-01, 8.19034853e-01, 3.12391531e-01],\n", - " [9.36373277e-01, 8.20107239e-01, 1.87434918e-01],\n", - " [9.33191941e-01, 8.20107239e-01, 3.12391531e-01],\n", - " [9.30717568e-01, 8.17426273e-01, 1.24956612e-01],\n", - " [9.27182750e-01, 8.16890080e-01, 1.25303714e-01],\n", - " [9.22234005e-01, 8.13941019e-01, 1.24956612e-01],\n", - " [9.19759632e-01, 8.11260054e-01, 6.21312044e-02],\n", - " [9.13750442e-01, 8.08042895e-01, 1.25303714e-01],\n", - " [9.11629551e-01, 8.04825737e-01, 1.24609511e-01],\n", - " [9.08094733e-01, 8.01608579e-01, 1.24956612e-01],\n", - " [9.04206433e-01, 7.98927614e-01, 6.24783061e-02],\n", - " [9.02439024e-01, 7.95442359e-01, 6.28254078e-02],\n", - " [9.02439024e-01, 7.91420912e-01, 1.87087817e-01],\n", - " [8.98550725e-01, 7.86327078e-01, 1.24956612e-01],\n", - " [8.97490279e-01, 7.81769437e-01, 6.24783061e-02],\n", - " [8.98197243e-01, 7.76943700e-01, 6.24783061e-02],\n", - " [8.98550725e-01, 7.71045576e-01, 6.24783061e-02],\n", - " [8.97490279e-01, 7.63270777e-01, 6.24783061e-02],\n", - " [8.98904206e-01, 7.58176944e-01, 6.28254078e-02],\n", - " [9.01732061e-01, 7.53351206e-01, 6.21312044e-02],\n", - " [9.05973842e-01, 7.50670241e-01, 6.28254078e-02],\n", - " [9.05973842e-01, 7.46916890e-01, 6.21312044e-02],\n", - " [9.09155179e-01, 7.45040214e-01, 6.24783061e-02],\n", - " [9.12689996e-01, 7.39946381e-01, 6.24783061e-02],\n", - " [9.17638742e-01, 7.35656836e-01, 6.28254078e-02],\n", - " [9.22940969e-01, 7.33780161e-01, 6.21312044e-02],\n", - " [9.26475786e-01, 7.30563003e-01, 6.24783061e-02],\n", - " [9.31778013e-01, 7.29490617e-01, 1.87782020e-01],\n", - " [9.36373277e-01, 7.29222520e-01, 4.37001041e-01],\n", - " [9.43089431e-01, 7.28150134e-01, 1.87434918e-01],\n", - " [9.47331212e-01, 7.28954424e-01, 1.25303714e-01],\n", - " [9.51219512e-01, 7.28686327e-01, 3.12044429e-01],\n", - " [9.55814776e-01, 7.28150134e-01, 1.24956612e-01],\n", - " [9.58996112e-01, 7.26809651e-01, 2.49913225e-01],\n", - " [9.59703075e-01, 7.23592493e-01, 5.00173551e-01],\n", - " [9.55107812e-01, 7.25469169e-01, 6.87261368e-01],\n", - " [9.58289148e-01, 7.24664879e-01, 3.74522735e-01],\n", - " [9.61470484e-01, 7.24128686e-01, 1.87782020e-01],\n", - " [9.64298339e-01, 7.25737265e-01, 2.49913225e-01],\n", - " [9.67126193e-01, 7.27345845e-01, 1.24956612e-01],\n", - " [9.70661011e-01, 7.27345845e-01, 6.21312044e-02],\n", - " [9.74902793e-01, 7.29490617e-01, 1.24956612e-01],\n", - " [9.78084129e-01, 7.32707775e-01, 4.37695245e-01],\n", - " [9.80911983e-01, 7.31099196e-01, 1.24956612e-01],\n", - " [9.82679392e-01, 7.34852547e-01, 4.99826449e-01],\n", - " [9.83739837e-01, 7.37801609e-01, 1.24956612e-01],\n", - " [9.86567692e-01, 7.39410188e-01, 1.24956612e-01],\n", - " [9.90102510e-01, 7.41286863e-01, 1.87434918e-01],\n", - " [9.90102510e-01, 7.45308311e-01, 2.49913225e-01],\n", - " [9.92223400e-01, 7.49061662e-01, 1.24956612e-01],\n", - " [9.94697773e-01, 7.51742627e-01, 6.24783061e-02],\n", - " [9.97172146e-01, 7.54691689e-01, 1.24956612e-01],\n", - " [9.97172146e-01, 7.58176944e-01, 1.24956612e-01],\n", - " [9.99293036e-01, 7.63002681e-01, 1.24956612e-01],\n", - " [9.99293036e-01, 7.66756032e-01, 6.24783061e-02],\n", - " [9.99293036e-01, 7.69973190e-01, 6.24783061e-02],\n", - " [1.00000000e+00, 7.74530831e-01, 6.24783061e-02],\n", - " [9.98939555e-01, 7.78016086e-01, 6.24783061e-02],\n", - " [9.96111700e-01, 7.79624665e-01, 6.24783061e-02],\n", - " [9.93990809e-01, 7.84718499e-01, 1.24956612e-01],\n", - " [9.92930364e-01, 7.88739946e-01, 6.24783061e-02],\n", - " [9.88688583e-01, 7.93297587e-01, 1.24956612e-01],\n", - " [9.85860728e-01, 7.97319035e-01, 6.24783061e-02],\n", - " [9.82679392e-01, 8.01340483e-01, 6.24783061e-02],\n", - " [9.78791092e-01, 8.04021448e-01, 6.24783061e-02],\n", - " [9.73488865e-01, 8.06702413e-01, 6.24783061e-02],\n", - " [9.68893602e-01, 8.11260054e-01, 6.24783061e-02],\n", - " [9.62530930e-01, 8.12332440e-01, 6.24783061e-02],\n", - " [9.56875221e-01, 8.15013405e-01, 6.24783061e-02],\n", - " [9.50159067e-01, 8.17962466e-01, 6.24783061e-02],\n", - " [9.44856840e-01, 8.17962466e-01, 6.24783061e-02],\n", - " [9.38494168e-01, 8.19571046e-01, 6.24783061e-02],\n", - " [9.30010604e-01, 8.16890080e-01, 1.24956612e-01],\n", - " [9.24354896e-01, 8.13136729e-01, 1.24956612e-01],\n", - " [9.21880523e-01, 8.10723861e-01, 1.24956612e-01],\n", - " [9.20113114e-01, 8.08042895e-01, 1.87434918e-01],\n", - " [9.16578296e-01, 8.06166220e-01, 1.24956612e-01],\n", - " [9.13750442e-01, 8.04557641e-01, 1.87434918e-01],\n", - " [9.16224814e-01, 8.02144772e-01, 1.24956612e-01],\n", - " [9.12336515e-01, 8.02144772e-01, 2.49913225e-01],\n", - " [9.15517851e-01, 8.02680965e-01, 5.00173551e-01],\n", - " [9.10922587e-01, 8.02412869e-01, 2.49566123e-01],\n", - " [9.11629551e-01, 7.99463807e-01, 3.12738632e-01],\n", - " [9.08801697e-01, 7.96782842e-01, 3.12044429e-01],\n", - " [9.12336515e-01, 7.97319035e-01, 4.37695245e-01],\n", - " [9.11983033e-01, 8.00268097e-01, 1.24609511e-01],\n", - " [9.07741251e-01, 7.98391421e-01, 3.12391531e-01],\n", - " [9.05973842e-01, 7.95174263e-01, 2.50260326e-01],\n", - " [9.03145988e-01, 7.93565684e-01, 1.87087817e-01],\n", - " [9.00671615e-01, 7.91420912e-01, 1.24956612e-01],\n", - " [8.98550725e-01, 7.88471850e-01, 6.24783061e-02],\n", - " [8.96076352e-01, 7.83109920e-01, 1.24956612e-01],\n", - " [8.94662425e-01, 7.78820375e-01, 1.24956612e-01],\n", - " [8.90067162e-01, 7.74798928e-01, 6.24783061e-02],\n", - " [8.87946271e-01, 7.71045576e-01, 6.24783061e-02],\n", - " [8.87592789e-01, 7.67828418e-01, 6.24783061e-02],\n", - " [8.87946271e-01, 7.63270777e-01, 1.25303714e-01],\n", - " [8.86885825e-01, 7.59785523e-01, 6.21312044e-02],\n", - " [8.86885825e-01, 7.56300268e-01, 6.24783061e-02],\n", - " [8.88653234e-01, 7.51474531e-01, 1.24956612e-01],\n", - " [8.89713680e-01, 7.47721180e-01, 1.25303714e-01],\n", - " [8.90420643e-01, 7.44504021e-01, 1.24609511e-01],\n", - " [8.90420643e-01, 7.39946381e-01, 3.12738632e-01],\n", - " [8.92541534e-01, 7.34584450e-01, 6.21312044e-02],\n", - " [8.96076352e-01, 7.30563003e-01, 6.24783061e-02],\n", - " [8.98197243e-01, 7.25469169e-01, 6.24783061e-02],\n", - " [8.96429834e-01, 7.28686327e-01, 1.87782020e-01],\n", - " [8.98550725e-01, 7.24128686e-01, 1.87087817e-01],\n", - " [9.01025097e-01, 7.21715818e-01, 1.24956612e-01],\n", - " [9.02792506e-01, 7.19302949e-01, 1.87434918e-01],\n", - " [9.00671615e-01, 7.22520107e-01, 1.87434918e-01],\n", - " [9.03145988e-01, 7.17962466e-01, 1.25303714e-01],\n", - " [9.00671615e-01, 7.20107239e-01, 6.21312044e-02],\n", - " [9.03499470e-01, 7.16890080e-01, 1.87782020e-01],\n", - " [9.06327324e-01, 7.14477212e-01, 1.87434918e-01],\n", - " [9.10569106e-01, 7.11528150e-01, 1.24956612e-01],\n", - " [9.06327324e-01, 7.12600536e-01, 1.24609511e-01],\n", - " [9.10922587e-01, 7.09115282e-01, 1.87434918e-01],\n", - " [9.07741251e-01, 7.11796247e-01, 1.87782020e-01],\n", - " [9.10922587e-01, 7.08579088e-01, 2.49913225e-01],\n", - " [9.08801697e-01, 7.13672922e-01, 1.87087817e-01],\n", - " [9.20820078e-01, 7.18230563e-01, 6.24783061e-02],\n", - " [9.32484977e-01, 7.12868633e-01, 6.24783061e-02],\n", - " [9.37433722e-01, 7.11796247e-01, 6.24783061e-02],\n", - " [9.46270767e-01, 7.20375335e-01, 6.28254078e-02],\n", - " [9.54047367e-01, 7.22252011e-01, 2.29087123e-02],\n", - " [9.75963238e-01, 7.43699732e-01, 2.29087123e-02],\n", - " [9.75609756e-01, 7.78016086e-01, 2.15203054e-02],\n", - " [9.39908095e-01, 8.10991957e-01, 2.15203054e-02],\n", - " [8.83704489e-01, 8.25201072e-01, 2.22145089e-02],\n", - " [8.23259102e-01, 8.20643432e-01, 2.29087123e-02],\n", - " [7.61046306e-01, 7.94638070e-01, 2.39500174e-02],\n", - " [7.08377519e-01, 7.47721180e-01, 2.49913225e-02],\n", - " [6.59243549e-01, 7.11796247e-01, 2.15203054e-02],\n", - " [6.06574761e-01, 6.98659517e-01, 2.11732037e-02],\n", - " [5.62036055e-01, 7.04021448e-01, 2.18674072e-02],\n", - " [5.31990103e-01, 7.22252011e-01, 2.18674072e-02],\n", - " [5.08306822e-01, 7.51206434e-01, 2.46442208e-02],\n", - " [4.78967833e-01, 7.85790885e-01, 2.39500174e-02],\n", - " [4.47154472e-01, 8.22788204e-01, 2.42971191e-02],\n", - " [4.15341110e-01, 8.59249330e-01, 2.46442208e-02],\n", - " [3.87769530e-01, 8.89544236e-01, 2.39500174e-02],\n", - " [3.65500177e-01, 9.12064343e-01, 2.42971191e-02],\n", - " [3.45705196e-01, 9.30831099e-01, 2.42971191e-02],\n", - " [3.29091552e-01, 9.42359249e-01, 2.11732037e-02],\n", - " [3.12831389e-01, 9.53351206e-01, 2.42971191e-02],\n", - " [2.98692117e-01, 9.62198391e-01, 2.42971191e-02],\n", - " [2.85613291e-01, 9.67560322e-01, 2.42971191e-02],\n", - " [2.74301873e-01, 9.70777480e-01, 2.36029157e-02],\n", - " [2.65111347e-01, 9.73190349e-01, 2.15203054e-02],\n", - " [2.55920820e-01, 9.73726542e-01, 2.42971191e-02],\n", - " [2.47437257e-01, 9.72654155e-01, 2.39500174e-02],\n", - " [2.38600212e-01, 9.70241287e-01, 2.39500174e-02],\n", - " [2.30823613e-01, 9.67292225e-01, 2.11732037e-02],\n", - " [2.23400495e-01, 9.61662198e-01, 2.46442208e-02],\n", - " [2.15623895e-01, 9.54423592e-01, 2.39500174e-02],\n", - " [2.07847296e-01, 9.48257373e-01, 2.46442208e-02],\n", - " [2.00070696e-01, 9.42359249e-01, 2.36029157e-02],\n", - " [1.94768469e-01, 9.55764075e-01, 2.11732037e-02],\n", - " [1.68257335e-01, 9.85254692e-01, 2.22145089e-02],\n", - " [1.18769883e-01, 1.00000000e+00, 2.15203054e-02],\n", - " [5.86779781e-02, 9.84450402e-01, 2.25616106e-02],\n", - " [1.62601626e-02, 9.38873995e-01, 2.15203054e-02],\n", - " [4.24178155e-03, 8.67560322e-01, 2.32558140e-02],\n", - " [3.18133616e-03, 7.82573727e-01, 2.46442208e-02],\n", - " [2.12089077e-03, 6.89812332e-01, 2.36029157e-02],\n", - " [7.06963591e-04, 5.89544236e-01, 2.42971191e-02],\n", - " [0.00000000e+00, 4.99195710e-01, 2.11732037e-02],\n", - " [1.76740898e-03, 3.80160858e-01, 2.46442208e-02],\n", - " [1.44927536e-02, 2.54691689e-01, 2.39500174e-02],\n", - " [3.53481796e-02, 1.28418231e-01, 2.42971191e-02],\n", - " [6.78685048e-02, 0.00000000e+00, 2.39500174e-02]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92175338, 0.07678624, 0.97222222],\n", - " [0.84391643, 0.1544619 , 0.97222222],\n", - " [0.77550184, 0.22235399, 0.84722222],\n", - " [0.69848423, 0.29914023, 0.95833333],\n", - " [0.62023761, 0.37711236, 0.98611111],\n", - " [0.54362966, 0.45360213, 0.95833333],\n", - " [0.46538304, 0.53276015, 0.97222222],\n", - " [0.38918476, 0.61102876, 0.95833333],\n", - " [0.30766079, 0.69107619, 1. ],\n", - " [0.23064318, 0.76845538, 0.95833333],\n", - " [0.1544449 , 0.84435221, 0.95833333],\n", - " [0.07660795, 0.92232434, 0.98611111],\n", - " [0. , 1. , 0.97222222]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.80009921, 0.80321285, 0.83246073],\n", - " [0.68700397, 0.69076305, 0.47120419],\n", - " [0.44593254, 0.45381526, 1. ],\n", - " [0.29464286, 0.30378657, 0.61780105],\n", - " [0.19642857, 0.20252438, 0.41884817],\n", - " [0.08333333, 0.08605852, 0.48167539],\n", - " [0. , 0. , 0.35602094]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88482075, 0.88559322, 0.98507463],\n", - " [0.77421815, 0.77093719, 0.98507463],\n", - " [0.65675057, 0.65727817, 0.98507463],\n", - " [0.54385965, 0.54411765, 0.98507463],\n", - " [0.43554539, 0.43170489, 0.98507463],\n", - " [0.33028223, 0.31904287, 0.97014925],\n", - " [0.21205187, 0.20687936, 1. ],\n", - " [0.10297483, 0.09920239, 0.97014925],\n", - " [0. , 0. , 0.91044776]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90441383, 0.90661479, 0.575 ],\n", - " [0.80657858, 0.80505837, 0.58333333],\n", - " [0.63817824, 0.63696498, 1. ],\n", - " [0.48608378, 0.48404669, 0.91666667],\n", - " [0.36069722, 0.35992218, 0.75 ],\n", - " [0.26258083, 0.26264591, 0.59166667],\n", - " [0.16671352, 0.16575875, 0.58333333],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.03158406, 0.92285714, 1. ],\n", - " [0.06365403, 0.84371429, 0.97183099],\n", - " [0.10349854, 0.76514286, 1. ],\n", - " [0.1350826 , 0.69942857, 0.98591549],\n", - " [0.16083576, 0.63085714, 0.97183099],\n", - " [0.19727891, 0.56571429, 1. ],\n", - " [0.24927114, 0.50314286, 0.97183099],\n", - " [0.31389699, 0.44942857, 0.98591549],\n", - " [0.39990282, 0.396 , 1. ],\n", - " [0.49611273, 0.33942857, 0.97183099],\n", - " [0.59183673, 0.28142857, 0.98591549],\n", - " [0.68415938, 0.22171429, 1. ],\n", - " [0.76676385, 0.16457143, 0.95774648],\n", - " [0.83624879, 0.11657143, 0.85915493],\n", - " [0.9212828 , 0.06028571, 0.97183099],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89943609, 0.89965398, 0.8875 ],\n", - " [0.78618421, 0.78575548, 0.9875 ],\n", - " [0.69971805, 0.69867359, 0.7625 ],\n", - " [0.59727444, 0.59602076, 0.875 ],\n", - " [0.50046992, 0.49740484, 0.8625 ],\n", - " [0.41212406, 0.411188 , 0.775 ],\n", - " [0.31531955, 0.31459054, 0.85 ],\n", - " [0.20065789, 0.19982699, 1. ],\n", - " [0.10103383, 0.10034602, 0.8875 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16821192, 0.16409067, 0.97014925],\n", - " [0.33377483, 0.33127254, 1. ],\n", - " [0.50066225, 0.49793921, 0.97014925],\n", - " [0.66754967, 0.66460587, 1. ],\n", - " [0.83245033, 0.83075734, 0.97014925],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.19902518, 0.21813842, 1. ],\n", - " [0.37043054, 0.37494033, 0.73825503],\n", - " [0.48009748, 0.47565632, 0.46979866],\n", - " [0.60357433, 0.59164678, 0.53020134],\n", - " [0.77010561, 0.76634845, 0.80536913],\n", - " [0.89114541, 0.89952267, 0.61073826],\n", - " [1. , 1. , 0.46308725]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8526373 , 0.13913282, 0.91666667],\n", - " [0.70799347, 0.27963776, 0.91666667],\n", - " [0.56824361, 0.41822173, 0.91666667],\n", - " [0.42631865, 0.55927552, 0.91666667],\n", - " [0.28602501, 0.70032931, 0.91666667],\n", - " [0.14953779, 0.84248079, 0.91666667],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91984334, 0.9775641 , 0.85915493],\n", - " [0.8308094 , 0.93269231, 0.97183099],\n", - " [0.7381201 , 0.75641026, 0.98591549],\n", - " [0.6464752 , 0.51923077, 1. ],\n", - " [0.55587467, 0.44230769, 0.97183099],\n", - " [0.46109661, 0.38141026, 1. ],\n", - " [0.37180157, 0.34935897, 0.97183099],\n", - " [0.27832898, 0.30448718, 1. ],\n", - " [0.18720627, 0.18910256, 0.97183099],\n", - " [0.09373368, 0.05128205, 1. ],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15300961, 0.11282051, 1. ],\n", - " [0.287304 , 0.22564103, 0.87142857],\n", - " [0.42134547, 0.37435897, 0.88571429],\n", - " [0.57688417, 0.51794872, 1. ],\n", - " [0.712696 , 0.63076923, 0.88571429],\n", - " [0.86418816, 0.81538462, 1. ],\n", - " [1. , 1. , 0.88571429]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.07977026, 0.07945967, 0.97222222],\n", - " [0.15954052, 0.16567342, 0.95833333],\n", - " [0.23931078, 0.25148987, 0.97222222],\n", - " [0.32450542, 0.33094954, 0.98611111],\n", - " [0.40970006, 0.41716329, 0.95833333],\n", - " [0.48947033, 0.49662296, 0.95833333],\n", - " [0.57434588, 0.58283671, 1. ],\n", - " [0.65954052, 0.66229638, 0.97222222],\n", - " [0.74473516, 0.74811283, 0.95833333],\n", - " [0.82961072, 0.82757251, 0.97222222],\n", - " [0.91480536, 0.91378625, 0.98611111],\n", - " [1. , 1. , 0.97222222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12962963, 0.09155937, 1. ],\n", - " [0.25925926, 0.18407248, 0.98591549],\n", - " [0.38683128, 0.27539342, 1. ],\n", - " [0.51234568, 0.36599905, 0.95774648],\n", - " [0.63786008, 0.45779685, 0.98591549],\n", - " [0.76748971, 0.54911779, 0.98591549],\n", - " [0.89917695, 0.64210777, 1. ],\n", - " [1. , 0.73056748, 0.97183099],\n", - " [0.93209877, 0.81592752, 0.98591549],\n", - " [0.84156379, 0.90724845, 1. ],\n", - " [0.75308642, 1. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89874096, 0.88837209, 0.87142857],\n", - " [0.78542727, 0.76511628, 0.97142857],\n", - " [0.68229306, 0.67209302, 0.88571429],\n", - " [0.5657648 , 0.5627907 , 1. ],\n", - " [0.44923654, 0.43488372, 1. ],\n", - " [0.33297616, 0.33023256, 1. ],\n", - " [0.21618002, 0.22093023, 1. ],\n", - " [0.10018752, 0.09302326, 0.98571429],\n", - " [0. , 0. , 0.87142857]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90331853, 0.94148021, 0.775 ],\n", - " [0.80167233, 0.79518072, 0.8375 ],\n", - " [0.70525216, 0.71772806, 0.8 ],\n", - " [0.6117063 , 0.53184165, 0.7875 ],\n", - " [0.51607003, 0.53700516, 0.7875 ],\n", - " [0.4290567 , 0.40275387, 0.7625 ],\n", - " [0.33263653, 0.33907057, 0.7875 ],\n", - " [0.21766397, 0.21858864, 0.95 ],\n", - " [0.09615887, 0.05335628, 1. ],\n", - " [0. , 0. , 0.7875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89003759, 0.89073634, 0.91428571],\n", - " [0.77866541, 0.77998812, 0.91428571],\n", - " [0.67105263, 0.6716152 , 0.91428571],\n", - " [0.55357143, 0.55374109, 0.97142857],\n", - " [0.44595865, 0.44625891, 0.91428571],\n", - " [0.32847744, 0.32897862, 0.97142857],\n", - " [0.22509398, 0.22505938, 0.88571429],\n", - " [0.12077068, 0.12084323, 0.87142857],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88933121, 0.88826367, 0.97014925],\n", - " [0.77839703, 0.77652733, 0.98507463],\n", - " [0.66613588, 0.66157556, 0.98507463],\n", - " [0.5552017 , 0.54983923, 0.98507463],\n", - " [0.44559448, 0.43971061, 0.98507463],\n", - " [0.33333333, 0.32797428, 1. ],\n", - " [0.22080679, 0.21864952, 0.98507463],\n", - " [0.10934183, 0.10771704, 0.98507463],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90257252, 0.89949324, 0.79120879],\n", - " [0.80706076, 0.80658784, 0.75824176],\n", - " [0.68390805, 0.68412162, 0.98901099],\n", - " [0.58976464, 0.58783784, 0.75824176],\n", - " [0.49151615, 0.4847973 , 0.79120879],\n", - " [0.39709907, 0.3910473 , 0.75824176],\n", - " [0.27285167, 0.26942568, 1. ],\n", - " [0.18007663, 0.17736486, 0.74725275],\n", - " [0.09660646, 0.09628378, 0.67032967],\n", - " [0. , 0. , 0.78021978]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.0950764 , 0.10149821, 0.97222222],\n", - " [0.1901528 , 0.20151931, 0.97222222],\n", - " [0.28862479, 0.30132939, 0.97222222],\n", - " [0.39728353, 0.39839629, 0.95833333],\n", - " [0.50764007, 0.49736231, 0.98611111],\n", - " [0.61205433, 0.59843849, 0.97222222],\n", - " [0.71052632, 0.69845959, 0.97222222],\n", - " [0.80560272, 0.79742562, 0.95833333],\n", - " [0.90237691, 0.89807976, 0.97222222],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08163265, 0.10818308, 0.94366197],\n", - " [0.18367347, 0.2196024 , 0.92957746],\n", - " [0.28571429, 0.32755432, 0.91549296],\n", - " [0.40816327, 0.43966713, 0.94366197],\n", - " [0.53061224, 0.54946833, 0.92957746],\n", - " [0.67346939, 0.65903837, 0.91549296],\n", - " [0.79591837, 0.76907074, 0.94366197],\n", - " [0.93877551, 0.88765603, 1. ],\n", - " [1. , 1. , 0.94366197]]),\n", - " array([[1. , 0.08 , 0. ],\n", - " [0.90946822, 0.5 , 0.875 ],\n", - " [0.81867704, 0.68 , 0.875 ],\n", - " [0.74396887, 0.78 , 0.7625 ],\n", - " [0.65499351, 0.9 , 0.875 ],\n", - " [0.56446174, 1. , 0.8875 ],\n", - " [0.47808042, 1. , 0.85 ],\n", - " [0.3846952 , 0.88 , 0.875 ],\n", - " [0.28093385, 0.88 , 1. ],\n", - " [0.17898833, 0.84 , 1. ],\n", - " [0.08949416, 0.7 , 0.8875 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14366425, 0.11971831, 0.98507463],\n", - " [0.28786656, 0.20774648, 0.97014925],\n", - " [0.43502825, 0.41197183, 0.98507463],\n", - " [0.56497175, 0.52816901, 0.91044776],\n", - " [0.71078827, 0.58802817, 0.97014925],\n", - " [0.85660479, 0.76408451, 1. ],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12486938, 0.12357994, 0.91666667],\n", - " [0.2476489 , 0.24771405, 0.91666667],\n", - " [0.37095089, 0.37129399, 0.91666667],\n", - " [0.49320794, 0.49293433, 0.91666667],\n", - " [0.62852665, 0.62759767, 1. ],\n", - " [0.75182863, 0.7514547 , 0.91666667],\n", - " [0.87304075, 0.87531172, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14258503, 0.1395881 , 0.97014925],\n", - " [0.28517007, 0.2791762 , 1. ],\n", - " [0.42802721, 0.42334096, 0.98507463],\n", - " [0.57061224, 0.56521739, 0.98507463],\n", - " [0.71292517, 0.70709382, 0.98507463],\n", - " [0.8555102 , 0.85125858, 0.97014925],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90088594, 0.8975265 , 1. ],\n", - " [0.80066445, 0.79681979, 0.98591549],\n", - " [0.70459579, 0.68551237, 0.97183099],\n", - " [0.60326689, 0.59717314, 1. ],\n", - " [0.50249169, 0.50353357, 0.98591549],\n", - " [0.39922481, 0.3975265 , 1. ],\n", - " [0.30177187, 0.28798587, 0.97183099],\n", - " [0.19988926, 0.19081272, 0.98591549],\n", - " [0.10077519, 0.09893993, 0.97183099],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.97721128, 0.975458 , 0.95833333],\n", - " [0.95365006, 0.95229865, 0.97222222],\n", - " [0.92854384, 0.92879364, 0.98611111],\n", - " [0.90305137, 0.9073626 , 0.95833333],\n", - " [0.87794515, 0.88385759, 0.98611111],\n", - " [0.85515643, 0.86035258, 0.95833333],\n", - " [0.83120896, 0.8365019 , 0.98611111],\n", - " [0.80571649, 0.81610785, 0.95833333],\n", - " [0.78331402, 0.7974421 , 0.84722222],\n", - " [0.75859405, 0.77808503, 0.95833333],\n", - " [0.73387408, 0.75803664, 0.98611111],\n", - " [0.70876786, 0.73695126, 0.95833333],\n", - " [0.68636539, 0.71552022, 0.98611111],\n", - " [0.66319042, 0.69374352, 0.95833333],\n", - " [0.63924295, 0.67058417, 0.97222222],\n", - " [0.61684048, 0.64707916, 0.97222222],\n", - " [0.59791425, 0.62737643, 0.84722222],\n", - " [0.57396678, 0.6049084 , 0.94444444],\n", - " [0.55156431, 0.58071206, 1. ],\n", - " [0.52954809, 0.55789838, 0.95833333],\n", - " [0.50560062, 0.53543035, 0.97222222],\n", - " [0.47856315, 0.51434497, 0.97222222],\n", - " [0.45616068, 0.49256827, 0.97222222],\n", - " [0.43144071, 0.47010024, 0.97222222],\n", - " [0.40942449, 0.44694089, 0.95833333],\n", - " [0.38624952, 0.42896647, 0.84722222],\n", - " [0.3626883 , 0.4051158 , 0.98611111],\n", - " [0.33989958, 0.38161078, 0.97222222],\n", - " [0.3182696 , 0.35637746, 0.97222222],\n", - " [0.29818463, 0.3314898 , 0.95833333],\n", - " [0.27500966, 0.30729347, 0.97222222],\n", - " [0.25337968, 0.28136882, 0.98611111],\n", - " [0.23213596, 0.2561355 , 0.97222222],\n", - " [0.20625724, 0.23263049, 0.97222222],\n", - " [0.18462727, 0.20636018, 0.97222222],\n", - " [0.1637698 , 0.17974421, 0.97222222],\n", - " [0.13750483, 0.15589354, 0.95833333],\n", - " [0.11201236, 0.12996889, 0.98611111],\n", - " [0.09076864, 0.10438991, 0.95833333],\n", - " [0.06720742, 0.07846526, 0.98611111],\n", - " [0.04441869, 0.0535776 , 0.95833333],\n", - " [0.02162997, 0.02730729, 0.97222222],\n", - " [0. , 0. , 0.97222222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10442909, 0.11861421, 0.87341772],\n", - " [0.19504267, 0.22019965, 0.7721519 ],\n", - " [0.30150345, 0.33763946, 0.88607595],\n", - " [0.42909386, 0.46741045, 1. ],\n", - " [0.54490045, 0.57809748, 0.88607595],\n", - " [0.66273872, 0.6881973 , 0.89873418],\n", - " [0.780577 , 0.79800352, 0.88607595],\n", - " [0.88419342, 0.89342337, 0.7721519 ],\n", - " [1. , 1. , 0.86075949]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87413235, 0.86961986, 0.8988764 ],\n", - " [0.76723739, 0.75683318, 0.7752809 ],\n", - " [0.64044424, 0.62016965, 0.92134831],\n", - " [0.53308653, 0.50518379, 0.76404494],\n", - " [0.42572883, 0.38862708, 0.78651685],\n", - " [0.29477094, 0.25416274, 0.91011236],\n", - " [0.14854234, 0.11530003, 1. ],\n", - " [0. , 0. , 0.91011236]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91420308, 0.08526805, 0.98591549],\n", - " [0.82969152, 0.17306881, 0.98591549],\n", - " [0.7438946 , 0.25960321, 0.98591549],\n", - " [0.65938303, 0.34402702, 0.97183099],\n", - " [0.57326478, 0.42634023, 1. ],\n", - " [0.48746787, 0.51371887, 1. ],\n", - " [0.40552699, 0.60109751, 0.95774648],\n", - " [0.33097686, 0.66779232, 0.85915493],\n", - " [0.25064267, 0.75137189, 0.97183099],\n", - " [0.16773779, 0.83030815, 0.98591549],\n", - " [0.08322622, 0.91557619, 0.98591549],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 0.99622107, 0. ],\n", - " [0.8804878 , 0.99905527, 0.7 ],\n", - " [0.72317073, 1. , 0.91 ],\n", - " [0.55213415, 0.97779877, 1. ],\n", - " [0.43993902, 0.92300425, 0.69 ],\n", - " [0.34207317, 0.82002834, 0.71 ],\n", - " [0.26676829, 0.67831838, 0.68 ],\n", - " [0.20762195, 0.50921115, 0.71 ],\n", - " [0.14634146, 0.34671705, 0.7 ],\n", - " [0.07987805, 0.18422296, 0.7 ],\n", - " [0. , 0. , 0.8 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90095238, 0.89590998, 0.63063063],\n", - " [0.8 , 0.79268557, 0.62162162],\n", - " [0.64380952, 0.63103224, 1. ],\n", - " [0.53714286, 0.52802424, 0.62162162],\n", - " [0.4152381 , 0.41203203, 0.72072072],\n", - " [0.31809524, 0.30729279, 0.63963964],\n", - " [0.20190476, 0.20688163, 0.62162162],\n", - " [0.10666667, 0.10495564, 0.63063063],\n", - " [0. , 0. , 0.63963964]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89692044, 0.07033466, 0.98591549],\n", - " [0.79298546, 0.14152014, 0.98591549],\n", - " [0.69118905, 0.21157119, 0.98591549],\n", - " [0.58853721, 0.28247306, 0.97183099],\n", - " [0.48545766, 0.35422575, 1. ],\n", - " [0.38836612, 0.43221781, 1. ],\n", - " [0.31907613, 0.51956892, 0.97183099],\n", - " [0.25363559, 0.61542825, 0.98591549],\n", - " [0.19118905, 0.71072036, 0.97183099],\n", - " [0.12917023, 0.80714691, 0.98591549],\n", - " [0.06330197, 0.90754396, 1. ],\n", - " [0. , 1. , 0.97183099]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.9227027 , 0.08519481, 1. ],\n", - " [0.84864865, 0.17402597, 1. ],\n", - " [0.78162162, 0.25376623, 0.87142857],\n", - " [0.68486486, 0.33324675, 1. ],\n", - " [0.58594595, 0.41116883, 1. ],\n", - " [0.47405405, 0.48649351, 0.98571429],\n", - " [0.36324324, 0.56363636, 1. ],\n", - " [0.26486486, 0.63558442, 0.91428571],\n", - " [0.19837838, 0.72285714, 0.95714286],\n", - " [0.13621622, 0.81220779, 0.98571429],\n", - " [0.06918919, 0.90467532, 1. ],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14686825, 0.14530551, 0.98507463],\n", - " [0.29319654, 0.28961749, 0.98507463],\n", - " [0.424946 , 0.4212618 , 0.91044776],\n", - " [0.56965443, 0.56582216, 0.97014925],\n", - " [0.71382289, 0.7106309 , 1. ],\n", - " [0.8574514 , 0.85519126, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88333941, 0.88224181, 0.93589744],\n", - " [0.76558513, 0.76322418, 0.92307692],\n", - " [0.65730952, 0.65554156, 0.84615385],\n", - " [0.5501276 , 0.54911839, 0.84615385],\n", - " [0.44148742, 0.43986146, 0.84615385],\n", - " [0.33357638, 0.33217884, 0.83333333],\n", - " [0.23660226, 0.23551637, 0.78205128],\n", - " [0.10864017, 0.10831234, 1. ],\n", - " [0. , 0. , 0.84615385]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87549933, 0.876553 , 0.90410959],\n", - " [0.75166445, 0.75337034, 0.90410959],\n", - " [0.63115846, 0.63230241, 0.89041096],\n", - " [0.50798935, 0.50832672, 0.91780822],\n", - " [0.38482024, 0.38435104, 0.89041096],\n", - " [0.24833555, 0.24900872, 1. ],\n", - " [0.126498 , 0.12714777, 0.89041096],\n", - " [0. , 0. , 0.91780822]]),\n", - " array([[0.93979592, 0.97787398, 0. ],\n", - " [0.95408163, 0.97763348, 0.01236338],\n", - " [0.9622449 , 0.98027898, 0.03601505],\n", - " [0.95918367, 0.97643098, 0.02526429],\n", - " [0.95714286, 0.98075998, 0.03189393],\n", - " [0.95408163, 0.97715248, 0.06450457],\n", - " [0.96530612, 0.97883598, 0.22612435],\n", - " [0.97755102, 0.98003848, 0.70883354],\n", - " [0.96938776, 0.97883598, 0.3228812 ],\n", - " [0.9744898 , 0.98148148, 0.16090306],\n", - " [0.9755102 , 0.97787398, 0.03278982],\n", - " [0.97040816, 0.98124098, 0.03207311],\n", - " [0.98061224, 0.98244348, 0.03189393],\n", - " [0.9744898 , 0.97787398, 0.03278982],\n", - " [0.97040816, 0.98244348, 0.06414621],\n", - " [0.97244898, 0.97763348, 0.03243146],\n", - " [0.96428571, 0.97883598, 0.03189393],\n", - " [0.97244898, 0.97667148, 0.12954668],\n", - " [0.96428571, 0.98075998, 0.09675685],\n", - " [0.96938776, 0.97763348, 0.03243146],\n", - " [0.96428571, 0.97546898, 0.28973302],\n", - " [0.9744898 , 0.97594998, 0.48378427],\n", - " [0.97959184, 0.97835498, 0.19351371],\n", - " [0.96530612, 0.98003848, 0.22612435],\n", - " [0.96938776, 0.97763348, 0.64468733],\n", - " [0.96428571, 0.97546898, 0.80684465],\n", - " [0.9744898 , 0.98027898, 0.06432539],\n", - " [0.9744898 , 0.97763348, 0.03171475],\n", - " [0.98469388, 0.97835498, 0.09693603],\n", - " [0.97040816, 0.97715248, 0.29044974],\n", - " [0.98265306, 0.97715248, 0.03225228],\n", - " [0.9755102 , 0.98003848, 0.06468375],\n", - " [0.95510204, 0.98725349, 0.03207311],\n", - " [0.97040816, 0.97907648, 0.03243146],\n", - " [0.96734694, 0.97667148, 0.03225228],\n", - " [0.97755102, 0.97667148, 0.03171475],\n", - " [0.96938776, 0.97835498, 0.06504211],\n", - " [0.97244898, 0.97546898, 0.03171475],\n", - " [0.97244898, 0.97955748, 0.09729439],\n", - " [0.97040816, 0.97643098, 0.09639849],\n", - " [0.96938776, 0.98027898, 0.09657767],\n", - " [0.96938776, 0.97667148, 0.2908081 ],\n", - " [0.96020408, 0.97474747, 0.16090306],\n", - " [0.96530612, 0.97835498, 0.25801828],\n", - " [0.96428571, 0.97546898, 0.19333453],\n", - " [0.9744898 , 0.97522848, 0.22612435],\n", - " [0.99489796, 0.97907648, 0.1614406 ],\n", - " [0.98571429, 0.98075998, 0.16090306],\n", - " [0.97755102, 0.98388648, 0.80648629],\n", - " [0.9877551 , 0.98364598, 0.35441677],\n", - " [0.99591837, 0.98027898, 0.22576599],\n", - " [0.99285714, 0.98364598, 0.03243146],\n", - " [0.98061224, 0.98124098, 0.09657767],\n", - " [0.98979592, 0.98148148, 0.19369289],\n", - " [0.98061224, 0.97955748, 1. ],\n", - " [0.9744898 , 0.98436748, 0.19369289],\n", - " [0.98265306, 0.97835498, 0.06414621],\n", - " [0.98469388, 0.98244348, 0.1614406 ],\n", - " [0.99591837, 0.98148148, 0.25801828],\n", - " [0.98979592, 0.98508899, 0.19369289],\n", - " [0.99591837, 0.98268398, 0.06450457],\n", - " [0.99081633, 0.98484848, 0.06450457],\n", - " [1. , 0.98268398, 0.06468375],\n", - " [0.98979592, 0.98244348, 0.1284716 ],\n", - " [0.97959184, 0.98436748, 0.09675685],\n", - " [0.99081633, 0.98148148, 0.09675685],\n", - " [0.97755102, 0.98316498, 0.1293675 ],\n", - " [0.99489796, 0.98027898, 0.03207311],\n", - " [0.98469388, 0.98268398, 0.09675685],\n", - " [0.98061224, 0.98003848, 0.16108224],\n", - " [0.97244898, 0.97715248, 0.29062892],\n", - " [0.96020408, 0.97594998, 0.03207311],\n", - " [0.94693878, 0.97306397, 0.03243146],\n", - " [0.95204082, 0.97715248, 0.61225587],\n", - " [0.95408163, 0.97282347, 0.03261064],\n", - " [0.95204082, 0.97667148, 0.48360509],\n", - " [0.94387755, 0.97907648, 0.09693603],\n", - " [0.95204082, 0.97787398, 0.03243146],\n", - " [0.95918367, 0.97594998, 0.06396703],\n", - " [0.94897959, 0.97715248, 0.03225228],\n", - " [0.95714286, 0.97594998, 0.03243146],\n", - " [0.93979592, 0.98075998, 0.09657767],\n", - " [0.94897959, 0.97546898, 0.06522129],\n", - " [0.95408163, 0.97186147, 0.64486651],\n", - " [0.96020408, 0.97787398, 0.06414621],\n", - " [0.96020408, 0.97522848, 0.03278982],\n", - " [0.94897959, 0.97354497, 0.03189393],\n", - " [0.96020408, 0.97402597, 0.12900914],\n", - " [0.94183673, 0.97522848, 0.03243146],\n", - " [0.95204082, 0.97306397, 0.06432539],\n", - " [0.95408163, 0.97546898, 0.38684824],\n", - " [0.94489796, 0.97402597, 0.25819746],\n", - " [0.94387755, 0.97667148, 0.12918832],\n", - " [0.94387755, 0.97402597, 0.16090306],\n", - " [0.93979592, 0.97715248, 0.22576599],\n", - " [0.95510204, 0.97667148, 0.45189034],\n", - " [0.94183673, 0.97643098, 0.12865078],\n", - " [0.95204082, 0.97667148, 0.06486293],\n", - " [0.95918367, 0.97474747, 0.41874216],\n", - " [0.95408163, 0.97835498, 0.12918832],\n", - " [0.95204082, 0.97474747, 0.06450457],\n", - " [0.94897959, 0.97787398, 0.06468375],\n", - " [0.95204082, 0.98027898, 0.09693603],\n", - " [0.94183673, 0.97763348, 0.03207311],\n", - " [0.94693878, 0.97426647, 0.03189393],\n", - " [0.94387755, 0.97715248, 0.06468375],\n", - " [0.95510204, 0.97282347, 0.03225228],\n", - " [0.93979592, 0.97907648, 0.03243146],\n", - " [0.94897959, 0.97426647, 0.03189393],\n", - " [0.94489796, 0.97715248, 0.38702741],\n", - " [0.95204082, 0.97282347, 0.03243146],\n", - " [0.93877551, 0.97546898, 0.23830855],\n", - " [0.91428571, 0.97546898, 0.01272173],\n", - " [0.88877551, 0.97715248, 0.01236338],\n", - " [0.86734694, 0.98316498, 0.01146748],\n", - " [0.84489796, 0.98869649, 0.0112883 ],\n", - " [0.84489796, 0.9963925 , 0.01146748],\n", - " [0.86326531, 1. , 0.0112883 ],\n", - " [0.84489796, 0.9987975 , 0.03691095],\n", - " [0.81938776, 0.98917749, 0.01272173],\n", - " [0.78877551, 0.97065897, 0.01254256],\n", - " [0.76020408, 0.94660895, 0.01254256],\n", - " [0.73265306, 0.91871092, 0.01236338],\n", - " [0.70510204, 0.88263588, 0.01254256],\n", - " [0.67653061, 0.84175084, 0.01272173],\n", - " [0.64387755, 0.8003848 , 0.01254256],\n", - " [0.60816327, 0.75781626, 0.01236338],\n", - " [0.56938776, 0.71212121, 0.01272173],\n", - " [0.53163265, 0.66522367, 0.01254256],\n", - " [0.49489796, 0.62169312, 0.01236338],\n", - " [0.45510204, 0.57142857, 0.01254256],\n", - " [0.42142857, 0.52982203, 0.01092994],\n", - " [0.38877551, 0.47931698, 0.01236338],\n", - " [0.34489796, 0.42448292, 0.01236338],\n", - " [0.30408163, 0.36820587, 0.01290091],\n", - " [0.26020408, 0.31409331, 0.01254256],\n", - " [0.20918367, 0.25877826, 0.01236338],\n", - " [0.16326531, 0.1996152 , 0.01272173],\n", - " [0.12346939, 0.14502165, 0.01236338],\n", - " [0.07755102, 0.08922559, 0.01254256],\n", - " [0.03877551, 0.04569505, 0.01092994],\n", - " [0. , 0. , 0.01236338]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08333333, 0.08589909, 0.95833333],\n", - " [0.16306306, 0.16817594, 0.95833333],\n", - " [0.23603604, 0.24346701, 0.84722222],\n", - " [0.31441441, 0.32626132, 0.95833333],\n", - " [0.39594595, 0.41319534, 0.98611111],\n", - " [0.47612613, 0.49831824, 0.97222222],\n", - " [0.56306306, 0.58085382, 0.95833333],\n", - " [0.65225225, 0.66416559, 1. ],\n", - " [0.73783784, 0.7461837 , 0.95833333],\n", - " [0.82612613, 0.8313066 , 0.98611111],\n", - " [0.91126126, 0.91435964, 0.97222222],\n", - " [1. , 1. , 0.97222222]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.0192199 , 0.94057638, 1. ],\n", - " [0.04126625, 0.87681714, 0.95774648],\n", - " [0.06726964, 0.80642693, 1. ],\n", - " [0.09101187, 0.73960724, 0.90140845],\n", - " [0.09723007, 0.66794185, 0.91549296],\n", - " [0.09779536, 0.59882683, 0.90140845],\n", - " [0.11984172, 0.53098699, 0.88732394],\n", - " [0.16732617, 0.46977812, 0.85915493],\n", - " [0.21763708, 0.40168324, 0.90140845],\n", - " [0.2866026 , 0.33996429, 0.87323944],\n", - " [0.39174675, 0.28589645, 0.95774648],\n", - " [0.50876201, 0.22800306, 0.97183099],\n", - " [0.6308649 , 0.17087478, 0.98591549],\n", - " [0.75296778, 0.11425657, 0.98591549],\n", - " [0.87563595, 0.05738332, 0.98591549],\n", - " [1. , 0. , 0.98591549]]),\n", - " array([[0.5390322 , 0.33616419, 0. ],\n", - " [0.55875906, 0.21832979, 0.00987959],\n", - " [0.59484067, 0.16737438, 0.00987959],\n", - " [0.6317653 , 0.15923567, 0.00957086],\n", - " [0.67391671, 0.15923567, 0.00987959],\n", - " [0.7244984 , 0.17692852, 0.01265823],\n", - " [0.76816726, 0.20169851, 0.01096017],\n", - " [0.80880121, 0.21832979, 0.0108058 ],\n", - " [0.84252234, 0.23602265, 0.0108058 ],\n", - " [0.87337717, 0.24769993, 0.00972522],\n", - " [0.90440061, 0.25442321, 0.00987959],\n", - " [0.93238914, 0.24769993, 0.00987959],\n", - " [0.95767999, 0.22434536, 0.00957086],\n", - " [0.97824987, 0.18577495, 0.00987959],\n", - " [0.99140111, 0.14154282, 0.01018833],\n", - " [1. , 0.09731069, 0.00987959],\n", - " [0.99983139, 0.05307856, 0.00972522],\n", - " [0.99426741, 0.01769285, 0.00972522],\n", - " [0.98297083, 0. , 0.00941649],\n", - " [0.97150565, 0.01061571, 0.00972522],\n", - " [0.9669533 , 0.03963199, 0.00972522],\n", - " [0.96341258, 0.07678698, 0.00972522],\n", - " [0.96054628, 0.10615711, 0.00987959],\n", - " [0.95767999, 0.12774239, 0.00972522],\n", - " [0.95767999, 0.13411182, 0.00941649],\n", - " [0.95767999, 0.12986553, 0.0108058 ],\n", - " [0.96054628, 0.12986553, 0.01065144],\n", - " [0.96054628, 0.12384996, 0.0108058 ],\n", - " [0.96611027, 0.10615711, 0.02624267],\n", - " [0.96341258, 0.10615711, 0.02794072],\n", - " [0.96526724, 0.10120311, 0.02778635],\n", - " [0.9701568 , 0.09023355, 0.02763199],\n", - " [0.97740685, 0.0651097 , 0.05572708],\n", - " [0.98027314, 0.0651097 , 0.02747762],\n", - " [0.98297083, 0.0651097 , 0.05572708],\n", - " [0.98027314, 0.0651097 , 0.08335906],\n", - " [0.98297083, 0.07077141, 0.27801791],\n", - " [0.98179059, 0.06723284, 0.02763199],\n", - " [0.98027314, 0.0651097 , 0.05572708],\n", - " [0.98297083, 0.0651097 , 0.19435011],\n", - " [0.98027314, 0.0651097 , 0.02794072],\n", - " [0.98297083, 0.0651097 , 0.08320469],\n", - " [0.98027314, 0.0651097 , 0.02778635],\n", - " [0.98297083, 0.0651097 , 0.16671812],\n", - " [0.98027314, 0.0651097 , 0.05572708],\n", - " [0.98297083, 0.0651097 , 0.08320469],\n", - " [0.98297083, 0.07077141, 0.1387774 ],\n", - " [0.98297083, 0.0651097 , 0.05588144],\n", - " [0.98027314, 0.0651097 , 0.11083668],\n", - " [0.98297083, 0.0651097 , 0.02794072],\n", - " [0.98145338, 0.06581741, 0.02794072],\n", - " [0.98297083, 0.0651097 , 0.02778635],\n", - " [0.98027314, 0.0651097 , 0.02747762],\n", - " [0.98297083, 0.0651097 , 0.05557271],\n", - " [0.98027314, 0.0651097 , 0.02794072],\n", - " [0.98297083, 0.0651097 , 0.08351343],\n", - " [0.98027314, 0.0651097 , 0.02747762],\n", - " [0.98297083, 0.0651097 , 0.02794072],\n", - " [0.98027314, 0.05909413, 0.05572708],\n", - " [0.98027314, 0.0651097 , 0.05526397],\n", - " [0.98027314, 0.05909413, 0.05588144],\n", - " [0.98027314, 0.0651097 , 0.05541834],\n", - " [0.97740685, 0.05909413, 0.05572708],\n", - " [0.98027314, 0.0651097 , 0.05557271],\n", - " [0.98111617, 0.06192498, 0.05557271],\n", - " [0.98027314, 0.0651097 , 0.02778635],\n", - " [0.98027314, 0.05909413, 0.08335906],\n", - " [0.98027314, 0.0651097 , 0.30564989],\n", - " [0.98027314, 0.05909413, 0.02778635],\n", - " [0.97740685, 0.05909413, 0.08320469],\n", - " [0.97943011, 0.05909413, 0.02778635],\n", - " [0.98027314, 0.0651097 , 0.11129978],\n", - " [0.98027314, 0.05909413, 0.08320469],\n", - " [0.97993593, 0.0626327 , 0.02778635],\n", - " [0.98027314, 0.05909413, 0.08351343],\n", - " [0.98027314, 0.0651097 , 0.05557271],\n", - " [0.98027314, 0.05909413, 0.05557271],\n", - " [0.98027314, 0.0651097 , 0.05557271],\n", - " [0.98027314, 0.05909413, 0.02747762],\n", - " [0.98027314, 0.0651097 , 0.08351343],\n", - " [0.98297083, 0.0651097 , 0.05572708],\n", - " [0.98027314, 0.0651097 , 0.02778635],\n", - " [0.98027314, 0.05909413, 0.02747762],\n", - " [0.98027314, 0.0651097 , 0.02794072],\n", - " [0.98027314, 0.05909413, 0.08335906],\n", - " [0.97740685, 0.05909413, 0.1387774 ],\n", - " [0.9790929 , 0.06086341, 0.05572708],\n", - " [0.98094756, 0.06157113, 0.11114542],\n", - " [0.98027314, 0.0651097 , 0.13908614],\n", - " [0.98027314, 0.05980184, 0.02763199],\n", - " [0.97740685, 0.05909413, 0.24992282],\n", - " [0.9789243 , 0.05732484, 0.02809509],\n", - " [0.97740685, 0.05909413, 0.02763199],\n", - " [0.98027314, 0.05909413, 0.05541834],\n", - " [0.97740685, 0.05909413, 0.05588144],\n", - " [0.97740685, 0.05307856, 0.13893177],\n", - " [0.97740685, 0.05909413, 0.05541834],\n", - " [0.97740685, 0.05307856, 0.02763199],\n", - " [0.9789243 , 0.05803255, 0.02809509],\n", - " [0.97740685, 0.05909413, 0.02763199],\n", - " [0.97740685, 0.05307856, 0.02763199],\n", - " [0.97740685, 0.05909413, 0.02809509],\n", - " [0.97774406, 0.0552017 , 0.02763199],\n", - " [0.97740685, 0.05909413, 0.11129978],\n", - " [0.97740685, 0.05307856, 0.05557271],\n", - " [0.97454055, 0.05307856, 0.11114542],\n", - " [0.97740685, 0.05307856, 0.16671812],\n", - " [0.97454055, 0.05307856, 0.02778635],\n", - " [0.97656382, 0.05201699, 0.05557271],\n", - " [0.97454055, 0.05307856, 0.11099105],\n", - " [0.97740685, 0.05307856, 0.19465885],\n", - " [0.97454055, 0.05307856, 0.02763199],\n", - " [0.97454055, 0.04741684, 0.08335906],\n", - " [0.97454055, 0.05307856, 0.02778635],\n", - " [0.97740685, 0.05307856, 0.05541834],\n", - " [0.97454055, 0.04741684, 0.05588144],\n", - " [0.97454055, 0.05307856, 0.02763199],\n", - " [0.97740685, 0.05307856, 0.16671812],\n", - " [0.97504637, 0.05166313, 0.08335906],\n", - " [0.97740685, 0.05307856, 0.11114542],\n", - " [0.97420334, 0.04953999, 0.05572708],\n", - " [0.97454055, 0.05307856, 0.02763199],\n", - " [0.97622661, 0.05237084, 0.02794072],\n", - " [0.97454055, 0.05307856, 0.02747762],\n", - " [0.97454055, 0.04741684, 0.02778635],\n", - " [0.97454055, 0.05307856, 0.02809509],\n", - " [0.97454055, 0.04741684, 0.02747762],\n", - " [0.97184286, 0.04741684, 0.36137697],\n", - " [0.97504637, 0.04847841, 0.05557271],\n", - " [0.97352892, 0.04706299, 0.27786354],\n", - " [0.97470916, 0.04953999, 0.27801791],\n", - " [0.97740685, 0.05307856, 0.19435011],\n", - " [0.97504637, 0.0502477 , 0.02778635],\n", - " [0.97740685, 0.05307856, 0.11114542],\n", - " [0.97841848, 0.05590941, 0.25023155],\n", - " [0.97740685, 0.05307856, 0.08335906],\n", - " [0.97504637, 0.05095541, 1. ],\n", - " [0.97454055, 0.04741684, 0.16687249],\n", - " [0.97184286, 0.04741684, 0.66687249],\n", - " [0.97454055, 0.04741684, 0.11114542],\n", - " [0.97184286, 0.04741684, 0.11099105],\n", - " [0.96897656, 0.04140127, 0.11145415],\n", - " [0.97032541, 0.04635527, 0.02763199],\n", - " [0.97184286, 0.04741684, 0.02794072],\n", - " [0.97454055, 0.04741684, 0.30549552],\n", - " [0.97521497, 0.05095541, 0.16671812],\n", - " [0.97454055, 0.04741684, 0.02794072],\n", - " [0.97184286, 0.04741684, 0.33343625],\n", - " [0.97454055, 0.04741684, 0.16671812],\n", - " [0.97454055, 0.05307856, 0.08320469],\n", - " [0.97572079, 0.05060156, 0.02794072],\n", - " [0.97454055, 0.05307856, 0.02778635],\n", - " [0.97454055, 0.04741684, 0.02763199],\n", - " [0.97740685, 0.05307856, 0.11099105],\n", - " [0.97454055, 0.05307856, 0.27786354],\n", - " [0.97740685, 0.05307856, 0.05588144],\n", - " [0.97740685, 0.05909413, 0.41648657],\n", - " [0.97875569, 0.0552017 , 0.02809509],\n", - " [0.97740685, 0.05307856, 0.05541834],\n", - " [0.98027314, 0.05909413, 0.02763199],\n", - " [0.97740685, 0.05307856, 0.08335906],\n", - " [0.98027314, 0.05307856, 0.02809509],\n", - " [0.97740685, 0.05307856, 0.02763199],\n", - " [0.97454055, 0.05307856, 0.22229083],\n", - " [0.97740685, 0.05307856, 0.05572708],\n", - " [0.97454055, 0.04741684, 0.16671812],\n", - " [0.97454055, 0.05307856, 0.02763199],\n", - " [0.97740685, 0.05307856, 0.11129978],\n", - " [0.97454055, 0.05307856, 0.11099105],\n", - " [0.97622661, 0.05626327, 0.13908614],\n", - " [0.97740685, 0.05307856, 0.05541834],\n", - " [0.97454055, 0.04741684, 0.05541834],\n", - " [0.97184286, 0.04741684, 0.11129978],\n", - " [0.97454055, 0.04741684, 0.11099105],\n", - " [0.97555218, 0.05060156, 0.05572708],\n", - " [0.97740685, 0.05307856, 0.11129978],\n", - " [0.98044175, 0.0576787 , 0.19435011],\n", - " [0.98297083, 0.05909413, 0.16671812],\n", - " [0.98297083, 0.0651097 , 0.05572708],\n", - " [0.98297083, 0.05909413, 0.02763199],\n", - " [0.98027314, 0.05909413, 0.05557271],\n", - " [0.98297083, 0.05909413, 0.13893177],\n", - " [0.98027314, 0.05909413, 0.05557271],\n", - " [0.97740685, 0.05307856, 0.05557271],\n", - " [0.97454055, 0.04741684, 0.55572708],\n", - " [0.97184286, 0.04741684, 0.02794072],\n", - " [0.96897656, 0.04140127, 0.02763199],\n", - " [0.96611027, 0.04140127, 0.02763199],\n", - " [0.97268589, 0.04706299, 0.02794072],\n", - " [0.97454055, 0.04741684, 0.02778635],\n", - " [0.97184286, 0.04741684, 0.05557271],\n", - " [0.96897656, 0.04741684, 0.16687249],\n", - " [0.96863935, 0.04352442, 0.02763199],\n", - " [0.97184286, 0.04741684, 0.08335906],\n", - " [0.97454055, 0.04741684, 0.16687249],\n", - " [0.97454055, 0.05307856, 0.22213646],\n", - " [0.97454055, 0.04741684, 0.02778635],\n", - " [0.97454055, 0.05307856, 0.05572708],\n", - " [0.97454055, 0.04741684, 0.02763199],\n", - " [0.97454055, 0.05307856, 0.02778635],\n", - " [0.97454055, 0.04741684, 0.05557271],\n", - " [0.97454055, 0.05307856, 0.02778635],\n", - " [0.97454055, 0.04741684, 0.11129978],\n", - " [0.9730231 , 0.04847841, 0.02778635],\n", - " [0.97454055, 0.04741684, 0.05557271],\n", - " [0.97234868, 0.04741684, 0.16671812],\n", - " [0.97066262, 0.04741684, 0.41679531],\n", - " [0.96897656, 0.04741684, 0.02747762],\n", - " [0.97184286, 0.04741684, 0.05588144],\n", - " [0.97454055, 0.04741684, 0.08305032],\n", - " [0.97184286, 0.04741684, 0.13924051],\n", - " [0.97454055, 0.04741684, 0.55557271],\n", - " [0.97538358, 0.05307856, 0.02794072],\n", - " [0.97740685, 0.05307856, 0.02763199],\n", - " [0.97740685, 0.05909413, 0.08351343],\n", - " [0.97740685, 0.05307856, 0.11099105],\n", - " [0.97740685, 0.05909413, 0.02794072],\n", - " [0.97740685, 0.05307856, 0.02778635],\n", - " [0.97538358, 0.0527247 , 0.08320469],\n", - " [0.97740685, 0.05307856, 0.1387774 ],\n", - " [0.97740685, 0.04741684, 0.02794072],\n", - " [0.97555218, 0.0502477 , 0.02794072],\n", - " [0.97740685, 0.05307856, 0.02763199],\n", - " [0.97184286, 0.07678698, 0.16671812],\n", - " [0.96897656, 0.08280255, 0.02778635],\n", - " [0.964087 , 0.10509554, 0.05572708],\n", - " [0.96054628, 0.11818825, 0.02763199],\n", - " [0.95262182, 0.13552725, 0.05572708],\n", - " [0.94655201, 0.14154282, 0.01883297],\n", - " [0.94655201, 0.14755839, 0.01065144],\n", - " [0.94250548, 0.15711253, 0.0108058 ],\n", - " [0.94081942, 0.17126681, 0.0108058 ],\n", - " [0.93795313, 0.1836518 , 0.00941649],\n", - " [0.9310403 , 0.20205237, 0.01065144],\n", - " [0.91552858, 0.22434536, 0.01096017],\n", - " [0.89597033, 0.2537155 , 0.01049707],\n", - " [0.87303996, 0.2915782 , 0.01111454],\n", - " [0.84808633, 0.33050248, 0.01065144],\n", - " [0.8172315 , 0.37756546, 0.01234949],\n", - " [0.79126623, 0.41967445, 0.00941649],\n", - " [0.76378351, 0.46602972, 0.01065144],\n", - " [0.73006238, 0.507431 , 0.01096017],\n", - " [0.69920755, 0.55449398, 0.01065144],\n", - " [0.66835272, 0.59589526, 0.01065144],\n", - " [0.63732929, 0.63694268, 0.0108058 ],\n", - " [0.60360816, 0.68435952, 0.01111454],\n", - " [0.56988703, 0.73142251, 0.0108058 ],\n", - " [0.53616591, 0.77848549, 0.01204075],\n", - " [0.50817737, 0.81988677, 0.00987959],\n", - " [0.47479346, 0.83828733, 0.01049707],\n", - " [0.44073512, 0.8492569 , 0.01018833],\n", - " [0.4071826 , 0.85633404, 0.00972522],\n", - " [0.36705446, 0.85491861, 0.01234949],\n", - " [0.33670545, 0.85527247, 0.01096017],\n", - " [0.30585062, 0.8492569 , 0.0108058 ],\n", - " [0.28190862, 0.84359519, 0.01065144],\n", - " [0.25796662, 0.83757962, 0.0108058 ],\n", - " [0.23840836, 0.83757962, 0.0108058 ],\n", - " [0.21581521, 0.83156405, 0.01404755],\n", - " [0.20182094, 0.83156405, 0.00957086],\n", - " [0.19052436, 0.83156405, 0.01049707],\n", - " [0.17939639, 0.81988677, 0.01065144],\n", - " [0.16995448, 0.80431706, 0.00987959],\n", - " [0.15966953, 0.79617834, 0.01018833],\n", - " [0.14837296, 0.79051663, 0.0108058 ],\n", - " [0.13724498, 0.78450106, 0.0108058 ],\n", - " [0.1288147 , 0.78450106, 0.01096017],\n", - " [0.11751813, 0.77848549, 0.01049707],\n", - " [0.10622155, 0.77848549, 0.01096017],\n", - " [0.09509358, 0.77282378, 0.0108058 ],\n", - " [0.08936098, 0.76680821, 0.01096017],\n", - " [0.083797 , 0.76680821, 0.01234949],\n", - " [0.0809307 , 0.76079264, 0.01049707],\n", - " [0.07823301, 0.76079264, 0.01250386],\n", - " [0.07536672, 0.75548478, 0.01234949],\n", - " [0.07536672, 0.74911536, 0.00941649],\n", - " [0.07250042, 0.75513093, 0.04013584],\n", - " [0.06693644, 0.75513093, 0.00957086],\n", - " [0.0600236 , 0.75017693, 0.00987959],\n", - " [0.05294217, 0.73743808, 0.00972522],\n", - " [0.0480526 , 0.71196037, 0.01234949],\n", - " [0.04737818, 0.6861288 , 0.0108058 ],\n", - " [0.04720958, 0.6606511 , 0.01096017],\n", - " [0.05007587, 0.63694268, 0.0108058 ],\n", - " [0.05294217, 0.61358811, 0.00957086],\n", - " [0.05007587, 0.58386412, 0.00987959],\n", - " [0.0387793 , 0.56617127, 0.00972522],\n", - " [0.03034901, 0.57218684, 0.00972522],\n", - " [0.02309897, 0.60474168, 0.01049707],\n", - " [0.01922104, 0.64897381, 0.01065144],\n", - " [0.01686056, 0.7059448 , 0.00987959],\n", - " [0.01635475, 0.76079264, 0.01003396],\n", - " [0.01348845, 0.8138712 , 0.01003396],\n", - " [0.01079076, 0.86694975, 0.01173202],\n", - " [0.00758725, 0.90835103, 0.01096017],\n", - " [0.00505817, 0.93772116, 0.00957086],\n", - " [0.00219187, 0.96850672, 0.00941649],\n", - " [0. , 1. , 0.00972522]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91932169, 0.92038993, 0.91139241],\n", - " [0.84429599, 0.84646629, 0.86075949],\n", - " [0.76464543, 0.76929326, 0.89873418],\n", - " [0.68961973, 0.69374492, 0.87341772],\n", - " [0.62487153, 0.62659085, 0.7721519 ],\n", - " [0.54727646, 0.55104251, 0.88607595],\n", - " [0.4696814 , 0.47305714, 0.88607595],\n", - " [0.39260021, 0.3975088 , 0.88607595],\n", - " [0.30421377, 0.31004603, 1. ],\n", - " [0.22970195, 0.23178987, 0.89873418],\n", - " [0.15313464, 0.15651232, 0.87341772],\n", - " [0.07605344, 0.07744381, 0.89873418],\n", - " [0. , 0. , 0.87341772]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90531742, 0.90415913, 0.86419753],\n", - " [0.80982094, 0.81374322, 0.85185185],\n", - " [0.7116115 , 0.70886076, 0.88888889],\n", - " [0.60336408, 0.60216998, 0.97530864],\n", - " [0.50623983, 0.51175407, 0.86419753],\n", - " [0.41155724, 0.41952984, 0.86419753],\n", - " [0.29924037, 0.2965642 , 1. ],\n", - " [0.19017906, 0.19529837, 0.97530864],\n", - " [0.09549647, 0.09764919, 0.86419753],\n", - " [0. , 0. , 0.85185185]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90515252, 0.91035857, 0.88405797],\n", - " [0.80748526, 0.81673307, 0.89855072],\n", - " [0.70699821, 0.71115538, 0.92753623],\n", - " [0.60830556, 0.60756972, 0.91304348],\n", - " [0.50961292, 0.5059761 , 0.91304348],\n", - " [0.40579339, 0.4063745 , 0.95652174],\n", - " [0.30992053, 0.31474104, 0.88405797],\n", - " [0.20507562, 0.21115538, 0.95652174],\n", - " [0.10561395, 0.10756972, 0.92753623],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89394969, 0.10206212, 1. ],\n", - " [0.79537729, 0.20281911, 0.98571429],\n", - " [0.69408566, 0.30775255, 1. ],\n", - " [0.60639021, 0.39650222, 0.87142857],\n", - " [0.50577838, 0.49830332, 0.98571429],\n", - " [0.40244731, 0.60114853, 1. ],\n", - " [0.31407206, 0.69015923, 0.87142857],\n", - " [0.20734194, 0.79352649, 1. ],\n", - " [0.10401088, 0.89689376, 1. ],\n", - " [0. , 1. , 0.98571429]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10367893, 0.10566242, 0.85185185],\n", - " [0.22449833, 0.22785153, 0.98765432],\n", - " [0.32859532, 0.33568139, 0.86419753],\n", - " [0.45150502, 0.45814143, 1. ],\n", - " [0.55643813, 0.55973991, 0.85185185],\n", - " [0.66429766, 0.66946627, 0.87654321],\n", - " [0.76588629, 0.77296126, 0.85185185],\n", - " [0.87667224, 0.87862368, 0.87654321],\n", - " [1. , 1. , 0.98765432]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1052364 , 0.10800357, 0.69306931],\n", - " [0.2282664 , 0.23385897, 0.79207921],\n", - " [0.36959837, 0.37935138, 0.88118812],\n", - " [0.52364006, 0.53704255, 1. ],\n", - " [0.6314184 , 0.64504612, 0.7029703 ],\n", - " [0.73817997, 0.75156204, 0.67326733],\n", - " [0.8551093 , 0.86462362, 0.7029703 ],\n", - " [1. , 1. , 0.88118812]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88933121, 0.88826367, 0.97014925],\n", - " [0.77839703, 0.77652733, 0.98507463],\n", - " [0.66613588, 0.66157556, 0.98507463],\n", - " [0.5552017 , 0.54983923, 0.98507463],\n", - " [0.44559448, 0.43971061, 0.98507463],\n", - " [0.33333333, 0.32797428, 1. ],\n", - " [0.22080679, 0.21864952, 0.98507463],\n", - " [0.10934183, 0.10771704, 0.98507463],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8998999 , 0.07954545, 0.97183099],\n", - " [0.8018018 , 0.16477273, 0.98591549],\n", - " [0.7007007 , 0.23295455, 1. ],\n", - " [0.60085085, 0.30681818, 0.98591549],\n", - " [0.50075075, 0.42045455, 0.98591549],\n", - " [0.40365365, 0.52272727, 0.95774648],\n", - " [0.30205205, 0.61363636, 1. ],\n", - " [0.20195195, 0.73295455, 0.98591549],\n", - " [0.1006006 , 0.86931818, 1. ],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08333333, 0.08589909, 0.95833333],\n", - " [0.16306306, 0.16817594, 0.95833333],\n", - " [0.23603604, 0.24346701, 0.84722222],\n", - " [0.31441441, 0.32626132, 0.95833333],\n", - " [0.39594595, 0.41319534, 0.98611111],\n", - " [0.47612613, 0.49831824, 0.97222222],\n", - " [0.56306306, 0.58085382, 0.95833333],\n", - " [0.65225225, 0.66416559, 1. ],\n", - " [0.73783784, 0.7461837 , 0.95833333],\n", - " [0.82612613, 0.8313066 , 0.98611111],\n", - " [0.91126126, 0.91435964, 0.97222222],\n", - " [1. , 1. , 0.97222222]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09622707, 0.84419166, 0.92424242],\n", - " [0.2211838 , 0.71216822, 0.96969697],\n", - " [0.35375562, 0.5887625 , 1. ],\n", - " [0.48840429, 0.4622544 , 1. ],\n", - " [0.62132226, 0.34298518, 0.98484848],\n", - " [0.73970232, 0.23612547, 0.92424242],\n", - " [0.87088958, 0.11651155, 1. ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.03138374, 0.04688973, 0.86419753],\n", - " [0.08131241, 0.09519321, 0.85185185],\n", - " [0.12981455, 0.13972667, 0.75308642],\n", - " [0.18259629, 0.19180019, 0.86419753],\n", - " [0.21112696, 0.24434496, 0.83950617],\n", - " [0.20399429, 0.29948162, 0.86419753],\n", - " [0.17689016, 0.35626767, 0.88888889],\n", - " [0.15406562, 0.41093308, 0.83950617],\n", - " [0.13552068, 0.46347785, 0.88888889],\n", - " [0.13694722, 0.50895382, 0.83950617],\n", - " [0.15121255, 0.55207352, 0.87654321],\n", - " [0.18116976, 0.59731385, 0.87654321],\n", - " [0.2296719 , 0.64373233, 0.86419753],\n", - " [0.30813124, 0.6972196 , 0.97530864],\n", - " [0.42225392, 0.74858624, 1. ],\n", - " [0.54208274, 0.80136664, 0.96296296],\n", - " [0.64621969, 0.84566447, 0.88888889],\n", - " [0.73894437, 0.88407163, 0.86419753],\n", - " [0.82310984, 0.92059378, 0.85185185],\n", - " [0.91012839, 0.9594722 , 0.86419753],\n", - " [1. , 1. , 0.85185185]]),\n", - " array([[0.27722772, 1. , 0. ],\n", - " [0. , 0.8795045 , 1. ],\n", - " [0.04950495, 0.76914414, 1. ],\n", - " [0.07920792, 0.65923423, 1. ],\n", - " [0.12871287, 0.54774775, 1. ],\n", - " [0.17821782, 0.44121622, 1. ],\n", - " [0.07920792, 0.32972973, 1. ],\n", - " [0.24752475, 0.23986486, 1. ],\n", - " [0.62376238, 0.11148649, 1. ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92137592, 0.91666667, 0.74725275],\n", - " [0.84766585, 0.84682765, 0.67032967],\n", - " [0.74078624, 0.73697917, 1. ],\n", - " [0.65847666, 0.65435606, 0.76923077],\n", - " [0.58599509, 0.56889205, 0.76923077],\n", - " [0.50614251, 0.48768939, 0.74725275],\n", - " [0.43243243, 0.41595644, 0.67032967],\n", - " [0.34520885, 0.33072917, 0.78021978],\n", - " [0.25552826, 0.24928977, 0.76923077],\n", - " [0.16830467, 0.16619318, 0.75824176],\n", - " [0.07616708, 0.0842803 , 0.78021978],\n", - " [0. , 0. , 0.76923077]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86811352, 0.86810417, 0.86813187],\n", - " [0.74791319, 0.75021003, 0.78021978],\n", - " [0.63550362, 0.63623635, 0.75824176],\n", - " [0.49693934, 0.49929992, 0.89010989],\n", - " [0.38286032, 0.38392607, 0.76923077],\n", - " [0.26655537, 0.26743209, 0.75824176],\n", - " [0.11574847, 0.11593391, 1. ],\n", - " [0. , 0. , 0.76923077]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9276407 , 0.93355482, 0.875 ],\n", - " [0.86664818, 0.87707641, 0.7625 ],\n", - " [0.79484336, 0.79568106, 0.8625 ],\n", - " [0.73357361, 0.74086379, 0.7625 ],\n", - " [0.66176878, 0.66943522, 0.875 ],\n", - " [0.58913224, 0.59966777, 0.875 ],\n", - " [0.51594123, 0.53156146, 0.875 ],\n", - " [0.44219573, 0.4551495 , 0.875 ],\n", - " [0.36179651, 0.37209302, 1. ],\n", - " [0.29026892, 0.30232558, 0.875 ],\n", - " [0.2184641 , 0.22093023, 0.875 ],\n", - " [0.14582756, 0.14119601, 0.8625 ],\n", - " [0.07208206, 0.06976744, 0.8875 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11267218, 0.88849348, 0.98611111],\n", - " [0.22534435, 0.77758007, 0.95833333],\n", - " [0.33911846, 0.66251483, 1. ],\n", - " [0.45041322, 0.55160142, 0.95833333],\n", - " [0.56363636, 0.43831554, 0.95833333],\n", - " [0.67630854, 0.32562278, 0.98611111],\n", - " [0.79118457, 0.20996441, 0.97222222],\n", - " [0.88677686, 0.113879 , 0.84722222],\n", - " [1. , 0. , 0.95833333]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12690919, 0.12635379, 1. ],\n", - " [0.24687587, 0.24729242, 0.97183099],\n", - " [0.35406831, 0.35740072, 0.85915493],\n", - " [0.47542349, 0.48375451, 0.98591549],\n", - " [0.59844488, 0.60830325, 0.97183099],\n", - " [0.63343516, 0.64259928, 0.28169014],\n", - " [0.75645654, 0.76353791, 0.98591549],\n", - " [0.87892252, 0.88628159, 0.98591549],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90237603, 0.90572687, 0.6969697 ],\n", - " [0.80785124, 0.810279 , 0.71717172],\n", - " [0.7107438 , 0.71483113, 0.70707071],\n", - " [0.57954545, 0.58002937, 1. ],\n", - " [0.48140496, 0.48516887, 0.71717172],\n", - " [0.37551653, 0.37826725, 0.80808081],\n", - " [0.28305785, 0.28546256, 0.6969697 ],\n", - " [0.1875 , 0.189721 , 0.70707071],\n", - " [0.07902893, 0.08017621, 0.81818182],\n", - " [0. , 0. , 0.61616162]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8555311 , 0.10659898, 0.93055556],\n", - " [0.7135388 , 0.20304569, 0.90277778],\n", - " [0.57402312, 0.29949239, 0.91666667],\n", - " [0.43258118, 0.39086294, 0.91666667],\n", - " [0.29003853, 0.56852792, 0.91666667],\n", - " [0.15024766, 0.79695431, 0.91666667],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14975192, 0.14799214, 0.67708333],\n", - " [0.29995489, 0.29879247, 0.69791667],\n", - " [0.47902571, 0.47739399, 0.8125 ],\n", - " [0.63148399, 0.63100253, 0.6875 ],\n", - " [0.85160126, 0.8511654 , 1. ],\n", - " [1. , 1. , 0.67708333]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91905388, 0.90140845, 0.79775281],\n", - " [0.83731932, 0.84507042, 0.78651685],\n", - " [0.75637319, 0.79342723, 0.78651685],\n", - " [0.65413929, 0.66197183, 1. ],\n", - " [0.57424442, 0.5258216 , 0.79775281],\n", - " [0.49408673, 0.45070423, 0.78651685],\n", - " [0.41340342, 0.37558685, 0.78651685],\n", - " [0.33166886, 0.30985915, 0.79775281],\n", - " [0.25045992, 0.24413146, 0.78651685],\n", - " [0.15952694, 0.15492958, 0.88764045],\n", - " [0.07858081, 0.08450704, 0.79775281],\n", - " [0. , 0. , 0.78651685]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11636557, 0.33333333, 0.875 ],\n", - " [0.23166844, 0.73333333, 0.875 ],\n", - " [0.36716259, 0.86666667, 1. ],\n", - " [0.49760893, 1. , 0.9875 ],\n", - " [0.61716259, 0.8 , 0.9 ],\n", - " [0.74920298, 0.86666667, 0.9875 ],\n", - " [0.88469713, 0.73333333, 1. ],\n", - " [1. , 0.8 , 0.875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88519213, 0.88570671, 0.86904762],\n", - " [0.77881912, 0.77910369, 0.77380952],\n", - " [0.67291471, 0.67303103, 0.78571429],\n", - " [0.56841612, 0.56854946, 0.78571429],\n", - " [0.45173383, 0.45133917, 0.85714286],\n", - " [0.34395501, 0.3439406 , 0.79761905],\n", - " [0.23992502, 0.23972421, 0.77380952],\n", - " [0.13448922, 0.13418191, 0.78571429],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85824977, 0.85678601, 0.97014925],\n", - " [0.71558797, 0.71412712, 0.98507463],\n", - " [0.57247037, 0.57063558, 1. ],\n", - " [0.42889699, 0.42797669, 0.97014925],\n", - " [0.2857794 , 0.28531779, 0.98507463],\n", - " [0.14448496, 0.14487927, 0.98507463],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.07623318, 0.08402235, 0.98591549],\n", - " [0.14798206, 0.15597765, 0.85915493],\n", - " [0.24215247, 0.24156425, 0.98591549],\n", - " [0.33183857, 0.32424581, 0.98591549],\n", - " [0.38565022, 0.40960894, 1. ],\n", - " [0.44843049, 0.49385475, 0.98591549],\n", - " [0.52017937, 0.57653631, 0.97183099],\n", - " [0.62780269, 0.66189944, 0.98591549],\n", - " [0.71748879, 0.74458101, 0.98591549],\n", - " [0.8161435 , 0.8301676 , 0.98591549],\n", - " [0.89237668, 0.90592179, 0.85915493],\n", - " [1. , 1. , 0.97183099]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14686825, 0.14530551, 0.98507463],\n", - " [0.29319654, 0.28961749, 0.98507463],\n", - " [0.424946 , 0.4212618 , 0.91044776],\n", - " [0.56965443, 0.56582216, 0.97014925],\n", - " [0.71382289, 0.7106309 , 1. ],\n", - " [0.8574514 , 0.85519126, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13428252, 0.12765957, 1. ],\n", - " [0.25823562, 0.24680851, 0.90277778],\n", - " [0.36795087, 0.36085106, 0.84722222],\n", - " [0.49274149, 0.49191489, 0.91666667],\n", - " [0.61501954, 0.61361702, 0.91666667],\n", - " [0.74008934, 0.73957447, 0.91666667],\n", - " [0.87520938, 0.87234043, 1. ],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.96296296, 0.93545391, 0.97222222],\n", - " [0.88888889, 0.8699791 , 0.95833333],\n", - " [0.85185185, 0.81193406, 0.84722222],\n", - " [0.74074074, 0.74483399, 0.97222222],\n", - " [0.62962963, 0.67750174, 0.97222222],\n", - " [0.59259259, 0.61133039, 0.98611111],\n", - " [0.59259259, 0.54399814, 0.95833333],\n", - " [0.44444444, 0.47736243, 0.97222222],\n", - " [0.33333333, 0.409798 , 0.95833333],\n", - " [0.37037037, 0.34269793, 0.97222222],\n", - " [0.22222222, 0.2739726 , 0.97222222],\n", - " [0.14814815, 0.20455073, 1. ],\n", - " [0.18518519, 0.13791502, 0.94444444],\n", - " [0.07407407, 0.06826097, 0.97222222],\n", - " [0. , 0. , 0.97222222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16385435, 0.16465018, 0.85542169],\n", - " [0.30284192, 0.30720673, 0.73493976],\n", - " [0.46847247, 0.47448711, 0.86746988],\n", - " [0.63721137, 0.64018937, 0.86746988],\n", - " [0.83081705, 0.83166754, 1. ],\n", - " [1. , 1. , 0.87951807]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1104178 , 0.09268707, 0.8625 ],\n", - " [0.23412914, 0.21428571, 1. ],\n", - " [0.34427564, 0.31972789, 0.875 ],\n", - " [0.45496473, 0.43707483, 0.8875 ],\n", - " [0.56348345, 0.55782313, 0.875 ],\n", - " [0.67308736, 0.66156463, 0.8625 ],\n", - " [0.78241997, 0.77465986, 0.875 ],\n", - " [0.88931091, 0.89710884, 0.8625 ],\n", - " [1. , 1. , 0.8875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89736978, 0.89257082, 0.83950617],\n", - " [0.78494069, 0.78460716, 0.87654321],\n", - " [0.67663744, 0.67771245, 0.87654321],\n", - " [0.56936565, 0.57215393, 0.85185185],\n", - " [0.44507478, 0.45002672, 0.98765432],\n", - " [0.32181537, 0.3241582 , 1. ],\n", - " [0.21402785, 0.21619455, 0.86419753],\n", - " [0.10778752, 0.11036879, 0.85185185],\n", - " [0. , 0. , 0.87654321]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13333333, 0.12178189, 0.90277778],\n", - " [0.25941043, 0.24645647, 0.91666667],\n", - " [0.38321995, 0.37199884, 0.91666667],\n", - " [0.49569161, 0.48625976, 0.84722222],\n", - " [0.61904762, 0.61209141, 0.91666667],\n", - " [0.74240363, 0.73763379, 0.90277778],\n", - " [0.86575964, 0.86317616, 0.93055556],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.1658805 , 0.74470588, 1. ],\n", - " [0.29690776, 0.52941176, 0.78571429],\n", - " [0.43238994, 0.35294118, 0.78571429],\n", - " [0.56761006, 0.23529412, 0.78571429],\n", - " [0.7206499 , 0.15647059, 0.85714286],\n", - " [0.86032495, 0.07882353, 0.78571429],\n", - " [1. , 0. , 0.79761905]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.08618368, 0.10447761, 0.98611111],\n", - " [0.16859682, 0.20298507, 0.95833333],\n", - " [0.25181794, 0.29452736, 0.97222222],\n", - " [0.33396176, 0.38606965, 0.97222222],\n", - " [0.41718287, 0.47761194, 0.97222222],\n", - " [0.49905737, 0.56218905, 0.95833333],\n", - " [0.58416375, 0.64577114, 1. ],\n", - " [0.66684622, 0.72139303, 0.95833333],\n", - " [0.74925936, 0.79502488, 0.98611111],\n", - " [0.83032588, 0.86766169, 0.94444444],\n", - " [0.91300835, 0.93233831, 0.98611111],\n", - " [1. , 1. , 0.98611111]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90005522, 0.89772727, 0.85185185],\n", - " [0.77912755, 0.77355876, 1. ],\n", - " [0.65930425, 0.654102 , 1. ],\n", - " [0.55494202, 0.54961197, 0.85185185],\n", - " [0.44837107, 0.44595344, 0.85185185],\n", - " [0.32633904, 0.32732816, 0.98765432],\n", - " [0.22418553, 0.22256098, 0.86419753],\n", - " [0.10546659, 0.10338137, 1. ],\n", - " [0. , 0. , 0.86419753]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91603053, 0.13511675, 0.57894737],\n", - " [0.80916031, 0.27318068, 0.57894737],\n", - " [0.61832061, 0.45817275, 0.78947368],\n", - " [0.42748092, 0.60530492, 0.63157895],\n", - " [0.23664122, 0.76535933, 0.68421053],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88820043, 0.88438134, 1. ],\n", - " [0.79229526, 0.79107505, 0.86419753],\n", - " [0.68292026, 0.68559838, 0.98765432],\n", - " [0.58701509, 0.5862069 , 0.85185185],\n", - " [0.47737069, 0.48073022, 0.98765432],\n", - " [0.38200431, 0.37728195, 0.87654321],\n", - " [0.28609914, 0.28803245, 0.87654321],\n", - " [0.19342672, 0.20081136, 0.83950617],\n", - " [0.09509698, 0.09736308, 0.87654321],\n", - " [0. , 0. , 0.85185185]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.9015984 , 0.07929515, 0.85 ],\n", - " [0.8001998 , 0.1938326 , 0.875 ],\n", - " [0.69855145, 0.30396476, 0.9 ],\n", - " [0.5989011 , 0.40088106, 0.875 ],\n", - " [0.49875125, 0.4845815 , 0.875 ],\n", - " [0.40034965, 0.5814978 , 0.8625 ],\n", - " [0.30044955, 0.6784141 , 0.8625 ],\n", - " [0.2017982 , 0.77973568, 0.875 ],\n", - " [0.11438561, 0.87665198, 0.7625 ],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.06887347, 0.92717155, 0.98591549],\n", - " [0.14201815, 0.84902008, 0.98591549],\n", - " [0.21569674, 0.76844907, 0.98591549],\n", - " [0.30005339, 0.68013549, 0.98591549],\n", - " [0.3966898 , 0.58674087, 0.98591549],\n", - " [0.49546183, 0.4914106 , 0.97183099],\n", - " [0.59530166, 0.39293491, 1. ],\n", - " [0.6983449 , 0.29349141, 0.98591549],\n", - " [0.79871863, 0.19695137, 0.98591549],\n", - " [0.89909237, 0.09774982, 1. ],\n", - " [1. , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87068966, 0.85956298, 0.98484848],\n", - " [0.73354232, 0.71249693, 1. ],\n", - " [0.59012539, 0.56837712, 1. ],\n", - " [0.44278997, 0.42597594, 1. ],\n", - " [0.29702194, 0.28382028, 1. ],\n", - " [0.15125392, 0.14387429, 1. ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.82985822, 0.83132239, 0.98507463],\n", - " [0.66638866, 0.66795367, 0.98507463],\n", - " [0.50125104, 0.50168919, 0.98507463],\n", - " [0.33110926, 0.33301158, 0.98507463],\n", - " [0.16513761, 0.16650579, 1. ],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15594937, 0.16025641, 0.83544304],\n", - " [0.34329114, 0.35227273, 1. ],\n", - " [0.49974684, 0.50903263, 0.82278481],\n", - " [0.65670886, 0.66841492, 0.83544304],\n", - " [0.83037975, 0.84120047, 0.92405063],\n", - " [1. , 1. , 0.83544304]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12106918, 0.12217195, 0.84810127],\n", - " [0.23925577, 0.23755656, 0.82278481],\n", - " [0.38259958, 0.37556561, 1. ],\n", - " [0.50235849, 0.49321267, 0.83544304],\n", - " [0.63128931, 0.62443439, 0.91139241],\n", - " [0.75262055, 0.74434389, 0.83544304],\n", - " [0.88312369, 0.87104072, 0.91139241],\n", - " [1. , 1. , 0.83544304]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9106652 , 0.91666667, 0.8875 ],\n", - " [0.81913139, 0.82564103, 0.875 ],\n", - " [0.73062122, 0.72179487, 0.875 ],\n", - " [0.62699285, 0.61282051, 1. ],\n", - " [0.5371083 , 0.5474359 , 0.875 ],\n", - " [0.44832325, 0.46025641, 0.8625 ],\n", - " [0.35816383, 0.3525641 , 0.8875 ],\n", - " [0.2680044 , 0.25769231, 0.875 ],\n", - " [0.17921935, 0.18589744, 0.8625 ],\n", - " [0.0893348 , 0.10384615, 0.875 ],\n", - " [0. , 0. , 0.8875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.18918919, 0.17648521, 1. ],\n", - " [0.34459459, 0.31891623, 0.8 ],\n", - " [0.47972973, 0.44419587, 0.72222222],\n", - " [0.61486486, 0.601044 , 0.86666667],\n", - " [0.74324324, 0.73204077, 0.74444444],\n", - " [0.86486486, 0.8650261 , 0.73333333],\n", - " [1. , 1. , 0.72222222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1111679 , 0.16666667, 0.98507463],\n", - " [0.22208025, 0.30952381, 0.97014925],\n", - " [0.33299259, 0.45238095, 1. ],\n", - " [0.44441605, 0.64285714, 0.98507463],\n", - " [0.55762842, 0.83333333, 0.98507463],\n", - " [0.66700741, 1. , 0.98507463],\n", - " [0.77970866, 0.97619048, 0.98507463],\n", - " [0.89087657, 0.95238095, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89145001, 0.89066667, 0.85185185],\n", - " [0.78236398, 0.78266667, 0.88888889],\n", - " [0.67354597, 0.66533333, 0.83950617],\n", - " [0.56445993, 0.55466667, 0.87654321],\n", - " [0.45456982, 0.448 , 0.87654321],\n", - " [0.34548378, 0.332 , 0.85185185],\n", - " [0.2358617 , 0.22133333, 0.85185185],\n", - " [0.12570356, 0.12 , 0.87654321],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.2962963 , 0.887449 , 0.97014925],\n", - " [0.55555556, 0.78257739, 0.91044776],\n", - " [0.51851852, 0.67458603, 0.94029851],\n", - " [0.33333333, 0.55987521, 1. ],\n", - " [0.59259259, 0.45140389, 0.95522388],\n", - " [0.85185185, 0.33549316, 1. ],\n", - " [0.92592593, 0.22606192, 0.94029851],\n", - " [1. , 0.11183105, 0.98507463],\n", - " [0.92592593, 0. , 0.95522388]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10986367, 0.10578512, 0.87654321],\n", - " [0.21785619, 0.19834711, 0.86419753],\n", - " [0.32745255, 0.31735537, 0.86419753],\n", - " [0.43785084, 0.43801653, 0.86419753],\n", - " [0.54530874, 0.53719008, 0.86419753],\n", - " [0.65490511, 0.64793388, 0.85185185],\n", - " [0.78134189, 0.79173554, 1. ],\n", - " [0.88906709, 0.89256198, 0.86419753],\n", - " [1. , 1. , 0.86419753]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91304348, 0.14041657, 0.97014925],\n", - " [0.73913043, 0.2864498 , 0.98507463],\n", - " [0.52173913, 0.42990873, 0.98507463],\n", - " [0.39130435, 0.57243155, 0.98507463],\n", - " [0.13043478, 0.71495436, 1. ],\n", - " [0.17391304, 0.85513691, 0.97014925],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.95631641, 0.95151372, 0.84722222],\n", - " [0.90436836, 0.89522233, 0.97222222],\n", - " [0.84533648, 0.83869442, 0.95833333],\n", - " [0.79338843, 0.78122044, 1. ],\n", - " [0.73553719, 0.7256386 , 0.95833333],\n", - " [0.67532468, 0.66958373, 0.95833333],\n", - " [0.61393152, 0.61305582, 0.97222222],\n", - " [0.57969303, 0.56456954, 0.84722222],\n", - " [0.52538371, 0.50875118, 0.95833333],\n", - " [0.46635183, 0.45175024, 0.98611111],\n", - " [0.40968123, 0.39640492, 0.95833333],\n", - " [0.35182999, 0.33940397, 0.98611111],\n", - " [0.29279811, 0.28311258, 0.95833333],\n", - " [0.23494687, 0.22587512, 1. ],\n", - " [0.17473436, 0.17005676, 0.94444444],\n", - " [0.11924439, 0.11352886, 0.97222222],\n", - " [0.06493506, 0.05558184, 0.98611111],\n", - " [0. , 0. , 0.95833333]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12454723, 0.13357401, 0.95833333],\n", - " [0.24825857, 0.26534296, 1. ],\n", - " [0.37419894, 0.39169675, 0.95833333],\n", - " [0.49846754, 0.50541516, 0.98611111],\n", - " [0.62385065, 0.62815884, 0.95833333],\n", - " [0.74533296, 0.74729242, 0.95833333],\n", - " [0.87461688, 0.8700361 , 0.97222222],\n", - " [1. , 1. , 0.98611111]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90951743, 0.0944217 , 0.75308642],\n", - " [0.80093834, 0.20061412, 0.86419753],\n", - " [0.69369973, 0.30962129, 0.86419753],\n", - " [0.5730563 , 0.43091095, 0.98765432],\n", - " [0.44705094, 0.55552712, 0.98765432],\n", - " [0.3424933 , 0.66248721, 0.86419753],\n", - " [0.23324397, 0.76970317, 0.85185185],\n", - " [0.10656836, 0.89406346, 1. ],\n", - " [0. , 1. , 0.85185185]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91245791, 0.91351975, 0.86419753],\n", - " [0.82210999, 0.8279043 , 0.86419753],\n", - " [0.71997755, 0.73018161, 0.98765432],\n", - " [0.62121212, 0.63072932, 1. ],\n", - " [0.53535354, 0.5448256 , 0.85185185],\n", - " [0.44893378, 0.45863361, 0.86419753],\n", - " [0.36251403, 0.37071202, 0.88888889],\n", - " [0.27833895, 0.2848083 , 0.83950617],\n", - " [0.17845118, 0.18449121, 1. ],\n", - " [0.09652076, 0.10031709, 0.85185185],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10586881, 0.1083973 , 0.875 ],\n", - " [0.21403913, 0.21842289, 0.875 ],\n", - " [0.32336018, 0.32914631, 0.875 ],\n", - " [0.42347526, 0.44010235, 0.8875 ],\n", - " [0.52819333, 0.54826704, 0.875 ],\n", - " [0.63981588, 0.65875785, 0.875 ],\n", - " [0.74798619, 0.76506164, 0.8625 ],\n", - " [0.88607595, 0.89137009, 1. ],\n", - " [1. , 1. , 0.8875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1221253 , 0.12259307, 0.85714286],\n", - " [0.24504362, 0.24518614, 0.85714286],\n", - " [0.36743325, 0.3677792 , 0.85714286],\n", - " [0.49193762, 0.49229782, 0.85714286],\n", - " [0.63283109, 0.6322208 , 1. ],\n", - " [0.74544013, 0.74518614, 0.79220779],\n", - " [0.86915147, 0.86842105, 0.85714286],\n", - " [1. , 1. , 0.93506494]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14693878, 0.14700544, 1. ],\n", - " [0.28954082, 0.28675136, 1. ],\n", - " [0.43647959, 0.43557169, 1. ],\n", - " [0.57908163, 0.57713249, 0.98484848],\n", - " [0.71045918, 0.70961887, 0.92424242],\n", - " [0.85739796, 0.8584392 , 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0.47216036, 0.93603936, 0. ],\n", - " [0.43838159, 0.92841328, 0.00827423],\n", - " [0.37936154, 0.91783518, 0.01536643],\n", - " ...,\n", - " [0.91833705, 0.08314883, 0.00839243],\n", - " [0.96139569, 0.0403444 , 0.00827423],\n", - " [1. , 0. , 0.00815603]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.05869242, 0.91642229, 0.38888889],\n", - " [0.1077266 , 0.83108504, 0.38333333],\n", - " [0.14895988, 0.75806452, 0.33888889],\n", - " [0.22548291, 0.64252199, 0.55555556],\n", - " [0.28194651, 0.56392962, 0.38888889],\n", - " [0.45245171, 0.41524927, 0.89444444],\n", - " [0.65527489, 0.26099707, 1. ],\n", - " [0.74368499, 0.1914956 , 0.43888889],\n", - " [0.85995542, 0.10322581, 0.55555556],\n", - " [1. , 0. , 0.66111111]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1115 , 0.11496503, 0.57024793],\n", - " [0.2355 , 0.24307692, 0.65289256],\n", - " [0.379 , 0.39048951, 0.75206612],\n", - " [0.5085 , 0.51692308, 0.66115702],\n", - " [0.708 , 0.71076923, 1. ],\n", - " [0.8385 , 0.83972028, 0.65289256],\n", - " [1. , 1. , 0.83471074]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91496689, 0.91418564, 0.75308642],\n", - " [0.81536424, 0.82311734, 0.85185185],\n", - " [0.70993377, 0.72504378, 0.88888889],\n", - " [0.61033113, 0.62171629, 0.83950617],\n", - " [0.50728477, 0.52014011, 0.87654321],\n", - " [0.42119205, 0.43082312, 0.75308642],\n", - " [0.3181457 , 0.32574431, 0.85185185],\n", - " [0.21907285, 0.22942207, 0.85185185],\n", - " [0.11629139, 0.11908932, 0.86419753],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90172504, 0.9018598 , 0.46308725],\n", - " [0.79822269, 0.79914163, 0.47651007],\n", - " [0.67067433, 0.67267525, 0.59731544],\n", - " [0.56926294, 0.57052933, 0.46979866],\n", - " [0.46785154, 0.46924177, 0.47651007],\n", - " [0.32618923, 0.32732475, 0.66442953],\n", - " [0.21066388, 0.21144492, 0.54362416],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89955993, 0.89710145, 0.87654321],\n", - " [0.80326171, 0.8 , 0.85185185],\n", - " [0.70256278, 0.69130435, 0.87654321],\n", - " [0.59047373, 0.5826087 , 0.97530864],\n", - " [0.47657261, 0.45797101, 1. ],\n", - " [0.38234533, 0.34927536, 0.83950617],\n", - " [0.29640176, 0.26956522, 0.75308642],\n", - " [0.19777375, 0.18405797, 0.86419753],\n", - " [0.10018121, 0.09565217, 0.85185185],\n", - " [0. , 0. , 0.87654321]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.06150943, 0.88525547, 0.97183099],\n", - " [0.1245283 , 0.78540146, 0.90140845],\n", - " [0.22264151, 0.70043796, 0.94366197],\n", - " [0.3245283 , 0.61605839, 0.97183099],\n", - " [0.42943396, 0.52992701, 1. ],\n", - " [0.53320755, 0.44525547, 0.98591549],\n", - " [0.63433962, 0.36116788, 0.98591549],\n", - " [0.73509434, 0.2779562 , 0.97183099],\n", - " [0.83320755, 0.19240876, 0.98591549],\n", - " [0.91698113, 0.09781022, 0.98591549],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87544484, 0.08695652, 1. ],\n", - " [0.77142075, 0.18115942, 0.79775281],\n", - " [0.67369286, 0.26811594, 0.7752809 ],\n", - " [0.57897618, 0.41304348, 0.79775281],\n", - " [0.48042705, 0.57971014, 0.7752809 ],\n", - " [0.38215166, 0.67391304, 0.79775281],\n", - " [0.28223378, 0.77536232, 0.76404494],\n", - " [0.1938133 , 0.88405797, 0.69662921],\n", - " [0.09471667, 0.92753623, 0.7752809 ],\n", - " [0. , 1. , 0.7752809 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88658892, 0.11301775, 0.97183099],\n", - " [0.77142857, 0.22426036, 1. ],\n", - " [0.6548105 , 0.34260355, 0.98591549],\n", - " [0.54169096, 0.4556213 , 0.97183099],\n", - " [0.4271137 , 0.57159763, 1. ],\n", - " [0.31078717, 0.68757396, 0.98591549],\n", - " [0.21253644, 0.78698225, 0.85915493],\n", - " [0.09970845, 0.89881657, 0.97183099],\n", - " [0. , 1. , 0.85915493]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90303359, 0.93186004, 0.52980132],\n", - " [0.79469122, 0.85451197, 0.58940397],\n", - " [0.72345612, 0.80294659, 0.40397351],\n", - " [0.61863489, 0.70165746, 0.58278146],\n", - " [0.468039 , 0.53959484, 0.86754967],\n", - " [0.38407367, 0.44935543, 0.47019868],\n", - " [0.27221018, 0.33517495, 0.65562914],\n", - " [0.10021668, 0.1252302 , 1. ],\n", - " [0. , 0. , 0.58940397]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86805556, 0.8636589 , 0.92424242],\n", - " [0.71924603, 0.71888944, 1. ],\n", - " [0.57142857, 0.57164105, 1. ],\n", - " [0.42509921, 0.42513634, 0.98484848],\n", - " [0.27926587, 0.27838374, 1. ],\n", - " [0.14583333, 0.14476946, 0.92424242],\n", - " [0. , 0. , 0.98484848]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88405797, 0.89355357, 0.83333333],\n", - " [0.7826087 , 0.78435421, 0.84615385],\n", - " [0.69565217, 0.67699014, 0.84615385],\n", - " [0.53623188, 0.55173205, 1. ],\n", - " [0.46376812, 0.4338151 , 0.92307692],\n", - " [0.34782609, 0.3259922 , 0.84615385],\n", - " [0.24637681, 0.21748107, 0.84615385],\n", - " [0.11594203, 0.09795825, 0.92307692],\n", - " [0. , 0. , 0.78205128]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89230769, 0.1337252 , 0.83544304],\n", - " [0.73846154, 0.28385991, 0.91139241],\n", - " [0.62307692, 0.42174871, 0.84810127],\n", - " [0.47692308, 0.55326965, 0.82278481],\n", - " [0.29230769, 0.71589518, 1. ],\n", - " [0.15384615, 0.85378398, 0.83544304],\n", - " [0. , 1. , 0.91139241]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.97680891, 0.11246731, 1. ],\n", - " [0.94526902, 0.224644 , 0.98591549],\n", - " [0.89517625, 0.32984598, 0.97183099],\n", - " [0.83024119, 0.43214182, 0.94366197],\n", - " [0.74721707, 0.52281314, 0.88732394],\n", - " [0.62894249, 0.60650974, 1. ],\n", - " [0.50556586, 0.68904388, 0.98591549],\n", - " [0.37987013, 0.76460331, 0.97183099],\n", - " [0.25046382, 0.84394071, 0.98591549],\n", - " [0.12662338, 0.92153444, 1. ],\n", - " [0. , 1. , 0.97183099]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1083757 , 0.1084507 , 0.85185185],\n", - " [0.22290607, 0.22957746, 0.87654321],\n", - " [0.33128178, 0.34507042, 0.85185185],\n", - " [0.45838908, 0.47605634, 1. ],\n", - " [0.57265186, 0.5943662 , 0.86419753],\n", - " [0.66818303, 0.68028169, 0.75308642],\n", - " [0.78191062, 0.79295775, 0.86419753],\n", - " [0.89055392, 0.8971831 , 0.85185185],\n", - " [1. , 1. , 0.85185185]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10283505, 0.13666229, 0.91044776],\n", - " [0.21340206, 0.28383706, 0.98507463],\n", - " [0.32371134, 0.42444152, 0.97014925],\n", - " [0.43582474, 0.52956636, 0.98507463],\n", - " [0.54845361, 0.62549277, 0.98507463],\n", - " [0.66134021, 0.72010512, 0.98507463],\n", - " [0.7742268 , 0.81603154, 1. ],\n", - " [0.88737113, 0.90801577, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.98653199, 0.92090818, 0.875 ],\n", - " [0.91245791, 0.82659681, 1. ],\n", - " [0.85858586, 0.74575848, 0.8625 ],\n", - " [0.77104377, 0.66167665, 0.8875 ],\n", - " [0.67003367, 0.58008982, 0.875 ],\n", - " [0.58922559, 0.49800399, 0.875 ],\n", - " [0.50505051, 0.41417166, 0.875 ],\n", - " [0.43771044, 0.33033932, 0.875 ],\n", - " [0.35690236, 0.24775449, 0.875 ],\n", - " [0.25589226, 0.16641717, 0.875 ],\n", - " [0.13468013, 0.08333333, 0.875 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08260325, 0.91874694, 0.77777778],\n", - " [0.16739675, 0.83749388, 0.78888889],\n", - " [0.24937422, 0.7670093 , 0.76666667],\n", - " [0.33573217, 0.69309838, 0.78888889],\n", - " [0.42052566, 0.61674009, 0.78888889],\n", - " [0.4965582 , 0.52716593, 0.76666667],\n", - " [0.57478098, 0.43808125, 0.76666667],\n", - " [0.6548811 , 0.35633872, 0.78888889],\n", - " [0.76376721, 0.25648556, 1. ],\n", - " [0.83416771, 0.18502203, 0.67777778],\n", - " [0.9120776 , 0.09789525, 0.75555556],\n", - " [1. , 0. , 0.88888889]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86585026, 0.86891386, 1. ],\n", - " [0.76342889, 0.77153558, 0.75824176],\n", - " [0.65738937, 0.69662921, 0.76923077],\n", - " [0.55246312, 0.6329588 , 0.78021978],\n", - " [0.43417757, 0.53558052, 0.85714286],\n", - " [0.32925132, 0.45318352, 0.78021978],\n", - " [0.22182021, 0.32209738, 0.78021978],\n", - " [0.11828556, 0.19101124, 0.76923077],\n", - " [0. , 0. , 0.86813187]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12321181, 0.12563896, 1. ],\n", - " [0.24596216, 0.25127791, 1. ],\n", - " [0.36917397, 0.37664783, 1. ],\n", - " [0.49238579, 0.50686037, 1. ],\n", - " [0.61513613, 0.63223029, 1. ],\n", - " [0.730503 , 0.76674738, 1. ],\n", - " [0.86894324, 0.88781275, 1. ],\n", - " [1. , 1. , 0.93939394]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12094595, 0.88481968, 0.64285714],\n", - " [0.22972973, 0.78221974, 0.57142857],\n", - " [0.33108108, 0.68157674, 0.57857143],\n", - " [0.47432432, 0.53816047, 0.79285714],\n", - " [0.56216216, 0.44786134, 0.49285714],\n", - " [0.73783784, 0.26977914, 1. ],\n", - " [0.87162162, 0.13055633, 0.77857143],\n", - " [1. , 0. , 0.71428571]]),\n", - " array([[1. , 0. , 0. ],\n", - " [1. , 0.10674656, 0.97183099],\n", - " [0.93023256, 0.21393697, 0.98591549],\n", - " [0.8372093 , 0.32490013, 0.98591549],\n", - " [0.62790698, 0.43919219, 1. ],\n", - " [0.48837209, 0.55614736, 0.98591549],\n", - " [0.34883721, 0.65823347, 0.85915493],\n", - " [0.20930233, 0.77030626, 0.92957746],\n", - " [0.11627907, 0.88459831, 0.94366197],\n", - " [0. , 1. , 0.92957746]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14445008, 0.1446198 , 0.92307692],\n", - " [0.30207805, 0.3010043 , 1. ],\n", - " [0.43385707, 0.43328551, 0.84615385],\n", - " [0.56715661, 0.56700143, 0.85897436],\n", - " [0.69944247, 0.69928264, 0.83333333],\n", - " [0.85352255, 0.85337159, 0.98717949],\n", - " [1. , 1. , 0.94871795]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91051396, 0.94007989, 0.78021978],\n", - " [0.82337595, 0.88015979, 0.76923077],\n", - " [0.7338899 , 0.82023968, 0.76923077],\n", - " [0.65823115, 0.76830892, 0.67032967],\n", - " [0.57031046, 0.70838881, 0.76923077],\n", - " [0.48291156, 0.64980027, 0.75824176],\n", - " [0.36916254, 0.57256991, 0.97802198],\n", - " [0.2794156 , 0.50732357, 0.78021978],\n", - " [0.19462562, 0.38348868, 0.76923077],\n", - " [0.11035742, 0.21571238, 0.76923077],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.82985822, 0.83132239, 0.98507463],\n", - " [0.66638866, 0.66795367, 0.98507463],\n", - " [0.50125104, 0.50168919, 0.98507463],\n", - " [0.33110926, 0.33301158, 0.98507463],\n", - " [0.16513761, 0.16650579, 1. ],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8590604 , 0.14042722, 0.89041096],\n", - " [0.70469799, 0.29351266, 1. ],\n", - " [0.56073826, 0.43314873, 0.90410959],\n", - " [0.41979866, 0.57278481, 0.90410959],\n", - " [0.28120805, 0.7147943 , 0.89041096],\n", - " [0.14295302, 0.85719937, 0.91780822],\n", - " [0. , 1. , 0.90410959]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87358684, 0.87167449, 1. ],\n", - " [0.75976362, 0.75117371, 0.88607595],\n", - " [0.65236382, 0.64788732, 0.89873418],\n", - " [0.53751285, 0.53208138, 0.87341772],\n", - " [0.43011305, 0.43035994, 0.89873418],\n", - " [0.31577595, 0.31924883, 0.87341772],\n", - " [0.20863309, 0.21126761, 0.88607595],\n", - " [0.11408016, 0.12050078, 0.7721519 ],\n", - " [0. , 0. , 0.87341772]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15552632, 0.17119565, 1. ],\n", - " [0.29421053, 0.32608696, 0.91666667],\n", - " [0.43763158, 0.47282609, 0.93055556],\n", - " [0.57631579, 0.61141304, 0.90277778],\n", - " [0.72131579, 0.74728261, 0.93055556],\n", - " [0.85947368, 0.8763587 , 0.90277778],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11142857, 0.88778878, 0.98484848],\n", - " [0.22415584, 0.77887789, 1. ],\n", - " [0.33662338, 0.669967 , 1. ],\n", - " [0.43974026, 0.56765677, 0.92424242],\n", - " [0.55090909, 0.45874587, 0.98484848],\n", - " [0.66337662, 0.34323432, 1. ],\n", - " [0.77558442, 0.2310231 , 1. ],\n", - " [0.88727273, 0.11551155, 1. ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90076531, 0.90322581, 0.98591549],\n", - " [0.8 , 0.79626486, 0.98591549],\n", - " [0.70153061, 0.70288625, 0.97183099],\n", - " [0.60382653, 0.60950764, 0.98591549],\n", - " [0.50204082, 0.51103565, 1. ],\n", - " [0.40382653, 0.41086587, 0.97183099],\n", - " [0.30408163, 0.30560272, 0.98591549],\n", - " [0.20153061, 0.20373514, 1. ],\n", - " [0.10127551, 0.10016978, 0.98591549],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92789374, 0.93026992, 0.7721519 ],\n", - " [0.84364326, 0.84768638, 0.88607595],\n", - " [0.76091082, 0.76542416, 0.87341772],\n", - " [0.67741935, 0.68059126, 0.88607595],\n", - " [0.59089184, 0.59511568, 0.89873418],\n", - " [0.5085389 , 0.51253213, 0.86075949],\n", - " [0.43529412, 0.43798201, 0.7721519 ],\n", - " [0.34990512, 0.35250643, 0.89873418],\n", - " [0.25351044, 0.25642674, 1. ],\n", - " [0.16774194, 0.17030848, 0.89873418],\n", - " [0.08614801, 0.0874036 , 0.86075949],\n", - " [0. , 0. , 0.89873418]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.85332859, 0.1473448 , 1. ],\n", - " [0.70665717, 0.2946896 , 0.98484848],\n", - " [0.57351371, 0.42819746, 0.92424242],\n", - " [0.42684229, 0.57442034, 1. ],\n", - " [0.28017088, 0.72026926, 1. ],\n", - " [0.13314347, 0.86649215, 0.98484848],\n", - " [0. , 1. , 0.92424242]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.07962058, 0.09466667, 0.98591549],\n", - " [0.16096579, 0.19555556, 1. ],\n", - " [0.24144869, 0.29777778, 0.98591549],\n", - " [0.32250647, 0.40044444, 0.97183099],\n", - " [0.40385168, 0.49022222, 0.97183099],\n", - " [0.48433458, 0.56222222, 1. ],\n", - " [0.56050589, 0.63244444, 0.98591549],\n", - " [0.63380282, 0.69911111, 0.98591549],\n", - " [0.70767462, 0.768 , 1. ],\n", - " [0.77809715, 0.83244444, 0.97183099],\n", - " [0.85139408, 0.89155556, 0.98591549],\n", - " [0.92555332, 0.94711111, 0.98591549],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[0. , 0.00231303, 0. ],\n", - " [0.07305936, 0. , 0.97222222],\n", - " [0.15410959, 0.0077101 , 0.98611111],\n", - " [0.22745434, 0.01464919, 0.97222222],\n", - " [0.29252283, 0.01927525, 0.97222222],\n", - " [0.3678653 , 0.02235929, 0.95833333],\n", - " [0.44006849, 0.0308404 , 1. ],\n", - " [0.5119863 , 0.06630686, 0.90277778],\n", - " [0.56934932, 0.13261372, 0.84722222],\n", - " [0.62842466, 0.24441018, 0.875 ],\n", - " [0.69006849, 0.3770239 , 0.98611111],\n", - " [0.73858447, 0.51888975, 0.86111111],\n", - " [0.78510274, 0.68080185, 0.91666667],\n", - " [0.8533105 , 0.84425598, 1. ],\n", - " [0.92579909, 0.95065536, 0.86111111],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12960123, 0.14681892, 1. ],\n", - " [0.24335378, 0.24959217, 0.875 ],\n", - " [0.35787321, 0.36052202, 0.875 ],\n", - " [0.45373211, 0.45350734, 0.7625 ],\n", - " [0.56825153, 0.57096248, 0.875 ],\n", - " [0.68123722, 0.69004894, 0.875 ],\n", - " [0.79064417, 0.79282219, 0.8625 ],\n", - " [0.90490798, 0.91353997, 0.875 ],\n", - " [1. , 1. , 0.7625 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14937193, 0.14018692, 0.94444444],\n", - " [0.27580557, 0.27102804, 0.73333333],\n", - " [0.44756963, 0.43925234, 1. ],\n", - " [0.6116876 , 0.56074766, 1. ],\n", - " [0.74604042, 0.74766355, 0.8 ],\n", - " [0.8806663 , 0.87850467, 0.8 ],\n", - " [1. , 1. , 0.73333333]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12217659, 0.12384717, 0.875 ],\n", - " [0.24435318, 0.2455863 , 0.8625 ],\n", - " [0.36704312, 0.36758893, 0.875 ],\n", - " [0.49332649, 0.49459816, 0.9 ],\n", - " [0.61344969, 0.61528327, 0.8625 ],\n", - " [0.73973306, 0.73860343, 0.8875 ],\n", - " [0.85985626, 0.86166008, 0.8625 ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09632446, 0.09997369, 0.85915493],\n", - " [0.21863118, 0.21652197, 0.97183099],\n", - " [0.33586819, 0.33017627, 0.97183099],\n", - " [0.44803549, 0.44330439, 1. ],\n", - " [0.57034221, 0.56116811, 0.97183099],\n", - " [0.68948035, 0.67640095, 0.98591549],\n", - " [0.78453739, 0.77821626, 0.85915493],\n", - " [0.89797212, 0.89871087, 0.98591549],\n", - " [1. , 1. , 0.85915493]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13713245, 0.13663968, 0.80487805],\n", - " [0.26021337, 0.26012146, 0.74390244],\n", - " [0.43091335, 0.43421053, 1. ],\n", - " [0.56700494, 0.56680162, 0.81707317],\n", - " [0.70335675, 0.70647773, 0.80487805],\n", - " [0.85089774, 0.85222672, 0.87804878],\n", - " [1. , 1. , 0.87804878]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.12345679, 0.88327695, 1. ],\n", - " [0.24074074, 0.76848719, 1. ],\n", - " [0.35802469, 0.65418076, 0.97183099],\n", - " [0.47283951, 0.54253262, 0.97183099],\n", - " [0.58765432, 0.42895118, 1. ],\n", - " [0.70123457, 0.31778637, 1. ],\n", - " [0.8037037 , 0.20976317, 0.95774648],\n", - " [0.91358025, 0.09497342, 1. ],\n", - " [1. , 0. , 0.85915493]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15040757, 0.14968153, 0.98809524],\n", - " [0.25532474, 0.24522293, 0.72619048],\n", - " [0.37233763, 0.36305732, 0.77380952],\n", - " [0.49092821, 0.49681529, 0.78571429],\n", - " [0.60662635, 0.62420382, 0.78571429],\n", - " [0.75414147, 0.7866242 , 1. ],\n", - " [0.88193531, 0.88535032, 0.85714286],\n", - " [1. , 1. , 0.78571429]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89034296, 0.88786394, 0.98591549],\n", - " [0.78113718, 0.77832228, 0.97183099],\n", - " [0.6683213 , 0.66589795, 1. ],\n", - " [0.558213 , 0.55664457, 0.97183099],\n", - " [0.4467509 , 0.44566157, 0.98591549],\n", - " [0.33483755, 0.33467858, 0.98591549],\n", - " [0.22337545, 0.22340732, 0.98591549],\n", - " [0.1101083 , 0.11011819, 1. ],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88871424, 0.88682834, 0.85185185],\n", - " [0.75699466, 0.75558726, 1. ],\n", - " [0.65985539, 0.65763195, 0.75308642],\n", - " [0.5460547 , 0.54541132, 0.86419753],\n", - " [0.43634077, 0.4341417 , 0.83950617],\n", - " [0.33731531, 0.33666191, 0.75308642],\n", - " [0.22571518, 0.22491679, 0.85185185],\n", - " [0.11191449, 0.10699001, 0.87654321],\n", - " [0. , 0. , 0.85185185]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11518047, 0.11066127, 0.98507463],\n", - " [0.235138 , 0.22591093, 0.97014925],\n", - " [0.33970276, 0.32901484, 0.91044776],\n", - " [0.4485138 , 0.44102564, 0.97014925],\n", - " [0.54936306, 0.54278003, 0.91044776],\n", - " [0.66082803, 0.65668016, 0.97014925],\n", - " [0.77707006, 0.77165992, 1. ],\n", - " [0.88375796, 0.88178138, 0.97014925],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 0.23076923, 0. ],\n", - " [0.8891455 , 0.38461538, 0.90410959],\n", - " [0.78008725, 0. , 0.90410959],\n", - " [0.66127791, 0.38461538, 1. ],\n", - " [0.54400821, 0.30769231, 0.95890411],\n", - " [0.44341801, 0.53846154, 0.83561644],\n", - " [0.32768797, 0.76923077, 0.97260274],\n", - " [0.21041827, 1. , 0.95890411],\n", - " [0.09828073, 1. , 0.93150685],\n", - " [0. , 0.61538462, 0.83561644]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91106719, 0.91081081, 0.59322034],\n", - " [0.81884058, 0.81837838, 0.60169492],\n", - " [0.66996047, 0.66648649, 1. ],\n", - " [0.58102767, 0.57675676, 0.60169492],\n", - " [0.48945982, 0.48702703, 0.59322034],\n", - " [0.39986825, 0.39702703, 0.59322034],\n", - " [0.2826087 , 0.28027027, 0.76271186],\n", - " [0.17061924, 0.16810811, 0.76271186],\n", - " [0.09156785, 0.08918919, 0.51694915],\n", - " [0. , 0. , 0.59322034]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8443038 , 0.84266263, 1. ],\n", - " [0.72658228, 0.72339889, 0.75824176],\n", - " [0.60632911, 0.60085729, 0.76923077],\n", - " [0.49113924, 0.48159355, 0.76923077],\n", - " [0.36455696, 0.35955623, 0.76923077],\n", - " [0.24303797, 0.23877963, 0.78021978],\n", - " [0.11898734, 0.11649017, 0.76923077],\n", - " [0. , 0. , 0.74725275]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90253807, 0.90490798, 0.875 ],\n", - " [0.79314721, 0.79754601, 1. ],\n", - " [0.69314721, 0.69018405, 0.8875 ],\n", - " [0.59746193, 0.59509202, 0.875 ],\n", - " [0.50152284, 0.50613497, 0.8625 ],\n", - " [0.40329949, 0.41717791, 0.875 ],\n", - " [0.30583756, 0.30981595, 0.875 ],\n", - " [0.20685279, 0.21472393, 0.8875 ],\n", - " [0.0964467 , 0.10122699, 1. ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87976438, 0.12968406, 0.85897436],\n", - " [0.75848926, 0.25679647, 0.84615385],\n", - " [0.61088011, 0.40080823, 1. ],\n", - " [0.48267498, 0.52204262, 0.84615385],\n", - " [0.35862786, 0.63997061, 0.83333333],\n", - " [0.24532225, 0.75202057, 0.78205128],\n", - " [0.12300762, 0.87692873, 0.84615385],\n", - " [0. , 1. , 0.84615385]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88482759, 0.91802431, 0.8625 ],\n", - " [0.75862069, 0.83191104, 0.8875 ],\n", - " [0.64344828, 0.74579778, 0.8625 ],\n", - " [0.51724138, 0.66382208, 0.9 ],\n", - " [0.39034483, 0.57770882, 0.8625 ],\n", - " [0.31034483, 0.48719938, 0.8625 ],\n", - " [0.24137931, 0.39229377, 0.875 ],\n", - " [0.19517241, 0.3061805 , 0.7625 ],\n", - " [0.11448276, 0.1939488 , 1. ],\n", - " [0.05724138, 0.09490561, 0.875 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.14266193, 0.84558824, 0.98507463],\n", - " [0.28368407, 0.69852941, 0.97014925],\n", - " [0.42661929, 0.55147059, 0.98507463],\n", - " [0.56982782, 0.40441176, 0.98507463],\n", - " [0.71522274, 0.27205882, 1. ],\n", - " [0.85679147, 0.14705882, 0.97014925],\n", - " [1. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12199264, 0.13542795, 0.93055556],\n", - " [0.25870365, 0.28494041, 1. ],\n", - " [0.38126238, 0.40520043, 0.91666667],\n", - " [0.50325502, 0.54279523, 0.91666667],\n", - " [0.62666289, 0.66413868, 0.91666667],\n", - " [0.75035381, 0.77789816, 0.90277778],\n", - " [0.87630909, 0.89057421, 0.91666667],\n", - " [1. , 1. , 0.93055556]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11979167, 0.12317185, 0.84722222],\n", - " [0.26432292, 0.26942413, 1. ],\n", - " [0.40755208, 0.41521938, 1. ],\n", - " [0.55338542, 0.56147166, 1. ],\n", - " [0.70833333, 0.70795247, 1. ],\n", - " [0.85677083, 0.85397623, 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.128 , 0.12765535, 0.93939394],\n", - " [0.248 , 0.24538416, 0.95454545],\n", - " [0.37733333, 0.37562041, 0.95454545],\n", - " [0.508 , 0.5054596 , 0.98484848],\n", - " [0.62533333, 0.62358547, 0.98484848],\n", - " [0.76533333, 0.76493945, 1. ],\n", - " [0.88266667, 0.88246972, 0.92424242],\n", - " [1. , 1. , 0.93939394]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12121212, 0.12217997, 0.85185185],\n", - " [0.25 , 0.24435995, 0.87654321],\n", - " [0.36363636, 0.36704689, 0.85185185],\n", - " [0.47727273, 0.48948035, 0.86419753],\n", - " [0.63257576, 0.63092522, 1. ],\n", - " [0.75757576, 0.75234474, 0.85185185],\n", - " [0.89772727, 0.87528517, 0.87654321],\n", - " [1. , 1. , 0.85185185]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91048593, 0.91094771, 0.85185185],\n", - " [0.82193095, 0.82148693, 0.86419753],\n", - " [0.73209719, 0.72916667, 0.86419753],\n", - " [0.64386189, 0.63643791, 0.86419753],\n", - " [0.53868286, 0.53308824, 1. ],\n", - " [0.43734015, 0.43341503, 0.97530864],\n", - " [0.35709719, 0.35498366, 0.75308642],\n", - " [0.26822251, 0.26674837, 0.85185185],\n", - " [0.17838875, 0.17769608, 0.86419753],\n", - " [0.08887468, 0.08905229, 0.86419753],\n", - " [0. , 0. , 0.85185185]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1048951 , 0.10485592, 0.76923077],\n", - " [0.21888112, 0.21931697, 0.76923077],\n", - " [0.32377622, 0.31803629, 0.76923077],\n", - " [0.43006993, 0.42209178, 0.75824176],\n", - " [0.56993007, 0.55843116, 1. ],\n", - " [0.67692308, 0.66488794, 0.75824176],\n", - " [0.7958042 , 0.78842049, 0.87912088],\n", - " [0.8972028 , 0.89300961, 0.76923077],\n", - " [1. , 1. , 0.78021978]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1403277 , 0.05051302, 1. ],\n", - " [0.27325581, 0.09944751, 0.93055556],\n", - " [0.40142706, 0.1878453 , 0.91666667],\n", - " [0.51902748, 0.33307024, 0.90277778],\n", - " [0.63874207, 0.50907656, 0.91666667],\n", - " [0.75554968, 0.68271507, 0.91666667],\n", - " [0.87896406, 0.85872139, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89375349, 0.90441176, 0.71 ],\n", - " [0.78945901, 0.81617647, 0.7 ],\n", - " [0.68516453, 0.73529412, 0.7 ],\n", - " [0.56525376, 0.6372549 , 0.8 ],\n", - " [0.4601227 , 0.54411765, 0.69 ],\n", - " [0.37116564, 0.47058824, 0.61 ],\n", - " [0.2665923 , 0.36764706, 0.7 ],\n", - " [0.11795873, 0.20098039, 1. ],\n", - " [0. , 0. , 0.8 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91709013, 0.91745283, 0.875 ],\n", - " [0.8422038 , 0.84080189, 0.7625 ],\n", - " [0.75956138, 0.76179245, 0.85 ],\n", - " [0.67424445, 0.67688679, 0.9 ],\n", - " [0.57796202, 0.57665094, 1. ],\n", - " [0.49505215, 0.49174528, 0.8625 ],\n", - " [0.40946777, 0.40566038, 0.8875 ],\n", - " [0.3254881 , 0.32193396, 0.875 ],\n", - " [0.24097352, 0.23938679, 0.875 ],\n", - " [0.15645895, 0.15683962, 0.875 ],\n", - " [0.07461888, 0.07783019, 0.85 ],\n", - " [0. , 0. , 0.775 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8816568 , 0.87946778, 0.92957746],\n", - " [0.75443787, 0.75032612, 0.94366197],\n", - " [0.6183432 , 0.61466214, 1. ],\n", - " [0.49753452, 0.4949126 , 0.92957746],\n", - " [0.36932939, 0.36785807, 0.94366197],\n", - " [0.24408284, 0.24445604, 0.91549296],\n", - " [0.12475345, 0.12418471, 0.92957746],\n", - " [0. , 0. , 0.92957746]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92156863, 0.16892809, 1. ],\n", - " [0.84313725, 0.33808232, 1. ],\n", - " [0.74509804, 0.45251018, 0.66666667],\n", - " [0.58823529, 0.52849389, 0.44444444],\n", - " [0.37254902, 0.63432836, 0.61666667],\n", - " [0.21568627, 0.70081411, 0.38888889],\n", - " [0. , 0.7663953 , 0.38333333],\n", - " [0. , 0.83333333, 0.39444444],\n", - " [0.01960784, 0.89891452, 0.38888889],\n", - " [0.11764706, 1. , 0.60555556]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14471058, 0.13897281, 0.98507463],\n", - " [0.28767465, 0.27492447, 1. ],\n", - " [0.43038922, 0.41540785, 0.97014925],\n", - " [0.57285429, 0.55891239, 1. ],\n", - " [0.71806387, 0.70996979, 0.98507463],\n", - " [0.85778443, 0.85196375, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90751445, 0.10955056, 0.97183099],\n", - " [0.8150289 , 0.2207397 , 0.98591549],\n", - " [0.68786127, 0.33333333, 1. ],\n", - " [0.56647399, 0.44452247, 0.98591549],\n", - " [0.44508671, 0.55430712, 0.97183099],\n", - " [0.31791908, 0.66736891, 0.98591549],\n", - " [0.21387283, 0.77691948, 0.98591549],\n", - " [0.11560694, 0.89115169, 1. ],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1369181 , 0.15015015, 0.84615385],\n", - " [0.26985312, 0.3003003 , 0.84615385],\n", - " [0.43166542, 0.45045045, 1. ],\n", - " [0.56858352, 0.6006006 , 0.83333333],\n", - " [0.7137167 , 0.75075075, 0.93589744],\n", - " [0.85486682, 0.9009009 , 0.84615385],\n", - " [1. , 1. , 0.92307692]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89968107, 0.89993667, 0.98591549],\n", - " [0.79820238, 0.79924003, 0.97183099],\n", - " [0.69585387, 0.69917669, 0.98591549],\n", - " [0.59582488, 0.59848005, 1. ],\n", - " [0.49695564, 0.49588347, 0.98591549],\n", - " [0.39576689, 0.3939202 , 0.98591549],\n", - " [0.29660771, 0.2951235 , 0.98591549],\n", - " [0.19831835, 0.19506016, 0.98591549],\n", - " [0.09944912, 0.09943002, 0.97183099],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0.53657363, 0. , 0. ],\n", - " [0.45572666, 0.05637084, 0.98611111],\n", - " [0.37776708, 0.10784999, 0.95833333],\n", - " [0.29740135, 0.15676683, 0.95833333],\n", - " [0.21270452, 0.20847892, 0.98611111],\n", - " [0.13089509, 0.26484976, 0.98611111],\n", - " [0.06641001, 0.32611228, 0.94444444],\n", - " [0.01828681, 0.39715816, 1. ],\n", - " [0. , 0.46866993, 0.94444444],\n", - " [0.00721848, 0.53692057, 0.88888889],\n", - " [0.05149182, 0.59795015, 0.93055556],\n", - " [0.13233879, 0.65571861, 0.97222222],\n", - " [0.219923 , 0.70696483, 0.95833333],\n", - " [0.31905679, 0.76054041, 0.98611111],\n", - " [0.4307026 , 0.79711158, 0.97222222],\n", - " [0.55582291, 0.83205218, 0.95833333],\n", - " [0.66313763, 0.86186816, 0.84722222],\n", - " [0.7892204 , 0.89634288, 0.97222222],\n", - " [0.91578441, 0.94036804, 0.97222222],\n", - " [1. , 1. , 0.97222222]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.07363292, 0.07086614, 0.63636364],\n", - " [0.13806172, 0.12598425, 0.55454545],\n", - " [0.23362209, 0.22834646, 0.81818182],\n", - " [0.30806714, 0.30708661, 0.62727273],\n", - " [0.39956687, 0.3976378 , 0.73636364],\n", - " [0.47888468, 0.46456693, 0.63636364],\n", - " [0.55711965, 0.53543307, 0.63636364],\n", - " [0.63535463, 0.62204724, 0.62727273],\n", - " [0.71250677, 0.7007874 , 0.63636364],\n", - " [0.792366 , 0.77559055, 0.64545455],\n", - " [0.87384949, 0.86220472, 0.63636364],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14366425, 0.11971831, 0.98507463],\n", - " [0.28786656, 0.20774648, 0.97014925],\n", - " [0.43502825, 0.41197183, 0.98507463],\n", - " [0.56497175, 0.52816901, 0.91044776],\n", - " [0.71078827, 0.58802817, 0.97014925],\n", - " [0.85660479, 0.76408451, 1. ],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87973274, 0.11837121, 0.78571429],\n", - " [0.76020787, 0.23555871, 0.78571429],\n", - " [0.63845583, 0.35440341, 0.78571429],\n", - " [0.52115813, 0.47277462, 0.78571429],\n", - " [0.4060876 , 0.5875947 , 0.77380952],\n", - " [0.28582034, 0.70880682, 0.79761905],\n", - " [0.13363029, 0.86221591, 1. ],\n", - " [0. , 1. , 0.92857143]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09309309, 0.91705375, 1. ],\n", - " [0.22222222, 0.83985844, 0.97183099],\n", - " [0.3963964 , 0.76177837, 0.98591549],\n", - " [0.57957958, 0.66423358, 0.98591549],\n", - " [0.78378378, 0.56093785, 0.98591549],\n", - " [0.99399399, 0.45697854, 0.87323944],\n", - " [1. , 0.34815306, 0.94366197],\n", - " [0.98798799, 0.22915284, 0.91549296],\n", - " [0.94594595, 0.11391285, 0.92957746],\n", - " [0.89189189, 0. , 0.92957746]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11283243, 0.11195929, 1. ],\n", - " [0.22334108, 0.21967769, 0.98507463],\n", - " [0.33643171, 0.34266327, 0.98507463],\n", - " [0.44719855, 0.45801527, 0.98507463],\n", - " [0.5582236 , 0.57336726, 0.97014925],\n", - " [0.67105603, 0.68023749, 0.98507463],\n", - " [0.77485154, 0.7769296 , 0.91044776],\n", - " [0.88794216, 0.89143342, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8588 , 0.85936528, 0.98507463],\n", - " [0.716 , 0.71717486, 0.97014925],\n", - " [0.5692 , 0.56938395, 1. ],\n", - " [0.4264 , 0.42812694, 0.98507463],\n", - " [0.2852 , 0.28593653, 0.98507463],\n", - " [0.1412 , 0.14187928, 0.98507463],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.17321207, 0.16753472, 1. ],\n", - " [0.30963208, 0.29918981, 0.79761905],\n", - " [0.44481191, 0.43084491, 0.78571429],\n", - " [0.57833816, 0.5630787 , 0.77380952],\n", - " [0.70855726, 0.69328704, 0.78571429],\n", - " [0.86233981, 0.85445602, 0.94047619],\n", - " [1. , 1. , 0.8452381 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11007155, 0.11143852, 0.97183099],\n", - " [0.22949917, 0.22314492, 0.98591549],\n", - " [0.33957072, 0.33485133, 0.98591549],\n", - " [0.44964227, 0.44628985, 1. ],\n", - " [0.5690699 , 0.56255023, 0.98591549],\n", - " [0.67914144, 0.66514867, 0.97183099],\n", - " [0.78921299, 0.78114117, 0.98591549],\n", - " [0.88992845, 0.89284758, 1. ],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.0990688 , 0.09188361, 0.89873418],\n", - " [0.19736161, 0.1914242 , 0.86075949],\n", - " [0.30212106, 0.30168453, 0.89873418],\n", - " [0.40041386, 0.40122511, 0.87341772],\n", - " [0.48887739, 0.48545176, 0.7721519 ],\n", - " [0.59363683, 0.58958652, 0.88607595],\n", - " [0.69839628, 0.69678407, 0.89873418],\n", - " [0.79694775, 0.79173047, 0.88607595],\n", - " [0.91257113, 0.90658499, 1. ],\n", - " [1. , 1. , 0.7721519 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11339148, 0.11436797, 0.8019802 ],\n", - " [0.21292971, 0.21198639, 0.69306931],\n", - " [0.35454079, 0.35383407, 0.98019802],\n", - " [0.45356593, 0.45406962, 0.7029703 ],\n", - " [0.55053874, 0.55064119, 0.69306931],\n", - " [0.66495639, 0.66448574, 0.79207921],\n", - " [0.75987686, 0.76158074, 0.69306931],\n", - " [0.85787583, 0.85919916, 0.68316832],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90162272, 0.90258046, 0.45333333],\n", - " [0.78803245, 0.7895042 , 0.54 ],\n", - " [0.68813387, 0.68947521, 0.46666667],\n", - " [0.59178499, 0.59176573, 0.46666667],\n", - " [0.46551724, 0.46506234, 0.6 ],\n", - " [0.35294118, 0.35198608, 0.53333333],\n", - " [0.14148073, 0.14120035, 1. ],\n", - " [0. , 0. , 0.67333333]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90349265, 0.89948968, 0.97183099],\n", - " [0.80330882, 0.79653872, 1. ],\n", - " [0.69577206, 0.69425338, 0.98591549],\n", - " [0.59007353, 0.59196805, 0.98591549],\n", - " [0.48897059, 0.48857333, 0.98591549],\n", - " [0.39797794, 0.40004438, 0.85915493],\n", - " [0.29227941, 0.29798092, 0.95774648],\n", - " [0.20588235, 0.20900821, 0.85915493],\n", - " [0.10661765, 0.10561349, 0.98591549],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14817688, 0.14906348, 1. ],\n", - " [0.29712956, 0.29604579, 0.98484848],\n", - " [0.42746315, 0.42715921, 0.92424242],\n", - " [0.57176106, 0.57284079, 0.98484848],\n", - " [0.72226532, 0.72294485, 1. ],\n", - " [0.8541505 , 0.85379813, 0.92424242],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12048193, 0.10714286, 0.9875 ],\n", - " [0.23274918, 0.22619048, 0.9 ],\n", - " [0.34200438, 0.28571429, 0.85 ],\n", - " [0.44277108, 0.38690476, 0.875 ],\n", - " [0.55284775, 0.47619048, 0.875 ],\n", - " [0.66511501, 0.5952381 , 0.8875 ],\n", - " [0.7694414 , 0.73214286, 0.8625 ],\n", - " [0.89184009, 0.88095238, 1. ],\n", - " [1. , 1. , 0.8875 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89123288, 0.00909091, 0.87654321],\n", - " [0.78356164, 0.01818182, 0.87654321],\n", - " [0.67479452, 0.07272727, 0.83950617],\n", - " [0.5660274 , 0.14545455, 0.86419753],\n", - " [0.45671233, 0.21818182, 0.87654321],\n", - " [0.35068493, 0.42727273, 0.85185185],\n", - " [0.23753425, 0.69090909, 0.87654321],\n", - " [0.12986301, 0.83636364, 0.85185185],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 0.18950437, 0. ],\n", - " [0.91155914, 0.21574344, 0.87341772],\n", - " [0.80887097, 0.28571429, 1. ],\n", - " [0.7188172 , 0.41690962, 0.89873418],\n", - " [0.62930108, 0.56559767, 0.88607595],\n", - " [0.54032258, 0.70262391, 0.88607595],\n", - " [0.45053763, 0.8483965 , 0.88607595],\n", - " [0.35887097, 0.99708455, 0.88607595],\n", - " [0.26747312, 1. , 0.88607595],\n", - " [0.17526882, 0.76093294, 0.88607595],\n", - " [0.08682796, 0.44897959, 0.88607595],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09948394, 0.09249677, 0.97183099],\n", - " [0.19581422, 0.1843467 , 1. ],\n", - " [0.29071101, 0.27619664, 0.98591549],\n", - " [0.38188073, 0.37063389, 0.98591549],\n", - " [0.47161697, 0.46054334, 1. ],\n", - " [0.56049312, 0.54721863, 0.97183099],\n", - " [0.64506881, 0.63195343, 0.97183099],\n", - " [0.71387615, 0.70181113, 0.85915493],\n", - " [0.79042431, 0.78072445, 0.98591549],\n", - " [0.86295872, 0.85705045, 0.98591549],\n", - " [0.93319954, 0.9301423 , 1. ],\n", - " [1. , 1. , 0.97183099]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88194812, 0.04724409, 0.84615385],\n", - " [0.75092642, 0.12755906, 0.92307692],\n", - " [0.62519852, 0.24173228, 0.91025641],\n", - " [0.4862361 , 0.39527559, 1. ],\n", - " [0.37056644, 0.53307087, 0.85897436],\n", - " [0.24483854, 0.68818898, 0.92307692],\n", - " [0.12784542, 0.83622047, 0.84615385],\n", - " [0. , 1. , 0.92307692]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92597968, 0.92989344, 0.98591549],\n", - " [0.85486212, 0.85530006, 0.98591549],\n", - " [0.78035801, 0.78575435, 0.97183099],\n", - " [0.71843251, 0.72378015, 0.85915493],\n", - " [0.64537978, 0.65143017, 0.97183099],\n", - " [0.57329463, 0.57823892, 0.98591549],\n", - " [0.5002419 , 0.50476725, 1. ],\n", - " [0.42960813, 0.431576 , 0.97183099],\n", - " [0.35558781, 0.3589456 , 0.98591549],\n", - " [0.29027576, 0.29444756, 0.85915493],\n", - " [0.21770682, 0.224341 , 0.98591549],\n", - " [0.14513788, 0.14946719, 0.98591549],\n", - " [0.07305273, 0.07655637, 0.97183099],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85108434, 0.84398605, 0.98630137],\n", - " [0.72289157, 0.71963974, 0.83561644],\n", - " [0.58457831, 0.58018594, 0.89041096],\n", - " [0.43180723, 0.42969204, 1. ],\n", - " [0.29108434, 0.29285299, 0.89041096],\n", - " [0.13542169, 0.14148751, 0.98630137],\n", - " [0. , 0. , 0.90410959]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11051693, 0.89400922, 0.77272727],\n", - " [0.21865716, 0.78639198, 0.80681818],\n", - " [0.31729055, 0.69341285, 0.69318182],\n", - " [0.42602496, 0.58660884, 0.78409091],\n", - " [0.5466429 , 0.46218487, 0.92045455],\n", - " [0.65181224, 0.35429656, 0.78409091],\n", - " [0.76351753, 0.24722147, 0.79545455],\n", - " [0.86809269, 0.13580916, 0.80681818],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14154144, 0.14054054, 0.92957746],\n", - " [0.29714009, 0.29702703, 1. ],\n", - " [0.43625788, 0.43567568, 0.94366197],\n", - " [0.58167717, 0.58162162, 0.94366197],\n", - " [0.7198255 , 0.72081081, 0.91549296],\n", - " [0.85555017, 0.86054054, 0.91549296],\n", - " [1. , 1. , 0.94366197]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13428252, 0.12765957, 1. ],\n", - " [0.25823562, 0.24680851, 0.90277778],\n", - " [0.36795087, 0.36085106, 0.84722222],\n", - " [0.49274149, 0.49191489, 0.91666667],\n", - " [0.61501954, 0.61361702, 0.91666667],\n", - " [0.74008934, 0.73957447, 0.91666667],\n", - " [0.87520938, 0.87234043, 1. ],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11789067, 0.87979798, 0.78888889],\n", - " [0.2515185 , 0.74646465, 0.88888889],\n", - " [0.35229155, 0.64646465, 0.67777778],\n", - " [0.46990613, 0.52929293, 0.77777778],\n", - " [0.60077305, 0.4030303 , 0.86666667],\n", - " [0.72004417, 0.28686869, 0.77777778],\n", - " [0.86996135, 0.13636364, 1. ],\n", - " [1. , 0. , 0.88888889]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12706737, 0.13003941, 1. ],\n", - " [0.25252118, 0.25522886, 0.97014925],\n", - " [0.37716821, 0.37859958, 0.98507463],\n", - " [0.50786608, 0.50106093, 0.98507463],\n", - " [0.63816055, 0.62473477, 0.97014925],\n", - " [0.76401775, 0.75386481, 1. ],\n", - " [0.87615974, 0.87117308, 0.91044776],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9009264 , 0.89835165, 1. ],\n", - " [0.80082347, 0.78296703, 0.98591549],\n", - " [0.69917653, 0.69230769, 0.98591549],\n", - " [0.59933093, 0.5989011 , 0.98591549],\n", - " [0.49948533, 0.48626374, 0.98591549],\n", - " [0.39912506, 0.38461538, 1. ],\n", - " [0.3010808 , 0.2967033 , 0.97183099],\n", - " [0.19943387, 0.18406593, 1. ],\n", - " [0.0998456 , 0.08516484, 0.97183099],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12107734, 0.10344828, 0.89041096],\n", - " [0.25772177, 0.22758621, 1. ],\n", - " [0.38028169, 0.35862069, 0.89041096],\n", - " [0.50605387, 0.46896552, 0.91780822],\n", - " [0.62984927, 0.6137931 , 0.90410959],\n", - " [0.75364468, 0.73103448, 0.90410959],\n", - " [0.87546331, 0.89655172, 0.90410959],\n", - " [1. , 1. , 0.89041096]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89838751, 0.90734824, 0.89873418],\n", - " [0.79959048, 0.79233227, 0.87341772],\n", - " [0.71103148, 0.71565495, 0.7721519 ],\n", - " [0.61453801, 0.61341853, 0.87341772],\n", - " [0.51138981, 0.49840256, 0.89873418],\n", - " [0.41284873, 0.41214058, 0.87341772],\n", - " [0.29971845, 0.29392971, 1. ],\n", - " [0.21141541, 0.2172524 , 0.78481013],\n", - " [0.10033274, 0.10223642, 1. ],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.16264547, 0.8392385 , 1. ],\n", - " [0.30059608, 0.70333157, 0.84259259],\n", - " [0.43315356, 0.56848228, 0.83333333],\n", - " [0.56713029, 0.43151772, 0.84259259],\n", - " [0.68833381, 0.31147541, 0.74074074],\n", - " [0.79165484, 0.20888419, 0.63888889],\n", - " [0.89753051, 0.10312004, 0.65740741],\n", - " [1. , 0. , 0.63888889]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88877985, 0.88875526, 0.97014925],\n", - " [0.7775597 , 0.77781118, 0.98507463],\n", - " [0.66404972, 0.66746843, 0.98507463],\n", - " [0.55446516, 0.55562237, 0.98507463],\n", - " [0.44357213, 0.44497895, 0.98507463],\n", - " [0.33333333, 0.33343355, 0.98507463],\n", - " [0.21982336, 0.2230908 , 0.98507463],\n", - " [0.11089303, 0.11064342, 1. ],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11867835, 0.11882547, 0.83333333],\n", - " [0.24072825, 0.2395719 , 0.84615385],\n", - " [0.36547539, 0.36333699, 0.84615385],\n", - " [0.48550236, 0.48408342, 0.84615385],\n", - " [0.62238705, 0.62623491, 1. ],\n", - " [0.74376264, 0.74945115, 0.85897436],\n", - " [0.87660148, 0.8784303 , 0.91025641],\n", - " [1. , 1. , 0.85897436]]),\n", - " array([[9.92181070e-01, 4.05246744e-01, 0.00000000e+00],\n", - " [9.92592593e-01, 3.45808109e-01, 1.78384050e-03],\n", - " [9.91358025e-01, 2.95725555e-01, 1.60020986e-03],\n", - " [9.90946502e-01, 2.42891213e-01, 1.83630640e-03],\n", - " [9.91769547e-01, 1.95927353e-01, 1.86253935e-03],\n", - " [9.93415638e-01, 1.57035406e-01, 1.78384050e-03],\n", - " [9.93004115e-01, 1.22179417e-01, 1.86253935e-03],\n", - " [9.93004115e-01, 9.20931939e-02, 1.83630640e-03],\n", - " [9.98765432e-01, 7.02623372e-02, 1.65267576e-03],\n", - " [1.00000000e+00, 5.09998165e-02, 1.67890871e-03],\n", - " [9.90534979e-01, 3.39387268e-02, 1.65267576e-03],\n", - " [9.71604938e-01, 2.03632361e-02, 1.65267576e-03],\n", - " [9.41975309e-01, 1.24747753e-02, 1.67890871e-03],\n", - " [9.01234568e-01, 1.41258485e-02, 1.65267576e-03],\n", - " [8.50205761e-01, 2.01797835e-02, 1.83630640e-03],\n", - " [7.91358025e-01, 2.77013392e-02, 1.81007345e-03],\n", - " [7.34156379e-01, 3.61401578e-02, 1.70514166e-03],\n", - " [6.71193416e-01, 3.81581361e-02, 1.73137461e-03],\n", - " [6.06995885e-01, 3.66905155e-02, 1.83630640e-03],\n", - " [5.43209877e-01, 3.44890846e-02, 1.81007345e-03],\n", - " [4.80246914e-01, 3.11869382e-02, 1.86253935e-03],\n", - " [4.25925926e-01, 2.82516969e-02, 1.60020986e-03],\n", - " [3.65843621e-01, 2.53164557e-02, 1.78384050e-03],\n", - " [3.04938272e-01, 2.38488351e-02, 1.83630640e-03],\n", - " [2.55555556e-01, 2.27481196e-02, 1.62644281e-03],\n", - " [2.04115226e-01, 2.12804990e-02, 1.78384050e-03],\n", - " [1.62551440e-01, 1.92625206e-02, 1.60020986e-03],\n", - " [1.18930041e-01, 1.83452578e-02, 1.83630640e-03],\n", - " [8.31275720e-02, 1.65107320e-02, 1.83630640e-03],\n", - " [6.54320988e-02, 1.57769217e-02, 1.86253935e-03],\n", - " [5.26748971e-02, 1.43093010e-02, 1.81007345e-03],\n", - " [4.19753086e-02, 1.17409650e-02, 1.83630640e-03],\n", - " [3.16872428e-02, 1.10071547e-02, 1.83630640e-03],\n", - " [2.13991770e-02, 9.35608145e-03, 1.83630640e-03],\n", - " [1.15226337e-02, 8.62227114e-03, 1.86253935e-03],\n", - " [4.93827160e-03, 7.52155568e-03, 1.78384050e-03],\n", - " [4.11522634e-04, 7.52155568e-03, 1.21720881e-02],\n", - " [0.00000000e+00, 1.00898918e-02, 1.00000000e+00],\n", - " [4.11522634e-03, 1.52265639e-02, 1.81007345e-03],\n", - " [1.39917695e-02, 1.98128784e-02, 1.60020986e-03],\n", - " [3.33333333e-02, 2.23812145e-02, 1.83630640e-03],\n", - " [6.29629630e-02, 2.40322877e-02, 1.83630640e-03],\n", - " [9.62962963e-02, 2.62337186e-02, 1.78384050e-03],\n", - " [1.27572016e-01, 2.45826454e-02, 1.60020986e-03],\n", - " [1.62139918e-01, 1.96294258e-02, 1.86253935e-03],\n", - " [1.85185185e-01, 1.17409650e-02, 1.65267576e-03],\n", - " [1.93415638e-01, 5.87048248e-03, 1.65267576e-03],\n", - " [1.90123457e-01, 2.38488351e-03, 1.65267576e-03],\n", - " [1.80658436e-01, 0.00000000e+00, 1.67890871e-03],\n", - " [1.73662551e-01, 6.42084021e-03, 1.65267576e-03],\n", - " [1.83539095e-01, 1.68776371e-02, 1.62644281e-03],\n", - " [2.06584362e-01, 2.58668134e-02, 1.70514166e-03],\n", - " [2.47325103e-01, 2.84351495e-02, 1.73137461e-03],\n", - " [2.92592593e-01, 2.86186021e-02, 1.60020986e-03],\n", - " [3.45679012e-01, 2.86186021e-02, 1.81007345e-03],\n", - " [4.02469136e-01, 2.99027701e-02, 1.86253935e-03],\n", - " [4.57613169e-01, 3.24711062e-02, 1.81007345e-03],\n", - " [5.16049383e-01, 3.46725371e-02, 1.83630640e-03],\n", - " [5.76131687e-01, 3.65070629e-02, 1.83630640e-03],\n", - " [6.35390947e-01, 4.12768299e-02, 1.81007345e-03],\n", - " [6.90123457e-01, 4.69638598e-02, 1.70514166e-03],\n", - " [7.41975309e-01, 4.16437351e-02, 1.70514166e-03],\n", - " [7.84362140e-01, 3.50394423e-02, 1.60020986e-03],\n", - " [8.21810700e-01, 2.69675289e-02, 1.60020986e-03],\n", - " [8.63786008e-01, 1.79783526e-02, 1.65267576e-03],\n", - " [9.09465021e-01, 1.35754907e-02, 1.73137461e-03],\n", - " [9.48559671e-01, 2.34819299e-02, 1.67890871e-03],\n", - " [9.74074074e-01, 4.78811227e-02, 1.65267576e-03],\n", - " [9.81893004e-01, 8.47550908e-02, 1.65267576e-03],\n", - " [9.81069959e-01, 1.33736929e-01, 1.86253935e-03],\n", - " [9.83950617e-01, 1.90423775e-01, 1.81007345e-03],\n", - " [9.88065844e-01, 2.54448725e-01, 1.83630640e-03],\n", - " [9.88477366e-01, 3.23059989e-01, 1.86253935e-03],\n", - " [9.90123457e-01, 3.91854706e-01, 1.83630640e-03],\n", - " [9.89711934e-01, 4.49275362e-01, 1.65267576e-03],\n", - " [9.47736626e-01, 4.94955054e-01, 1.65267576e-03],\n", - " [8.76543210e-01, 5.25591635e-01, 1.65267576e-03],\n", - " [7.88065844e-01, 5.41368556e-01, 1.67890871e-03],\n", - " [6.89300412e-01, 5.49623922e-01, 1.73137461e-03],\n", - " [5.90946502e-01, 5.58796551e-01, 1.67890871e-03],\n", - " [5.26337449e-01, 5.87782058e-01, 1.65267576e-03],\n", - " [4.77777778e-01, 6.26490552e-01, 1.67890871e-03],\n", - " [4.22633745e-01, 6.77490369e-01, 1.81007345e-03],\n", - " [3.62139918e-01, 7.35644836e-01, 1.83630640e-03],\n", - " [2.96707819e-01, 8.00036691e-01, 1.83630640e-03],\n", - " [2.32098765e-01, 8.67547239e-01, 1.81007345e-03],\n", - " [1.76543210e-01, 9.27719684e-01, 1.60020986e-03],\n", - " [1.13580247e-01, 1.00000000e+00, 1.86253935e-03]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90873786, 0.10034014, 0.875 ],\n", - " [0.81608877, 0.18197279, 0.8875 ],\n", - " [0.7220527 , 0.26615646, 0.8625 ],\n", - " [0.63106796, 0.36734694, 0.8875 ],\n", - " [0.54285714, 0.46768707, 0.8625 ],\n", - " [0.45270458, 0.56122449, 0.875 ],\n", - " [0.34951456, 0.65816327, 1. ],\n", - " [0.25742025, 0.73809524, 0.875 ],\n", - " [0.18113731, 0.81462585, 0.7625 ],\n", - " [0.09042996, 0.90986395, 0.85 ],\n", - " [0. , 1. , 0.875 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91578947, 0.080373 , 0.82926829],\n", - " [0.83421053, 0.16363233, 0.87804878],\n", - " [0.75 , 0.24356128, 0.84146341],\n", - " [0.67105263, 0.32371226, 0.84146341],\n", - " [0.57894737, 0.42118117, 1. ],\n", - " [0.5 , 0.5008881 , 0.84146341],\n", - " [0.41842105, 0.58414742, 0.86585366],\n", - " [0.33947368, 0.6651865 , 0.84146341],\n", - " [0.25 , 0.74844583, 0.86585366],\n", - " [0.17105263, 0.82992895, 0.85365854],\n", - " [0.08421053, 0.91230018, 0.84146341],\n", - " [0. , 1. , 0.85365854]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.89919586, 0.10881801, 0.7 ],\n", - " [0.79379667, 0.22232645, 0.73333333],\n", - " [0.68811028, 0.33489681, 0.73333333],\n", - " [0.58328547, 0.44465291, 0.73333333],\n", - " [0.47472717, 0.55159475, 0.73333333],\n", - " [0.32768524, 0.69230769, 1. ],\n", - " [0.21883975, 0.79502814, 0.73333333],\n", - " [0.10913268, 0.89774859, 0.73333333],\n", - " [0. , 1. , 0.73333333]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.204914 , 0.19736053, 1. ],\n", - " [0.36560197, 0.35272945, 0.77647059],\n", - " [0.52481572, 0.51109778, 0.76470588],\n", - " [0.68108108, 0.67186563, 0.78823529],\n", - " [0.83144963, 0.82873425, 0.77647059],\n", - " [1. , 1. , 0.83529412]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88933121, 0.88826367, 0.97014925],\n", - " [0.77839703, 0.77652733, 0.98507463],\n", - " [0.66613588, 0.66157556, 0.98507463],\n", - " [0.5552017 , 0.54983923, 0.98507463],\n", - " [0.44559448, 0.43971061, 0.98507463],\n", - " [0.33333333, 0.32797428, 1. ],\n", - " [0.22080679, 0.21864952, 0.98507463],\n", - " [0.10934183, 0.10771704, 0.98507463],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86133333, 0.94091182, 0.98591549],\n", - " [0.72488889, 0.87822436, 1. ],\n", - " [0.60133333, 0.80533893, 1. ],\n", - " [0.50888889, 0.71925615, 0.97183099],\n", - " [0.43155556, 0.61967606, 1. ],\n", - " [0.35822222, 0.5179964 , 0.97183099],\n", - " [0.28044444, 0.4130174 , 0.98591549],\n", - " [0.20355556, 0.30773845, 0.98591549],\n", - " [0.12755556, 0.19826035, 1. ],\n", - " [0.06266667, 0.09118176, 0.97183099],\n", - " [0. , 0. , 0.85915493]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09865471, 0.09921415, 0.97183099],\n", - " [0.19994724, 0.19941061, 1. ],\n", - " [0.30018465, 0.29862475, 0.98591549],\n", - " [0.40015827, 0.39882122, 0.97183099],\n", - " [0.49881298, 0.49214145, 0.98591549],\n", - " [0.59746769, 0.59724951, 0.97183099],\n", - " [0.70113427, 0.70530452, 1. ],\n", - " [0.80110789, 0.80353635, 1. ],\n", - " [0.89897125, 0.90176817, 0.97183099],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16938776, 0.17280996, 1. ],\n", - " [0.32857143, 0.34298708, 1. ],\n", - " [0.4755102 , 0.50981331, 1. ],\n", - " [0.63469388, 0.66586884, 0.92424242],\n", - " [0.81632653, 0.83413116, 0.98484848],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90549961, 0.89603025, 0.87341772],\n", - " [0.80686806, 0.80907372, 0.89873418],\n", - " [0.71159308, 0.71077505, 0.86075949],\n", - " [0.61399432, 0.61625709, 0.89873418],\n", - " [0.51768655, 0.52362949, 0.88607595],\n", - " [0.40511232, 0.4026465 , 1. ],\n", - " [0.30570617, 0.31758034, 0.91139241],\n", - " [0.19571392, 0.19659735, 1. ],\n", - " [0.09630777, 0.09073724, 0.88607595],\n", - " [0. , 0. , 0.87341772]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12522407, 0.12554745, 0.98507463],\n", - " [0.24814341, 0.24817518, 0.97014925],\n", - " [0.37490397, 0.37372263, 1. ],\n", - " [0.49987196, 0.50072993, 0.98507463],\n", - " [0.62279129, 0.62189781, 0.97014925],\n", - " [0.75006402, 0.75182482, 0.98507463],\n", - " [0.87503201, 0.87591241, 1. ],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91106719, 0.91081081, 0.59322034],\n", - " [0.81884058, 0.81837838, 0.60169492],\n", - " [0.66996047, 0.66648649, 1. ],\n", - " [0.58102767, 0.57675676, 0.60169492],\n", - " [0.48945982, 0.48702703, 0.59322034],\n", - " [0.39986825, 0.39702703, 0.59322034],\n", - " [0.2826087 , 0.28027027, 0.76271186],\n", - " [0.17061924, 0.16810811, 0.76271186],\n", - " [0.09156785, 0.08918919, 0.51694915],\n", - " [0. , 0. , 0.59322034]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88591591, 0.10953058, 0.97183099],\n", - " [0.77124375, 0.22285443, 0.98591549],\n", - " [0.66480447, 0.32811759, 0.98591549],\n", - " [0.54895619, 0.44238976, 1. ],\n", - " [0.43987063, 0.54812707, 0.97183099],\n", - " [0.32755072, 0.6628734 , 0.98591549],\n", - " [0.21875919, 0.77524893, 1. ],\n", - " [0.10761541, 0.88999526, 0.97183099],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89051888, 0.90364026, 0.98611111],\n", - " [0.78212442, 0.79657388, 0.94444444],\n", - " [0.66911165, 0.68522484, 1. ],\n", - " [0.55609889, 0.57173448, 0.97222222],\n", - " [0.44879109, 0.45824411, 0.97222222],\n", - " [0.33795164, 0.34689507, 0.95833333],\n", - " [0.22656887, 0.2248394 , 0.97222222],\n", - " [0.11192611, 0.10492505, 0.98611111],\n", - " [0. , 0. , 0.97222222]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08595989, 0.90207786, 0.8625 ],\n", - " [0.16905444, 0.80702173, 0.85 ],\n", - " [0.252149 , 0.7105326 , 0.9 ],\n", - " [0.36962751, 0.60114641, 1. ],\n", - " [0.48997135, 0.4903272 , 1. ],\n", - " [0.6017192 , 0.38213518, 0.975 ],\n", - " [0.68767908, 0.28707905, 0.875 ],\n", - " [0.77936963, 0.18987342, 0.8875 ],\n", - " [0.89684814, 0.09386195, 0.875 ],\n", - " [1. , 0. , 0.875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89031595, 0.88479263, 0.87341772],\n", - " [0.77754945, 0.77419355, 0.91139241],\n", - " [0.66632417, 0.64516129, 0.88607595],\n", - " [0.53917287, 0.51612903, 1. ],\n", - " [0.44361675, 0.42396313, 0.7721519 ],\n", - " [0.33418957, 0.30414747, 0.87341772],\n", - " [0.22296429, 0.19354839, 0.88607595],\n", - " [0.095813 , 0.09677419, 1. ],\n", - " [0. , 0. , 0.7721519 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87004405, 0.03798141, 0.86419753],\n", - " [0.75682819, 0.09322709, 0.86419753],\n", - " [0.66872247, 0.17237716, 0.87654321],\n", - " [0.60572687, 0.26772908, 0.85185185],\n", - " [0.53436123, 0.36812749, 0.86419753],\n", - " [0.45859031, 0.4690571 , 0.86419753],\n", - " [0.3660793 , 0.59150066, 1. ],\n", - " [0.28722467, 0.70092961, 0.86419753],\n", - " [0.20396476, 0.80371846, 0.85185185],\n", - " [0.10704846, 0.90039841, 0.86419753],\n", - " [0. , 1. , 0.86419753]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14588305, 0.1395655 , 1. ],\n", - " [0.28818616, 0.27781435, 0.97014925],\n", - " [0.43078759, 0.41935484, 0.98507463],\n", - " [0.57547733, 0.55892034, 0.98507463],\n", - " [0.72106205, 0.70046083, 1. ],\n", - " [0.86127685, 0.8439763 , 0.97014925],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86044444, 0.12144638, 0.60185185],\n", - " [0.73777778, 0.24563591, 0.61111111],\n", - " [0.60533333, 0.3840399 , 0.66666667],\n", - " [0.376 , 0.59600998, 1. ],\n", - " [0.26222222, 0.73017456, 0.66666667],\n", - " [0.12533333, 0.87605985, 0.67592593],\n", - " [0. , 1. , 0.61111111]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86870229, 0.13065539, 0.92307692],\n", - " [0.75572519, 0.24651163, 0.84615385],\n", - " [0.61832061, 0.38625793, 1. ],\n", - " [0.49465649, 0.51374207, 0.92307692],\n", - " [0.3648855 , 0.64080338, 0.92307692],\n", - " [0.24580153, 0.75708245, 0.84615385],\n", - " [0.13587786, 0.87336152, 0.84615385],\n", - " [0. , 1. , 0.92307692]]),\n", - " array([[1.33710407e-01, 8.37188612e-01, 0.00000000e+00],\n", - " [1.02488688e-01, 8.06049822e-01, 1.93331465e-03],\n", - " [7.51131222e-02, 7.74911032e-01, 1.96133371e-03],\n", - " [5.00000000e-02, 7.44661922e-01, 1.96133371e-03],\n", - " [2.94117647e-02, 7.17081851e-01, 1.93331465e-03],\n", - " [1.80995475e-02, 6.99288256e-01, 1.96133371e-03],\n", - " [1.49321267e-02, 6.90391459e-01, 1.98935276e-03],\n", - " [1.28959276e-02, 6.80604982e-01, 1.70916223e-03],\n", - " [9.72850679e-03, 6.65480427e-01, 1.96133371e-03],\n", - " [7.23981900e-03, 6.51245552e-01, 1.90529560e-03],\n", - " [5.88235294e-03, 6.44128114e-01, 6.73858224e-02],\n", - " [2.71493213e-03, 6.65480427e-01, 1.00000000e+00],\n", - " [4.52488688e-04, 6.80604982e-01, 1.70916223e-03],\n", - " [0.00000000e+00, 6.95729537e-01, 1.96133371e-03],\n", - " [5.65610860e-03, 7.10854093e-01, 1.96133371e-03],\n", - " [1.96832579e-02, 7.36654804e-01, 1.93331465e-03],\n", - " [4.27601810e-02, 7.69572954e-01, 1.96133371e-03],\n", - " [7.37556561e-02, 8.02491103e-01, 1.96133371e-03],\n", - " [1.10633484e-01, 8.38078292e-01, 1.98935276e-03],\n", - " [1.49321267e-01, 8.68327402e-01, 1.96133371e-03],\n", - " [1.85067873e-01, 8.91459075e-01, 1.93331465e-03],\n", - " [2.19457014e-01, 9.16370107e-01, 1.98935276e-03],\n", - " [2.50452489e-01, 9.35943060e-01, 1.96133371e-03],\n", - " [2.72171946e-01, 9.43060498e-01, 1.76520034e-03],\n", - " [2.91176471e-01, 9.41281139e-01, 1.76520034e-03],\n", - " [3.09049774e-01, 9.50177936e-01, 1.79321939e-03],\n", - " [3.23303167e-01, 9.83096085e-01, 1.76520034e-03],\n", - " [3.37330317e-01, 1.00000000e+00, 1.76520034e-03],\n", - " [3.57013575e-01, 9.91992883e-01, 1.76520034e-03],\n", - " [3.83484163e-01, 9.59074733e-01, 1.79321939e-03],\n", - " [4.16515837e-01, 8.92348754e-01, 1.90529560e-03],\n", - " [4.55203620e-01, 7.87366548e-01, 1.93331465e-03],\n", - " [4.95701357e-01, 6.40569395e-01, 1.96133371e-03],\n", - " [5.33710407e-01, 4.78647687e-01, 1.93331465e-03],\n", - " [5.65837104e-01, 3.29181495e-01, 1.70916223e-03],\n", - " [6.01357466e-01, 1.79715302e-01, 1.76520034e-03],\n", - " [6.41176471e-01, 7.02846975e-02, 1.79321939e-03],\n", - " [6.82579186e-01, 1.69039146e-02, 1.76520034e-03],\n", - " [7.27828054e-01, 0.00000000e+00, 1.93331465e-03],\n", - " [7.68325792e-01, 1.60142349e-02, 1.70916223e-03],\n", - " [8.15610860e-01, 5.78291815e-02, 1.96133371e-03],\n", - " [8.68778281e-01, 1.09430605e-01, 1.93331465e-03],\n", - " [9.31447964e-01, 1.81494662e-01, 1.98935276e-03],\n", - " [1.00000000e+00, 2.69572954e-01, 1.93331465e-03]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.84745763, 0.1525 , 0.72222222],\n", - " [0.69061071, 0.30583333, 0.73333333],\n", - " [0.47968792, 0.51416667, 1. ],\n", - " [0.31853645, 0.68 , 0.73333333],\n", - " [0.1614205 , 0.83333333, 0.73333333],\n", - " [0. , 1. , 0.74444444]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.1138088 , 0.88624339, 0.91549296],\n", - " [0.21760243, 0.78344671, 0.85915493],\n", - " [0.33323217, 0.6670446 , 0.92957746],\n", - " [0.45584219, 0.54535147, 1. ],\n", - " [0.55781487, 0.4425548 , 0.85915493],\n", - " [0.67010622, 0.33106576, 0.92957746],\n", - " [0.78300455, 0.21844293, 0.92957746],\n", - " [0.89165402, 0.1095994 , 0.91549296],\n", - " [1. , 0. , 0.92957746]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.1000535 , 0.90861813, 0.85185185],\n", - " [0.20278224, 0.81624567, 0.88888889],\n", - " [0.30551097, 0.72362556, 0.86419753],\n", - " [0.40342429, 0.63447251, 0.85185185],\n", - " [0.50775816, 0.54160475, 0.86419753],\n", - " [0.5917603 , 0.46433878, 0.75308642],\n", - " [0.68967362, 0.37270926, 0.85185185],\n", - " [0.79026217, 0.26597325, 1. ],\n", - " [0.87693954, 0.17360079, 0.85185185],\n", - " [0.93953986, 0.0936107 , 0.75308642],\n", - " [1. , 0. , 0.85185185]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8966525 , 0.88308977, 1. ],\n", - " [0.79596174, 0.76826722, 0.98591549],\n", - " [0.69899044, 0.66805846, 0.97183099],\n", - " [0.59829968, 0.57202505, 1. ],\n", - " [0.49628055, 0.47599165, 0.98591549],\n", - " [0.39638682, 0.37995825, 0.98591549],\n", - " [0.29702444, 0.28392484, 0.98591549],\n", - " [0.20031881, 0.18997912, 0.97183099],\n", - " [0.09936238, 0.09394572, 1. ],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91652174, 0.0825 , 0.97183099],\n", - " [0.82608696, 0.17045455, 1. ],\n", - " [0.74869565, 0.25272727, 0.97183099],\n", - " [0.66521739, 0.33795455, 0.98591549],\n", - " [0.58 , 0.42409091, 1. ],\n", - " [0.49304348, 0.5075 , 0.97183099],\n", - " [0.40956522, 0.59363636, 1. ],\n", - " [0.33391304, 0.67795455, 0.97183099],\n", - " [0.24521739, 0.76090909, 0.98591549],\n", - " [0.16086957, 0.84477273, 0.98591549],\n", - " [0.08695652, 0.91659091, 0.85915493],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09847716, 0.09154203, 1. ],\n", - " [0.18375635, 0.16915936, 0.89873418],\n", - " [0.26598985, 0.2503868 , 0.88607595],\n", - " [0.34720812, 0.33470861, 0.89873418],\n", - " [0.4284264 , 0.41645178, 0.86075949],\n", - " [0.5071066 , 0.49845281, 0.88607595],\n", - " [0.59137056, 0.58561114, 0.89873418],\n", - " [0.6822335 , 0.67715317, 0.87341772],\n", - " [0.75228426, 0.74548736, 0.88607595],\n", - " [0.83604061, 0.83032491, 0.91139241],\n", - " [0.9213198 , 0.92135121, 0.87341772],\n", - " [1. , 1. , 0.87341772]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91950558, 0.91319857, 0.97183099],\n", - " [0.83629786, 0.82282996, 1. ],\n", - " [0.75309014, 0.73067776, 0.97183099],\n", - " [0.67199276, 0.64090369, 0.98591549],\n", - " [0.58908652, 0.54875149, 1. ],\n", - " [0.50406994, 0.45541023, 0.98591549],\n", - " [0.42056075, 0.36801427, 0.98591549],\n", - " [0.33765451, 0.27586207, 0.98591549],\n", - " [0.25444679, 0.18192628, 0.98591549],\n", - " [0.17304793, 0.08799049, 0.97183099],\n", - " [0.08561954, 0.02021403, 1. ],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10882182, 0.1049936 , 0.86419753],\n", - " [0.21445154, 0.2099872 , 0.85185185],\n", - " [0.32356355, 0.32010243, 0.87654321],\n", - " [0.44486361, 0.44558259, 0.97530864],\n", - " [0.55223447, 0.55569782, 0.86419753],\n", - " [0.66163668, 0.66325224, 0.86419753],\n", - " [0.78583865, 0.78318395, 1. ],\n", - " [0.89320952, 0.88860435, 0.85185185],\n", - " [1. , 1. , 0.86419753]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10660039, 0.07021792, 1. ],\n", - " [0.21181994, 0.14043584, 0.98591549],\n", - " [0.31400166, 0.20096852, 0.95774648],\n", - " [0.40568904, 0.26271186, 0.85915493],\n", - " [0.51090859, 0.32687651, 0.98591549],\n", - " [0.61723281, 0.38498789, 0.98591549],\n", - " [0.72493786, 0.45762712, 1. ],\n", - " [0.82988125, 0.53268765, 0.97183099],\n", - " [0.92239713, 0.68523002, 0.90140845],\n", - " [1. , 1. , 0.88732394]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.83281116, 0.83225806, 1. ],\n", - " [0.66647679, 0.65403226, 1. ],\n", - " [0.49985759, 0.48467742, 1. ],\n", - " [0.33380803, 0.31129032, 1. ],\n", - " [0.16775847, 0.13709677, 1. ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11480519, 0.06835938, 0.59166667],\n", - " [0.24337662, 0.171875 , 0.66666667],\n", - " [0.43896104, 0.35742188, 1. ],\n", - " [0.55038961, 0.46484375, 0.575 ],\n", - " [0.66103896, 0.58203125, 0.58333333],\n", - " [0.77506494, 0.71875 , 0.58333333],\n", - " [0.88753247, 0.85546875, 0.58333333],\n", - " [1. , 1. , 0.58333333]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86426999, 0.13653234, 0.91011236],\n", - " [0.75568599, 0.25662778, 0.78651685],\n", - " [0.63316214, 0.37698834, 0.78651685],\n", - " [0.53411592, 0.47773065, 0.68539326],\n", - " [0.4108584 , 0.59968187, 0.7752809 ],\n", - " [0.25825385, 0.75026511, 1. ],\n", - " [0.11958914, 0.88335101, 0.91011236],\n", - " [0. , 1. , 0.7752809 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12033195, 0.12414837, 0.90277778],\n", - " [0.23236515, 0.23921272, 0.84722222],\n", - " [0.36514523, 0.36613677, 0.91666667],\n", - " [0.48547718, 0.49356548, 0.91666667],\n", - " [0.60580913, 0.62074186, 0.90277778],\n", - " [0.71369295, 0.73681554, 0.84722222],\n", - " [0.85062241, 0.86373959, 0.90277778],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12231819, 0.11845103, 0.875 ],\n", - " [0.24630816, 0.24373576, 0.8875 ],\n", - " [0.3633324 , 0.3690205 , 0.8625 ],\n", - " [0.49038729, 0.49886105, 0.875 ],\n", - " [0.62886598, 0.63553531, 1. ],\n", - " [0.7514628 , 0.75170843, 0.875 ],\n", - " [0.87601003, 0.87015945, 0.8875 ],\n", - " [1. , 1. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11297284, 0.08495146, 0.98507463],\n", - " [0.22264534, 0.17961165, 0.98507463],\n", - " [0.33384108, 0.29126214, 0.98507463],\n", - " [0.4460523 , 0.40776699, 0.98507463],\n", - " [0.5575019 , 0.51456311, 0.98507463],\n", - " [0.66895151, 0.6407767 , 0.98507463],\n", - " [0.7796395 , 0.76699029, 1. ],\n", - " [0.89058137, 0.88834951, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8886619 , 0.88770515, 0.86419753],\n", - " [0.76353422, 0.7615894 , 1. ],\n", - " [0.65372829, 0.65102217, 0.86419753],\n", - " [0.54902962, 0.54563778, 0.85185185],\n", - " [0.42390194, 0.41980996, 0.98765432],\n", - " [0.3319714 , 0.32623092, 0.75308642],\n", - " [0.22318693, 0.21595163, 0.86419753],\n", - " [0.11899898, 0.11229485, 0.86419753],\n", - " [0. , 0. , 0.86419753]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88215962, 0.12964348, 0.97014925],\n", - " [0.76197183, 0.2582897 , 1. ],\n", - " [0.63661972, 0.38344552, 0.98507463],\n", - " [0.51173709, 0.50536026, 0.97014925],\n", - " [0.38403756, 0.62827225, 0.98507463],\n", - " [0.25539906, 0.75442533, 0.98507463],\n", - " [0.12769953, 0.87733732, 1. ],\n", - " [0. , 1. , 0.97014925]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.82269504, 0.16643646, 0.97014925],\n", - " [0.65957447, 0.33517495, 1. ],\n", - " [0.5177305 , 0.49930939, 0.98507463],\n", - " [0.34751773, 0.66620626, 0.98507463],\n", - " [0.14893617, 0.83333333, 0.97014925],\n", - " [0. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87978723, 0.88235294, 0.66666667],\n", - " [0.69893617, 0.69683258, 1. ],\n", - " [0.58989362, 0.58823529, 0.59166667],\n", - " [0.47207447, 0.46757164, 0.65 ],\n", - " [0.35132979, 0.3453997 , 0.675 ],\n", - " [0.24468085, 0.23680241, 0.58333333],\n", - " [0.13803191, 0.12971342, 0.58333333],\n", - " [0. , 0. , 0.74166667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91185582, 0.91067961, 0.85 ],\n", - " [0.8203323 , 0.82006472, 0.875 ],\n", - " [0.71472825, 0.71003236, 1. ],\n", - " [0.62545762, 0.61747573, 0.875 ],\n", - " [0.53534216, 0.52556634, 0.875 ],\n", - " [0.44297381, 0.43300971, 0.8875 ],\n", - " [0.35342157, 0.34239482, 0.8625 ],\n", - " [0.27400732, 0.26213592, 0.7625 ],\n", - " [0.18248381, 0.17087379, 0.875 ],\n", - " [0.09293157, 0.0789644 , 0.8625 ],\n", - " [0. , 0. , 0.8875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08280467, 0.91759554, 0.86585366],\n", - " [0.16427379, 0.84076433, 0.84146341],\n", - " [0.24941569, 0.76035032, 0.86585366],\n", - " [0.33055092, 0.68351911, 0.85365854],\n", - " [0.41803005, 0.59872611, 0.97560976],\n", - " [0.49482471, 0.52030255, 0.82926829],\n", - " [0.57863105, 0.45262739, 1. ],\n", - " [0.66510851, 0.34992038, 0.84146341],\n", - " [0.7672788 , 0.26552548, 0.98780488],\n", - " [0.83806344, 0.20063694, 0.84146341],\n", - " [0.92253756, 0.125 , 0.85365854],\n", - " [1. , 0. , 0.97560976]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92167722, 0.91552303, 0.72093023],\n", - " [0.83662975, 0.83836536, 0.73255814],\n", - " [0.75079114, 0.74717902, 0.77906977],\n", - " [0.63568038, 0.63708448, 1. ],\n", - " [0.55063291, 0.55138762, 0.74418605],\n", - " [0.44778481, 0.45013724, 0.88372093],\n", - " [0.35047468, 0.35346142, 0.8255814 ],\n", - " [0.25830696, 0.26044526, 0.81395349],\n", - " [0.16811709, 0.1704788 , 0.76744186],\n", - " [0.08386076, 0.0863068 , 0.73255814],\n", - " [0. , 0. , 0.74418605]]),\n", - " array([[0.81345566, 1. , 0. ],\n", - " [0.94495413, 0.91027367, 1. ],\n", - " [1. , 0.82951996, 0.95833333],\n", - " [0.88685015, 0.74383131, 0.97222222],\n", - " [0.8440367 , 0.6615074 , 0.98611111],\n", - " [0.77370031, 0.57828623, 0.94444444],\n", - " [0.73394495, 0.49685958, 0.98611111],\n", - " [0.617737 , 0.4149843 , 0.98611111],\n", - " [0.51070336, 0.3328847 , 0.95833333],\n", - " [0.35779817, 0.25056079, 0.97222222],\n", - " [0.25382263, 0.16823688, 0.97222222],\n", - " [0.16207951, 0.08591297, 0.95833333],\n", - " [0. , 0. , 0.98611111]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16824197, 0.16919806, 0.98507463],\n", - " [0.33005671, 0.32715674, 0.98507463],\n", - " [0.4952741 , 0.4927096 , 1. ],\n", - " [0.66616257, 0.66433779, 0.98507463],\n", - " [0.83175803, 0.82381531, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 0.0625 , 0. ],\n", - " [0.88338271, 0. , 0.61068702],\n", - " [0.77673041, 0.1875 , 0.53435115],\n", - " [0.67250202, 0.25 , 0.53435115],\n", - " [0.56881228, 0.1875 , 0.53435115],\n", - " [0.46593051, 0.375 , 0.52671756],\n", - " [0.26986264, 0.5625 , 1. ],\n", - " [0.13493132, 0.8125 , 0.6870229 ],\n", - " [0. , 1. , 0.6870229 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13338997, 0.13373162, 0.6875 ],\n", - " [0.2740017 , 0.27504596, 0.73958333],\n", - " [0.39804588, 0.39797794, 0.63541667],\n", - " [0.53313509, 0.53262868, 0.6875 ],\n", - " [0.66864911, 0.66750919, 0.6875 ],\n", - " [0.81138488, 0.81043199, 0.75 ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.85887208, 0.13259669, 1. ],\n", - " [0.71774415, 0.25414365, 1. ],\n", - " [0.56973865, 0.38674033, 1. ],\n", - " [0.43026135, 0.54696133, 1. ],\n", - " [0.28500688, 0.70718232, 1. ],\n", - " [0.14222834, 0.85082873, 1. ],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90038314, 0.90257404, 0.88888889],\n", - " [0.79166667, 0.79518406, 0.97530864],\n", - " [0.68295019, 0.68779408, 0.98765432],\n", - " [0.57136015, 0.57708276, 1. ],\n", - " [0.47509579, 0.48104069, 0.85185185],\n", - " [0.37931034, 0.38444506, 0.86419753],\n", - " [0.28400383, 0.28978688, 0.85185185],\n", - " [0.18726054, 0.19153058, 0.87654321],\n", - " [0.0914751 , 0.09382784, 0.87654321],\n", - " [0. , 0. , 0.83950617]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11486103, 0.88744344, 0.4964539 ],\n", - " [0.22887124, 0.77262443, 0.4964539 ],\n", - " [0.34231424, 0.65837104, 0.4822695 ],\n", - " [0.45717527, 0.54298643, 0.5035461 ],\n", - " [0.63754963, 0.36255656, 0.77304965],\n", - " [0.86670448, 0.13065611, 1. ],\n", - " [1. , 0. , 0.56737589]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88677303, 0.88751545, 0.97222222],\n", - " [0.77303139, 0.77676143, 0.95833333],\n", - " [0.66083376, 0.66205192, 0.98611111],\n", - " [0.5491508 , 0.54932015, 0.95833333],\n", - " [0.43386516, 0.43584672, 1. ],\n", - " [0.32269686, 0.32509271, 0.94444444],\n", - " [0.22593927, 0.22793572, 0.84722222],\n", - " [0.11580031, 0.11644005, 0.95833333],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.11660951, 0.88236703, 0.98507463],\n", - " [0.23811857, 0.75922377, 0.98507463],\n", - " [0.36501715, 0.63320556, 0.98507463],\n", - " [0.49289564, 0.51054145, 0.98507463],\n", - " [0.62371387, 0.38524197, 0.97014925],\n", - " [0.74865262, 0.25706756, 1. ],\n", - " [0.87359138, 0.12913273, 0.98507463],\n", - " [1. , 0. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.82985822, 0.83132239, 0.98507463],\n", - " [0.66638866, 0.66795367, 0.98507463],\n", - " [0.50125104, 0.50168919, 0.98507463],\n", - " [0.33110926, 0.33301158, 0.98507463],\n", - " [0.16513761, 0.16650579, 1. ],\n", - " [0. , 0. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89179906, 0.88330046, 0.89873418],\n", - " [0.78273937, 0.77021696, 0.87341772],\n", - " [0.68913697, 0.67094017, 0.7721519 ],\n", - " [0.5757836 , 0.56147272, 0.88607595],\n", - " [0.46543581, 0.45266272, 0.87341772],\n", - " [0.35294118, 0.34549638, 0.87341772],\n", - " [0.23958781, 0.23372781, 0.89873418],\n", - " [0.1266638 , 0.12228797, 0.89873418],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89185033, 0.91043203, 0.97183099],\n", - " [0.77703742, 0.81348788, 0.98591549],\n", - " [0.66299334, 0.7028451 , 1. ],\n", - " [0.55484367, 0.59747102, 0.97183099],\n", - " [0.44720656, 0.49209694, 0.97183099],\n", - " [0.33444387, 0.37934668, 1. ],\n", - " [0.22731932, 0.26027397, 0.98591549],\n", - " [0.11327524, 0.1317176 , 0.98591549],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.95009074, 0.09995124, 0.71 ],\n", - " [0.90471869, 0.19795222, 0.7 ],\n", - " [0.86206897, 0.28937104, 0.69 ],\n", - " [0.81669691, 0.38152121, 0.7 ],\n", - " [0.77041742, 0.48878596, 0.8 ],\n", - " [0.70780399, 0.58386153, 0.71 ],\n", - " [0.59165154, 0.66723549, 0.7 ],\n", - " [0.45099819, 0.7574354 , 0.8 ],\n", - " [0.26497278, 0.85884934, 1. ],\n", - " [0.13339383, 0.92881521, 0.68 ],\n", - " [0. , 1. , 0.71 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90669431, 0.91631206, 0.97222222],\n", - " [0.82790284, 0.84491726, 0.84722222],\n", - " [0.73904028, 0.76595745, 0.97222222],\n", - " [0.65195498, 0.68652482, 0.94444444],\n", - " [0.56309242, 0.60425532, 1. ],\n", - " [0.47837678, 0.52671395, 0.95833333],\n", - " [0.3924763 , 0.44964539, 0.98611111],\n", - " [0.30776066, 0.37304965, 0.97222222],\n", - " [0.22867299, 0.28652482, 0.95833333],\n", - " [0.15225118, 0.19054374, 0.95833333],\n", - " [0.07671801, 0.09361702, 0.97222222],\n", - " [0. , 0. , 0.98611111]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9073111 , 0.90712251, 0.78481013],\n", - " [0.78923218, 0.78803419, 1. ],\n", - " [0.69807281, 0.6962963 , 0.78481013],\n", - " [0.59926583, 0.6 , 0.81012658],\n", - " [0.49005812, 0.49002849, 0.93670886],\n", - " [0.39736923, 0.3977208 , 0.78481013],\n", - " [0.29703273, 0.2968661 , 0.83544304],\n", - " [0.19027225, 0.18917379, 0.91139241],\n", - " [0.09513613, 0.09344729, 0.78481013],\n", - " [0. , 0. , 0.81012658]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87990607, 0.86831009, 0.90277778],\n", - " [0.7577994 , 0.7356471 , 0.91666667],\n", - " [0.64441463, 0.61368797, 0.84722222],\n", - " [0.52130158, 0.48394421, 0.90277778],\n", - " [0.39483395, 0.35809277, 0.91666667],\n", - " [0.27675277, 0.24813493, 0.84722222],\n", - " [0.1338477 , 0.11644502, 1. ],\n", - " [0. , 0. , 0.90277778]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1286285 , 0.19135802, 1. ],\n", - " [0.25113182, 0.31481481, 0.98507463],\n", - " [0.38029294, 0.44444444, 0.97014925],\n", - " [0.50679095, 0.5617284 , 1. ],\n", - " [0.63195739, 0.67901235, 0.97014925],\n", - " [0.75099867, 0.79320988, 0.98507463],\n", - " [0.87829561, 0.89197531, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08917407, 0.91238564, 0.85915493],\n", - " [0.19381375, 0.80928923, 0.98591549],\n", - " [0.29680816, 0.70724842, 0.98591549],\n", - " [0.39749918, 0.60626319, 0.98591549],\n", - " [0.50082264, 0.50316678, 0.98591549],\n", - " [0.60184271, 0.40218156, 0.98591549],\n", - " [0.70253373, 0.30154821, 0.98591549],\n", - " [0.80289569, 0.20091485, 1. ],\n", - " [0.90062521, 0.10133709, 0.95774648],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12763242, 0.13199004, 0.98507463],\n", - " [0.22335673, 0.24518904, 0.91044776],\n", - " [0.35098915, 0.37355671, 0.97014925],\n", - " [0.47862157, 0.49807562, 1. ],\n", - " [0.60625399, 0.62259452, 0.97014925],\n", - " [0.73388641, 0.75096219, 0.98507463],\n", - " [0.87236758, 0.8754811 , 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89595202, 0.89603766, 0.95833333],\n", - " [0.79310345, 0.79325226, 0.98611111],\n", - " [0.69055472, 0.69046685, 0.95833333],\n", - " [0.5862069 , 0.58650451, 1. ],\n", - " [0.48365817, 0.48254217, 0.95833333],\n", - " [0.3952024 , 0.39584151, 0.84722222],\n", - " [0.29385307, 0.29580228, 0.94444444],\n", - " [0.205997 , 0.20753237, 0.84722222],\n", - " [0.09985007, 0.10082385, 0.98611111],\n", - " [0. , 0. , 0.95833333]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09301691, 0.90568119, 0.88732394],\n", - " [0.19067103, 0.80750138, 0.92957746],\n", - " [0.29405346, 0.70490899, 0.98591549],\n", - " [0.3867976 , 0.61279647, 0.90140845],\n", - " [0.48690671, 0.51241037, 0.94366197],\n", - " [0.58701582, 0.41312741, 0.97183099],\n", - " [0.69285325, 0.30832874, 1. ],\n", - " [0.79378069, 0.20683949, 0.97183099],\n", - " [0.89634479, 0.1042471 , 1. ],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.86883721, 0.87310276, 0.94366197],\n", - " [0.74046512, 0.74744961, 0.92957746],\n", - " [0.61767442, 0.62403583, 0.91549296],\n", - " [0.48930233, 0.49763623, 0.94366197],\n", - " [0.36744186, 0.3749689 , 0.91549296],\n", - " [0.25116279, 0.25901966, 0.85915493],\n", - " [0.12837209, 0.13386415, 0.92957746],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1095994 , 0.08031746, 0.88607595],\n", - " [0.21768707, 0.16253968, 0.89873418],\n", - " [0.32539683, 0.24285714, 0.86075949],\n", - " [0.43197279, 0.32222222, 0.88607595],\n", - " [0.54270597, 0.4047619 , 0.89873418],\n", - " [0.65381708, 0.48190476, 0.89873418],\n", - " [0.75661376, 0.59047619, 1. ],\n", - " [0.81519274, 0.68190476, 0.7721519 ],\n", - " [0.88284203, 0.78984127, 0.86075949],\n", - " [0.93801965, 0.88730159, 0.7721519 ],\n", - " [1. , 1. , 0.88607595]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92970522, 0.08523857, 1. ],\n", - " [0.861678 , 0.15581511, 0.85915493],\n", - " [0.77777778, 0.24030815, 0.97183099],\n", - " [0.70521542, 0.32455268, 1. ],\n", - " [0.61904762, 0.40780318, 0.97183099],\n", - " [0.53514739, 0.49428429, 1. ],\n", - " [0.44897959, 0.57753479, 0.97183099],\n", - " [0.35827664, 0.66227634, 0.98591549],\n", - " [0.26303855, 0.74751491, 0.97183099],\n", - " [0.17460317, 0.83126243, 0.98591549],\n", - " [0.08390023, 0.9167495 , 1. ],\n", - " [0. , 1. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92917847, 0.92784357, 0.86419753],\n", - " [0.85949008, 0.85816579, 0.85185185],\n", - " [0.78640227, 0.78656018, 0.87654321],\n", - " [0.71501416, 0.71578078, 0.86419753],\n", - " [0.64419263, 0.64637841, 0.86419753],\n", - " [0.5694051 , 0.57339576, 0.87654321],\n", - " [0.50028329, 0.50234095, 0.85185185],\n", - " [0.43002833, 0.43073533, 0.86419753],\n", - " [0.35694051, 0.36023134, 0.86419753],\n", - " [0.28441926, 0.28945194, 0.86419753],\n", - " [0.21189802, 0.22060039, 0.85185185],\n", - " [0.13031161, 0.13522446, 1. ],\n", - " [0.06062323, 0.06141559, 0.86419753],\n", - " [0. , 0. , 0.75308642]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16824197, 0.16919806, 0.98507463],\n", - " [0.33005671, 0.32715674, 0.98507463],\n", - " [0.4952741 , 0.4927096 , 1. ],\n", - " [0.66616257, 0.66433779, 0.98507463],\n", - " [0.83175803, 0.82381531, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89772125, 0.92239859, 1. ],\n", - " [0.79623741, 0.84832451, 0.95833333],\n", - " [0.69607843, 0.77601411, 0.95833333],\n", - " [0.59326974, 0.66313933, 1. ],\n", - " [0.49390567, 0.53791887, 0.95833333],\n", - " [0.40540541, 0.43915344, 0.84722222],\n", - " [0.30418654, 0.31922399, 0.95833333],\n", - " [0.20429253, 0.20458554, 0.95833333],\n", - " [0.10121887, 0.08641975, 1. ],\n", - " [0. , 0. , 0.95833333]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.10322581, 0.87261146, 0.8875 ],\n", - " [0.2283871 , 0.73566879, 1. ],\n", - " [0.33496774, 0.61783439, 0.875 ],\n", - " [0.44722581, 0.49044586, 0.8875 ],\n", - " [0.55509677, 0.37420382, 0.8625 ],\n", - " [0.67096774, 0.24363057, 0.8875 ],\n", - " [0.77754839, 0.13853503, 0.8625 ],\n", - " [0.89187097, 0.06050955, 0.875 ],\n", - " [1. , 0. , 0.875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91610911, 0.912 , 0.98611111],\n", - " [0.83401956, 0.81866667, 0.95833333],\n", - " [0.75193001, 0.73066667, 0.97222222],\n", - " [0.66778178, 0.624 , 0.97222222],\n", - " [0.58569223, 0.528 , 0.97222222],\n", - " [0.50102934, 0.44266667, 0.97222222],\n", - " [0.41842512, 0.36533333, 0.95833333],\n", - " [0.33453423, 0.29333333, 0.97222222],\n", - " [0.24935666, 0.21866667, 1. ],\n", - " [0.16572311, 0.14133333, 0.95833333],\n", - " [0.08183222, 0.06666667, 0.97222222],\n", - " [0. , 0. , 0.97222222]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.83281116, 0.83225806, 1. ],\n", - " [0.66647679, 0.65403226, 1. ],\n", - " [0.49985759, 0.48467742, 1. ],\n", - " [0.33380803, 0.31129032, 1. ],\n", - " [0.16775847, 0.13709677, 1. ],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12008073, 0.11428571, 1. ],\n", - " [0.23309788, 0.22326169, 0.97183099],\n", - " [0.34510595, 0.33249052, 0.98591549],\n", - " [0.45812311, 0.4437421 , 0.98591549],\n", - " [0.5691221 , 0.55474083, 0.98591549],\n", - " [0.67709384, 0.66573957, 0.98591549],\n", - " [0.78607467, 0.77825537, 0.98591549],\n", - " [0.89303734, 0.88900126, 1. ],\n", - " [1. , 1. , 0.97183099]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11337209, 0.1167002 , 1. ],\n", - " [0.22122093, 0.22434608, 0.94444444],\n", - " [0.33255814, 0.33249497, 0.98611111],\n", - " [0.44680233, 0.44668008, 0.98611111],\n", - " [0.55465116, 0.55382294, 0.94444444],\n", - " [0.66715116, 0.66599598, 0.98611111],\n", - " [0.77790698, 0.77665996, 0.97222222],\n", - " [0.8877907 , 0.88581489, 0.97222222],\n", - " [1. , 1. , 0.98611111]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90253807, 0.90490798, 0.875 ],\n", - " [0.79314721, 0.79754601, 1. ],\n", - " [0.69314721, 0.69018405, 0.8875 ],\n", - " [0.59746193, 0.59509202, 0.875 ],\n", - " [0.50152284, 0.50613497, 0.8625 ],\n", - " [0.40329949, 0.41717791, 0.875 ],\n", - " [0.30583756, 0.30981595, 0.875 ],\n", - " [0.20685279, 0.21472393, 0.8875 ],\n", - " [0.0964467 , 0.10122699, 1. ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09852357, 0.05820433, 0.97222222],\n", - " [0.19222033, 0.12074303, 0.95833333],\n", - " [0.28591709, 0.18575851, 0.97222222],\n", - " [0.38472459, 0.26315789, 0.98611111],\n", - " [0.4826803 , 0.35108359, 0.97222222],\n", - " [0.57495741, 0.43343653, 0.97222222],\n", - " [0.66780239, 0.51517028, 0.97222222],\n", - " [0.76604202, 0.60371517, 0.97222222],\n", - " [0.84241908, 0.70278638, 0.84722222],\n", - " [0.92078365, 0.84148607, 0.94444444],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.16398204, 0.19233074, 1. ],\n", - " [0.32532348, 0.39724386, 1. ],\n", - " [0.49062583, 0.58298382, 1. ],\n", - " [0.66147346, 0.72438586, 1. ],\n", - " [0.83337734, 0.86039545, 0.98387097],\n", - " [1. , 1. , 0.98387097]]),\n", - " array([[0.56537102, 1. , 0. ],\n", - " [0.35689046, 0.8934983 , 0.94444444],\n", - " [0.16961131, 0.7860262 , 0.98611111],\n", - " [0. , 0.67515769, 0.95833333],\n", - " [0.03886926, 0.56477438, 1. ],\n", - " [0.2155477 , 0.45487627, 0.94444444],\n", - " [0.3745583 , 0.34497817, 0.97222222],\n", - " [0.55123675, 0.22755944, 0.98611111],\n", - " [0.77031802, 0.11475012, 0.95833333],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87991498, 0.88330632, 0.73333333],\n", - " [0.75956429, 0.76661264, 0.73333333],\n", - " [0.63735388, 0.64667747, 0.73333333],\n", - " [0.52072264, 0.53160454, 0.72222222],\n", - " [0.3987779 , 0.41166937, 0.73333333],\n", - " [0.28081828, 0.2917342 , 0.73333333],\n", - " [0.15967056, 0.16693679, 0.73333333],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10746269, 0.11522634, 0.87341772],\n", - " [0.21818182, 0.22427984, 0.89873418],\n", - " [0.32645862, 0.32921811, 0.87341772],\n", - " [0.43880597, 0.44238683, 0.89873418],\n", - " [0.56065129, 0.56378601, 1. ],\n", - " [0.67354138, 0.67695473, 0.89873418],\n", - " [0.78263229, 0.78600823, 0.88607595],\n", - " [0.8890095 , 0.8909465 , 0.87341772],\n", - " [1. , 1. , 0.89873418]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1707989 , 0.17039534, 0.73333333],\n", - " [0.34205693, 0.34201655, 0.72666667],\n", - " [0.43939394, 0.43824701, 0.41333333],\n", - " [0.67263545, 0.67300031, 1. ],\n", - " [0.85950413, 0.85902544, 0.8 ],\n", - " [1. , 1. , 0.6 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92263056, 0.91887046, 0.86419753],\n", - " [0.84719536, 0.83975796, 0.86419753],\n", - " [0.77756286, 0.76378306, 0.86419753],\n", - " [0.70019342, 0.6869117 , 0.86419753],\n", - " [0.62475822, 0.60779919, 0.86419753],\n", - " [0.55125725, 0.53070372, 0.85185185],\n", - " [0.48355899, 0.46391753, 0.75308642],\n", - " [0.40232108, 0.38502913, 0.86419753],\n", - " [0.33462282, 0.31712237, 0.75308642],\n", - " [0.26499033, 0.2431645 , 0.83950617],\n", - " [0.1934236 , 0.16472434, 0.87654321],\n", - " [0.10058027, 0.08695652, 0.85185185],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89234312, 0.88938423, 0.79775281],\n", - " [0.78641336, 0.78239064, 0.76404494],\n", - " [0.6919977 , 0.68849262, 0.68539326],\n", - " [0.57052389, 0.56673168, 0.8988764 ],\n", - " [0.43005181, 0.42908888, 1. ],\n", - " [0.32124352, 0.32014489, 0.79775281],\n", - " [0.21531376, 0.21426581, 0.78651685],\n", - " [0.10592976, 0.10560045, 0.79775281],\n", - " [0. , 0. , 0.7752809 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.09876543, 0.1125 , 0.88607595],\n", - " [0.17283951, 0.20816327, 0.7721519 ],\n", - " [0.24897119, 0.31862245, 0.86075949],\n", - " [0.33333333, 0.43239796, 0.91139241],\n", - " [0.44650206, 0.54311224, 0.87341772],\n", - " [0.58436214, 0.65306122, 0.89873418],\n", - " [0.74691358, 0.77857143, 1. ],\n", - " [0.87654321, 0.8875 , 0.88607595],\n", - " [1. , 1. , 0.89873418]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.06973768, 0.91664574, 0.88607595],\n", - " [0.13755598, 0.83630429, 0.88607595],\n", - " [0.20665387, 0.75520964, 0.88607595],\n", - " [0.28854766, 0.66432337, 1. ],\n", - " [0.34293026, 0.59477781, 0.7721519 ],\n", - " [0.41202815, 0.51644489, 0.87341772],\n", - " [0.48944338, 0.43861411, 0.89873418],\n", - " [0.56877799, 0.3648004 , 0.87341772],\n", - " [0.64939219, 0.28922922, 0.88607595],\n", - " [0.73192578, 0.21240271, 0.89873418],\n", - " [0.82085733, 0.14034647, 0.87341772],\n", - " [0.91106846, 0.06879237, 0.88607595],\n", - " [1. , 0. , 0.87341772]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.19607843, 0.1969648 , 1. ],\n", - " [0.35553089, 0.35615111, 0.79761905],\n", - " [0.50832408, 0.50920245, 0.77380952],\n", - " [0.66259711, 0.66483694, 0.78571429],\n", - " [0.81982982, 0.821763 , 0.78571429],\n", - " [1. , 1. , 0.92857143]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.92263461, 0.07878788, 0.97183099],\n", - " [0.84997386, 0.14440053, 0.85915493],\n", - " [0.77104025, 0.22424242, 0.98591549],\n", - " [0.7009932 , 0.3027668 , 0.97183099],\n", - " [0.61055933, 0.37839262, 1. ],\n", - " [0.53476215, 0.45638999, 0.98591549],\n", - " [0.46053319, 0.5372859 , 0.98591549],\n", - " [0.37794041, 0.61212121, 0.98591549],\n", - " [0.30527967, 0.69354414, 0.98591549],\n", - " [0.22739153, 0.76969697, 0.97183099],\n", - " [0.15786722, 0.83847167, 0.85915493],\n", - " [0.08363826, 0.9198946 , 0.98591549],\n", - " [0. , 1. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91282953, 0.91537133, 1. ],\n", - " [0.83479789, 0.8373057 , 0.92307692],\n", - " [0.7599297 , 0.76303972, 0.87179487],\n", - " [0.68471002, 0.68290155, 0.92307692],\n", - " [0.61230228, 0.60276339, 0.8974359 ],\n", - " [0.53673111, 0.52746114, 0.88461538],\n", - " [0.45940246, 0.45492228, 0.88461538],\n", - " [0.38137083, 0.3806563 , 0.8974359 ],\n", - " [0.30509666, 0.30189983, 0.91025641],\n", - " [0.23093146, 0.22348877, 0.88461538],\n", - " [0.15711775, 0.1492228 , 0.8974359 ],\n", - " [0.07908612, 0.07426598, 0.91025641],\n", - " [0. , 0. , 0.91025641]]),\n", - " array([[0.02540835, 0. , 0. ],\n", - " [0. , 0.12496662, 1. ],\n", - " [0.02631579, 0.24993324, 0.95833333],\n", - " [0.11751361, 0.35941255, 0.97222222],\n", - " [0.25635209, 0.44432577, 0.98611111],\n", - " [0.40517241, 0.49986649, 0.97222222],\n", - " [0.55626134, 0.55246996, 0.97222222],\n", - " [0.70372051, 0.60507343, 0.95833333],\n", - " [0.84392015, 0.66782377, 0.97222222],\n", - " [0.95326679, 0.76555407, 0.97222222],\n", - " [1. , 0.8753004 , 0.86111111],\n", - " [0.98593466, 1. , 0.94444444]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91563275, 0.91659091, 0.63636364],\n", - " [0.8325062 , 0.83477273, 0.62727273],\n", - " [0.74565757, 0.75 , 0.64545455],\n", - " [0.66129032, 0.665 , 0.63636364],\n", - " [0.57816377, 0.58295455, 0.62727273],\n", - " [0.49379653, 0.49954545, 0.63636364],\n", - " [0.41066998, 0.41636364, 0.63636364],\n", - " [0.32754342, 0.33204545, 0.64545455],\n", - " [0.22084367, 0.22568182, 0.81818182],\n", - " [0.12779156, 0.13181818, 0.71818182],\n", - " [0. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88276671, 0.88243462, 0.91666667],\n", - " [0.76553341, 0.76278639, 0.91666667],\n", - " [0.63305979, 0.62902106, 1. ],\n", - " [0.5017585 , 0.50451284, 0.90277778],\n", - " [0.37514654, 0.38787318, 0.84722222],\n", - " [0.24032825, 0.26220782, 0.91666667],\n", - " [0.11488863, 0.13214534, 0.91666667],\n", - " [0. , 0. , 0.91666667]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.88382391, 0.09782609, 0.52671756],\n", - " [0.67074759, 0.33695652, 0.98473282],\n", - " [0.5009117 , 0.5 , 0.77862595],\n", - " [0.35061214, 0.64130435, 0.6870229 ],\n", - " [0.21906747, 0.77173913, 0.60305344],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12480499, 0.14285714, 1. ],\n", - " [0.25013001, 0.271777 , 0.97014925],\n", - " [0.37545502, 0.39372822, 0.98507463],\n", - " [0.49869995, 0.51219512, 0.98507463],\n", - " [0.62584503, 0.63066202, 0.98507463],\n", - " [0.75091004, 0.75261324, 0.98507463],\n", - " [0.87467499, 0.87804878, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.94349142, 0.94297636, 0.89873418],\n", - " [0.88597376, 0.88966157, 0.87341772],\n", - " [0.82542886, 0.83449235, 0.91139241],\n", - " [0.76992936, 0.77978674, 0.86075949],\n", - " [0.72250252, 0.73133982, 0.7721519 ],\n", - " [0.66801211, 0.6754752 , 0.87341772],\n", - " [0.60847629, 0.61868336, 0.88607595],\n", - " [0.55398587, 0.56977283, 0.78481013],\n", - " [0.49545913, 0.51298099, 0.88607595],\n", - " [0.44500505, 0.45618915, 0.88607595],\n", - " [0.39959637, 0.40055633, 0.87341772],\n", - " [0.34308779, 0.34353268, 0.88607595],\n", - " [0.28960646, 0.28859527, 0.88607595],\n", - " [0.22300706, 0.22577654, 1. ],\n", - " [0.16851665, 0.16944831, 0.88607595],\n", - " [0.11402624, 0.1149745 , 0.88607595],\n", - " [0.05953582, 0.05748725, 0.88607595],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[0.09090909, 0. , 0. ],\n", - " [0. , 0.14289162, 1. ],\n", - " [0. , 0.28361091, 0.97014925],\n", - " [0.27272727, 0.42650253, 0.98507463],\n", - " [0.63636364, 0.5715665 , 0.98507463],\n", - " [1. , 0.71445812, 1. ],\n", - " [0.81818182, 0.85710838, 0.98507463],\n", - " [0.90909091, 1. , 0.98507463]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90708661, 0.90079474, 0.86419753],\n", - " [0.82572178, 0.81446972, 0.75308642],\n", - " [0.73070866, 0.71224993, 0.86419753],\n", - " [0.6351706 , 0.61030419, 0.86419753],\n", - " [0.53963255, 0.50972869, 0.86419753],\n", - " [0.43412073, 0.3959989 , 0.97530864],\n", - " [0.3191601 , 0.28610578, 1. ],\n", - " [0.21154856, 0.19101124, 0.86419753],\n", - " [0.10393701, 0.09372431, 0.86419753],\n", - " [0. , 0. , 0.83950617]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90077178, 0.90071344, 1. ],\n", - " [0.79713341, 0.79667063, 0.97183099],\n", - " [0.69652701, 0.69560048, 0.98591549],\n", - " [0.60915105, 0.60939358, 0.85915493],\n", - " [0.51074972, 0.51129608, 0.97183099],\n", - " [0.40656009, 0.40725327, 0.97183099],\n", - " [0.30733186, 0.30915577, 1. ],\n", - " [0.2053473 , 0.20630202, 0.97183099],\n", - " [0.09867696, 0.0980975 , 1. ],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09821019, 0.90069107, 0.875 ],\n", - " [0.19642038, 0.80163809, 0.875 ],\n", - " [0.29325379, 0.70360891, 0.85 ],\n", - " [0.39284075, 0.60302022, 0.8875 ],\n", - " [0.49150987, 0.50422319, 0.8875 ],\n", - " [0.59063791, 0.40542616, 0.875 ],\n", - " [0.6888481 , 0.30662913, 0.8625 ],\n", - " [0.80082607, 0.1952905 , 1. ],\n", - " [0.90041303, 0.09726133, 0.8625 ],\n", - " [1. , 0. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.23809524, 0.14565757, 0.79120879],\n", - " [0.38095238, 0.27617866, 0.72527473],\n", - " [0.71428571, 0.41290323, 0.73626374],\n", - " [0.71428571, 0.54367246, 0.72527473],\n", - " [0.80952381, 0.68734491, 0.78021978],\n", - " [0.95238095, 0.86774194, 1. ],\n", - " [1. , 1. , 0.71428571]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89869171, 0.90103781, 0.8875 ],\n", - " [0.79872526, 0.80244626, 0.875 ],\n", - " [0.70211338, 0.70644922, 0.8625 ],\n", - " [0.60348876, 0.60711638, 0.875 ],\n", - " [0.49211674, 0.49629355, 1. ],\n", - " [0.39248574, 0.39659007, 0.875 ],\n", - " [0.29352566, 0.29725723, 0.875 ],\n", - " [0.19389467, 0.19644181, 0.8875 ],\n", - " [0.09761825, 0.09859155, 0.8625 ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10938284, 0.10914052, 0.97014925],\n", - " [0.224285 , 0.22401091, 1. ],\n", - " [0.33266433, 0.33260573, 0.97014925],\n", - " [0.44405419, 0.44447476, 0.98507463],\n", - " [0.55644757, 0.5574352 , 1. ],\n", - " [0.66633216, 0.66712142, 0.97014925],\n", - " [0.77772203, 0.7781719 , 0.98507463],\n", - " [0.88861014, 0.88922237, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.1373212 , 0.14682003, 1. ],\n", - " [0.28322497, 0.30040595, 1. ],\n", - " [0.42288687, 0.45196211, 1. ],\n", - " [0.56827048, 0.60216509, 1. ],\n", - " [0.71053316, 0.73477673, 1. ],\n", - " [0.8556567 , 0.86738836, 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14103425, 0.14062887, 0.80722892],\n", - " [0.27938214, 0.27927705, 0.79518072],\n", - " [0.45601075, 0.45605348, 1. ],\n", - " [0.58159839, 0.58256994, 0.74698795],\n", - " [0.72061786, 0.7217133 , 0.77108434],\n", - " [0.86030893, 0.86110423, 0.79518072],\n", - " [1. , 1. , 0.79518072]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90676692, 0.87999087, 1. ],\n", - " [0.79097744, 0.76887976, 0.93055556],\n", - " [0.67218045, 0.66233174, 0.90277778],\n", - " [0.54887218, 0.55395848, 0.91666667],\n", - " [0.41954887, 0.44421629, 0.93055556],\n", - " [0.29172932, 0.32740132, 0.98611111],\n", - " [0.1924812 , 0.21879991, 0.91666667],\n", - " [0.09473684, 0.1076888 , 0.91666667],\n", - " [0. , 0. , 0.91666667]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87074148, 0.8702917 , 1. ],\n", - " [0.78006012, 0.77428491, 0.74725275],\n", - " [0.69839679, 0.68903993, 0.67032967],\n", - " [0.58867735, 0.57887284, 0.87912088],\n", - " [0.48697395, 0.47890116, 0.78021978],\n", - " [0.39178357, 0.38487681, 0.74725275],\n", - " [0.29458918, 0.2883036 , 0.76923077],\n", - " [0.19438878, 0.19031436, 0.78021978],\n", - " [0.09819639, 0.09629 , 0.75824176],\n", - " [0. , 0. , 0.76923077]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90481786, 0.90340741, 0.91139241],\n", - " [0.81668625, 0.81274074, 0.86075949],\n", - " [0.72581277, 0.72088889, 0.89873418],\n", - " [0.63650607, 0.6322963 , 0.88607595],\n", - " [0.54680768, 0.54488889, 0.89873418],\n", - " [0.44731688, 0.44651852, 1. ],\n", - " [0.36036036, 0.3602963 , 0.88607595],\n", - " [0.26400313, 0.2637037 , 1. ],\n", - " [0.17587152, 0.17422222, 0.91139241],\n", - " [0.08852331, 0.08711111, 0.87341772],\n", - " [0. , 0. , 0.88607595]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86020119, 0.14467005, 1. ],\n", - " [0.7173072 , 0.28680203, 1. ],\n", - " [0.57467114, 0.43654822, 1. ],\n", - " [0.42997163, 0.57106599, 1. ],\n", - " [0.28707764, 0.71573604, 1. ],\n", - " [0.1454733 , 0.85786802, 1. ],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.88974907, 0.89177489, 1. ],\n", - " [0.7736252 , 0.78354978, 0.97183099],\n", - " [0.67618793, 0.68831169, 0.85915493],\n", - " [0.565937 , 0.57359307, 0.98591549],\n", - " [0.44847838, 0.45887446, 0.98591549],\n", - " [0.33796049, 0.34199134, 0.98591549],\n", - " [0.22770956, 0.23160173, 0.97183099],\n", - " [0.11078484, 0.11255411, 0.98591549],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08544942, 0.85663082, 0.94285714],\n", - " [0.17573559, 0.70609319, 0.95714286],\n", - " [0.26279726, 0.56630824, 0.94285714],\n", - " [0.36074164, 0.44563919, 0.92857143],\n", - " [0.47722692, 0.35274791, 0.94285714],\n", - " [0.60419186, 0.26642772, 0.94285714],\n", - " [0.73397823, 0.17921147, 0.94285714],\n", - " [0.86255542, 0.09199522, 0.98571429],\n", - " [1. , 0. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.10675497, 0.78021978, 0.91666667],\n", - " [0.22251656, 0.6043956 , 0.91666667],\n", - " [0.34490066, 0.28571429, 1. ],\n", - " [0.45033113, 0.06593407, 0.90277778],\n", - " [0.55496689, 0. , 0.84722222],\n", - " [0.66675497, 0.16483516, 0.91666667],\n", - " [0.76874172, 0.43956044, 0.86111111],\n", - " [0.88662252, 0.72527473, 0.91666667],\n", - " [1. , 0.96703297, 0.93055556]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14412998, 0.14686469, 0.98507463],\n", - " [0.28930818, 0.29372937, 0.97014925],\n", - " [0.43422432, 0.44059406, 1. ],\n", - " [0.57756813, 0.58415842, 0.97014925],\n", - " [0.70938155, 0.71287129, 0.91044776],\n", - " [0.85560797, 0.85973597, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11208678, 0.10976616, 0.98412698],\n", - " [0.22365702, 0.22035763, 0.98412698],\n", - " [0.3357438 , 0.33122421, 0.98412698],\n", - " [0.44628099, 0.44209078, 0.98412698],\n", - " [0.5625 , 0.55488308, 1. ],\n", - " [0.66735537, 0.66519945, 0.96825397],\n", - " [0.77840909, 0.77661623, 0.98412698],\n", - " [0.88894628, 0.88830812, 0.98412698],\n", - " [1. , 1. , 0.98412698]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.09363195, 0.90345438, 0.875 ],\n", - " [0.18537507, 0.71656333, 0.95833333],\n", - " [0.27495953, 0.48361382, 1. ],\n", - " [0.35968699, 0.25863596, 0.95833333],\n", - " [0.44765246, 0.0761736 , 0.97222222],\n", - " [0.54020507, 0. , 0.95833333],\n", - " [0.63734485, 0.00797166, 0.98611111],\n", - " [0.73556395, 0.02834367, 0.95833333],\n", - " [0.83324339, 0.04517272, 0.97222222],\n", - " [0.91985969, 0.06200177, 0.97222222],\n", - " [1. , 0.09211692, 0.98611111]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13866069, 0.15498938, 0.91666667],\n", - " [0.29424944, 0.29299363, 1. ],\n", - " [0.43340802, 0.42887473, 0.91666667],\n", - " [0.57879014, 0.56900212, 0.93055556],\n", - " [0.7154593 , 0.72186837, 0.90277778],\n", - " [0.86109037, 0.85774947, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86044444, 0.12144638, 0.60185185],\n", - " [0.73777778, 0.24563591, 0.61111111],\n", - " [0.60533333, 0.3840399 , 0.66666667],\n", - " [0.376 , 0.59600998, 1. ],\n", - " [0.26222222, 0.73017456, 0.66666667],\n", - " [0.12533333, 0.87605985, 0.67592593],\n", - " [0. , 1. , 0.61111111]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.91712707, 0.08315514, 0.875 ],\n", - " [0.83867403, 0.1644096 , 0.875 ],\n", - " [0.75359116, 0.2482775 , 0.875 ],\n", - " [0.6839779 , 0.31765265, 0.7625 ],\n", - " [0.59889503, 0.40080779, 0.875 ],\n", - " [0.51381215, 0.48562604, 0.875 ],\n", - " [0.43093923, 0.56830601, 0.875 ],\n", - " [0.33149171, 0.66809218, 1. ],\n", - " [0.25303867, 0.74839629, 0.875 ],\n", - " [0.16464088, 0.8372535 , 0.875 ],\n", - " [0.08176796, 0.91708244, 0.875 ],\n", - " [0. , 1. , 0.875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89164905, 0.89003055, 0.875 ],\n", - " [0.78171247, 0.78033879, 0.875 ],\n", - " [0.6717759 , 0.67092474, 0.875 ],\n", - " [0.56342495, 0.56289919, 0.8625 ],\n", - " [0.45454545, 0.45348514, 0.875 ],\n", - " [0.34302326, 0.34296029, 0.9 ],\n", - " [0.21934461, 0.21993891, 0.975 ],\n", - " [0.09513742, 0.09497362, 1. ],\n", - " [0. , 0. , 0.7625 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89900387, 0.92107796, 0.98591549],\n", - " [0.79690094, 0.83253128, 0.97183099],\n", - " [0.6934145 , 0.72762271, 1. ],\n", - " [0.59241837, 0.62367661, 0.98591549],\n", - " [0.49252905, 0.52069297, 0.97183099],\n", - " [0.4039845 , 0.43022137, 0.85915493],\n", - " [0.30381848, 0.32435034, 0.98591549],\n", - " [0.20254566, 0.21751684, 0.97183099],\n", - " [0.10182623, 0.11068335, 0.98591549],\n", - " [0. , 0. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.14348908, 0.83253589, 0.98507463],\n", - " [0.28642521, 0.65550239, 1. ],\n", - " [0.42742604, 0.49282297, 0.97014925],\n", - " [0.57008571, 0.32057416, 0.98507463],\n", - " [0.7124689 , 0.19617225, 0.98507463],\n", - " [0.85595798, 0.11004785, 0.98507463],\n", - " [1. , 0. , 0.98507463]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.86910995, 0.11926606, 0.81 ],\n", - " [0.7556719 , 0.2214577 , 0.69 ],\n", - " [0.62303665, 0.34174312, 0.81 ],\n", - " [0.5104712 , 0.46279307, 0.8 ],\n", - " [0.36823735, 0.61442406, 0.98 ],\n", - " [0.2486911 , 0.73853211, 0.82 ],\n", - " [0.14485166, 0.84607543, 0.7 ],\n", - " [0. , 1. , 1. ]]),\n", - " array([[0.86666667, 0. , 0. ],\n", - " [0.7 , 0.15081071, 0.73333333],\n", - " [1. , 0.33033796, 0.74444444],\n", - " [0.43333333, 0.51553038, 1. ],\n", - " [0.7 , 0.69310412, 0.73333333],\n", - " [0. , 0.82359836, 0.72222222],\n", - " [0.36666667, 1. , 0.74444444]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9025522 , 0.89918699, 0.85 ],\n", - " [0.81722093, 0.81138211, 0.7625 ],\n", - " [0.69914927, 0.70243902, 1. ],\n", - " [0.5968033 , 0.59349593, 0.875 ],\n", - " [0.49574633, 0.49756098, 0.875 ],\n", - " [0.39391596, 0.39512195, 0.875 ],\n", - " [0.2910544 , 0.28780488, 0.875 ],\n", - " [0.18948183, 0.19349593, 0.8875 ],\n", - " [0.08945605, 0.08780488, 0.8625 ],\n", - " [0. , 0. , 0.7625 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90016685, 0.88480392, 0.98571429],\n", - " [0.79810901, 0.76715686, 1. ],\n", - " [0.69549499, 0.66421569, 1. ],\n", - " [0.60567297, 0.57352941, 0.88571429],\n", - " [0.50389321, 0.47058824, 0.98571429],\n", - " [0.39988877, 0.37254902, 0.98571429],\n", - " [0.2942158 , 0.28431373, 0.98571429],\n", - " [0.20439377, 0.20588235, 0.87142857],\n", - " [0.09510567, 0.08823529, 1. ],\n", - " [0. , 0. , 0.87142857]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.15734266, 0.15859031, 0.83333333],\n", - " [0.30150619, 0.3001888 , 0.75833333],\n", - " [0.4112426 , 0.4090623 , 0.58333333],\n", - " [0.58284024, 0.58464443, 0.925 ],\n", - " [0.76923077, 0.77281309, 1. ],\n", - " [0.87708445, 0.87979862, 0.575 ],\n", - " [1. , 1. , 0.675 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90179543, 0.89778535, 0.78888889],\n", - " [0.80522307, 0.79812606, 0.77777778],\n", - " [0.70674646, 0.70187394, 0.78888889],\n", - " [0.61153428, 0.60477002, 0.77777778],\n", - " [0.5008161 , 0.49403748, 0.86666667],\n", - " [0.40533188, 0.39948893, 0.78888889],\n", - " [0.3054951 , 0.29982964, 0.76666667],\n", - " [0.20973885, 0.20868825, 0.77777778],\n", - " [0.085963 , 0.08688245, 1. ],\n", - " [0. , 0. , 0.68888889]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90535642, 0.92314119, 0.97183099],\n", - " [0.83125252, 0.8512949 , 0.85915493],\n", - " [0.74748288, 0.76552492, 0.97183099],\n", - " [0.66290777, 0.67836257, 1. ],\n", - " [0.58034636, 0.59370649, 0.97183099],\n", - " [0.49496577, 0.50654414, 1. ],\n", - " [0.41159887, 0.42133111, 0.98591549],\n", - " [0.33064841, 0.33834586, 0.97183099],\n", - " [0.24808699, 0.25396825, 1. ],\n", - " [0.16673379, 0.17070454, 0.97183099],\n", - " [0.08296416, 0.08437761, 0.98591549],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.08262108, 0.90988584, 0.95774648],\n", - " [0.17094017, 0.81928589, 0.98591549],\n", - " [0.27065527, 0.72431382, 1. ],\n", - " [0.36467236, 0.63104202, 1. ],\n", - " [0.44729345, 0.53995628, 0.97183099],\n", - " [0.53561254, 0.44911343, 0.97183099],\n", - " [0.62962963, 0.37017246, 0.85915493],\n", - " [0.72079772, 0.27908671, 0.97183099],\n", - " [0.82905983, 0.18581491, 1. ],\n", - " [0.93732194, 0.09424338, 0.97183099],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8375 , 0.9146477 , 0.98591549],\n", - " [0.6875 , 0.83196266, 0.97183099],\n", - " [0.5625 , 0.74683263, 0.98591549],\n", - " [0.4625 , 0.66370305, 1. ],\n", - " [0.3375 , 0.58012892, 0.97183099],\n", - " [0.1625 , 0.49655479, 1. ],\n", - " [0. , 0.41342521, 0.97183099],\n", - " [0.025 , 0.32851745, 0.98591549],\n", - " [0.1125 , 0.24427651, 0.98591549],\n", - " [0.15 , 0.17026006, 0.85915493],\n", - " [0.225 , 0.08490776, 0.98591549],\n", - " [0.2625 , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.92330623, 0.92857143, 0.875 ],\n", - " [0.84661247, 0.85064935, 0.875 ],\n", - " [0.78102981, 0.78409091, 0.7625 ],\n", - " [0.70542005, 0.70779221, 0.8625 ],\n", - " [0.62059621, 0.61525974, 1. ],\n", - " [0.54363144, 0.53733766, 0.875 ],\n", - " [0.46666667, 0.46266234, 0.875 ],\n", - " [0.39214092, 0.38636364, 0.875 ],\n", - " [0.31463415, 0.31168831, 0.8875 ],\n", - " [0.23821138, 0.23376623, 0.875 ],\n", - " [0.16341463, 0.16233766, 0.8625 ],\n", - " [0.07696477, 0.0762987 , 1. ],\n", - " [0. , 0. , 0.875 ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91076257, 0.90163934, 0.875 ],\n", - " [0.82287723, 0.79391101, 0.8625 ],\n", - " [0.73201731, 0.70023419, 0.8875 ],\n", - " [0.6430503 , 0.6088993 , 0.875 ],\n", - " [0.55164954, 0.51522248, 0.875 ],\n", - " [0.46106003, 0.41920375, 0.875 ],\n", - " [0.37182261, 0.32552693, 0.875 ],\n", - " [0.26960519, 0.22716628, 1. ],\n", - " [0.17982693, 0.15222482, 0.875 ],\n", - " [0.08869659, 0.08196721, 0.8875 ],\n", - " [0. , 0. , 0.8625 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87873462, 0. , 1. ],\n", - " [0.77403967, 0. , 0.86419753],\n", - " [0.65679136, 0. , 0.96296296],\n", - " [0.5438112 , 0. , 0.92592593],\n", - " [0.44338438, 0. , 0.80246914],\n", - " [0.33467236, 0. , 0.88888889],\n", - " [0.2299774 , 0. , 0.85185185],\n", - " [0.12553352, 0. , 0.86419753],\n", - " [0. , 1. , 0.98765432]]),\n", - " array([[0.02540835, 0. , 0. ],\n", - " [0. , 0.12496662, 1. ],\n", - " [0.02631579, 0.24993324, 0.95833333],\n", - " [0.11751361, 0.35941255, 0.97222222],\n", - " [0.25635209, 0.44432577, 0.98611111],\n", - " [0.40517241, 0.49986649, 0.97222222],\n", - " [0.55626134, 0.55246996, 0.97222222],\n", - " [0.70372051, 0.60507343, 0.95833333],\n", - " [0.84392015, 0.66782377, 0.97222222],\n", - " [0.95326679, 0.76555407, 0.97222222],\n", - " [1. , 0.8753004 , 0.86111111],\n", - " [0.98593466, 1. , 0.94444444]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.14715822, 0.84768908, 0.6875 ],\n", - " [0.29953917, 0.69222689, 0.6875 ],\n", - " [0.44884793, 0.54271709, 0.6875 ],\n", - " [0.66850998, 0.32703081, 1. ],\n", - " [0.84884793, 0.14985994, 0.8125 ],\n", - " [1. , 0. , 0.6875 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.10768478, 0.8967334 , 1. ],\n", - " [0.20264317, 0.80532139, 0.8625 ],\n", - " [0.28781204, 0.72128556, 0.8 ],\n", - " [0.37249143, 0.63303477, 0.8375 ],\n", - " [0.46157611, 0.53767123, 0.8875 ],\n", - " [0.54380813, 0.45495258, 0.775 ],\n", - " [0.63142438, 0.36801897, 0.8375 ],\n", - " [0.72393539, 0.27818757, 0.8625 ],\n", - " [0.81889378, 0.18361433, 0.8875 ],\n", - " [0.90993637, 0.09193888, 0.8875 ],\n", - " [1. , 0. , 0.8625 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.13893654, 0.13689095, 1. ],\n", - " [0.26357919, 0.26102088, 0.91666667],\n", - " [0.38593482, 0.38352668, 0.91666667],\n", - " [0.50943396, 0.50835267, 0.91666667],\n", - " [0.63464837, 0.63271462, 0.90277778],\n", - " [0.74957118, 0.74802784, 0.84722222],\n", - " [0.87421384, 0.87285383, 0.91666667],\n", - " [1. , 1. , 0.91666667]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.87606383, 0.12567463, 0.97014925],\n", - " [0.75106383, 0.25314829, 1. ],\n", - " [0.62340426, 0.38190696, 0.98507463],\n", - " [0.49414894, 0.50809561, 0.98507463],\n", - " [0.36595745, 0.63351324, 0.97014925],\n", - " [0.24946809, 0.74916474, 0.91044776],\n", - " [0.12021277, 0.87586739, 0.97014925],\n", - " [0. , 1. , 1. ]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85641244, 0.85544267, 0.98507463],\n", - " [0.70941628, 0.70798258, 0.97014925],\n", - " [0.56838517, 0.56806967, 1. ],\n", - " [0.42394546, 0.42351234, 0.98507463],\n", - " [0.28845334, 0.28795356, 0.98507463],\n", - " [0.13634427, 0.13642961, 0.98507463],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[9.92181070e-01, 4.05246744e-01, 0.00000000e+00],\n", - " [9.92592593e-01, 3.45808109e-01, 1.78384050e-03],\n", - " [9.91358025e-01, 2.95725555e-01, 1.60020986e-03],\n", - " [9.90946502e-01, 2.42891213e-01, 1.83630640e-03],\n", - " [9.91769547e-01, 1.95927353e-01, 1.86253935e-03],\n", - " [9.93415638e-01, 1.57035406e-01, 1.78384050e-03],\n", - " [9.93004115e-01, 1.22179417e-01, 1.86253935e-03],\n", - " [9.93004115e-01, 9.20931939e-02, 1.83630640e-03],\n", - " [9.98765432e-01, 7.02623372e-02, 1.65267576e-03],\n", - " [1.00000000e+00, 5.09998165e-02, 1.67890871e-03],\n", - " [9.90534979e-01, 3.39387268e-02, 1.65267576e-03],\n", - " [9.71604938e-01, 2.03632361e-02, 1.65267576e-03],\n", - " [9.41975309e-01, 1.24747753e-02, 1.67890871e-03],\n", - " [9.01234568e-01, 1.41258485e-02, 1.65267576e-03],\n", - " [8.50205761e-01, 2.01797835e-02, 1.83630640e-03],\n", - " [7.91358025e-01, 2.77013392e-02, 1.81007345e-03],\n", - " [7.34156379e-01, 3.61401578e-02, 1.70514166e-03],\n", - " [6.71193416e-01, 3.81581361e-02, 1.73137461e-03],\n", - " [6.06995885e-01, 3.66905155e-02, 1.83630640e-03],\n", - " [5.43209877e-01, 3.44890846e-02, 1.81007345e-03],\n", - " [4.80246914e-01, 3.11869382e-02, 1.86253935e-03],\n", - " [4.25925926e-01, 2.82516969e-02, 1.60020986e-03],\n", - " [3.65843621e-01, 2.53164557e-02, 1.78384050e-03],\n", - " [3.04938272e-01, 2.38488351e-02, 1.83630640e-03],\n", - " [2.55555556e-01, 2.27481196e-02, 1.62644281e-03],\n", - " [2.04115226e-01, 2.12804990e-02, 1.78384050e-03],\n", - " [1.62551440e-01, 1.92625206e-02, 1.60020986e-03],\n", - " [1.18930041e-01, 1.83452578e-02, 1.83630640e-03],\n", - " [8.31275720e-02, 1.65107320e-02, 1.83630640e-03],\n", - " [6.54320988e-02, 1.57769217e-02, 1.86253935e-03],\n", - " [5.26748971e-02, 1.43093010e-02, 1.81007345e-03],\n", - " [4.19753086e-02, 1.17409650e-02, 1.83630640e-03],\n", - " [3.16872428e-02, 1.10071547e-02, 1.83630640e-03],\n", - " [2.13991770e-02, 9.35608145e-03, 1.83630640e-03],\n", - " [1.15226337e-02, 8.62227114e-03, 1.86253935e-03],\n", - " [4.93827160e-03, 7.52155568e-03, 1.78384050e-03],\n", - " [4.11522634e-04, 7.52155568e-03, 1.21720881e-02],\n", - " [0.00000000e+00, 1.00898918e-02, 1.00000000e+00],\n", - " [4.11522634e-03, 1.52265639e-02, 1.81007345e-03],\n", - " [1.39917695e-02, 1.98128784e-02, 1.60020986e-03],\n", - " [3.33333333e-02, 2.23812145e-02, 1.83630640e-03],\n", - " [6.29629630e-02, 2.40322877e-02, 1.83630640e-03],\n", - " [9.62962963e-02, 2.62337186e-02, 1.78384050e-03],\n", - " [1.27572016e-01, 2.45826454e-02, 1.60020986e-03],\n", - " [1.62139918e-01, 1.96294258e-02, 1.86253935e-03],\n", - " [1.85185185e-01, 1.17409650e-02, 1.65267576e-03],\n", - " [1.93415638e-01, 5.87048248e-03, 1.65267576e-03],\n", - " [1.90123457e-01, 2.38488351e-03, 1.65267576e-03],\n", - " [1.80658436e-01, 0.00000000e+00, 1.67890871e-03],\n", - " [1.73662551e-01, 6.42084021e-03, 1.65267576e-03],\n", - " [1.83539095e-01, 1.68776371e-02, 1.62644281e-03],\n", - " [2.06584362e-01, 2.58668134e-02, 1.70514166e-03],\n", - " [2.47325103e-01, 2.84351495e-02, 1.73137461e-03],\n", - " [2.92592593e-01, 2.86186021e-02, 1.60020986e-03],\n", - " [3.45679012e-01, 2.86186021e-02, 1.81007345e-03],\n", - " [4.02469136e-01, 2.99027701e-02, 1.86253935e-03],\n", - " [4.57613169e-01, 3.24711062e-02, 1.81007345e-03],\n", - " [5.16049383e-01, 3.46725371e-02, 1.83630640e-03],\n", - " [5.76131687e-01, 3.65070629e-02, 1.83630640e-03],\n", - " [6.35390947e-01, 4.12768299e-02, 1.81007345e-03],\n", - " [6.90123457e-01, 4.69638598e-02, 1.70514166e-03],\n", - " [7.41975309e-01, 4.16437351e-02, 1.70514166e-03],\n", - " [7.84362140e-01, 3.50394423e-02, 1.60020986e-03],\n", - " [8.21810700e-01, 2.69675289e-02, 1.60020986e-03],\n", - " [8.63786008e-01, 1.79783526e-02, 1.65267576e-03],\n", - " [9.09465021e-01, 1.35754907e-02, 1.73137461e-03],\n", - " [9.48559671e-01, 2.34819299e-02, 1.67890871e-03],\n", - " [9.74074074e-01, 4.78811227e-02, 1.65267576e-03],\n", - " [9.81893004e-01, 8.47550908e-02, 1.65267576e-03],\n", - " [9.81069959e-01, 1.33736929e-01, 1.86253935e-03],\n", - " [9.83950617e-01, 1.90423775e-01, 1.81007345e-03],\n", - " [9.88065844e-01, 2.54448725e-01, 1.83630640e-03],\n", - " [9.88477366e-01, 3.23059989e-01, 1.86253935e-03],\n", - " [9.90123457e-01, 3.91854706e-01, 1.83630640e-03],\n", - " [9.89711934e-01, 4.49275362e-01, 1.65267576e-03],\n", - " [9.47736626e-01, 4.94955054e-01, 1.65267576e-03],\n", - " [8.76543210e-01, 5.25591635e-01, 1.65267576e-03],\n", - " [7.88065844e-01, 5.41368556e-01, 1.67890871e-03],\n", - " [6.89300412e-01, 5.49623922e-01, 1.73137461e-03],\n", - " [5.90946502e-01, 5.58796551e-01, 1.67890871e-03],\n", - " [5.26337449e-01, 5.87782058e-01, 1.65267576e-03],\n", - " [4.77777778e-01, 6.26490552e-01, 1.67890871e-03],\n", - " [4.22633745e-01, 6.77490369e-01, 1.81007345e-03],\n", - " [3.62139918e-01, 7.35644836e-01, 1.83630640e-03],\n", - " [2.96707819e-01, 8.00036691e-01, 1.83630640e-03],\n", - " [2.32098765e-01, 8.67547239e-01, 1.81007345e-03],\n", - " [1.76543210e-01, 9.27719684e-01, 1.60020986e-03],\n", - " [1.13580247e-01, 1.00000000e+00, 1.86253935e-03]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.10739615, 0.1119334 , 1. ],\n", - " [0.21884498, 0.22340426, 0.95833333],\n", - " [0.33839919, 0.33533765, 0.97222222],\n", - " [0.44782168, 0.4440333 , 0.97222222],\n", - " [0.56737589, 0.55874191, 0.98611111],\n", - " [0.67173252, 0.66836263, 0.95833333],\n", - " [0.7781155 , 0.77775208, 0.97222222],\n", - " [0.89665653, 0.89176688, 0.98611111],\n", - " [1. , 1. , 0.95833333]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.83870968, 0.18051218, 1. ],\n", - " [0.67741935, 0.34603373, 0.91666667],\n", - " [0.35483871, 0.48573808, 0.91666667],\n", - " [0.27419355, 0.675203 , 0.91666667],\n", - " [0. , 0.81324172, 0.91666667],\n", - " [0.03225806, 1. , 0.91666667]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.07546674, 0.06754221, 0.95774648],\n", - " [0.14462267, 0.14071295, 0.85915493],\n", - " [0.21088614, 0.20825516, 0.85915493],\n", - " [0.28740468, 0.28142589, 0.97183099],\n", - " [0.36497502, 0.37148218, 0.97183099],\n", - " [0.433868 , 0.44090056, 0.85915493],\n", - " [0.51354194, 0.51782364, 0.98591549],\n", - " [0.59347883, 0.59287054, 0.98591549],\n", - " [0.67525638, 0.66228893, 1. ],\n", - " [0.75729687, 0.75046904, 0.98591549],\n", - " [0.83802261, 0.83114447, 0.97183099],\n", - " [0.91953721, 0.91557223, 1. ],\n", - " [1. , 1. , 0.98591549]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.85732041, 0.71428571, 0.91666667],\n", - " [0.71488939, 1. , 0.91666667],\n", - " [0.58563261, 1. , 0.84722222],\n", - " [0.44270445, 0.42857143, 0.90277778],\n", - " [0.30027343, 0.71428571, 0.91666667],\n", - " [0.14491673, 0.42857143, 1. ],\n", - " [0. , 1. , 0.91666667]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12607204, 0.12433989, 0.98507463],\n", - " [0.25557461, 0.25132021, 0.97014925],\n", - " [0.38336192, 0.37566011, 0.98507463],\n", - " [0.51200686, 0.50120019, 0.98507463],\n", - " [0.6406518 , 0.62698032, 1. ],\n", - " [0.75471698, 0.74843975, 0.98507463],\n", - " [0.87049743, 0.87469995, 0.98507463],\n", - " [1. , 1. , 0.98507463]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.11052763, 0.14403292, 0.72527473],\n", - " [0.21730433, 0.24691358, 0.73626374],\n", - " [0.31732933, 0.33950617, 0.67032967],\n", - " [0.4236059 , 0.45884774, 0.72527473],\n", - " [0.52988247, 0.54526749, 0.72527473],\n", - " [0.63490873, 0.62757202, 0.73626374],\n", - " [0.7511878 , 0.75102881, 0.79120879],\n", - " [0.85446362, 0.84979424, 0.69230769],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.12434002, 0.14088983, 1. ],\n", - " [0.2344245 , 0.23305085, 0.8875 ],\n", - " [0.34609293, 0.33368644, 0.875 ],\n", - " [0.45353749, 0.44597458, 0.8625 ],\n", - " [0.56362196, 0.55720339, 0.875 ],\n", - " [0.65733897, 0.65042373, 0.7625 ],\n", - " [0.76636748, 0.76165254, 0.8625 ],\n", - " [0.89017951, 0.89300847, 0.9875 ],\n", - " [1. , 1. , 0.875 ]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.07529208, 0.07518337, 1. ],\n", - " [0.15318044, 0.15281174, 1. ],\n", - " [0.23063609, 0.23013447, 1. ],\n", - " [0.30765902, 0.30776284, 1. ],\n", - " [0.38554738, 0.38569682, 1. ],\n", - " [0.46127218, 0.46210269, 1. ],\n", - " [0.53916054, 0.54003667, 1. ],\n", - " [0.6170489 , 0.61797066, 1. ],\n", - " [0.69363912, 0.69437653, 1. ],\n", - " [0.77022934, 0.77139364, 1. ],\n", - " [0.84681956, 0.84810513, 1. ],\n", - " [0.92340978, 0.924511 , 1. ],\n", - " [1. , 1. , 1. ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.10249237, 0.89552239, 1. ],\n", - " [0.20116989, 0.80099502, 0.97183099],\n", - " [0.30111902, 0.69983416, 0.98591549],\n", - " [0.40081384, 0.61028192, 0.98591549],\n", - " [0.50305188, 0.51243781, 1. ],\n", - " [0.60274669, 0.40961857, 0.98591549],\n", - " [0.70066124, 0.30182421, 0.97183099],\n", - " [0.79984741, 0.20066335, 1. ],\n", - " [0.89877925, 0.10447761, 0.97183099],\n", - " [1. , 0. , 1. ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.85803432, 0.14175655, 0.91666667],\n", - " [0.71346854, 0.28608115, 0.91666667],\n", - " [0.56058242, 0.43939394, 1. ],\n", - " [0.41809672, 0.58217771, 0.90277778],\n", - " [0.28653146, 0.71237802, 0.84722222],\n", - " [0.14352574, 0.8556754 , 0.91666667],\n", - " [0. , 1. , 0.90277778]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.91984334, 0.9775641 , 0.85915493],\n", - " [0.8308094 , 0.93269231, 0.97183099],\n", - " [0.7381201 , 0.75641026, 0.98591549],\n", - " [0.6464752 , 0.51923077, 1. ],\n", - " [0.55587467, 0.44230769, 0.97183099],\n", - " [0.46109661, 0.38141026, 1. ],\n", - " [0.37180157, 0.34935897, 0.97183099],\n", - " [0.27832898, 0.30448718, 1. ],\n", - " [0.18720627, 0.18910256, 0.97183099],\n", - " [0.09373368, 0.05128205, 1. ],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.89972074, 0.89626055, 0.8625 ],\n", - " [0.78446306, 0.77925211, 1. ],\n", - " [0.69840061, 0.68757539, 0.7625 ],\n", - " [0.58415842, 0.55850422, 0.9875 ],\n", - " [0.4843869 , 0.44270205, 0.8875 ],\n", - " [0.38563087, 0.33655006, 0.8625 ],\n", - " [0.2863671 , 0.24366707, 0.8625 ],\n", - " [0.20106626, 0.17370326, 0.7625 ],\n", - " [0.10307185, 0.09650181, 0.8625 ],\n", - " [0. , 0. , 0.8875 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.8638814 , 0.1354871 , 0.78571429],\n", - " [0.71428571, 0.28124217, 0.85714286],\n", - " [0.53773585, 0.45404458, 1. ],\n", - " [0.40161725, 0.590283 , 0.78571429],\n", - " [0.26954178, 0.72652141, 0.77380952],\n", - " [0.13477089, 0.86551465, 0.79761905],\n", - " [0. , 1. , 0.78571429]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.90916737, 0.94017094, 0.95833333],\n", - " [0.81889543, 0.85327635, 0.95833333],\n", - " [0.72694141, 0.75783476, 0.98611111],\n", - " [0.63751051, 0.66809117, 0.97222222],\n", - " [0.54667788, 0.57692308, 0.97222222],\n", - " [0.45360247, 0.48290598, 0.98611111],\n", - " [0.36192879, 0.38319088, 0.97222222],\n", - " [0.27361929, 0.29059829, 0.94444444],\n", - " [0.18222596, 0.19230769, 0.97222222],\n", - " [0.08999159, 0.09116809, 1. ],\n", - " [0. , 0. , 0.94444444]]),\n", - " array([[0. , 0. , 0. ],\n", - " [0.14893617, 0.12458234, 0.98507463],\n", - " [0.28723404, 0.24844869, 0.98507463],\n", - " [0.36170213, 0.37374702, 0.97014925],\n", - " [0.45744681, 0.50071599, 0.98507463],\n", - " [0.61702128, 0.62625298, 1. ],\n", - " [0.74468085, 0.75131265, 0.98507463],\n", - " [0.88297872, 0.87661098, 0.98507463],\n", - " [1. , 1. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.85517241, 0.85358025, 0.98507463],\n", - " [0.71724138, 0.70962963, 0.98507463],\n", - " [0.5862069 , 0.57382716, 0.98507463],\n", - " [0.42758621, 0.42271605, 0.98507463],\n", - " [0.30344828, 0.28691358, 1. ],\n", - " [0.13793103, 0.14049383, 0.98507463],\n", - " [0. , 0. , 0.97014925]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.9091623 , 0.85028249, 1. ],\n", - " [0.81963351, 0.72033898, 0.95774648],\n", - " [0.72774869, 0.62146893, 1. ],\n", - " [0.63298429, 0.52824859, 1. ],\n", - " [0.5434555 , 0.4180791 , 0.95774648],\n", - " [0.46361257, 0.33898305, 0.87323944],\n", - " [0.37382199, 0.27118644, 0.95774648],\n", - " [0.28010471, 0.21186441, 1. ],\n", - " [0.18586387, 0.14971751, 1. ],\n", - " [0.09424084, 0.0819209 , 0.97183099],\n", - " [0. , 0. , 0.98591549]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.8994695 , 0.89759503, 0.98591549],\n", - " [0.80132626, 0.79674166, 0.98591549],\n", - " [0.70185676, 0.6935609 , 0.98591549],\n", - " [0.60291777, 0.60046548, 0.97183099],\n", - " [0.50159151, 0.49650892, 1. ],\n", - " [0.40212202, 0.39953452, 0.98591549],\n", - " [0.29920424, 0.29402638, 0.98591549],\n", - " [0.19973475, 0.19782777, 0.98591549],\n", - " [0.09761273, 0.0969744 , 0.98591549],\n", - " [0. , 0. , 0.97183099]]),\n", - " array([[1. , 1. , 0. ],\n", - " [0.87866978, 0.86832061, 1. ],\n", - " [0.77058976, 0.76526718, 0.91666667],\n", - " [0.65887243, 0.65839695, 0.91666667],\n", - " [0.55079241, 0.54961832, 0.90277778],\n", - " [0.43907508, 0.42938931, 0.93055556],\n", - " [0.3289166 , 0.32824427, 0.91666667],\n", - " [0.22057677, 0.21374046, 0.91666667],\n", - " [0.11041829, 0.10496183, 0.90277778],\n", - " [0. , 0. , 0.93055556]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.06101104, 0.9713644 , 0.875 ],\n", - " [0.11359675, 0.93935991, 0.875 ],\n", - " [0.15979082, 0.90230208, 0.8875 ],\n", - " [0.19726903, 0.86524424, 0.875 ],\n", - " [0.22719349, 0.83267827, 0.85 ],\n", - " [0.25392214, 0.79337451, 0.8875 ],\n", - " [0.27803603, 0.75912409, 1. ],\n", - " [0.29924463, 0.7237507 , 0.9875 ],\n", - " [0.31900058, 0.67770915, 0.9 ],\n", - " [0.34195235, 0.62099944, 0.8625 ],\n", - " [0.37855898, 0.5300393 , 1. ],\n", - " [0.42475305, 0.43851769, 0.875 ],\n", - " [0.47298083, 0.35429534, 0.7625 ],\n", - " [0.5403835 , 0.26558113, 0.85 ],\n", - " [0.60981987, 0.19876474, 0.7625 ],\n", - " [0.69755956, 0.1398091 , 0.8625 ],\n", - " [0.79488669, 0.08927569, 0.8875 ],\n", - " [0.89570017, 0.04211117, 0.8875 ],\n", - " [1. , 0. , 0.875 ]]),\n", - " array([[1. , 0. , 0. ],\n", - " [0.90451389, 0.09230769, 0.875 ],\n", - " [0.81770833, 0.18353576, 0.875 ],\n", - " [0.73784722, 0.26153846, 0.7625 ],\n", - " [0.65046296, 0.35195682, 0.8625 ],\n", - " [0.56076389, 0.44156545, 0.875 ],\n", - " [0.4693287 , 0.53333333, 0.875 ],\n", - " [0.37673611, 0.62537112, 0.875 ],\n", - " [0.28530093, 0.71659919, 0.875 ],\n", - " [0.18229167, 0.81862348, 1. ],\n", - " [0.09259259, 0.90877193, 0.8625 ],\n", - " [0. , 1. , 0.9 ]]),\n", - " array([[0. , 1. , 0. ],\n", - " [0.13981849, 0.8614098 , 1. ],\n", - " [0.26035167, 0.73715651, 0.86419753],\n", - " [0.39619966, 0.6051374 , 0.97530864],\n", - " [0.51162791, 0.48864994, 0.82716049],\n", - " [0.64577425, 0.34946237, 0.96296296],\n", - " [0.76829268, 0.22640382, 0.87654321],\n", - " [0.87975043, 0.11827957, 0.80246914],\n", - " [1. , 0. , 0.85185185]])]" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data.corpus" - ] - }, { "cell_type": "markdown", "id": "12e4c956-0b49-4d06-9ff0-201cd1f3a27e", @@ -10834,12 +986,11 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "a22e802a-c924-4ead-9c8d-0fb3c262e84d", + "execution_count": 3, + "id": "303b9c84", "metadata": {}, "outputs": [], "source": [ - "%%time\n", "data = Data.Data(if_sample=True, n_samples=[100, 10, 10])\n", "data_full_names = [\n", " \"Adiac\",\n", @@ -10870,32 +1021,113 @@ " \"TwoLeadECG\",\n", " \"Wafer\",\n", " \"Wine\",\n", - "]\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a22e802a-c924-4ead-9c8d-0fb3c262e84d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 19min 32s, sys: 16min 42s, total: 36min 15s\n", + "Wall time: 5min 55s\n" + ] + } + ], + "source": [ + "%%time\n", + "depth = 5\n", + "signature_maha_knn = SignatureMahalanobisKNN()\n", "\n", - "signature_maha_knn = SignatureMahalanobisKNN(\n", - " augmentation_list=(\"addtime\",),\n", - " depth=5,\n", - ")\n", - "anomaly_level = 0.001\n", "iter = 10\n", "data_names = data_full_names\n", "\n", + "anomaly_level = 0.001\n", "roughpathsbest, roughpathserror = UCR_data_support.compute_best_and_std(\n", - " data_names, iter, data, signature_maha_knn, anomaly_level\n", + " data_set=data_names,\n", + " iter=iter,\n", + " data=data,\n", + " signature_maha_knn=signature_maha_knn,\n", + " depth=depth,\n", + " n_neighbours=n_neighbours,\n", + " anomaly_level=anomaly_level,\n", ")\n", "\n", "anomaly_level = 0.05\n", "roughpathsbest, roughpathserror = UCR_data_support.compute_best_and_std(\n", - " data_names, iter, data, signature_maha_knn, anomaly_level\n", + " data_set=data_names,\n", + " iter=iter,\n", + " data=data,\n", + " signature_maha_knn=signature_maha_knn,\n", + " depth=depth,\n", + " n_neighbours=n_neighbours,\n", + " anomaly_level=anomaly_level,\n", ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "e6043a4d-1ba9-4e77-acbb-5a758d9c1693", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/Users/zoos/PycharmProjects/Anomaly_detection/data/results_beggel_et_al_2019_tables_2_and_4.csv'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/paper-examples/examples.ipynb Cell 21\u001b[0m line \u001b[0;36m2\n\u001b[1;32m 1\u001b[0m fig, axs \u001b[39m=\u001b[39m plt\u001b[39m.\u001b[39msubplots(\u001b[39m1\u001b[39m, \u001b[39m2\u001b[39m, figsize\u001b[39m=\u001b[39m(\u001b[39m12\u001b[39m, \u001b[39m6\u001b[39m))\n\u001b[0;32m----> 2\u001b[0m comparison_table_1 \u001b[39m=\u001b[39m UCR_data_support\u001b[39m.\u001b[39;49mplot_ucr_result(\n\u001b[1;32m 3\u001b[0m roughpathsbest, roughpathserror, anomaly_level\u001b[39m=\u001b[39;49m\u001b[39m0.001\u001b[39;49m, ax_num\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m, axs\u001b[39m=\u001b[39;49maxs\n\u001b[1;32m 4\u001b[0m )\n\u001b[1;32m 5\u001b[0m comparison_table_2 \u001b[39m=\u001b[39m UCR_data_support\u001b[39m.\u001b[39mplot_ucr_result(\n\u001b[1;32m 6\u001b[0m roughpathsbest, roughpathserror, anomaly_level\u001b[39m=\u001b[39m\u001b[39m0.05\u001b[39m, ax_num\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m, axs\u001b[39m=\u001b[39maxs\n\u001b[1;32m 7\u001b[0m )\n\u001b[1;32m 8\u001b[0m fig\u001b[39m.\u001b[39msavefig(\u001b[39m\"\u001b[39m\u001b[39mbenchmark.pdf\u001b[39m\u001b[39m\"\u001b[39m)\n", + "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/paper-examples/UCR_data_support.py:63\u001b[0m, in \u001b[0;36mplot_ucr_result\u001b[0;34m(roughpathsbest, roughpathserror, anomaly_level, ax_num, axs)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mplot_ucr_result\u001b[39m(roughpathsbest, roughpathserror, anomaly_level, ax_num, axs):\n\u001b[1;32m 62\u001b[0m \u001b[39m# result from beggels 2019\u001b[39;00m\n\u001b[0;32m---> 63\u001b[0m comparisons \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39;49mread_csv(DATA_DIR \u001b[39m+\u001b[39;49m \u001b[39m\"\u001b[39;49m\u001b[39mresults_beggel_et_al_2019_tables_2_and_4.csv\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[1;32m 64\u001b[0m adslbest \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mmaximum(comparisons\u001b[39m.\u001b[39mADSL, comparisons\u001b[39m.\u001b[39mADSLbest)\n\u001b[1;32m 65\u001b[0m adslerror \u001b[39m=\u001b[39m comparisons[\u001b[39m\"\u001b[39m\u001b[39mADSL sd\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m*\u001b[39m (\n\u001b[1;32m 66\u001b[0m comparisons\u001b[39m.\u001b[39mADSLbest \u001b[39m<\u001b[39m comparisons\u001b[39m.\u001b[39mADSL\n\u001b[1;32m 67\u001b[0m ) \u001b[39m+\u001b[39m comparisons[\u001b[39m\"\u001b[39m\u001b[39mADSLbest sd\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m*\u001b[39m (comparisons\u001b[39m.\u001b[39mADSLbest \u001b[39m>\u001b[39m\u001b[39m=\u001b[39m comparisons\u001b[39m.\u001b[39mADSL)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/parsers/readers.py:948\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m 935\u001b[0m kwds_defaults \u001b[39m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 936\u001b[0m dialect,\n\u001b[1;32m 937\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 944\u001b[0m dtype_backend\u001b[39m=\u001b[39mdtype_backend,\n\u001b[1;32m 945\u001b[0m )\n\u001b[1;32m 946\u001b[0m kwds\u001b[39m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 948\u001b[0m \u001b[39mreturn\u001b[39;00m _read(filepath_or_buffer, kwds)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/parsers/readers.py:611\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 608\u001b[0m _validate_names(kwds\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39mnames\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mNone\u001b[39;00m))\n\u001b[1;32m 610\u001b[0m \u001b[39m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 611\u001b[0m parser \u001b[39m=\u001b[39m TextFileReader(filepath_or_buffer, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds)\n\u001b[1;32m 613\u001b[0m \u001b[39mif\u001b[39;00m chunksize \u001b[39mor\u001b[39;00m iterator:\n\u001b[1;32m 614\u001b[0m \u001b[39mreturn\u001b[39;00m parser\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/parsers/readers.py:1448\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39moptions[\u001b[39m\"\u001b[39m\u001b[39mhas_index_names\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m kwds[\u001b[39m\"\u001b[39m\u001b[39mhas_index_names\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[1;32m 1447\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles: IOHandles \u001b[39m|\u001b[39m \u001b[39mNone\u001b[39;00m \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m-> 1448\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_engine \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_make_engine(f, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mengine)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/parsers/readers.py:1705\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1703\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mb\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m mode:\n\u001b[1;32m 1704\u001b[0m mode \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mb\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m-> 1705\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles \u001b[39m=\u001b[39m get_handle(\n\u001b[1;32m 1706\u001b[0m f,\n\u001b[1;32m 1707\u001b[0m mode,\n\u001b[1;32m 1708\u001b[0m encoding\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mencoding\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[1;32m 1709\u001b[0m compression\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mcompression\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[1;32m 1710\u001b[0m memory_map\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mmemory_map\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mFalse\u001b[39;49;00m),\n\u001b[1;32m 1711\u001b[0m is_text\u001b[39m=\u001b[39;49mis_text,\n\u001b[1;32m 1712\u001b[0m errors\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mencoding_errors\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39m\"\u001b[39;49m\u001b[39mstrict\u001b[39;49m\u001b[39m\"\u001b[39;49m),\n\u001b[1;32m 1713\u001b[0m storage_options\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mstorage_options\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[1;32m 1714\u001b[0m )\n\u001b[1;32m 1715\u001b[0m \u001b[39massert\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 1716\u001b[0m f \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles\u001b[39m.\u001b[39mhandle\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/common.py:863\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 858\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39misinstance\u001b[39m(handle, \u001b[39mstr\u001b[39m):\n\u001b[1;32m 859\u001b[0m \u001b[39m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 860\u001b[0m \u001b[39m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 861\u001b[0m \u001b[39mif\u001b[39;00m ioargs\u001b[39m.\u001b[39mencoding \u001b[39mand\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mb\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m ioargs\u001b[39m.\u001b[39mmode:\n\u001b[1;32m 862\u001b[0m \u001b[39m# Encoding\u001b[39;00m\n\u001b[0;32m--> 863\u001b[0m handle \u001b[39m=\u001b[39m \u001b[39mopen\u001b[39;49m(\n\u001b[1;32m 864\u001b[0m handle,\n\u001b[1;32m 865\u001b[0m ioargs\u001b[39m.\u001b[39;49mmode,\n\u001b[1;32m 866\u001b[0m encoding\u001b[39m=\u001b[39;49mioargs\u001b[39m.\u001b[39;49mencoding,\n\u001b[1;32m 867\u001b[0m errors\u001b[39m=\u001b[39;49merrors,\n\u001b[1;32m 868\u001b[0m newline\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[1;32m 869\u001b[0m )\n\u001b[1;32m 870\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 871\u001b[0m \u001b[39m# Binary mode\u001b[39;00m\n\u001b[1;32m 872\u001b[0m handle \u001b[39m=\u001b[39m \u001b[39mopen\u001b[39m(handle, ioargs\u001b[39m.\u001b[39mmode)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/zoos/PycharmProjects/Anomaly_detection/data/results_beggel_et_al_2019_tables_2_and_4.csv'" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n", "comparison_table_1 = UCR_data_support.plot_ucr_result(\n", From b50d954cc2d002e914ccdae2a9cc4fe79563565a Mon Sep 17 00:00:00 2001 From: rchan Date: Thu, 2 Nov 2023 12:10:48 +0000 Subject: [PATCH 13/22] run last example --- paper-examples/UCR_data_support.py | 2 +- paper-examples/examples.ipynb | 31 +++++++----------------------- 2 files changed, 8 insertions(+), 25 deletions(-) diff --git a/paper-examples/UCR_data_support.py b/paper-examples/UCR_data_support.py index 4ca0480..f9e46e3 100644 --- a/paper-examples/UCR_data_support.py +++ b/paper-examples/UCR_data_support.py @@ -4,7 +4,7 @@ import numpy as np import pandas as pd -DATA_DIR = "/Users/zoos/PycharmProjects/Anomaly_detection/data/" +DATA_DIR = "data/" def compute_best_and_std( diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index 5106faf..066e80a 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "b7a56abc", "metadata": {}, "outputs": [], @@ -986,7 +986,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "303b9c84", "metadata": {}, "outputs": [], @@ -1026,7 +1026,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "a22e802a-c924-4ead-9c8d-0fb3c262e84d", "metadata": {}, "outputs": [ @@ -1058,8 +1058,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 19min 32s, sys: 16min 42s, total: 36min 15s\n", - "Wall time: 5min 55s\n" + "CPU times: user 17min 48s, sys: 18min 8s, total: 35min 57s\n", + "Wall time: 5min 57s\n" ] } ], @@ -1096,30 +1096,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "e6043a4d-1ba9-4e77-acbb-5a758d9c1693", "metadata": {}, "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: '/Users/zoos/PycharmProjects/Anomaly_detection/data/results_beggel_et_al_2019_tables_2_and_4.csv'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/paper-examples/examples.ipynb Cell 21\u001b[0m line \u001b[0;36m2\n\u001b[1;32m 1\u001b[0m fig, axs \u001b[39m=\u001b[39m plt\u001b[39m.\u001b[39msubplots(\u001b[39m1\u001b[39m, \u001b[39m2\u001b[39m, figsize\u001b[39m=\u001b[39m(\u001b[39m12\u001b[39m, \u001b[39m6\u001b[39m))\n\u001b[0;32m----> 2\u001b[0m comparison_table_1 \u001b[39m=\u001b[39m UCR_data_support\u001b[39m.\u001b[39;49mplot_ucr_result(\n\u001b[1;32m 3\u001b[0m roughpathsbest, roughpathserror, anomaly_level\u001b[39m=\u001b[39;49m\u001b[39m0.001\u001b[39;49m, ax_num\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m, axs\u001b[39m=\u001b[39;49maxs\n\u001b[1;32m 4\u001b[0m )\n\u001b[1;32m 5\u001b[0m comparison_table_2 \u001b[39m=\u001b[39m UCR_data_support\u001b[39m.\u001b[39mplot_ucr_result(\n\u001b[1;32m 6\u001b[0m roughpathsbest, roughpathserror, anomaly_level\u001b[39m=\u001b[39m\u001b[39m0.05\u001b[39m, ax_num\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m, axs\u001b[39m=\u001b[39maxs\n\u001b[1;32m 7\u001b[0m )\n\u001b[1;32m 8\u001b[0m fig\u001b[39m.\u001b[39msavefig(\u001b[39m\"\u001b[39m\u001b[39mbenchmark.pdf\u001b[39m\u001b[39m\"\u001b[39m)\n", - "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/paper-examples/UCR_data_support.py:63\u001b[0m, in \u001b[0;36mplot_ucr_result\u001b[0;34m(roughpathsbest, roughpathserror, anomaly_level, ax_num, axs)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mplot_ucr_result\u001b[39m(roughpathsbest, roughpathserror, anomaly_level, ax_num, axs):\n\u001b[1;32m 62\u001b[0m \u001b[39m# result from beggels 2019\u001b[39;00m\n\u001b[0;32m---> 63\u001b[0m comparisons \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39;49mread_csv(DATA_DIR \u001b[39m+\u001b[39;49m \u001b[39m\"\u001b[39;49m\u001b[39mresults_beggel_et_al_2019_tables_2_and_4.csv\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[1;32m 64\u001b[0m adslbest \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mmaximum(comparisons\u001b[39m.\u001b[39mADSL, comparisons\u001b[39m.\u001b[39mADSLbest)\n\u001b[1;32m 65\u001b[0m adslerror \u001b[39m=\u001b[39m comparisons[\u001b[39m\"\u001b[39m\u001b[39mADSL sd\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m*\u001b[39m (\n\u001b[1;32m 66\u001b[0m comparisons\u001b[39m.\u001b[39mADSLbest \u001b[39m<\u001b[39m comparisons\u001b[39m.\u001b[39mADSL\n\u001b[1;32m 67\u001b[0m ) \u001b[39m+\u001b[39m comparisons[\u001b[39m\"\u001b[39m\u001b[39mADSLbest sd\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m*\u001b[39m (comparisons\u001b[39m.\u001b[39mADSLbest \u001b[39m>\u001b[39m\u001b[39m=\u001b[39m comparisons\u001b[39m.\u001b[39mADSL)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/parsers/readers.py:948\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m 935\u001b[0m kwds_defaults \u001b[39m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 936\u001b[0m dialect,\n\u001b[1;32m 937\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 944\u001b[0m dtype_backend\u001b[39m=\u001b[39mdtype_backend,\n\u001b[1;32m 945\u001b[0m )\n\u001b[1;32m 946\u001b[0m kwds\u001b[39m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 948\u001b[0m \u001b[39mreturn\u001b[39;00m _read(filepath_or_buffer, kwds)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/parsers/readers.py:611\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 608\u001b[0m _validate_names(kwds\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39mnames\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mNone\u001b[39;00m))\n\u001b[1;32m 610\u001b[0m \u001b[39m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 611\u001b[0m parser \u001b[39m=\u001b[39m TextFileReader(filepath_or_buffer, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds)\n\u001b[1;32m 613\u001b[0m \u001b[39mif\u001b[39;00m chunksize \u001b[39mor\u001b[39;00m iterator:\n\u001b[1;32m 614\u001b[0m \u001b[39mreturn\u001b[39;00m parser\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/parsers/readers.py:1448\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39moptions[\u001b[39m\"\u001b[39m\u001b[39mhas_index_names\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m kwds[\u001b[39m\"\u001b[39m\u001b[39mhas_index_names\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[1;32m 1447\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles: IOHandles \u001b[39m|\u001b[39m \u001b[39mNone\u001b[39;00m \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m-> 1448\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_engine \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_make_engine(f, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mengine)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/parsers/readers.py:1705\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1703\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mb\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m mode:\n\u001b[1;32m 1704\u001b[0m mode \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mb\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m-> 1705\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles \u001b[39m=\u001b[39m get_handle(\n\u001b[1;32m 1706\u001b[0m f,\n\u001b[1;32m 1707\u001b[0m mode,\n\u001b[1;32m 1708\u001b[0m encoding\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mencoding\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[1;32m 1709\u001b[0m compression\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mcompression\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[1;32m 1710\u001b[0m memory_map\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mmemory_map\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mFalse\u001b[39;49;00m),\n\u001b[1;32m 1711\u001b[0m is_text\u001b[39m=\u001b[39;49mis_text,\n\u001b[1;32m 1712\u001b[0m errors\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mencoding_errors\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39m\"\u001b[39;49m\u001b[39mstrict\u001b[39;49m\u001b[39m\"\u001b[39;49m),\n\u001b[1;32m 1713\u001b[0m storage_options\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moptions\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mstorage_options\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[1;32m 1714\u001b[0m )\n\u001b[1;32m 1715\u001b[0m \u001b[39massert\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 1716\u001b[0m f \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandles\u001b[39m.\u001b[39mhandle\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/pandas/io/common.py:863\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 858\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39misinstance\u001b[39m(handle, \u001b[39mstr\u001b[39m):\n\u001b[1;32m 859\u001b[0m \u001b[39m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 860\u001b[0m \u001b[39m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 861\u001b[0m \u001b[39mif\u001b[39;00m ioargs\u001b[39m.\u001b[39mencoding \u001b[39mand\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mb\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m ioargs\u001b[39m.\u001b[39mmode:\n\u001b[1;32m 862\u001b[0m \u001b[39m# Encoding\u001b[39;00m\n\u001b[0;32m--> 863\u001b[0m handle \u001b[39m=\u001b[39m \u001b[39mopen\u001b[39;49m(\n\u001b[1;32m 864\u001b[0m handle,\n\u001b[1;32m 865\u001b[0m ioargs\u001b[39m.\u001b[39;49mmode,\n\u001b[1;32m 866\u001b[0m encoding\u001b[39m=\u001b[39;49mioargs\u001b[39m.\u001b[39;49mencoding,\n\u001b[1;32m 867\u001b[0m errors\u001b[39m=\u001b[39;49merrors,\n\u001b[1;32m 868\u001b[0m newline\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[1;32m 869\u001b[0m )\n\u001b[1;32m 870\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 871\u001b[0m \u001b[39m# Binary mode\u001b[39;00m\n\u001b[1;32m 872\u001b[0m handle \u001b[39m=\u001b[39m \u001b[39mopen\u001b[39m(handle, ioargs\u001b[39m.\u001b[39mmode)\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/zoos/PycharmProjects/Anomaly_detection/data/results_beggel_et_al_2019_tables_2_and_4.csv'" - ] - }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+AAAAH/CAYAAADXOLcaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAj00lEQVR4nO3dbWyd9Xn48SsP2AYVm7AszsNMM+gobYGEJsQ1FCEmr5FA6fJiagZVkkUURpshGmsrCQ9xKW2cPwUUqYRGpDAqrSxpEbCqicKo16iieIqaB4mOBEQDTVbVJlkXOw2tTez7/wLhzk1Cc8w5l53w+UjnRW7u2+d3fnK48vU5PmdMURRFAAAAABU1dqQXAAAAAO8HAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABKUHOA//vGPY968eTF16tQYM2ZMPPPMM3/0mq1bt8bHP/7xqK6ujg996EPx+OOPD2OpAEAGsx4AKqPkAD9y5EjMmDEj1q5de1Lnv/baa3HdddfFNddcE7t27YovfvGL8bnPfS6effbZkhcLAFSeWQ8AlTGmKIpi2BePGRNPP/10zJ8//4Tn3H777bFp06b42c9+Nnjsb//2b+PQoUOxZcuW4d41AJDArAeA8hlf6Tvo6OiI5ubmIcfmzp0bX/ziF094TW9vb/T29g7+eWBgIH7961/Hn/zJn8SYMWMqtVQAOClFUcThw4dj6tSpMXast1Mx6wE4HVVi3lc8wDs7O6O+vn7Isfr6+ujp6Ynf/va3ceaZZx5zTVtbW9xzzz2VXhoAvCf79++PP/uzPxvpZYw4sx6A01k5533FA3w4VqxYES0tLYN/7u7ujvPOOy/2798ftbW1I7gyAIjo6emJhoaGOPvss0d6Kacssx6A0a4S877iAT558uTo6uoacqyrqytqa2uP+xPxiIjq6uqorq4+5nhtba2hDMCo4aXSbzPrATidlXPeV/wX15qamqK9vX3Iseeeey6ampoqfdcAQAKzHgBOTskB/pvf/CZ27doVu3btioi3P3pk165dsW/fvoh4+yVlixYtGjz/lltuib1798aXvvSl2LNnTzz88MPx3e9+N5YtW1aeRwAAlJVZDwCVUXKA//SnP43LLrssLrvssoiIaGlpicsuuyxWrlwZERG/+tWvBgd0RMSf//mfx6ZNm+K5556LGTNmxAMPPBDf+ta3Yu7cuWV6CABAOZn1AFAZ7+lzwLP09PREXV1ddHd3+70wAEacuVR+9hSA0aYSs8mHlwIAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQIJhBfjatWtj+vTpUVNTE42NjbFt27Z3PX/NmjXx4Q9/OM4888xoaGiIZcuWxe9+97thLRgAqDyzHgDKr+QA37hxY7S0tERra2vs2LEjZsyYEXPnzo033njjuOc/8cQTsXz58mhtbY3du3fHo48+Ghs3bow77rjjPS8eACg/sx4AKqPkAH/wwQfjpptuiiVLlsRHP/rRWLduXZx11lnx2GOPHff8F154Ia688sq44YYbYvr06fGpT30qrr/++j/6k3QAYGSY9QBQGSUFeF9fX2zfvj2am5t//wXGjo3m5ubo6Og47jVXXHFFbN++fXAI7927NzZv3hzXXnvte1g2AFAJZj0AVM74Uk4+ePBg9Pf3R319/ZDj9fX1sWfPnuNec8MNN8TBgwfjk5/8ZBRFEUePHo1bbrnlXV+W1tvbG729vYN/7unpKWWZAMAwmfUAUDkVfxf0rVu3xqpVq+Lhhx+OHTt2xFNPPRWbNm2Ke++994TXtLW1RV1d3eCtoaGh0ssEAIbJrAeAkzOmKIriZE/u6+uLs846K5588smYP3/+4PHFixfHoUOH4t/+7d+Oueaqq66KT3ziE/H1r3998Ni//Mu/xM033xy/+c1vYuzYY38GcLyfijc0NER3d3fU1tae7HIBoCJ6enqirq7utJxLZj0AvK0S876kZ8Crqqpi1qxZ0d7ePnhsYGAg2tvbo6mp6bjXvPnmm8cM3nHjxkVExInav7q6Ompra4fcAIDKM+sBoHJK+h3wiIiWlpZYvHhxzJ49O+bMmRNr1qyJI0eOxJIlSyIiYtGiRTFt2rRoa2uLiIh58+bFgw8+GJdddlk0NjbGq6++GnfffXfMmzdvcDgDAKOHWQ8AlVFygC9YsCAOHDgQK1eujM7Ozpg5c2Zs2bJl8M1a9u3bN+Sn4HfddVeMGTMm7rrrrvjlL38Zf/qnfxrz5s2Lr33ta+V7FABA2Zj1AFAZJf0O+Eg5nX/XDoBTj7lUfvYUgNFmxH8HHAAAABgeAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAkEOAAAACQQ4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAmGFeBr166N6dOnR01NTTQ2Nsa2bdve9fxDhw7F0qVLY8qUKVFdXR0XXnhhbN68eVgLBgAqz6wHgPIbX+oFGzdujJaWlli3bl00NjbGmjVrYu7cufHyyy/HpEmTjjm/r68v/uqv/iomTZoUTz75ZEybNi1+8YtfxDnnnFOO9QMAZWbWA0BljCmKoijlgsbGxrj88svjoYceioiIgYGBaGhoiFtvvTWWL19+zPnr1q2Lr3/967Fnz54444wzhrXInp6eqKuri+7u7qitrR3W1wCAcjnd55JZDwCVmU0lvQS9r68vtm/fHs3Nzb//AmPHRnNzc3R0dBz3mu9///vR1NQUS5cujfr6+rj44otj1apV0d/ff8L76e3tjZ6eniE3AKDyzHoAqJySAvzgwYPR398f9fX1Q47X19dHZ2fnca/Zu3dvPPnkk9Hf3x+bN2+Ou+++Ox544IH46le/esL7aWtri7q6usFbQ0NDKcsEAIbJrAeAyqn4u6APDAzEpEmT4pFHHolZs2bFggUL4s4774x169ad8JoVK1ZEd3f34G3//v2VXiYAMExmPQCcnJLehG3ixIkxbty46OrqGnK8q6srJk+efNxrpkyZEmeccUaMGzdu8NhHPvKR6OzsjL6+vqiqqjrmmurq6qiuri5laQBAGZj1AFA5JT0DXlVVFbNmzYr29vbBYwMDA9He3h5NTU3HvebKK6+MV199NQYGBgaPvfLKKzFlypTjDmQAYOSY9QBQOSW/BL2lpSXWr18f3/72t2P37t3x+c9/Po4cORJLliyJiIhFixbFihUrBs///Oc/H7/+9a/jtttui1deeSU2bdoUq1atiqVLl5bvUQAAZWPWA0BllPw54AsWLIgDBw7EypUro7OzM2bOnBlbtmwZfLOWffv2xdixv+/6hoaGePbZZ2PZsmVx6aWXxrRp0+K2226L22+/vXyPAgAoG7MeACqj5M8BHwk+GxSA0cRcKj97CsBoM+KfAw4AAAAMjwAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACDBsAJ87dq1MX369KipqYnGxsbYtm3bSV23YcOGGDNmTMyfP384dwsAJDHrAaD8Sg7wjRs3RktLS7S2tsaOHTtixowZMXfu3HjjjTfe9brXX389/vEf/zGuuuqqYS8WAKg8sx4AKqPkAH/wwQfjpptuiiVLlsRHP/rRWLduXZx11lnx2GOPnfCa/v7++OxnPxv33HNPnH/++e9pwQBAZZn1AFAZJQV4X19fbN++PZqbm3//BcaOjebm5ujo6DjhdV/5yldi0qRJceONN57U/fT29kZPT8+QGwBQeWY9AFROSQF+8ODB6O/vj/r6+iHH6+vro7Oz87jXPP/88/Hoo4/G+vXrT/p+2traoq6ubvDW0NBQyjIBgGEy6wGgcir6LuiHDx+OhQsXxvr162PixIknfd2KFSuiu7t78LZ///4KrhIAGC6zHgBO3vhSTp44cWKMGzcuurq6hhzv6uqKyZMnH3P+z3/+83j99ddj3rx5g8cGBgbevuPx4+Pll1+OCy644Jjrqquro7q6upSlAQBlYNYDQOWU9Ax4VVVVzJo1K9rb2wePDQwMRHt7ezQ1NR1z/kUXXRQvvvhi7Nq1a/D26U9/Oq655prYtWuXl5sBwChj1gNA5ZT0DHhEREtLSyxevDhmz54dc+bMiTVr1sSRI0diyZIlERGxaNGimDZtWrS1tUVNTU1cfPHFQ64/55xzIiKOOQ4AjA5mPQBURskBvmDBgjhw4ECsXLkyOjs7Y+bMmbFly5bBN2vZt29fjB1b0V8tBwAqyKwHgMoYUxRFMdKL+GN6enqirq4uuru7o7a2dqSXA8D7nLlUfvYUgNGmErPJj68BAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEwwrwtWvXxvTp06OmpiYaGxtj27ZtJzx3/fr1cdVVV8WECRNiwoQJ0dzc/K7nAwAjz6wHgPIrOcA3btwYLS0t0draGjt27IgZM2bE3Llz44033jju+Vu3bo3rr78+fvSjH0VHR0c0NDTEpz71qfjlL3/5nhcPAJSfWQ8AlTGmKIqilAsaGxvj8ssvj4ceeigiIgYGBqKhoSFuvfXWWL58+R+9vr+/PyZMmBAPPfRQLFq06KTus6enJ+rq6qK7uztqa2tLWS4AlN3pPpfMegCozGwq6Rnwvr6+2L59ezQ3N//+C4wdG83NzdHR0XFSX+PNN9+Mt956K84999wTntPb2xs9PT1DbgBA5Zn1AFA5JQX4wYMHo7+/P+rr64ccr6+vj87OzpP6GrfffntMnTp1yGD/Q21tbVFXVzd4a2hoKGWZAMAwmfUAUDmp74K+evXq2LBhQzz99NNRU1NzwvNWrFgR3d3dg7f9+/cnrhIAGC6zHgBObHwpJ0+cODHGjRsXXV1dQ453dXXF5MmT3/Xa+++/P1avXh0//OEP49JLL33Xc6urq6O6urqUpQEAZWDWA0DllPQMeFVVVcyaNSva29sHjw0MDER7e3s0NTWd8Lr77rsv7r333tiyZUvMnj17+KsFACrKrAeAyinpGfCIiJaWlli8eHHMnj075syZE2vWrIkjR47EkiVLIiJi0aJFMW3atGhra4uIiP/3//5frFy5Mp544omYPn364O+PfeADH4gPfOADZXwoAEA5mPUAUBklB/iCBQviwIEDsXLlyujs7IyZM2fGli1bBt+sZd++fTF27O+fWP/mN78ZfX198Td/8zdDvk5ra2t8+ctffm+rBwDKzqwHgMoo+XPAR4LPBgVgNDGXys+eAjDajPjngAMAAADDI8ABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEggwAEAACCBAAcAAIAEAhwAAAASCHAAAABIIMABAAAggQAHAACABAIcAAAAEghwAAAASCDAAQAAIIEABwAAgAQCHAAAABIIcAAAAEgwrABfu3ZtTJ8+PWpqaqKxsTG2bdv2rud/73vfi4suuihqamrikksuic2bNw9rsQBADrMeAMqv5ADfuHFjtLS0RGtra+zYsSNmzJgRc+fOjTfeeOO457/wwgtx/fXXx4033hg7d+6M+fPnx/z58+NnP/vZe148AFB+Zj0AVMaYoiiKUi5obGyMyy+/PB566KGIiBgYGIiGhoa49dZbY/ny5cecv2DBgjhy5Ej84Ac/GDz2iU98ImbOnBnr1q07qfvs6emJurq66O7ujtra2lKWCwBld7rPJbMeACozm8aXcnJfX19s3749VqxYMXhs7Nix0dzcHB0dHce9pqOjI1paWoYcmzt3bjzzzDMnvJ/e3t7o7e0d/HN3d3dEvL0BADDS3plHJf4M+5Rg1gPA2yox70sK8IMHD0Z/f3/U19cPOV5fXx979uw57jWdnZ3HPb+zs/OE99PW1hb33HPPMccbGhpKWS4AVNT//M//RF1d3Ugvo6zMegAYqpzzvqQAz7JixYohP0k/dOhQfPCDH4x9+/addv/QGQk9PT3R0NAQ+/fv9zK/MrGn5WU/y8+elld3d3ecd955ce655470Uk5ZZn3l+XtfXvaz/OxpednP8qvEvC8pwCdOnBjjxo2Lrq6uIce7urpi8uTJx71m8uTJJZ0fEVFdXR3V1dXHHK+rq/PNVEa1tbX2s8zsaXnZz/Kzp+U1duzp92meZv3px9/78rKf5WdPy8t+ll85531JX6mqqipmzZoV7e3tg8cGBgaivb09mpqajntNU1PTkPMjIp577rkTng8AjByzHgAqp+SXoLe0tMTixYtj9uzZMWfOnFizZk0cOXIklixZEhERixYtimnTpkVbW1tERNx2221x9dVXxwMPPBDXXXddbNiwIX7605/GI488Ut5HAgCUhVkPAJVRcoAvWLAgDhw4ECtXrozOzs6YOXNmbNmyZfDNV/bt2zfkKforrrginnjiibjrrrvijjvuiL/4i7+IZ555Ji6++OKTvs/q6upobW097kvVKJ39LD97Wl72s/zsaXmd7vtp1p8e7Gl52c/ys6flZT/LrxJ7WvLngAMAAAClO/3ePQYAAABGIQEOAAAACQQ4AAAAJBDgAAAAkGDUBPjatWtj+vTpUVNTE42NjbFt27Z3Pf973/teXHTRRVFTUxOXXHJJbN68OWmlp4ZS9nP9+vVx1VVXxYQJE2LChAnR3Nz8R/f//ajU79F3bNiwIcaMGRPz58+v7AJPMaXu56FDh2Lp0qUxZcqUqK6ujgsvvNDf+z9Q6p6uWbMmPvzhD8eZZ54ZDQ0NsWzZsvjd736XtNrR7cc//nHMmzcvpk6dGmPGjIlnnnnmj16zdevW+PjHPx7V1dXxoQ99KB5//PGKr/NUY9aXl1lffmZ9+Zn35WXWl8+IzfpiFNiwYUNRVVVVPPbYY8V//dd/FTfddFNxzjnnFF1dXcc9/yc/+Ukxbty44r777iteeuml4q677irOOOOM4sUXX0xe+ehU6n7ecMMNxdq1a4udO3cWu3fvLv7u7/6uqKurK/77v/87eeWjV6l7+o7XXnutmDZtWnHVVVcVf/3Xf52z2FNAqfvZ29tbzJ49u7j22muL559/vnjttdeKrVu3Frt27Upe+ehV6p5+5zvfKaqrq4vvfOc7xWuvvVY8++yzxZQpU4ply5Ylr3x02rx5c3HnnXcWTz31VBERxdNPP/2u5+/du7c466yzipaWluKll14qvvGNbxTjxo0rtmzZkrPgU4BZX15mffmZ9eVn3peXWV9eIzXrR0WAz5kzp1i6dOngn/v7+4upU6cWbW1txz3/M5/5THHdddcNOdbY2Fj8/d//fUXXeaoodT//0NGjR4uzzz67+Pa3v12pJZ5yhrOnR48eLa644oriW9/6VrF48WJD+f8odT+/+c1vFueff37R19eXtcRTTql7unTp0uIv//IvhxxraWkprrzyyoqu81R0MkP5S1/6UvGxj31syLEFCxYUc+fOreDKTi1mfXmZ9eVn1pefeV9eZn3lZM76EX8Jel9fX2zfvj2am5sHj40dOzaam5ujo6PjuNd0dHQMOT8iYu7cuSc8//1kOPv5h958881466234txzz63UMk8pw93Tr3zlKzFp0qS48cYbM5Z5yhjOfn7/+9+PpqamWLp0adTX18fFF18cq1ativ7+/qxlj2rD2dMrrrgitm/fPvjStb1798bmzZvj2muvTVnz6cZcendmfXmZ9eVn1pefeV9eZv3IK9dcGl/ORQ3HwYMHo7+/P+rr64ccr6+vjz179hz3ms7OzuOe39nZWbF1niqGs59/6Pbbb4+pU6ce8w32fjWcPX3++efj0UcfjV27diWs8NQynP3cu3dv/Md//Ed89rOfjc2bN8err74aX/jCF+Ktt96K1tbWjGWPasPZ0xtuuCEOHjwYn/zkJ6Moijh69Gjccsstcccdd2Qs+bRzornU09MTv/3tb+PMM88coZWNDmZ9eZn15WfWl595X15m/cgr16wf8WfAGV1Wr14dGzZsiKeffjpqampGejmnpMOHD8fChQtj/fr1MXHixJFezmlhYGAgJk2aFI888kjMmjUrFixYEHfeeWesW7dupJd2ytq6dWusWrUqHn744dixY0c89dRTsWnTprj33ntHemlAhZn1751ZXxnmfXmZ9aPTiD8DPnHixBg3blx0dXUNOd7V1RWTJ08+7jWTJ08u6fz3k+Hs5zvuv//+WL16dfzwhz+MSy+9tJLLPKWUuqc///nP4/XXX4958+YNHhsYGIiIiPHjx8fLL78cF1xwQWUXPYoN53t0ypQpccYZZ8S4ceMGj33kIx+Jzs7O6Ovri6qqqoquebQbzp7efffdsXDhwvjc5z4XERGXXHJJHDlyJG6++ea48847Y+xYP58txYnmUm1t7fv+2e8Is77czPryM+vLz7wvL7N+5JVr1o/4rldVVcWsWbOivb198NjAwEC0t7dHU1PTca9pamoacn5ExHPPPXfC899PhrOfERH33Xdf3HvvvbFly5aYPXt2xlJPGaXu6UUXXRQvvvhi7Nq1a/D26U9/Oq655prYtWtXNDQ0ZC5/1BnO9+iVV14Zr7766uA/biIiXnnllZgyZcr7ehi/Yzh7+uabbx4zeN/5B8/b70VCKcyld2fWl5dZX35mffmZ9+Vl1o+8ss2lkt6yrUI2bNhQVFdXF48//njx0ksvFTfffHNxzjnnFJ2dnUVRFMXChQuL5cuXD57/k5/8pBg/fnxx//33F7t37y5aW1t9NMn/Uep+rl69uqiqqiqefPLJ4le/+tXg7fDhwyP1EEadUvf0D3ln1KFK3c99+/YVZ599dvEP//APxcsvv1z84Ac/KCZNmlR89atfHamHMOqUuqetra3F2WefXfzrv/5rsXfv3uLf//3fiwsuuKD4zGc+M1IPYVQ5fPhwsXPnzmLnzp1FRBQPPvhgsXPnzuIXv/hFURRFsXz58mLhwoWD57/z0ST/9E//VOzevbtYu3atjyH7A2Z9eZn15WfWl595X15mfXmN1KwfFQFeFEXxjW98ozjvvPOKqqqqYs6cOcV//ud/Dv63q6++uli8ePGQ87/73e8WF154YVFVVVV87GMfKzZt2pS84tGtlP384Ac/WETEMbfW1tb8hY9ipX6P/l+G8rFK3c8XXnihaGxsLKqrq4vzzz+/+NrXvlYcPXo0edWjWyl7+tZbbxVf/vKXiwsuuKCoqakpGhoaii984QvF//7v/+YvfBT60Y9+dNz/L76zh4sXLy6uvvrqY66ZOXNmUVVVVZx//vnFP//zP6eve7Qz68vLrC8/s778zPvyMuvLZ6Rm/Zii8PoDAAAAqLQR/x1wAAAAeD8Q4AAAAJBAgAMAAEACAQ4AAAAJBDgAAAAkEOAAAACQQIADAABAAgEOAAAACQQ4AAAAJBDgAAAAkECAAwAAQAIBDgAAAAn+PwJ2jMunR8fEAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] From 303c3de49cea7e04f0185489b81092515bcef78e Mon Sep 17 00:00:00 2001 From: jh83775 <77271032+jh83775@users.noreply.github.com> Date: Tue, 21 Nov 2023 12:53:28 +0000 Subject: [PATCH 14/22] added new notebook for bug testing --- paper-examples/example2.ipynb | 185 ++++++++++++++++++ .../sig_mahal_knn.py | 6 +- 2 files changed, 190 insertions(+), 1 deletion(-) create mode 100644 paper-examples/example2.ipynb diff --git a/paper-examples/example2.ipynb b/paper-examples/example2.ipynb new file mode 100644 index 0000000..5ad3d2d --- /dev/null +++ b/paper-examples/example2.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b430e261-33b2-4878-94d6-46e5dbb18c72", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.join(\"..\", \"..\"))\n", + "import random\n", + "import time\n", + "\n", + "import sklearn\n", + "import numpy as np\n", + "import matplotlib.lines as mlines\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "import Data\n", + "from signature_mahalanobis_knn import SignatureMahalanobisKNN,Mahalanobis\n", + "\n", + "from signature_mahalanobis_knn.utils import compute_auc_given_dists\n", + "import UCR_data_support" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "34fc097e-0eb5-4c0d-9973-4dc8810ec398", + "metadata": {}, + "outputs": [], + "source": [ + "DATA_DIR = \"./data/\"\n", + "#importlib.reload(Data)\n", + "#importlib.reload(SigMahaKNN)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b7a56abc", + "metadata": {}, + "outputs": [], + "source": [ + "n_neighbours = 50" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9", + "metadata": {}, + "outputs": [], + "source": [ + "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n", + "data.load_pen_digit()\n" + ] + }, + { + "cell_type": "markdown", + "id": "79e05b28", + "metadata": {}, + "source": [ + "## Can we reproduce distances?\n", + "\n", + "For depth 4, digit 0:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a4675b42", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 0 doing signature level 4\n", + "fit_time: 4.060782432556152\n" + ] + } + ], + "source": [ + "digit = 0\n", + "depth = 4\n", + "data.load_pen_digit(digit=digit)\n", + "print(\"doing digit\", digit, \"doing signature level \", depth)\n", + "signature_maha_knn = SignatureMahalanobisKNN()\n", + "# Measure the time spent on fit\n", + "start_time = time.time()\n", + "signature_maha_knn.fit(\n", + " knn_library=\"sklearn\",\n", + " X_train=data.corpus,\n", + " signature_kwargs={\n", + " \"depth\": depth,\n", + " },\n", + ")\n", + "fit_time = time.time() - start_time\n", + "print(f\"fit_time: {fit_time}\")\n", + "\n", + "inlier_dists, inlier_ix = signature_maha_knn.conformance(\n", + " data.test_inlier, n_neighbors=n_neighbours, debug=True\n", + ")\n", + "outlier_dists, outlier_ix = signature_maha_knn.conformance(\n", + " data.test_outlier, n_neighbors=n_neighbours, debug=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "index of closest train point to test_point[0] = 766\n", + "Reported conformance = 0.14569653916925893\n", + "Reported conformance squared = 0.0212274815258994\n" + ] + } + ], + "source": [ + "print('index of closest train point to test_point[0] =',inlier_ix[0,0])\n", + "print('Reported conformance =', inlier_dists[0])\n", + "print('Reported conformance squared =', inlier_dists[0]**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reported distance = 0.021227562800049782\n" + ] + } + ], + "source": [ + "# Compute distances as per the old method\n", + "test_sig = signature_maha_knn.signature_transform.transform(data.test_inlier[0]).iloc[0].values\n", + "train_sig = signature_maha_knn.signatures_train[766]\n", + "dist = signature_maha_knn.mahal_distance.distance(test_sig,train_sig)\n", + "print('Reported distance =', dist)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index f112a8e..04730f9 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -169,6 +169,7 @@ def conformance( X_test: np.ndarray | None = None, signatures_test: np.ndarray | None = None, n_neighbors: int = 20, + debug=False, ) -> np.ndarray: """ Compute the conformance scores for the data points either passed in @@ -260,4 +261,7 @@ def conformance( candidate_distances[rho > self.mahal_distance.subspace_thres] = np.inf # compute the minimum of the candidate distances for each data point - return np.min(candidate_distances, axis=-1) + if debug: + return np.min(candidate_distances, axis=-1), train_indices + else: + return np.min(candidate_distances, axis=-1) From 53d66827d14fbef5b6b4c62680432b0025b478a8 Mon Sep 17 00:00:00 2001 From: rchan Date: Wed, 22 Nov 2023 15:28:30 +0000 Subject: [PATCH 15/22] add transform-euclidean --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 767f6cf..55e87cf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,7 +29,7 @@ classifiers = [ ] dynamic = ["version"] dependencies = [ - "sktime", + "sktime >= 0.24.1", "numpy", "scikit-learn", "pynndescent", From a15e4a61031726f9f5c322a20d62ede428eac9b8 Mon Sep 17 00:00:00 2001 From: rchan Date: Thu, 23 Nov 2023 17:17:20 +0000 Subject: [PATCH 16/22] check reproduce old output --- paper-examples/example2.ipynb | 80 +- paper-examples/examples.ipynb | 1214 ++++++++++++++--- .../mahal_distance.py | 2 +- .../sig_mahal_knn.py | 9 +- 4 files changed, 1105 insertions(+), 200 deletions(-) diff --git a/paper-examples/example2.ipynb b/paper-examples/example2.ipynb index 5ad3d2d..a306440 100644 --- a/paper-examples/example2.ipynb +++ b/paper-examples/example2.ipynb @@ -21,7 +21,7 @@ "import pandas as pd\n", "\n", "import Data\n", - "from signature_mahalanobis_knn import SignatureMahalanobisKNN,Mahalanobis\n", + "from signature_mahalanobis_knn import SignatureMahalanobisKNN, Mahalanobis\n", "\n", "from signature_mahalanobis_knn.utils import compute_auc_given_dists\n", "import UCR_data_support" @@ -35,8 +35,8 @@ "outputs": [], "source": [ "DATA_DIR = \"./data/\"\n", - "#importlib.reload(Data)\n", - "#importlib.reload(SigMahaKNN)" + "# importlib.reload(Data)\n", + "# importlib.reload(SigMahaKNN)" ] }, { @@ -57,7 +57,7 @@ "outputs": [], "source": [ "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n", - "data.load_pen_digit()\n" + "data.load_pen_digit()" ] }, { @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 36, "id": "a4675b42", "metadata": {}, "outputs": [ @@ -81,7 +81,7 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 4\n", - "fit_time: 4.060782432556152\n" + "fit_time: 1.7248878479003906\n" ] } ], @@ -97,6 +97,7 @@ " knn_library=\"sklearn\",\n", " X_train=data.corpus,\n", " signature_kwargs={\n", + " \"augmentation_list\": None,\n", " \"depth\": depth,\n", " },\n", ")\n", @@ -113,52 +114,87 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "index of closest train point to test_point[0] = 766\n", - "Reported conformance = 0.14569653916925893\n", - "Reported conformance squared = 0.0212274815258994\n" + "index of closest train point to test_point[0] = 342\n", + "Reported conformance = 0.03967368329534612\n", + "Reported conformance squared = 0.0015740011462194255\n" ] } ], "source": [ - "print('index of closest train point to test_point[0] =',inlier_ix[0,0])\n", - "print('Reported conformance =', inlier_dists[0])\n", - "print('Reported conformance squared =', inlier_dists[0]**2)" + "print(\"index of closest train point to test_point[0] =\", inlier_ix[0, 0])\n", + "print(\"Reported conformance =\", inlier_dists[0])\n", + "print(\"Reported conformance squared =\", inlier_dists[0] ** 2)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Reported distance = 0.021227562800049782\n" + "Reported distance = 0.0015739502850919962\n" ] } ], "source": [ "# Compute distances as per the old method\n", - "test_sig = signature_maha_knn.signature_transform.transform(data.test_inlier[0]).iloc[0].values\n", - "train_sig = signature_maha_knn.signatures_train[766]\n", - "dist = signature_maha_knn.mahal_distance.distance(test_sig,train_sig)\n", - "print('Reported distance =', dist)" + "test_sig = (\n", + " signature_maha_knn.signature_transform.transform(data.test_inlier[0]).iloc[0].values\n", + ")\n", + "train_sig = signature_maha_knn.signatures_train[inlier_ix[0, 0]]\n", + "dist = signature_maha_knn.mahal_distance.distance(test_sig, train_sig)\n", + "print(\"Reported distance =\", dist)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "5.086112742926606e-08" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inlier_dists[0] ** 2 - dist" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.409984413327519e-07" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inlier_dists[0] - np.sqrt(dist)" + ] } ], "metadata": { diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index 066e80a..90fd4e7 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -48,17 +48,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "id": "b7a56abc", "metadata": {}, "outputs": [], "source": [ - "n_neighbours = 50" + "n_neighbours = 800" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9", "metadata": {}, "outputs": [], @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 35, "id": "a9b82cb0-4754-409c-891b-b19ec7e9b1a3", "metadata": {}, "outputs": [ @@ -81,44 +81,54 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 1\n", - "fit_time: 1.8175599575042725\n", - "compute_auc_time: 0.2454509735107422\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3241300582885742\n", + "compute_auc_time: 0.15503692626953125\n", "depth: 1 , Auc of digit: 0 is 0.9522222222222222\n", "doing digit 1 doing signature level 1\n", - "fit_time: 1.7983481884002686\n", - "compute_auc_time: 0.22825384140014648\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3169400691986084\n", + "compute_auc_time: 0.13514089584350586\n", "depth: 1 , Auc of digit: 1 is 0.8288888888888888\n", "doing digit 2 doing signature level 1\n", - "fit_time: 1.7937610149383545\n", - "compute_auc_time: 0.1955101490020752\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3055970668792725\n", + "compute_auc_time: 0.1642148494720459\n", "depth: 1 , Auc of digit: 2 is 0.9388888888888889\n", "doing digit 3 doing signature level 1\n", - "fit_time: 1.775019884109497\n", - "compute_auc_time: 0.24438023567199707\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3227732181549072\n", + "compute_auc_time: 0.1321120262145996\n", "depth: 1 , Auc of digit: 3 is 0.9644444444444444\n", "doing digit 4 doing signature level 1\n", - "fit_time: 1.7686738967895508\n", - "compute_auc_time: 0.2114849090576172\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3062961101531982\n", + "compute_auc_time: 0.14656996726989746\n", "depth: 1 , Auc of digit: 4 is 0.9311111111111111\n", "doing digit 5 doing signature level 1\n", - "fit_time: 1.7760677337646484\n", - "compute_auc_time: 0.19081592559814453\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3365981578826904\n", + "compute_auc_time: 0.28490185737609863\n", "depth: 1 , Auc of digit: 5 is 0.9377777777777778\n", "doing digit 6 doing signature level 1\n", - "fit_time: 1.862623929977417\n", - "compute_auc_time: 0.14302921295166016\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.345693826675415\n", + "compute_auc_time: 0.17109394073486328\n", "depth: 1 , Auc of digit: 6 is 0.8455555555555556\n", "doing digit 7 doing signature level 1\n", - "fit_time: 1.7721309661865234\n", - "compute_auc_time: 0.20407915115356445\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.301511287689209\n", + "compute_auc_time: 0.14022302627563477\n", "depth: 1 , Auc of digit: 7 is 0.8955555555555557\n", "doing digit 8 doing signature level 1\n", - "fit_time: 1.8542490005493164\n", - "compute_auc_time: 0.21956300735473633\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3029189109802246\n", + "compute_auc_time: 0.23799824714660645\n", "depth: 1 , Auc of digit: 8 is 0.9555555555555556\n", "doing digit 9 doing signature level 1\n", - "fit_time: 1.773684024810791\n", - "compute_auc_time: 0.21489596366882324\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3173649311065674\n", + "compute_auc_time: 0.15609216690063477\n", "depth: 1 , Auc of digit: 9 is 0.818888888888889\n" ] }, @@ -138,50 +148,60 @@ "text": [ "Overall, depth: 1 AUC: 0.9025000000000001\n", "doing digit 0 doing signature level 2\n", - "fit_time: 1.782930850982666\n", - "compute_auc_time: 0.17782831192016602\n", - "depth: 2 , Auc of digit: 0 is 0.9922222222222222\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3760838508605957\n", + "compute_auc_time: 0.14020204544067383\n", + "depth: 2 , Auc of digit: 0 is 1.0\n", "doing digit 1 doing signature level 2\n", - "fit_time: 1.8092701435089111\n", - "compute_auc_time: 0.19916629791259766\n", - "depth: 2 , Auc of digit: 1 is 0.9488888888888888\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3131299018859863\n", + "compute_auc_time: 0.14356303215026855\n", + "depth: 2 , Auc of digit: 1 is 0.9177777777777778\n", "doing digit 2 doing signature level 2\n", - "fit_time: 1.8085293769836426\n", - "compute_auc_time: 0.24826908111572266\n", - "depth: 2 , Auc of digit: 2 is 0.9933333333333334\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3730659484863281\n", + "compute_auc_time: 0.1465151309967041\n", + "depth: 2 , Auc of digit: 2 is 0.9588888888888889\n", "doing digit 3 doing signature level 2\n", - "fit_time: 1.828705072402954\n", - "compute_auc_time: 0.22558903694152832\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.5481741428375244\n", + "compute_auc_time: 0.1523730754852295\n", "depth: 2 , Auc of digit: 3 is 1.0\n", "doing digit 4 doing signature level 2\n", - "fit_time: 1.816422939300537\n", - "compute_auc_time: 0.2291879653930664\n", - "depth: 2 , Auc of digit: 4 is 0.9866666666666667\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3711528778076172\n", + "compute_auc_time: 0.14588427543640137\n", + "depth: 2 , Auc of digit: 4 is 0.967777777777778\n", "doing digit 5 doing signature level 2\n", - "fit_time: 1.9208240509033203\n", - "compute_auc_time: 0.26401209831237793\n", - "depth: 2 , Auc of digit: 5 is 0.9855555555555555\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.4503920078277588\n", + "compute_auc_time: 0.18131399154663086\n", + "depth: 2 , Auc of digit: 5 is 0.9988888888888889\n", "doing digit 6 doing signature level 2\n", - "fit_time: 1.8196361064910889\n", - "compute_auc_time: 0.19854211807250977\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.417189121246338\n", + "compute_auc_time: 0.10462093353271484\n", "depth: 2 , Auc of digit: 6 is 1.0\n", "doing digit 7 doing signature level 2\n", - "fit_time: 1.822005033493042\n", - "compute_auc_time: 0.31998777389526367\n", - "depth: 2 , Auc of digit: 7 is 0.9777777777777777\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.4176151752471924\n", + "compute_auc_time: 0.12642884254455566\n", + "depth: 2 , Auc of digit: 7 is 0.9633333333333334\n", "doing digit 8 doing signature level 2\n", - "fit_time: 1.8831498622894287\n", - "compute_auc_time: 0.1961832046508789\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3452069759368896\n", + "compute_auc_time: 0.14234519004821777\n", "depth: 2 , Auc of digit: 8 is 0.9977777777777778\n", "doing digit 9 doing signature level 2\n", - "fit_time: 1.846689224243164\n", - "compute_auc_time: 0.18111586570739746\n", - "depth: 2 , Auc of digit: 9 is 0.9677777777777778\n" + "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3965299129486084\n", + "compute_auc_time: 0.13335299491882324\n", + "depth: 2 , Auc of digit: 9 is 0.95\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABybElEQVR4nO3dd1hTZxsG8DsgYQ8VEEQU91YUR92LitbaunFU0Tpa96jWLe5Rd6utdaLWCs5qnXXvVqvi3kKd4A6yR97vj/MRjQwJJBwg9++6csF5c8aTnIwn73mHQgghQERERGSETOQOgIiIiEguTISIiIjIaDERIiIiIqPFRIiIiIiMFhMhIiIiMlpMhIiIiMhoMREiIiIio8VEiIiIiIwWEyEiIiIyWkyEjJCHhwd69uwpdxhGp3HjxmjcuLHcYXzU5MmToVAo8OLFC7lDyXEUCgUmT56sl32FhoZCoVAgICBAL/vL7bLy/ujZsyc8PDyyHMOmTZtQoEABREZGfnRdfb4WdHX06FEoFAps2bJFluO/7/r168iXLx+uXr0qdyiZxkRIzwICAqBQKDS3fPnywc3NDT179sTjx4/lDi9Hi4qKwrRp01ClShVYWVnB3t4eDRo0wLp165BbZoK5fv06Jk+ejNDQULlDSSEpKQlr1qxB48aNUaBAAZibm8PDwwO9evXCv//+K3d4evH7779j0aJFcoehJTtiSk6qkm+mpqYoWrQo2rZti+DgYIMeOzU9e/bUisfGxgYlSpRAhw4dsHXrVqjVaoMePzo6GpMnT8bRo0czvE1SUhL8/f0xePBg2NjYGC44Hcj1elar1QgICMAXX3wBd3d3WFtbo1KlSpg+fTpiY2O11q1QoQJatWqFSZMmZXuceiNIr9asWSMAiKlTp4r169eLFStWiN69ewtTU1NRsmRJERMTI3eIIjY2VsTHx8sdhpawsDBRsWJFYWJiIrp27Sp+/fVXsXjxYtGwYUMBQPj6+orExES5w/yozZs3CwDiyJEjKe6Li4sTcXFx2R+UECI6Olq0aNFCABANGzYUc+fOFatWrRITJ04UZcuWFQqFQjx8+FAIIYS/v78AIJ4/fy5LrFnRqlUrUaxYMYPtPyYmRiQkJOi0TVoxqdVqERMTo5fXdUhIiAAgunTpItavXy8CAgLE6NGjhZ2dnTA3NxcXL17M8jF04efnJ8zNzcX69evF+vXrxfLly8X48eNFlSpVBADRuHFjoVKptLbJyvsjPj5exMbGapafP38uAAh/f/8M72P79u1CoVCIR48eZWh9XfefGWm9do4cOSIAiM2bNxvkuG/fvhUAxCeffCKmT58uli9fLnr16iVMTExE48aNhVqt1lp/z549AoC4e/euQeIxNCZCepacCJ07d06rfPTo0QKACAoKkikyecXExIikpKQ07/fx8REmJiZix44dKe4bOXKkACBmz55tyBBTFRkZqdP66SVCcho4cKAAIBYuXJjivsTERDF37txsTYTUarWIjo7W+34NkQglJSVl6QeMoZMzId4lQnPnztUq37lzpwAg+vXrZ9Djf8jPz09YW1unet+sWbMEANGpUyeDHT8zidAXX3wh6tevn+H183IiFBcXJ06dOpWifMqUKQKAOHDggFZ5fHy8yJ8/v5g4caJB4jE0JkJ6llYitGvXLgFAzJw5U6v8xo0bon379iJ//vzC3NxceHl5pZoMvH79WgwbNkwUK1ZMKJVK4ebmJrp37671ZRUbGysmTZokSpYsKZRKpShSpIgYNWqU1i8lIYQoVqyY8PPzE0IIce7cOQFABAQEpDjmvn37BADx559/asoePXokevXqJZydnYVSqRQVKlQQq1at0tou+U26ceNGMX78eFG4cGGhUCjE69evU33Ozpw5IwCIr7/+OtX7ExISROnSpUX+/Pk1X57vf/AvWLBAFC1aVFhYWIiGDRuKK1eupNhHRp7n5HN39OhR0b9/f+Hk5CQcHByEEEKEhoaK/v37izJlyggLCwtRoEAB0aFDBxESEpJi+w9vyUlRo0aNRKNGjVI8T0FBQWL69OnCzc1NmJubi6ZNm4o7d+6keAxLliwRxYsXFxYWFqJmzZri+PHjKfaZmocPH4p8+fKJTz/9NN31kiUnQnfu3BF+fn7C3t5e2NnZiZ49e4qoqCitdVevXi2aNGkinJychFKpFOXLlxc///xzin0WK1ZMtGrVSuzbt094eXkJc3NzTVKW0X0IIf3ybNiwobCxsRG2traiRo0aYsOGDUII6fn98Ll//0sko+8PAGLgwIHit99+ExUqVBD58uUT27dv19z3/pdfRESEGDp0qOZ96eTkJLy9vcX58+c/GlPya3jNmjVax79x44bo2LGjcHR0FBYWFqJMmTJi3Lhx6Z2yNBOhyMhIAUDr3P/999/Cx8dH2NnZCUtLS9GwYUNx8uRJre10eQ2kJr1ESAghmjdvLhQKhbh165amLLXXcmhoqGjdurWwsrISTk5OYtiwYZrPpfd/bPj5+aV4Xj+8pZe0xMTECKVSKSZPnpzivtjYWDFs2DDh6OgobGxsROvWrcXDhw9T3acun4+BgYFi7NixolChQsLKykq0bt1aPHjwQOv5SOu1o+tnh75cvnxZABA//vhjivvatm0rqlSpYrBjG1K+rF1Yo4xKbjOSP39+Tdm1a9dQr149uLm5YcyYMbC2tsamTZvQpk0bbN26FW3btgUAREZGokGDBrhx4wa+/vprVK9eHS9evMDOnTvx6NEjODo6Qq1W44svvsDJkyfRr18/lC9fHleuXMHChQtx+/Zt/PHHH6nGVaNGDZQoUQKbNm2Cn5+f1n1BQUHInz8/fHx8AADh4eH45JNPoFAoMGjQIDg5OWHv3r3o3bs3IiIiMGzYMK3tp02bBqVSiZEjRyIuLg5KpTLVGP78808AQI8ePVK9P1++fOjatSumTJmCU6dOwdvbW3PfunXr8PbtWwwcOBCxsbFYvHgxmjZtiitXrqBQoUI6Pc/JBgwYACcnJ0yaNAlRUVEAgHPnzuH06dPo3LkzihQpgtDQUPzyyy9o3Lgxrl+/DisrKzRs2BBDhgzBjz/+iHHjxqF8+fIAoPmbltmzZ8PExAQjR46ESqXCDz/8gG7duuGff/7RrPPLL79g0KBBaNCgAYYPH47Q0FC0adMG+fPnR5EiRdLd/969e5GYmIju3bunu96HOnXqhOLFi2PWrFm4cOECVq5cCWdnZ8yZM0crrooVK+KLL75Avnz58Oeff2LAgAFQq9UYOHCg1v5u3bqFLl264JtvvkHfvn1RtmxZnfYREBCAr7/+GhUrVsTYsWPh4OCAixcvYt++fejatSvGjx8PlUqFR48eYeHChQCgaeuh6/vj8OHD2LRpEwYNGgRHR8c0G+J+++232LJlCwYNGoQKFSrg5cuXOHnyJG7cuIHq1aunG1NqLl++jAYNGsDMzAz9+vWDh4cH7t27hz///BMzZszI2Il7z7179wAABQsW1Dyuli1bwsvLC/7+/jAxMcGaNWvQtGlTnDhxArVq1dLaPiOvgczo3r07/vrrLxw4cABlypRJdZ2oqCg0bdoUT58+xdChQ+Hi4oLff/8dR44cSXffTk5O+OWXX9C/f3+0bdsW7dq1AwBUqVIlzW3Onz+P+Ph4VK9ePcV9ffr0wW+//YauXbuibt26OHz4MFq1apViPV0/H2fMmAGFQoHRo0fj2bNnWLRoEby9vREcHAxLS8sMvXYy8tkRHR2N6OjodJ8zADA1NdX6fkpNWFgYAMDR0THFfV5eXtixYwciIiJgZ2f30ePlKHJnYnlNcq3AwYMHxfPnz8XDhw/Fli1bhJOTkzA3N9dcfhBCiGbNmonKlStr/SJVq9Wibt26onTp0pqySZMmCQBi27ZtKY6XfK12/fr1wsTERJw4cULr/mXLlgkAWtWc79cICSHE2LFjhZmZmXj16pWmLC4uTjg4OGjV0vTu3Vu4urqKFy9eaB2jc+fOwt7eXlNbk/xrpUSJEhm6/NGmTRsBIM0aIyGE2LZtm9YvkeRffZaWllrX9P/55x8BQAwfPlxTltHnOfnc1a9fP0W7jdQeR3JN1rp16zRl6V0aS6tGqHz58lptIxYvXiwAaGq24uLiRMGCBUXNmjW12qcEBAQIAB+tERo+fLgAkOF2Ism1AR/W0LVt21YULFhQqyy158XHx0eUKFFCq6xYsWICgNi3b1+K9TOyjzdv3ghbW1tRu3btFJep3m+vkNalBF3eHwCEiYmJuHbtWor94INaAHt7ezFw4MAU670vrZhSqxFq2LChsLW1Ff/991+ajzE1yfuaMmWKeP78uQgLCxNHjx4V1apVEwDE1q1bhVqtFqVLlxY+Pj5a+4uOjhbFixfXqjXS5TWQmo/VCF28eDHF+/TD98f8+fMFAPHHH39oymJiYkS5cuXSrRESQvdLYytXrtR6zyULDg4WAMSAAQO0yrt27Zpi/7p+Prq5uYmIiAjNeps2bRIAxOLFizVlH7s09rHPDiHencuP3TJy+dbb21vY2dml+ln9+++/CwDin3/++eh+chr2GjMQb29vODk5wd3dHR06dIC1tTV27typ+fX+6tUrHD58GJ06dcLbt2/x4sULvHjxAi9fvoSPjw/u3Lmj6WW2detWVK1aNUXNBSB14QSAzZs3o3z58ihXrpxmXy9evEDTpk0BIN1fUb6+vkhISMC2bds0ZX/99RfevHkDX19fAIAQAlu3bkXr1q0hhNA6ho+PD1QqFS5cuKC1Xz8/P1haWn70uXr79i0AwNbWNs11ku+LiIjQKm/Tpg3c3Nw0y7Vq1ULt2rWxZ88eALo9z8n69u0LU1NTrbL3H0dCQgJevnyJUqVKwcHBIcXj1lWvXr20assaNGgAALh//z4A4N9//8XLly/Rt29f5Mv3rhK3W7duH/0FB7x7ztJ7flPz7bffai03aNAAL1++1DoH7z8vKpUKL168QKNGjXD//n2oVCqt7YsXL66pXXxfRvZx4MABvH37FmPGjIGFhYXW9snvgfTo+v5o1KgRKlSo8NH9Ojg44J9//sGTJ08+uu7HPH/+HMePH8fXX3+NokWLat2XkccIAP7+/nBycoKLiwsaN26Me/fuYc6cOWjXrh2Cg4Nx584ddO3aFS9fvtQ8B1FRUWjWrBmOHz+eojdXRl4DmZFcs5H83k/Nvn374Obmhi+++EJTZmFhgb59+2bp2Kl5+fIlAKR4PyV/jgwZMkSr/MPancx8Pvbo0UPrPdmhQwe4urpqjpkRH/vsSD7OgQMHPnrbsGFDuseaOXMmDh48iNmzZ8PBwSHF/cnPXW4cdoOXxgxk6dKlKFOmDFQqFVavXo3jx4/D3Nxcc//du3chhMDEiRMxceLEVPfx7NkzuLm54d69e2jfvn26x7tz5w5u3LgBJyenNPeVlqpVq6JcuXIICgpC7969AUiXxRwdHTVfFM+fP8ebN2+wfPlyLF++PEPHKF68eLoxJ0v+MHj79m2qb7Dk+95fN1np0qVTrFumTBls2rQJgG7Pc3pxx8TEYNasWVizZg0eP36s1Z3/wy98XX34pZf8gfL69WsAwH///QcAKFWqlNZ6+fLly9DYKcnV1Ol96egaV/I+T506BX9/f5w5cyZF9btKpYK9vb1mOa3XQ0b2kXyJp1KlSjo9hmS6vj8y+tr94Ycf4OfnB3d3d3h5eeGzzz5Djx49UKJECZ1jTP7yyuxjBIB+/fqhY8eOMDExgYODAypWrKj53Llz5w4ApLgE/j6VSqWVDGTkNZAZyeP0pJec//fffyhZsmSKJPDD94E+vf++To7BxMQEJUuW1CpPvqybLDOfjx9+dikUCpQqVUqnoTc+9tkBACVKlMjU6/F9QUFBmDBhAnr37o3+/funuk7yc5fRpD0nYSJkILVq1UKNGjUASLUW9evXR9euXXHr1i3Y2NhofnmNHDky1V/JgG5veLVajcqVK2PBggWp3u/u7p7u9r6+vpgxYwZevHgBW1tb7Ny5E126dNHUQCTH+9VXX6X5QfrhNfiM1AYBUhuaP/74A5cvX0bDhg1TXefy5csAkKFf6e/LzPOcWtyDBw/GmjVrMGzYMNSpUwf29vZQKBTo3LlzlsdE+bD2KdmHH8qZVa5cOQDAlStX4OnpmeHtPhbXvXv30KxZM5QrVw4LFiyAu7s7lEol9uzZg4ULF6Z4XlJ7XnXdR2bp+v7I6Gu3U6dOaNCgAbZv346//voLc+fOxZw5c7Bt2za0bNkyy3HrqnTp0lpt6N6X/FzOnTs3zdfBh21QDPXaTB58z5BJjS6S21C9fv36o23uUpOZz0d9yMj5iYyMzNAAkaampqn+UDhw4AB69OiBVq1aYdmyZWlun5x8pdZ+KKdjIpQNTE1NMWvWLDRp0gRLlizBmDFjNBm6mZlZmh9cyUqWLPnRUTtLliyJS5cuoVmzZpnKyH19fTFlyhRs3boVhQoVQkREBDp37qy538nJCba2tkhKSvpovLr6/PPPMWvWLKxbty7VRCgpKQm///478ufPj3r16mndl/wr9323b9/W1JTo8jynZ8uWLfDz88P8+fM1ZbGxsXjz5o3Weob4NVSsWDEAUu1WkyZNNOWJiYkIDQ396Adsy5YtYWpqit9++03nBtPp+fPPPxEXF4edO3dq/TL9WGPWzOwj+Rf51atX0/3yTOv5z+r7Iz2urq4YMGAABgwYgGfPnqF69eqYMWOGJhHK6PGSX6uGGqE3+Tm0s7PT+3tYV+vXr4dCocCnn36a5jrFihXD9evXIYTQeg7v3r370f3reo6TfyyEhISgcuXKWjGo1Wrcu3dPqxbo1q1bWttn5vPxw88uIQTu3r2r9X7Wx2t13rx5mDJlykfXK1asWIraqH/++Qdt27ZFjRo1sGnTJq1L8x8KCQmBiYlJmo3fczK2EcomjRs3Rq1atbBo0SLExsbC2dkZjRs3xq+//oqnT5+mWP/58+ea/9u3b49Lly5h+/btKdZLzvw7deqEx48fY8WKFSnWiYmJ0fR+Skv58uVRuXJlBAUFISgoCK6urlpJiampKdq3b4+tW7em+kH9fry6qlu3Lry9vbFmzRrs2rUrxf3jx4/H7du38f3336f4pf7HH39otfE5e/Ys/vnnH82XkC7Pc3pMTU1T/Ar+6aefkJSUpFVmbW0NACkSpKyoUaMGChYsiBUrViAxMVFTvmHDBq0q8LS4u7ujb9+++Ouvv/DTTz+luF+tVmP+/Pl49OiRTnEl/xr98DLhmjVr9L6P5s2bw9bWFrNmzUoxsu3721pbW6d6qTKr74/UJCUlpTiWs7MzChcujLi4uI/G9CEnJyc0bNgQq1evxoMHD7Tu00ftoJeXF0qWLIl58+alWkOQlfewLmbPno2//voLvr6+qV7aTubj44PHjx9j586dmrLY2NhUz+GHrKysAGT8fejl5QWlUplihPXkz5Eff/xRq/zD0Z4z8/mY3OM12ZYtW/D06VOtmsSMvnbSk9k2Qjdu3ECrVq3g4eGBXbt2fbSW9Pz586hYsaLW5fDcgjVC2WjUqFHo2LEjAgIC8O2332Lp0qWoX78+KleujL59+6JEiRIIDw/HmTNn8OjRI1y6dEmz3ZYtW9CxY0d8/fXX8PLywqtXr7Bz504sW7YMVatWRffu3bFp0yZ8++23OHLkCOrVq4ekpCTcvHkTmzZtwv79+zWX6tLi6+uLSZMmwcLCAr1794aJiXaePHv2bBw5cgS1a9dG3759UaFCBbx69QoXLlzAwYMH8erVq0w/N+vWrUOzZs3w5ZdfomvXrmjQoAHi4uKwbds2HD16FL6+vhg1alSK7UqVKoX69eujf//+iIuLw6JFi1CwYEF8//33mnUy+jyn5/PPP8f69ethb2+PChUq4MyZMzh48KCmSj2Zp6cnTE1NMWfOHKhUKpibm6Np06ZwdnbO9HOjVCoxefJkDB48GE2bNkWnTp0QGhqKgICAVNtQpGb+/Pm4d+8ehgwZgm3btuHzzz9H/vz58eDBA2zevBk3b97UqgHMiObNm0OpVKJ169b45ptvEBkZiRUrVsDZ2TnVpDMr+7Czs8PChQvRp08f1KxZE127dkX+/Plx6dIlREdHY+3atQCkL7SgoCCMGDECNWvWhI2NDVq3bq2X98eH3r59iyJFiqBDhw6oWrUqbGxscPDgQZw7d06r5jCtmFLz448/on79+qhevTr69euH4sWLIzQ0FLt3787yVBkmJiZYuXIlWrZsiYoVK6JXr15wc3PD48ePceTIEdjZ2WmGstCHxMRE/PbbbwCkBOa///7Dzp07cfnyZTRp0iTNtjTJvvnmGyxZsgRdunTB0KFD4erqig0bNmgay6f3ure0tESFChUQFBSEMmXKoECBAqhUqVKa7a8sLCzQvHlzHDx4EFOnTtWUe3p6okuXLvj555+hUqlQt25dHDp0KNVaKV0/HwsUKID69eujV69eCA8Px6JFi1CqVCmtxuC6vHbSkpk2Qm/fvoWPjw9ev36NUaNGYffu3Vr3lyxZEnXq1NEsJyQk4NixYxgwYIBOx8kxsrWPmhFIa0BFIaQRakuWLClKliyp6Z5979490aNHD+Hi4iLMzMyEm5ub+Pzzz8WWLVu0tn358qUYNGiQcHNz0wwG5+fnp9VVMz4+XsyZM0dUrFhRmJubi/z58wsvLy8xZcoUreHsP+w+n+zOnTuarpQfDrCWLDw8XAwcOFC4u7sLMzMz4eLiIpo1ayaWL1+uWSezo56+fftWTJ48WVSsWFFYWloKW1tbUa9ePREQEJCi+/D7A8jNnz9fuLu7C3Nzc9GgQQNx6dKlFPvOyPOc3rl7/fq16NWrl2ZQNR8fH3Hz5s1Un8sVK1aIEiVKCFNT0wwNqPjh85TWQHs//vijKFasmDA3Nxe1atUSp06dEl5eXqJFixYZeHalEaRXrlwpGjRoIOzt7YWZmZkoVqyY6NWrl1bX+rRGlk5+ft4fRHLnzp2iSpUqwsLCQnh4eIg5c+aI1atXp1gveUDF1GR0H8nr1q1bV1haWgo7OztRq1YtsXHjRs39kZGRomvXrsLBwSFFl+CMvj/w/wEVU4P3ukzHxcWJUaNGiapVqwpbW1thbW0tqlatmmIwyLRiSus8X716VbRt21Y4ODgICwsLUbZs2Y+O2JvWgIqpuXjxomjXrp0oWLCgMDc3F8WKFROdOnUShw4d0qyjy2sgNX5+flpds62srISHh4do37692LJlS6qjzKc2oOL9+/dFq1athKWlpXBychLfffed2Lp1qwAg/v77b63jfdj9+/Tp08LLy0solcoMdaXftm2bUCgUWoMaCiF12R8yZIgoWLCgsLa2TndARV0+Hzdu3CjGjh0rnJ2dhaWlpWjVqlWKYRPSeu3o+tmhq7QGpUy+ffiZt3fvXoH/D8CZGymEyCWzWRK9JzQ0FMWLF8fcuXMxcuRIucORhVqthpOTE9q1a5ehywVEecGiRYswfPhwPHr0SKu3Z1YlJSWhQoUK6NSpE6ZNm6a3/X7o6NGjaNKkCTZv3owOHToY7DjZqU2bNlAoFKk238gN2EaIKBeIjY1N0U5k3bp1ePXqFRo3bixPUEQGFhMTo7UcGxuLX3/9FaVLl9ZrEgRI7XymTp2KpUuXZqiXFUlu3LiBXbt2GTR5NDS2ESLKBf7++28MHz4cHTt2RMGCBXHhwgWsWrUKlSpVQseOHeUOj8gg2rVrh6JFi8LT0xMqlQq//fYbbt68+dHB/zLL19dXM4gsZUz58uW1OnHkRkyEiHIBDw8PuLu748cff8SrV69QoEAB9OjRA7Nnz05zDjei3M7HxwcrV67Ehg0bNJeuAgMDmayQXsnaRuj48eOYO3cuzp8/j6dPn2L79u1o06ZNutscPXoUI0aMwLVr1+Du7o4JEyagZ8+e2RIvERER5S2ythGKiopC1apVsXTp0gytHxISglatWqFJkyYIDg7GsGHD0KdPH+zfv9/AkRIREVFelGN6jSW3OE+vRmj06NHYvXu31oBVnTt3xps3b7Bv375siJKIiIjyklzVRujMmTMphi/38fFJMRPw++Li4rRGeVWr1Xj16hUKFiyYKyeHIyIiMkZCCLx9+xaFCxdOMeBvVuSqRCgsLAyFChXSKkueFysmJibVIcBnzZqVoXlWiIiIKOd7+PBhpibHTUuuSoQyY+zYsRgxYoRmWaVSoWjRonj48CHs7OxkjIzoHSGA6Gi5o5BERwM5ZFJwIjJyrbEDB/ApYmGFChUicP26O2xtbfV6jFyVCLm4uCA8PFyrLDw8HHZ2dmlOCGdubg5zc/MU5XZ2dkyE8oCclEBklhBAgwZAFqeSMojwcOD/88gSEWWfqCgoRwyE2Ya1SOjZB/FLViAxEXBwSH+euczIVYlQnTp1sGfPHq2yAwcOaE3+RnlDRhKcnJxA5AX16gFOTgCb0hFRtrp6FejUCbhxAzAxgVmJojCzEoh4a5jDyZoIRUZGas3iGxISguDgYBQoUABFixbF2LFj8fjxY6xbtw4A8O2332LJkiX4/vvv8fXXX+Pw4cPYtGlTiplxKXf5MOkx1gTH0xM4cSLnJB5WVjknFiIyAkIAq1cDgwcDMTGAqyvw+++AgacRkjUR+vfff9GkSRPNcnJbHj8/PwQEBODp06d48OCB5v7ixYtj9+7dGD58OBYvXowiRYpg5cqV8PHxyfbYST+EAOrXB06fzvw+cloCkVlMPIjIaEVGAt9+CyRPn9K8ObB+PeDsbPBD55hxhLJLREQE7O3toVKp2EbIgDLadicqCvigI6BGRhMcJhBERLnco0fSh/6bN8D06cD33wMfdJE31Pd3rmojRIalr4bHmb209WHDXCY4RERGokgRYONGwNJSukyQjZgIGYHc0PCYDXOJiIxIRATQrx/QuTOQPKPEp5/KEgoToTxOrQa8vORJcHRpu8PaHyIiI3H+PODrC9y7Bxw5IrUHsrKSLRwmQnmUEFL7m+rVgTt3Mr6dPhseM7khIiINIYAlS4CRI4H4eKBYMSAwUNYkCGAilCel1hOrdGngwgU2PCYiIhm8eQP07g1s2yYtt2kjdZXPn1/OqAAwEcpTktsCRUVpJ0GenlJNpB7nqCMiIsqYN2+AatWA0FDAzAyYN08aKyiH/OrmV2MekVwLZGOj3R09PFyqCWISREREsnBwAFq2BEqUkH6lDxmSY5IggDVCuV5atUAAe2IREZFMXr4EEhPf/TJfsACIiwPs7eWNKxWsJ8jF0qsFiozMG6MtExFRLnP6tHQprEsXIClJKrOwyJFJEMBEKFeLjk67FsjamkkQERFlI7UamDMHaNgQePhQuj19KndUH8VLY3lE8qjM7PVFRETZ7vlzwM8P2LtXWu7SBfj1V8DWVt64MoCJUA72sRGho6Le/W9trT09BRERUbY4cUIaIfrJE+kS2I8/An365Jpf5UyEZJReoiP3lBdEREQflZQEDBggJUHlygGbNgGVK8sdlU6YCMkktUEPM6tePdkH5iQiImNkaipNlrp4MbBwodR7J5dRCCGE3EFkp4iICNjb20OlUsHOzk62OKKiMvZ6yciUF2wXRERE2ebwYWnupm++ydbDGur7mzVC2ez9cX+SJTd0Tg2THCIiyhGSkoCpU4Fp06SaIC8voEYNuaPKMiZC2Sity2Fs6ExERDnakydAt27A0aPScs+eQIUKckakN0yEsokQUu/C1Mb9YfseIiLKsfbvB7p3l77EbGykbvFdu8odld5wQMVskFwTxNGfiYgoV5k8GWjRQkqCqlaVZvDOQ0kQwEQoW3w4AjRHfyYiolzBwUH6++23wN9/A2XKyBqOIfDSWDYLD+dEqERElINFRb1ruDp0qDRvWKNG8sZkQKwRMjAhUo4AzSSIiIhynIQEYNQooHp14O1bqUyhyNNJEMBEyKBSaxtERESU4/z3nzRZ6rx5wO3bwB9/yB1RtmEiZEBRUSnbBrGHGBER5Sg7dkij9/79N2BvD2zdKvUSMxJsI5RJH5sQVQipdjEZ2wYREVGOEh8PfP+9ND0GANSqBQQGAsWLyxtXNmMilAm6zhPm6ckkiIiIcpjRo98lQd99B8ycCSiV8sYkA14ay4QPu8Onx9NTGnaBSRAREeUoY8YAFSsCO3dKbYOMMAkCWCOUZenNEwZwrjAiIsohYmOB7duBLl2k5UKFgMuXARPjrhNhIpRFnCeMiIhyvDt3gE6dgOBgaTk5GTLyJAjgpTEiIqK8beNGqfdOcDDg6AgUKCB3RDkKEyEiIqK8KCYG6NdPmhssMlIaJyg4GPDxkTuyHIWJEBERUV5z8yZQuzawYoXUUHXCBODQIcDNTe7Ichy2EcoEIeSOgIiIKB337gFXrgDOzsCGDYC3t9wR5VhMhHQkBNCggdxREBERpaNVK6k2qFUrwNVV7mhyNF4a01F09LtG956enDKDiIhygGvXpF/p//33rqxPHyZBGcBESAcfziR/4gTHCCIiIhkJAaxeDdSsCZw8CQwbJndEuQ4ToQxKbSZ5JkFERCSbyEhpctTevaUeYs2bA7/+KndUuQ4ToQz6cFoNziRPRESyuXQJ8PKSGkKbmkrzhO3dKzWOJp2wsXQmcCZ5IiKSzYkTwKefAnFxUnf4wEDpkgVlChOhTLC2ZhJEREQyqVkTKFdOSoLWrpVGi6ZMYyKUQRw7iIiIZHPjBlCmjHQZzMICOHhQmiqDc4VlGZ/BDODYQUREJAshgCVLpPFaZsx4V+7oyCRIT1gjlAEcO4iIiLLdmzdSj7Bt26TlS5cAtZoJkJ7x2dQRxw4iIiKDO3sWqFZNSoLMzIBFi4AtW5gEGQBrhFIhhFQLlOz9QRSZBBERkcEIISU9o0cDCQlA8eJAUJDUQJoMgqnlB5IHTrSxeXd7fxBFIiIigwkJAcaNk5Kg9u2BCxeYBBkYa4Q+8OHAie/jIIpERGRQJUoAS5dKI0UPGMDLENmAiVA6wsOlMYOSWVnxNUlERHqkVgPz50tdkz/5RCr7+mt5YzIyTITSYW2tnQgRERHpzfPngJ+fNDVGsWLA1atSewzKVkyEiIiIstvx40CXLsCTJ9IAiePH85e3TNhYmoiIKLuo1dLAiE2aSElQ2bLAP/8Affuy7YVMWCNERESUHSIjgXbtgAMHpOXu3YGff+blMJkxESIiIsoO1taApaV0+/lnoGdPuSMiMBEiIiIynKQkID5eSn4UCmDNGiAsDKhQQe7I6P/YRgjSIIpRUe9uREREWfb0KeDtLbX/EUIqK1CASVAOY/Q1QskjSac1iCIREZHO/voL+OorqYu8tTVw/z5QsqTcUVEqjL5GKK2RpDmKNBER6SwxUeoK36KFlARVqQL8+y+ToBzM6GuE3vf+SNIcRZqIiHTy6BHQtStw4oS0/M03wMKFUvsgyrGYCL2HI0kTEVGmqNVAy5bS6NC2tsCKFYCvr9xRUQYY/aUxIiKiLDMxARYtAmrUkGaMZxKUazARIiIiyowHD6RG0cmaNZNGiS5VSr6YSGdMhIiIiHS1cyfg6Ql06ADcvfuu3IRfq7kNzxgREVFGxccDw4cDX34JvH4NlCsH5GNz29xM9kRo6dKl8PDwgIWFBWrXro2zZ8+mu/6iRYtQtmxZWFpawt3dHcOHD0dsbGw2RUtEREYrJEQaeG7RIml5+HDg5EnAw0POqCiLZE2EgoKCMGLECPj7++PChQuoWrUqfHx88OzZs1TX//333zFmzBj4+/vjxo0bWLVqFYKCgjBu3LhMx5A82CcREVGatm4FqlUDzp0D8ucHduwAFiwAlEq5I6MskjURWrBgAfr27YtevXqhQoUKWLZsGaysrLB69epU1z99+jTq1auHrl27wsPDA82bN0eXLl0+WouUFiGABg2y8giIiMgonD4NqFRAnTpAcDDwxRdyR0R6IlsiFB8fj/Pnz8Pb2/tdMCYm8Pb2xpkzZ1Ldpm7dujh//rwm8bl//z727NmDzz77LM3jxMXFISIiQuuWLDpaej0DUps3jiRNREQa718ymDULWLwYOHYMKFpUvphI72RLhF68eIGkpCQUKlRIq7xQoUIICwtLdZuuXbti6tSpqF+/PszMzFCyZEk0btw43Utjs2bNgr29vebm7u6e6nonTnAkaSIi+r/AQOCzz4CEBGlZqQSGDAHMzOSNi/RO9sbSujh69ChmzpyJn3/+GRcuXMC2bduwe/duTJs2Lc1txo4dC5VKpbk9fPgw1fWYBBEREWJipKkxunQB9u2TRoimPE22Pn+Ojo4wNTVFeHi4Vnl4eDhcXFxS3WbixIno3r07+vTpAwCoXLkyoqKi0K9fP4wfPx4mqYzfYG5uDnNzc/0/ACIiyltu3QI6dQIuX5Z+HY8bB/TrJ3dUZGCy1QgplUp4eXnh0KFDmjK1Wo1Dhw6hTp06qW4THR2dItkxNTUFAAh2/yIiosz67TfAy0tKgpydgf37genTOUaQEZD1DI8YMQJ+fn6oUaMGatWqhUWLFiEqKgq9evUCAPTo0QNubm6YNWsWAKB169ZYsGABqlWrhtq1a+Pu3buYOHEiWrdurUmIiIiIdDJjBjBhgvR/kybAhg2Aq6u8MVG2kTUR8vX1xfPnzzFp0iSEhYXB09MT+/bt0zSgfvDggVYN0IQJE6BQKDBhwgQ8fvwYTk5OaN26NWbMmCHXQyAiotyuQwfghx+AESOkhIg/rI2KQhjZNaWIiAjY29tDpVLB1NQONjZSeWQkYG0tb2xERJQNhJAugVWt+q7s5UugYEH5YqKPev/7287OTm/7zVW9xoiIiLIkMhLo0QOoXl0aEygZkyCjxUSIiIiMw+XLQI0aUsNoALh6Vd54KEdgIkRERHmbEMDy5UCtWlIXeTc34OhRYOBAuSOjHID9AomIKO+KiJAGSAwMlJZbtgTWrQMcHeWNi3IM1ggREVHetWOHlASZmko9w3btYhJEWlgjREREeddXXwEXLwIdO0ozxxN9gDVCRESUd7x5AwwaBLx+LS0rFMCCBUyCKE2sESIiorzh3DnA1xcICQFevHjXLogoHawRIiKi3E0IYNEioF49KQkqXhz47ju5o6JcgjVCRESUe716BfTqBezcKS23bw+sXAk4OMgaFuUeTISIiCh3unIF+Pxz4MEDQKmU2gINGCC1CyLKICZCRESUOxUuLF0WK1kS2LRJmjaDSEdMhIiIKPd4+xawsZFqfQoWBPbuBdzdAT1OwknGxWgbSwsBREXJHQUREWXYiRNA+fJAQMC7sooVmQRRlhhtItS8OVCokNxREBHRR6nVwMyZQJMmwOPHwE8/AUlJckdFeYTRJkJnz777v149wMpKvliIiCgNz54BLVoA48dLyc9XXwHHj0tTZhDpgdG3EQoPB5yc2MmAiCjHOXIE6NoVCAsDLC2BJUukrvL8wCY9MvpEyNqa7ykiohznv/+kNgyJiUCFClKvsIoV5Y6K8iCjT4SIiCgHKlYMGDsWePRIahNkbS13RJRHMREiIqKc4eBBwMMDKFVKWp4yhVX2ZHBG21iaiIhyiMREYMIE6VKYry8QFyeVMwmibMAaISIiks/jx0CXLtIYQQBQs6Y00BtRNmEiRERE8ti7F+jRA3jxArC1BZYvBzp3ljsqMjK8NEZERNkrIQEYPRr47DMpCapWDTh/nkkQyYKJEBERZS8hpDGCAGDgQOD0aaB0aXljIqPFS2NERJQ9hJAaQCuVQFAQcOEC0L693FGRkWMiREREhhUfD4wZA1hYSHOGAUDx4tKNSGZMhIiIyHBCQqS2P2fPSrVBPXoA5crJHRWRBtsIERGRYWzbJjWEPnsWcHAAtm9nEkQ5DhMhIiLSr7g4YPBgqf2PSgV88gkQHAx8+aXckRGlwEtjRESkP0JII0QfPy4tf/89MH06YGYmb1xEaTDqRKhePcDKSu4oiIjyEIUC6NMHuHYNWLdOGiuIKAdTCGFcY5lHRETA3t4ed++qUKKEHaeyISLKqpgYIDQUKF/+XdmrV0CBArKFRHlP8ve3SqWCnZ2d3vZrtG2ErKw4nx8RUZbduiW1AfL2Bp4/f1fOJIhyCaNNhIiIKIt++w3w8gIuX5amzQgJkTsiIp0xESIiIt1ERwO9ewPduwNRUUDjxlKvsFq15I6MSGdMhIiIKOOuX5cSntWrpfYF/v7AwYNA4cJyR0aUKUbda4yIiHQ0Z47UI8zFBdiwAWjaVO6IiLKEiRAREWXcjz8C+fJJc4YVKiR3NERZxktjRESUtitXgFGjpIESAcDeHli1ikkQ5RmsESIiopSEAFauBIYMAWJjgbJlpYESifIYJkJERKQtIgL45hsgMFBabtmS84RRnsVLY0RE9M7Fi9LYQIGBgKmp1Dh61y7AyUnuyIgMIks1QrGxsbCwsNBXLEREJKf166XLX/HxgLu7lAzVrSt3VEQGpXONkFqtxrRp0+Dm5gYbGxvcv38fADBx4kSsWrVK7wESEVE2KV4cSEoCWreWBkhkEkRGQOdEaPr06QgICMAPP/wApVKpKa9UqRJWrlyp1+CIiMjAVKp3/9evD5w5A+zYwbnCyGjonAitW7cOy5cvR7du3WBqaqopr1q1Km7evKnX4IiIyECEABYvBjw8pNGik9WsyRmpyajonAg9fvwYpUqVSlGuVquRkJCgl6CIiMiAXr0C2rYFhg0D3rwBAgJkDohIPjonQhUqVMCJEydSlG/ZsgXVqlXTS1BERGQgf/8NVKsmXf5SKoGffpJ6hhEZKZ17jU2aNAl+fn54/Pgx1Go1tm3bhlu3bmHdunXYtWuXIWIkIqKsUquBBQuAsWOBxESgZEkgKEjqKk9kxHSuEfryyy/x559/4uDBg7C2tsakSZNw48YN/Pnnn/j0008NESMREWXVb79JU2UkJgKdOgHnzzMJIgKgECJ5AhnjEBERAXt7ezx5ooKrq53c4RARZY/ERKBVK6lt0DffsEE05TrJ398qlQp2dvr7/ta5RqhEiRJ4+fJlivI3b96gRIkSegmKiIiySK2W5gqLi5OW8+UD9u0Dvv2WSRDRe3ROhEJDQ5GUlJSiPC4uDo8fP9ZLUERElAXPnknzg/XtC4we/a6cCRBRChluLL1z507N//v374e9vb1mOSkpCYcOHYKHh4degyMiIh0dPQp07Qo8fQpYWgJVqsgdEVGOluFEqE2bNgAAhUIBPz8/rfvMzMzg4eGB+fPn6zU4IiLKoKQkYMYMYMoU6bJY+fLA5s1AxYpyR0aUo2U4EVKr1QCA4sWL49y5c3B0dDRYUEREpIOwMKBbN+DwYWm5Vy9pfCBra3njIsoFdB5HKCQkxBBxEBFRZkVHA//+C1hZAcuWAd27yx0RUa6hcyIEAFFRUTh27BgePHiA+Ph4rfuGDBmil8CIiCgdQrxr/FyiBLBpE1CsGFCunLxxEeUyOidCFy9exGeffYbo6GhERUWhQIECePHiBaysrODs7MxEiIjI0B4/Br76SholunlzqczHR96YiHIpnbvPDx8+HK1bt8br169haWmJv//+G//99x+8vLwwb948Q8RIRETJ9u0DPD2l3mEDBkgDJRJRpumcCAUHB+O7776DiYkJTE1NERcXB3d3d/zwww8YN26cIWIkIqKEBGDMGGl8oBcvpGRozx5poEQiyjSdEyEzMzOYmEibOTs748GDBwAAe3t7PHz4UL/RERER8PAh0Ljxu1niBwwAzpwBypSRNSyivEDnRKhatWo4d+4cAKBRo0aYNGkSNmzYgGHDhqFSpUo6B7B06VJ4eHjAwsICtWvXxtmzZ9Nd/82bNxg4cCBcXV1hbm6OMmXKYM+ePTofl4goV3j8WKr9OX0asLOTxgZauhSwsJA7MqI8QedEaObMmXB1dQUAzJgxA/nz50f//v3x/Plz/PrrrzrtKygoCCNGjIC/vz8uXLiAqlWrwsfHB8+ePUt1/fj4eHz66acIDQ3Fli1bcOvWLaxYsQJubm66PgwiotzBzQ1o3RqoUQO4eBHo0EHuiIjyFFlnn69duzZq1qyJJUuWAJAGbXR3d8fgwYMxZsyYFOsvW7YMc+fOxc2bN2FmZpapY3L2eSLK8UJDARsbIHng2uhowNQUMDeXNSwiOeWY2efTcuHCBXz++ecZXj8+Ph7nz5+Ht7f3u2BMTODt7Y0zZ86kus3OnTtRp04dDBw4EIUKFUKlSpUwc+bMVCeBTRYXF4eIiAitGxFRjrV9u3QpzM9PmioDkAZKZBJEZBA6JUL79+/HyJEjMW7cONy/fx8AcPPmTbRp0wY1a9bUTMORES9evEBSUhIKFSqkVV6oUCGEhYWlus39+/exZcsWJCUlYc+ePZg4cSLmz5+P6dOnp3mcWbNmwd7eXnNzd3fPcIxERNkmLg4YMgRo1w5QqYCXL6W/RGRQGU6EVq1ahZYtWyIgIABz5szBJ598gt9++w116tSBi4sLrl69avBGy2q1Gs7Ozli+fDm8vLzg6+uL8ePHY9myZWluM3bsWKhUKs2NPduIKMe5dw+oV0+aHwwARo4ETpwA8ueXNy4iI5DhASgWL16MOXPmYNSoUdi6dSs6duyIn3/+GVeuXEGRIkV0PrCjoyNMTU0RHh6uVR4eHg4XF5dUt3F1dYWZmRlMTU01ZeXLl0dYWBji4+OhVCpTbGNubg5zVikTUU61aRPQpw/w9i1QsCCwdi3QqpXcUREZjQzXCN27dw8dO3YEALRr1w758uXD3LlzM5UEAYBSqYSXlxcOHTqkKVOr1Th06BDq1KmT6jb16tXD3bt3tS7B3b59G66urqkmQUREOVpsrDRNxtu3Uo1QcDCTIKJsluFEKCYmBlZWVgAAhUIBc3NzTTf6zBoxYgRWrFiBtWvX4saNG+jfvz+ioqLQq1cvAECPHj0wduxYzfr9+/fHq1evMHToUNy+fRu7d+/GzJkzMXDgwCzFQUQkCwsLICgIGDdOmjIjkz8siSjzdBqbfeXKlbCxsQEAJCYmIiAgAI7J3Tv/T5dJV319ffH8+XNMmjQJYWFh8PT0xL59+zQNqB88eKAZxRoA3N3dsX//fgwfPhxVqlSBm5sbhg4ditGjR+vyMIiI5PP771J3+D59pOUaNaQbEckiw+MIeXh4QKFQpL8zhULTmyyn4jhCRCSL6Ghg6FBg5UpAqZQug5UvL3dURLmGocYRynCNUGhoqN4OSkRkVG7cADp1Aq5eBRQKqV0Q5wkjyhE4bTERkSGtXStNkhodDRQqJF0aa9pU7qiI6P+YCBERGYIQQN++wKpV0rK3N/Dbb1IyREQ5ht6m2CAiovcoFECJEoCJCTBtGrBvH5MgohyINUJERPoihDQthoODtDxmDNCiBVC9uqxhEVHaWCNERKQPb98C3boBDRpI7YEAqTaISRBRjpapROjevXuYMGECunTpgmfPngEA9u7di2vXruk1OCKiXCE4GPDyAjZulHqIHT8ud0RElEE6J0LHjh1D5cqV8c8//2Dbtm2IjIwEAFy6dAn+/v56D5CIKMcSAvjlF+CTT4A7dwB3dykJatFC7siIKIN0ToTGjBmD6dOn48CBA1rzezVt2hR///23XoMjIsqxVCrA11fqGh8XB7RuDVy8CNStK3dkRKQDnROhK1euoG3btinKnZ2d8eLFC70ERUSU4w0aBGzeDOTLB8yfD+zYIc0eT0S5is6JkIODA54+fZqi/OLFi3Bzc9NLUEREOd6sWVK7oJMngREjpO7yRJTr6JwIde7cGaNHj0ZYWBgUCgXUajVOnTqFkSNHokePHoaIkYhIfq9fS6NEJytSBDh3DqhdW76YiCjLdE6EZs6ciXLlysHd3R2RkZGoUKECGjZsiLp162LChAmGiJGISF7//ANUqwb07CldAkvGWiCiXE/nARWVSiVWrFiBiRMn4urVq4iMjES1atVQunRpQ8RHRCQfIYAFC6SBERMTgZIlpZogIsozdE6ETp48ifr166No0aIoWrSoIWIiIpLfy5dSDdCuXdJyp07AihWAnZ2sYRGRful8aaxp06YoXrw4xo0bh+vXrxsiJiIieZ06BXh6SkmQubk0VlBgIJMgojxI50ToyZMn+O6773Ds2DFUqlQJnp6emDt3Lh49emSI+IiIst+TJ8CjR0Dp0sDffwPffsv2QER5lEIIITK7cUhICH7//Xds3LgRN2/eRMOGDXH48GF9xqd3ERERsLe3x5MnKri68tcdEf2fENrJztq1QLt2gK2tfDERkUby97dKpYKdHmtnszTpavHixTFmzBjMnj0blStXxrFjx/QVFxFR9jl2TBoT6P0x0vz8mAQRGYFMJ0KnTp3CgAED4Orqiq5du6JSpUrYvXu3PmMjIjKspCRg2jSgaVNpeoxJk+SOiIiymc69xsaOHYvAwEA8efIEn376KRYvXowvv/wSVlZWhoiPiMgwwsKAr74CDh2Slnv2BBYtkjMiIpKBzonQ8ePHMWrUKHTq1AmOjo6GiImIyLAOHQK6dQPCwwErK6lXGEfGJzJKOidCp06dMkQcRETZY/t2oH17qXF0pUrApk1A+fJyR0VEMslQIrRz5060bNkSZmZm2LlzZ7rrfvHFF3oJjIjIID79FChbFmjQAFi8GLC0lDsiIpJRhrrPm5iYICwsDM7OzjAxSbt9tUKhQFJSkl4D1Dd2nycyQufOSb3Ckj+/VCrA3l7emIhIJ7J2n1er1XB2dtb8n9YtpydBRGRkEhOBsWOBWrWkOcOSMQkiov/Tufv8unXrEBcXl6I8Pj4e69at00tQRERZ9vAh0LgxMHu2tMzR74koFTqPLG1qaoqnT59qaoiSvXz5Es7Ozjm+VoiXxoiMwO7dUi+wV6+k+cFWrQI6dJA7KiLKghwzsrQQAopU5tx59OgR7FndTERyio8HRo4EPv9cSoJq1JAGSmQSRERpyHD3+WrVqkGhUEChUKBZs2bIl+/dpklJSQgJCUGLFi0MEiQRUYbcuAH8+KP0/9ChwJw50uzxRERpyHAi1KZNGwBAcHAwfHx8YGNjo7lPqVTCw8MD7du313uAREQZVrUqsGQJ4OwM/P8zi4goPTq3EVq7di18fX1hYWFhqJgMim2EiPKQuDhg3Dige3fA01PuaIjIgAzVRkjnkaX9/Pz0dnAioky7dw/w9QXOnwd27QKuXgXMzOSOiohymQwlQgUKFMDt27fh6OiI/Pnzp9pYOtmrV6/0FhwRUao2bwb69AEiIoACBaQxgpgEEVEmZCgRWrhwIWxtbTX/p5cIEREZTGwsMGKENEkqANSrB2zcCLi7yxsXEeVaOrcRyu3YRogol3r+HGjeHAgOlpbHjgWmTgXy6XyFn4hyoRwzjtCFCxdw5coVzfKOHTvQpk0bjBs3DvHx8XoLjIhIS4ECgKMj4OQE7NsHzJzJJIiIskznROibb77B7du3AQD379+Hr68vrKyssHnzZnz//fd6D5CIjFh0NBATI/1vagps2CDVCPn4yBoWEeUdOidCt2/fhuf/u6lu3rwZjRo1wu+//46AgABs3bpV3/ERkbG6cQOoXRsYNuxdmbMzULiwbCERUd6TqSk21Go1AODgwYP47LPPAADu7u548eKFfqMjIuO0dq00PcbVq8COHVL7ICIiA9A5EapRowamT5+O9evX49ixY2jVqhUAICQkBIUKFdJ7gERkRKKigJ49pVt0NNCsmXQpzMlJ5sCIKK/SORFatGgRLly4gEGDBmH8+PEoVaoUAGDLli2oW7eu3gMkIiNx9SpQs6ZUG2RiAkybBuzfD7i4yB0ZEeVheus+HxsbC1NTU5jl8EHN2H2eKAeKjwdKlgQePZLaAP3+O9CokdxREVEOkmOm2Eh2/vx53LhxAwBQoUIFVK9eXW9BEZGRUSqBZcuApUulGiFeCiOibKJzIvTs2TP4+vri2LFjcHBwAAC8efMGTZo0QWBgIJz4AUZEGXHpEvDsGfDpp9Jyq1bAZ58BHLmeiLKRzm2EBg8ejMjISFy7dg2vXr3Cq1evcPXqVURERGDIkCGGiJGI8hIhpNqf2rWlSVMfPHh3H5MgIspmOtcI7du3DwcPHkT58uU1ZRUqVMDSpUvRvHlzvQZHRHmMSgX06wds2iQtf/opYG0tb0xEZNR0rhFSq9WpNog2MzPTjC9ERJTC+fNA9epSEpQvHzB/PrBzJ1CwoNyREZER0zkRatq0KYYOHYonT55oyh4/fozhw4ejWbNmeg2OiPKIn34C6tYF7t8HihUDTp6UZpHnpTAikpnOidCSJUsQEREBDw8PlCxZEiVLlkTx4sURERGBn376yRAxElFud+2a1EW+TRvg4kWpfRARUQ6gcxshd3d3XLhwAYcOHdJ0ny9fvjy8vb31HhwR5WJCvKvxWbhQqhHq3p21QESUo+iUCAUFBWHnzp2Ij49Hs2bNMHjwYEPFRUS5lRBS4nPgALBrlzRrvKUl0KOH3JEREaWQ4UTol19+wcCBA1G6dGlYWlpi27ZtuHfvHubOnWvI+IgoN3n5UponbNcuaXnbNqBjR1lDIiJKT4bbCC1ZsgT+/v64desWgoODsXbtWvz888+GjI2IcpPTp4Fq1aQkyNwc+OUXoEMHuaMiIkpXhhOh+/fvw8/PT7PctWtXJCYm4unTpwYJjIhyCbUamDMHaNgQePgQKF0a+Ptv4Ntv2R6IiHK8DCdCcXFxsH5v4DMTExMolUrExMQYJDAiyiWGDAHGjAGSkoCuXaXxgjw95Y6KiChDdGosPXHiRFhZWWmW4+PjMWPGDNjb22vKFixYoL/oiCjn69cP2LgR+OEH4OuvWQtERLlKhhOhhg0b4tatW1pldevWxf379zXLCn4AEuV9SUnAv/++GwuoShUgNBSwtZU1LCKizMhwInT06FEDhkFEuUJ4OPDVV8DRo9Lo0MnJEJMgIsqldB5ZmoiM1OHDQNWqwMGDgFIJPHokd0RERFnGRIiI0peUBPj7A97eUo1QpUrSpbH27eWOjIgoy3SeYoOIjMiTJ0C3btKlMADo0wdYvBh4r9MEEVFuxkSIiNK2bZuUBNnYAL/+KnWPJyLKQ3LEpbGlS5fCw8MDFhYWqF27Ns6ePZuh7QIDA6FQKNCmTRvDBkhkrAYOBEaOlMYGYhJERHlQphKhEydO4KuvvkKdOnXw+PFjAMD69etx8uRJnfcVFBSEESNGwN/fHxcuXEDVqlXh4+ODZ8+epbtdaGgoRo4ciQYNGmTmIRBRah49kuYKe/tWWlYogLlzgTJlZA2LiMhQdE6Etm7dCh8fH1haWuLixYuIi4sDAKhUKsycOVPnABYsWIC+ffuiV69eqFChApYtWwYrKyusXr06zW2SkpLQrVs3TJkyBSVKlND5mESUit27pRGh164FvvtO7miIiLKFzonQ9OnTsWzZMqxYsQJmZmaa8nr16uHChQs67Ss+Ph7nz5+Ht7f3u4BMTODt7Y0zZ86kud3UqVPh7OyM3r17f/QYcXFxiIiI0LoR0XsSEoBRo4DPP5dmj/fyAkaPljsqIqJsoXMidOvWLTRs2DBFub29Pd68eaPTvl68eIGkpCQUKlRIq7xQoUIICwtLdZuTJ09i1apVWLFiRYaOMWvWLNjb22tu7u7uOsVIlKf99580Weq8edLykCHAqVNAyZLyxkVElE10ToRcXFxw9+7dFOUnT540+GWqt2/fonv37lixYgUcHR0ztM3YsWOhUqk0t4cPHxo0RqJc48QJ6VLY338DDg7A9u1S13hzc7kjIyLKNjp3n+/bty+GDh2K1atXQ6FQ4MmTJzhz5gxGjhyJiRMn6rQvR0dHmJqaIjw8XKs8PDwcLi4uKda/d+8eQkND0bp1a02ZWq2WHki+fLh16xZKfvBL1tzcHOb8YCdKqXRpKempXRsIDAQ8POSOiIgo2+mcCI0ZMwZqtRrNmjVDdHQ0GjZsCHNzc4wcORKDBw/WaV9KpRJeXl44dOiQpgu8Wq3GoUOHMGjQoBTrlytXDleuXNEqmzBhAt6+fYvFixfzshfRx7x8CRQsKP3v4iKNEVSihDRlBhGREdI5EVIoFBg/fjxGjRqFu3fvIjIyEhUqVICNjU2mAhgxYgT8/PxQo0YN1KpVC4sWLUJUVBR69eoFAOjRowfc3Nwwa9YsWFhYoFKlSlrbOzg4AECKciL6wJYtQO/ewPLlgK+vVFaunLwxERHJLNMjSyuVSlSoUCHLAfj6+uL58+eYNGkSwsLC4OnpiX379mkaUD948AAmJjli3Eei3Ck2VuoO//PP0vLatUCnTtIYQURERk4hhBC6bNCkSRMo0vkAPXz4cJaDMqSIiAjY29vjyRMVXF3t5A6HyLDu3JGSnuBgaXnMGGDqVOC9oS+IiHKD5O9vlUoFOzv9fX/rXCPk6emptZyQkIDg4GBcvXoVfn5++oqLiLJq40agXz8gMhJwdATWrwdatJA7KiKiHEXnRGjhwoWplk+ePBmRkZFZDoiI9ODy5XdzgzVsCPz+O+DmJm9MREQ5kM6XxtJy9+5d1KpVC69evdLH7gyGl8bIaIwaBVhaApMmAfky3RyQiChHyDGXxtJy5swZWFhY6Gt3RKSrDRuABg2AokWl5R9+YINoIqKP0DkRateundayEAJPnz7Fv//+q/OAikSkB1FRwODBwJo1QN260thAZmZMgoiIMkDnRMje3l5r2cTEBGXLlsXUqVPRvHlzvQVGRBlw7ZrUK+z6dcDEBPDxkf4SEVGG6JQIJSUloVevXqhcuTLy589vqJiI6GOEkGqABg0CYmIAV1epQXTjxnJHRkSUq+j009HU1BTNmzfXeZZ5ItKjqCigRw9plOiYGKkWKDiYSRARUSboXIdeqVIl3L9/3xCxEFFGmJhI3eNNTYFZs4A9ewBnZ7mjIiLKlXRuIzR9+nSMHDkS06ZNg5eXF6ytrbXu12eXNiL6PyGkm4mJ1CV+0ybg+XOgfn25IyMiytUyPI7Q1KlT8d1338HW1vbdxu/1ShFCQKFQICkpSf9R6hHHEaJcR6WSRoiuXBmYMEHuaIiIZGGocYQynAiZmpri6dOnuHHjRrrrNWrUSC+BGQoTIcpVzp+XZoq/dw+wsADu35caRhMRGRnZB1RMzpdyeqJDlCcIASxZAowcCcTHA8WKAYGBTIKIiPRMpzZC6c06T0R68uaN1CNs2zZpuU0bYPVqgENWEBHpnU6JUJkyZT6aDOX0ucaIcrTERGl06Bs3pNGh582TRo3mjxAiIoPQKRGaMmVKipGliUiP8uUDhg6V5gkLCgJq1JA7IiKiPC3DjaVNTEwQFhYG51w+XgkbS1OO8+oV8PQpULGitCwEEB0NfDA0BRGRMTNUY+kMD6jI9kFEBnD6NODpCXz+udQ2CJAugzEJIiLKFhlOhDJYcUREGaFWA3PmAA0bAg8fSu2Bnj2TOyoiIqOT4TZCarXakHEQGY/nzwE/P2DvXmm5Sxfg11+B9wYrJSKi7KHzFBtElAXHj0uJz5Mn0gCJP/0kdZXnpWciIlkwESLKTgsWSElQuXLSfGGVK8sdERGRUWMiRJSdVq0CSpQApk4FbGzkjoaIyOhluLE0EWXC4cPAd99JXeIBoGBBqVaISRARUY7AGiEiQ0hKkmp9pk2TkqDatYFOneSOioiIPsBEiEjfnjwBunUDjh6Vlnv3lsYJIiKiHIeJEJE+/fUX8NVXUhd5a2upW3y3bnJHRUREaWAbISJ9mTsXaNFCSoKqVgUuXGASRESUwzERItKXatWkv/37A3//DZQpI288RET0Ubw0RpQVz54ByRMRe3sDV668mzyViIhyPNYIEWVGQgIwapRU63Pv3rtyJkFERLkKEyEiXf33H9CgATBvHqBSAX/+KXdERESUSbw0RqSLP/4AevUC3rwB7O2B1auBdu3kjoqIiDKJNUJEGREfDwwbBrRtKyVBtWoBFy8yCSIiyuWYCBFlxJIlwOLF0v8jRgAnTgDFi8sbExERZRkvjRFlxKBBwIEDwIABQOvWckdDRER6whohotTExkqToyYkSMtKJbB3L5MgIqI8hjVCRB+6cwfw9ZXaAD1/DsyaJXdERERkIKwRInpfYCBQvbqUBDk6Ag0byh0REREZEBMhIgCIiQG++Qbo0gWIjJTGCQoOBlq2lDsyIiIyICZCRLdvA7VrA8uXAwoFMGECcPgw4OYmd2RERGRgbCNEpFYD9+9Lc4Zt2CDNGUZEREaBiRAZJ7UaMPl/hWi5csC2bUDlyoCrq7xxERFRtuKlMTI+164Bnp7A8ePvypo3ZxJERGSEmAiR8RACWLUKqFkTuHIF+O47qYyIiIwWEyEyDm/fAt27A336SD3EmjcHdu+WGkcTEZHRYiJEed+lS0CNGlJDaFNTYOZMaZRoZ2e5IyMiIpmxsTTlbTduSF3j4+Kk7vCBgUD9+nJHRUREOQQTIcrbypUDvvgCiIoC1q6VRosmIiL6PyZClPdcvAgULw44OEhtgNauBczN33WXJyIi+j9+M1DeIQSwZAnwySdSo+jkHmGWlkyCiIgoVawRorzhzRugd29pYEQASEwEYmOlJIiIiCgN/JlMud/Zs0C1alISZGYGLFoEbN/OJIiIiD6KiRDlXkIACxdKvcBCQ6V2QadOAUOHcnwgIiLKECZClHupVMCCBUBCAtC+PXDhgjRqNBERUQaxjRDlXg4OwMaN0oCJAwawFoiIiHTGRIhyD7UamDcPcHEBevSQyurX5wCJRESUaUyEKHd4/hzw85OmxrCyApo0Adzd5Y6KiIhyOSZClPOdOAF07gw8eQJYWEi9wooUkTsqIiLKA9hYmnIutRqYMQNo3FhKgsqWBf75B+jbl+2BiIhIL1gjRDlTUhLQqhWwf7+03L078PPPgI2NvHEREVGewhohyplMTYEaNaT2QGvWAOvWMQkiIiK9YyJEOUdSktQoOtnkyUBwMNCzp0wBERFRXpcjEqGlS5fCw8MDFhYWqF27Ns6ePZvmuitWrECDBg2QP39+5M+fH97e3umuT7nE06fAp58CLVsCcXFSWb58QOnS8sZFRER5muyJUFBQEEaMGAF/f39cuHABVatWhY+PD549e5bq+kePHkWXLl1w5MgRnDlzBu7u7mjevDkeP36czZGT3vz1F1C1KnDkCHDzpjRAIhERUTZQCCGEnAHUrl0bNWvWxJIlSwAAarUa7u7uGDx4MMaMGfPR7ZOSkpA/f34sWbIEPZIH2UtHREQE7O3t8eSJCq6udlmOn7IgMRHw9wdmzZLmDatSBdi0SeodRkRE9J7k72+VSgU7O/19f8taIxQfH4/z58/D29tbU2ZiYgJvb2+cOXMmQ/uIjo5GQkICChQokOr9cXFxiIiI0LpRDvDoEdC0KTBzppQEffMN8PffTIKIiChbyZoIvXjxAklJSShUqJBWeaFChRAWFpahfYwePRqFCxfWSqbeN2vWLNjb22tu7hyNOGfo21caKNHWFggMBJYtAywt5Y6KiIiMjOxthLJi9uzZCAwMxPbt22FhYZHqOmPHjoVKpdLcHj58mM1RUqqWLpWmybhwAfD1lTsaIiIyUrIOqOjo6AhTU1OEh4drlYeHh8PFxSXdbefNm4fZs2fj4MGDqFKlSprrmZubw9zcXC/xUhY8eCA1iu7TR1ouUQI4fFjemIiIyOjJWiOkVCrh5eWFQ4cOacrUajUOHTqEOnXqpLndDz/8gGnTpmHfvn2oUaNGdoRKWbFzJ+DpCfTrJyVDREREOYTsU2yMGDECfn5+qFGjBmrVqoVFixYhKioKvXr1AgD06NEDbm5umDVrFgBgzpw5mDRpEn7//Xd4eHho2hLZ2NjAhiMP5yzx8cDo0dIkqQBQsybHBSIiohxF9kTI19cXz58/x6RJkxAWFgZPT0/s27dP04D6wYMHMDF5V3H1yy+/ID4+Hh06dNDaj7+/PyZPnpydoVN6QkKktj/nzknLw4cDs2cDSqW8cREREb1H9nGEshvHEcoGf/whTYuhUgH58wMBAcAXX8gcFBER5WaGGkdI9hohyoMiIqQkqE4dqWt80aJyR0RERJQqJkKkH0lJ0ozxANCjB2BhAbRtC5iZyRsXERFROnL1OEKUQwQGApUrAy9evCvr1IlJEBER5XhMhCjzYmKkqTG6dAFu3AAWLJA7IiIiIp3w0hhlzs2bUq3PlSuAQgGMGwew1x4REeUyTIRId+vXA/37A1FRgLMz8NtvwKefyh0VERGRzpgIkW5+/RX49lvp/yZNgA0bAFdXeWMiIiLKJLYRIt107gyUKiVdBjtwgEkQERHlaqwRovQJIU2O2rSp1BbI3h64fBmwtJQ7MiIioixjjRClLTIS8PMDvL2BZcvelTMJIiKiPII1QpS6y5elXmG3bgEmJlLDaCIiojyGiRBpEwJYvhwYOhSIiwPc3ICNG4EGDeSOjIiISO+YCNE7ERFAv35AUJC03LIlsG4d4Ogob1xEREQGwjZC9M7Vq8DmzdKcYT/8AOzaxSSIiIjyNNYI0Tt16wJLlgCentLM8URERHkca4SM2Zs3QPfu0jxhyfr3ZxJERERGgzVCxurcOcDXFwgJAa5fB/79VxoniIiIyIiwRsjYCAEsWgTUqyclQR4e0hhBTIKIiMgIsUbImLx6BfTqBezcKS23awesWgU4OMgaFhERkVyYCBmLkBCgcWPgwQNAqQQWLAAGDGBNEBERGTUmQsbC3R0oWhQwMwM2bQKqV5c7IiIiItkxEcrLXr4EbG2lGqB8+aQxgqysADs7uSMjIiLKEdhYOq86cQKoWhUYPfpdmYsLkyAiIqL3MBHKa9RqYOZMoEkT4PFjYN8+TphKRESUBiZCecmzZ0CLFsD48UBSEvDVV9J4QdbWckdGRESUI7GNUF5x5AjQtSsQFgZYWgJLlwI9e7JXGBERUTqYCOUFERFA+/bA69dAhQpSr7CKFeWOioiIKMdjIpQX2NkBv/4K7N0L/PQTL4URERFlEBOh3OrgQcDEBGjaVFru2FG6ERERUYaxsXRuk5gITJgANG8OdOkCPH0qd0RERES5FmuEcpPHj6Xk58QJablNG84TRkRElAVMhHKLvXuBHj2AFy8AGxtgxQqgc2e5oyIiIsrVeGksp1OrpdGhP/tMSoKqVQMuXGASREREpAdMhHI6ExNpbCAAGDgQOH0aKF1a3piIiIjyCF4ay6kSE6WJUgFpcMSOHYHPP5c3JiIiA0tKSkJCQoLcYZBMzMzMYGpqmq3HZCKU08THA2PGAHfvAjt2SCND29gwCSKiPC8yMhKPHj2CEELuUEgmCoUCRYoUgY2NTbYdk4lQThISAvj6SvODAcDRo9LkqUREeVxSUhIePXoEKysrODk5QcHpgYyOEALPnz/Ho0ePULp06WyrGWIilFNs2wZ8/TWgUkld4gMCmAQRkdFISEiAEAJOTk6wtLSUOxySiZOTE0JDQ5GQkJBtiRAbS8stLg4YPFiaK0ylAj75BAgOBr78Uu7IiIiyHWuCjJsc55+JkNy6dQOWLJH+HzUKOH4cKFZM3piIiIiMBBMhuY0eDbi6Art2AT/8AJiZyR0RERGR0WAilN1iYoBjx94t16wJ3L8PtGolX0xERJQlZ86cgampKVql8ll+9OhRKBQKvHnzJsV9Hh4eWLRokVbZkSNH8Nlnn6FgwYKwsrJChQoV8N133+Hx48cGih6IjY3FwIEDUbBgQdjY2KB9+/YIDw9Pd5vw8HD07NkThQsXhpWVFVq0aIE7d+5orRMWFobu3bvDxcUF1tbWqF69OrZu3Wqwx5EZTISy061bUhsgHx+pHVAyCwvZQiIioqxbtWoVBg8ejOPHj+PJkyeZ3s+vv/4Kb29vuLi4YOvWrbh+/TqWLVsGlUqF+fPn6zFibcOHD8eff/6JzZs349ixY3jy5AnatWuX5vpCCLRp0wb379/Hjh07cPHiRRQrVgze3t6IiorSrNejRw/cunULO3fuxJUrV9CuXTt06tQJFy9eNNhj0ZkwMiqVSgAQT56osvfAv/0mhLW1EIAQTk5CHDmSvccnIsrBYmJixPXr10VMTIzcoejs7du3wsbGRty8eVP4+vqKGTNmaN1/5MgRAUC8fv06xbbFihUTCxcuFEII8fDhQ6FUKsWwYcNSPU5q2+vDmzdvhJmZmdi8ebOm7MaNGwKAOHPmTKrb3Lp1SwAQV69e1ZQlJSUJJycnsWLFCk2ZtbW1WLdunda2BQoU0Frnfem9DpK/v1Uq/X5/s0bI0KKjgT59gK++AqKigMaNpdqgxo1lDoyIKOcSQvrIlOOm63iOmzZtQrly5VC2bFl89dVXWL16daYGhdy8eTPi4+Px/fffp3q/g4NDmtu2bNkSNjY2ad4qVqyY5rbnz59HQkICvL29NWXlypVD0aJFcebMmVS3iYuLAwBYvHdFw8TEBObm5jh58qSmrG7duggKCsKrV6+gVqsRGBiI2NhYNM5B34EcR8iQrl8HOnUCrl2TRoieNAmYOBHI5uHDiYhym+hoaVB9OURGAtbWGV9/1apV+OqrrwAALVq0gEqlwrFjx3T+sr9z5w7s7Ozg6uqq03YAsHLlSsTExKR5v1k6HXHCwsKgVCpTJFqFChVCWPJclx9ITpTGjh2LX3/9FdbW1li4cCEePXqEp0+fatbbtGkTfH19UbBgQeTLlw9WVlbYvn07SpUqpdsDNCAmQoa0Y4eUBLm4ABs2AE2byh0RERHp0a1bt3D27Fls374dAJAvXz74+vpi1apVOidCQohMj6Pj5uaWqe0yy8zMDNu2bUPv3r1RoEABmJqawtvbGy1bttSqDZs4cSLevHmDgwcPwtHREX/88Qc6deqEEydOoHLlytkac1qYCBnS999L9ayDBwOFCskdDRFRrmFlJdXMyHXsjFq1ahUSExNRuHBhTZkQAubm5liyZAns7e1hZ2cHAFCpVClqXd68eQN7e3sAQJkyZaBSqfD06VOda4VatmyJEydOpHl/sWLFcO3atVTvc3FxQXx8PN68eaMVX3h4OFxcXNLcp5eXF4KDg6FSqRAfHw8nJyfUrl0bNWrUAADcu3cPS5YswdWrVzWX5qpWrYoTJ05g6dKlWLZsmU6P0VCYCOnTlSvA1KnAunWApaV0CWz6dLmjIiLKdRQK3S5PySExMRHr1q3D/Pnz0bx5c6372rRpg40bN+Lbb79F6dKlYWJigvPnz6PYewPm3r9/HyqVCmXKlAEAdOjQAWPGjMEPP/yAhQsXpjjeh4nK+7JyaczLywtmZmY4dOgQ2rdvD0Cq6Xrw4AHq1KmT5nbJkhO5O3fu4N9//8W0adMAANHR0QCktkPvMzU1hVqt/uh+s41em17nAgbpNaZWC7F8uRAWFlKvsO+/19++iYiMQG7sNbZ9+3ahVCrFmzdvUtz3/fffixo1amiW+/XrJzw8PMSOHTvE/fv3xbFjx8Qnn3wiPvnkE6FWqzXrLV26VCgUCvH111+Lo0ePitDQUHHy5EnRr18/MWLECIM9lm+//VYULVpUHD58WPz777+iTp06ok6dOlrrlC1bVmzbtk2zvGnTJnHkyBFx79498ccff4hixYqJdu3aae6Pj48XpUqVEg0aNBD//POPuHv3rpg3b55QKBRi9+7dqcYhR68xJkJZ36EQnTtLCRAgRIsWQjx7pp99ExEZidyYCH3++efis88+S/W+f/75RwAQly5dEkJIj8/f31+UK1dOWFpaiuLFi4t+/fqJ58+fp9j2wIEDwsfHR+TPn19YWFiIcuXKiZEjR4onT54Y7LHExMSIAQMGiPz58wsrKyvRtm1b8fTpU611AIg1a9ZolhcvXiyKFCkizMzMRNGiRcWECRNEXFyc1ja3b98W7dq1E87OzsLKykpUqVIlRXf6D+PI7kRIIUQm+vjlYhEREbC3t8eTJyq4utplbWcXL0q9wu7elS6DzZwJjBwJmHBUAiIiXcTGxiIkJATFixfX6pJNxiW910Hy97dKpdK0u9IHthHKrO3bgc6dgfh4wN0dCAwE6taVOyoiIiLSAROhzKpRQxrkol49YM0aoGBBuSMiIiIiHTER0sXjx0DyWA3u7sDZs0CJElL3BiIiIsp12JglI4QAFi+Wkp6dO9+VlyzJJIiIiCgXYyL0Ma9eAW3bAsOGSe2B3k+EiIiIKFdjIpSev/8GqlWTpspQKoGffgJWrJA7KiKiPMvIOjLTB+Q4/0yEUqNWA/PmAQ0aAA8eSJfATp8GBg3ipTAiIgMw/f9k1PHx8TJHQnJKPv+m2Tg5ORtLp+b4cWDUKOn/Tp2kWiA9jllARETakmcmf/78OczMzFJMy0B5n1qtxvPnz2FlZYV8+bIvPWEilJrGjYGhQ4Fy5YBvvmEtEBGRgSkUCri6uiIkJAT//fef3OGQTExMTFC0aFEosvF7l4kQIF0KW7wY6NIFSJ5pd9EiWUMiIjI2SqUSpUuX5uUxI6ZUKrO9NjBHJEJLly7F3LlzERYWhqpVq+Knn35CrVq10lx/8+bNmDhxIkJDQ1G6dGnMmTMHn332WeYO/uwZ0L078NdfwK5dwIEDnCKDiEgmJiYmnGKDspXs3/hBQUEYMWIE/P39ceHCBVStWhU+Pj549uxZquufPn0aXbp0Qe/evXHx4kW0adMGbdq0wdWrV3U/+NGjgKenlARZWgLduvEyGBERkRGRfdLV2rVro2bNmliyZAkAqbGUu7s7Bg8ejDFjxqRY39fXF1FRUdi1a5em7JNPPoGnpyeWLVv20eMlT9r2fORYOC6YI10WK18e2LQJqFRJfw+MiIiI9MZQk67KWiMUHx+P8+fPw9vbW1NmYmICb29vnDlzJtVtzpw5o7U+APj4+KS5flqU82ZJSVCvXsC5c0yCiIiIjJCsbYRevHiBpKQkFCpUSKu8UKFCuHnzZqrbhIWFpbp+WFhYquvHxcUhLi5Os6xSqaS/FhZSA+nOnYGkJCAiIisPhYiIiAwo4v/f0/q+kJUjGksb0qxZszBlypQU5UVjY6Wu8d98I0NURERElBkvX76Evb293vYnayLk6OgIU1NThIeHa5WHh4fDJbkb+wdcXFx0Wn/s2LEYMWKEZvnNmzcoVqwYHjx4oNcnknQXEREBd3d3PHz4UK/XeylzeD5yDp6LnIPnIudQqVQoWrQoChQooNf9ypoIKZVKeHl54dChQ2jTpg0AqbH0oUOHMGjQoFS3qVOnDg4dOoRhw4Zpyg4cOIA6deqkur65uTnMzc1TlNvb2/NFnUPY2dnxXOQgPB85B89FzsFzkXPoe5wh2S+NjRgxAn5+fqhRowZq1aqFRYsWISoqCr169QIA9OjRA25ubpg1axYAYOjQoWjUqBHmz5+PVq1aITAwEP/++y+WL18u58MgIiKiXEj2RMjX1xfPnz/HpEmTEBYWBk9PT+zbt0/TIPrBgwda2V/dunXx+++/Y8KECRg3bhxKly6NP/74A5XY64uIiIh0JHsiBACDBg1K81LY0aNHU5R17NgRHTt2zNSxzM3N4e/vn+rlMspePBc5C89HzsFzkXPwXOQchjoXsg+oSERERCQX2afYICIiIpILEyEiIiIyWkyEiIiIyGgxESIiIiKjlScToaVLl8LDwwMWFhaoXbs2zp49m+76mzdvRrly5WBhYYHKlStjz5492RRp3qfLuVixYgUaNGiA/PnzI3/+/PD29v7ouSPd6PreSBYYGAiFQqEZ+JSyTtdz8ebNGwwcOBCurq4wNzdHmTJl+FmlJ7qei0WLFqFs2bKwtLSEu7s7hg8fjtjY2GyKNu86fvw4WrdujcKFC0OhUOCPP/746DZHjx5F9erVYW5ujlKlSiEgIED3A4s8JjAwUCiVSrF69Wpx7do10bdvX+Hg4CDCw8NTXf/UqVPC1NRU/PDDD+L69etiwoQJwszMTFy5ciWbI897dD0XXbt2FUuXLhUXL14UN27cED179hT29vbi0aNH2Rx53qTr+UgWEhIi3NzcRIMGDcSXX36ZPcHmcbqei7i4OFGjRg3x2WefiZMnT4qQkBBx9OhRERwcnM2R5z26nosNGzYIc3NzsWHDBhESEiL2798vXF1dxfDhw7M58rxnz549Yvz48WLbtm0CgNi+fXu669+/f19YWVmJESNGiOvXr4uffvpJmJqain379ul03DyXCNWqVUsMHDhQs5yUlCQKFy4sZs2aler6nTp1Eq1atdIqq127tvjmm28MGqcx0PVcfCgxMVHY2tqKtWvXGipEo5KZ85GYmCjq1q0rVq5cKfz8/JgI6Ymu5+KXX34RJUqUEPHx8dkVotHQ9VwMHDhQNG3aVKtsxIgRol69egaN09hkJBH6/vvvRcWKFbXKfH19hY+Pj07HylOXxuLj43H+/Hl4e3trykxMTODt7Y0zZ86kus2ZM2e01gcAHx+fNNenjMnMufhQdHQ0EhIS9D7BnjHK7PmYOnUqnJ2d0bt37+wI0yhk5lzs3LkTderUwcCBA1GoUCFUqlQJM2fORFJSUnaFnSdl5lzUrVsX58+f11w+u3//Pvbs2YPPPvssW2Kmd/T1/Z0jRpbWlxcvXiApKUkzPUeyQoUK4ebNm6luExYWlur6YWFhBovTGGTmXHxo9OjRKFy4cIoXOukuM+fj5MmTWLVqFYKDg7MhQuORmXNx//59HD58GN26dcOePXtw9+5dDBgwAAkJCfD398+OsPOkzJyLrl274sWLF6hfvz6EEEhMTMS3336LcePGZUfI9J60vr8jIiIQExMDS0vLDO0nT9UIUd4xe/ZsBAYGYvv27bCwsJA7HKPz9u1bdO/eHStWrICjo6Pc4Rg9tVoNZ2dnLF++HF5eXvD19cX48eOxbNkyuUMzOkePHsXMmTPx888/48KFC9i2bRt2796NadOmyR0aZVKeqhFydHSEqakpwsPDtcrDw8Ph4uKS6jYuLi46rU8Zk5lzkWzevHmYPXs2Dh48iCpVqhgyTKOh6/m4d+8eQkND0bp1a02ZWq0GAOTLlw+3bt1CyZIlDRt0HpWZ94arqyvMzMxgamqqKStfvjzCwsIQHx8PpVJp0Jjzqsyci4kTJ6J79+7o06cPAKBy5cqIiopCv379MH78eK1Jwsmw0vr+trOzy3BtEJDHaoSUSiW8vLxw6NAhTZlarcahQ4dQp06dVLepU6eO1voAcODAgTTXp4zJzLkAgB9++AHTpk3Dvn37UKNGjewI1Sjoej7KlSuHK1euIDg4WHP74osv0KRJEwQHB8Pd3T07w89TMvPeqFevHu7evatJRgHg9u3bcHV1ZRKUBZk5F9HR0SmSneQEVXDqzmylt+9v3dpx53yBgYHC3NxcBAQEiOvXr4t+/foJBwcHERYWJoQQonv37mLMmDGa9U+dOiXy5csn5s2bJ27cuCH8/f3ZfV5PdD0Xs2fPFkqlUmzZskU8ffpUc3v79q1cDyFP0fV8fIi9xvRH13Px4MEDYWtrKwYNGiRu3boldu3aJZydncX06dPlegh5hq7nwt/fX9ja2oqNGzeK+/fvi7/++kuULFlSdOrUSa6HkGe8fftWXLx4UVy8eFEAEAsWLBAXL14U//33nxBCiDFjxoju3btr1k/uPj9q1Chx48YNsXTpUnafT/bTTz+JokWLCqVSKWrVqiX+/vtvzX2NGjUSfn5+Wutv2rRJlClTRiiVSlGxYkWxe/fubI4479LlXBQrVkwASHHz9/fP/sDzKF3fG+9jIqRfup6L06dPi9q1awtzc3NRokQJMWPGDJGYmJjNUedNupyLhIQEMXnyZFGyZElhYWEh3N3dxYABA8Tr16+zP/A85siRI6l+ByQ//35+fqJRo0YptvH09BRKpVKUKFFCrFmzRufjKoRgXR4REREZpzzVRoiIiIhIF0yEiIiIyGgxESIiIiKjxUSIiIiIjBYTISIiIjJaTISIiIjIaDERIiIiIqPFRIiItAQEBMDBwUHuMDJNoVDgjz/+SHednj17ok2bNtkSDxHlbEyEiPKgnj17QqFQpLjdvXtX7tAQEBCgicfExARFihRBr1698OzZM73s/+nTp2jZsiUAIDQ0FAqFAsHBwVrrLF68GAEBAXo5XlomT56seZympqZwd3dHv3798OrVK532w6SNyLDy1OzzRPROixYtsGbNGq0yJycnmaLRZmdnh1u3bkGtVuPSpUvo1asXnjx5gv3792d532nNGv4+e3v7LB8nIypWrIiDBw8iKSkJN27cwNdffw2VSoWgoKBsOT4RfRxrhIjyKHNzc7i4uGjdTE1NsWDBAlSuXBnW1tZwd3fHgAEDEBkZmeZ+Ll26hCZNmsDW1hZ2dnbw8vLCv//+q7n/5MmTaNCgASwtLeHu7o4hQ4YgKioq3dgUCgVcXFxQuHBhtGzZEkOGDMHBgwcRExMDtVqNqVOnokiRIjA3N4enpyf27dun2TY+Ph6DBg2Cq6srLCwsUKxYMcyaNUtr38mXxooXLw4AqFatGhQKBRo3bgxAu5Zl+fLlKFy4sNbM7gDw5Zdf4uuvv9Ys79ixA9WrV4eFhQVKlCiBKVOmIDExMd3HmS9fPri4uMDNzQ3e3t7o2LEjDhw4oLk/KSkJvXv3RvHixWFpaYmyZcti8eLFmvsnT56MtWvXYseOHZrapaNHjwIAHj58iE6dOsHBwQEFChTAl19+idDQ0HTjIaKUmAgRGRkTExP8+OOPuHbtGtauXYvDhw/j+++/T3P9bt26oUiRIjh37hzOnz+PMWPGwMzMDABw7949tGjRAu3bt8fly5cRFBSEkydPYtCgQTrFZGlpCbVajcTERCxevBjz58/HvHnzcPnyZfj4+OCLL77AnTt3AAA//vgjdu7ciU2bNuHWrVvYsGEDPDw8Ut3v2bNnAQAHDx7E06dPsW3bthTrdOzYES9fvsSRI0c0Za9evcK+ffvQrVs3AMCJEyfQo0cPDB06FNevX8evv/6KgIAAzJgxI8OPMTQ0FPv374dSqdSUqdVqFClSBJs3b8b169cxadIkjBs3Dps2bQIAjBw5Ep06dUKLFi3w9OlTPH36FHXr1kVCQgJ8fHxga2uLEydO4NSpU7CxsUGLFi0QHx+f4ZiICMiTs88TGTs/Pz9hamoqrK2tNbcOHTqkuu7mzZtFwYIFNctr1qwR9vb2mmVbW1sREBCQ6ra9e/cW/fr10yo7ceKEMDExETExMalu8+H+b9++LcqUKSNq1KghhBCicOHCYsaMGVrb1KxZUwwYMEAIIcTgwYNF06ZNhVqtTnX/AMT27duFEEKEhIQIAOLixYta6/j5+Ykvv/xSs/zll1+Kr7/+WrP866+/isKFC4ukpCQhhBDNmjUTM2fO1NrH+vXrhaura6oxCCGEv7+/MDExEdbW1sLCwkIzk/aCBQvS3EYIIQYOHCjat2+fZqzJxy5btqzWcxAXFycsLS3F/v37090/EWljGyGiPKpJkyb45ZdfNMvW1tYApNqRWbNm4ebNm4iIiEBiYiJiY2MRHR0NKyurFPsZMWIE+vTpg/Xr12su75QsWRKAdNns8uXL2LBhg2Z9IQTUajVCQkJQvnz5VGNTqVSwsbGBWq1GbGws6tevj5UrVyIiIgJPnjxBvXr1tNavV68eLl26BEC6rPXpp5+ibNmyaNGiBT7//HM0b948S89Vt27d0LdvX/z8888wNzfHhg0b0LlzZ5iYmGge56lTp7RqgJKSktJ93gCgbNmy2LlzJ2JjY/Hbb78hODgYgwcP1lpn6dKlWL16NR48eICYmBjEx8fD09Mz3XgvXbqEu3fvwtbWVqs8NjYW9+7dy8QzQGS8mAgR5VHW1tYoVaqUVlloaCg+//xz9O/fHzNmzECBAgVw8uRJ9O7dG/Hx8al+oU+ePBldu3bF7t27sXfvXvj7+yMwMBBt27ZFZGQkvvnmGwwZMiTFdkWLFk0zNltbW1y4cAEmJiZwdXWFpaUlACAiIuKjj6t69eoICQnB3r17cfDgQXTq1Ane3t7YsmXLR7dNS+vWrSGEwO7du1GzZk2cOHECCxcu1NwfGRmJKVOmoF27dim2tbCwSHO/SqVScw5mz56NVq1aYcqUKZg2bRoAIDAwECNHjsT8+fNRp04d2NraYu7cufjnn3/SjTcyMhJeXl5aCWiynNIgnii3YCJEZETOnz8PtVqN+fPna2o7ktujpKdMmTIoU6YMhg8fji5dumDNmjVo27YtqlevjuvXr6dIuD7GxMQk1W3s7OxQuHBhnDp1Co0aNdKUnzp1CrVq1dJaz9fXF76+vujQoQNatGiBV69eoUCBAlr7S26Pk5SUlG48FhYWaNeuHTZs2IC7d++ibNmyqF69uub+6tWr49atWzo/zg9NmDABTZs2Rf/+/TWPs27duhgwYIBmnQ9rdJRKZYr4q1evjqCgIDg7O8POzi5LMREZOzaWJjIipUqVQkJCAn766Sfcv38f69evx7Jly9JcPyYmBoMGDcLRo0fx33//4dSpUzh37pzmktfo0aNx+vRpDBo0CMHBwbhz5w527Nihc2Pp940aNQpz5sxBUFAQbt26hTFjxiA4OBhDhw4FACxYsAAbN27EzZs3cfv2bWzevBkuLi6pDgLp7OwMS0tL7Nu3D+Hh4VCpVGket1u3bti9ezdWr16taSSdbNKkSVi3bh2mTJmCa9eu4caNGwgMDMSECRN0emx16tRBlSpVMHPmTABA6dKl8e+//2L//v24ffs2Jk6ciHPnzmlt4+HhgcuXL+PWrVt48eIFEhIS0K1bNzg6OuLLL7/EiRMnEBISgqNHj2LIkCF49OiRTjERGT25GykRkf6l1sA22YIFC4Srq6uwtLQUPj4+Yt26dQKAeP36tRBCuzFzXFyc6Ny5s3B3dxdKpVIULlxYDBo0SKsh9NmzZ8Wnn34qbGxshLW1tahSpUqKxs7v+7Cx9IeSkpLE5MmThZubmzAzMxNVq1YVe/fu1dy/fPly4enpKaytrYWdnZ1o1qyZuHDhguZ+vNdYWgghVqxYIdzd3YWJiYlo1KhRms9PUlKScHV1FQDEvXv3UsS1b98+UbduXWFpaSns7OxErVq1xPLly9N8HP7+/qJq1aopyjdu3CjMzc3FgwcPRGxsrOjZs6ewt7cXDg4Oon///mLMmDFa2z179kzz/AIQR44cEUII8fTpU9GjRw/h6OgozM3NRYkSJUTfvn2FSqVKMyYiSkkhhBDypmJERERE8uClMSIiIjJaTISIiIjIaDERIiIiIqPFRIiIiIiMFhMhIiIiMlpMhIiIiMhoMREiIiIio8VEiIiIiIwWEyEiIiIyWkyEiIiIyGgxESIiIiKjxUSIiIiIjNb/ACV+r/rZAKdjAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -193,52 +213,62 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 2 AUC: 0.9826555555555556\n", + "Overall, depth: 2 AUC: 0.9773777777777778\n", "doing digit 0 doing signature level 3\n", - "fit_time: 1.8771882057189941\n", - "compute_auc_time: 0.2520630359649658\n", - "depth: 3 , Auc of digit: 0 is 0.9933333333333334\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.4143779277801514\n", + "compute_auc_time: 0.12943410873413086\n", + "depth: 3 , Auc of digit: 0 is 1.0\n", "doing digit 1 doing signature level 3\n", - "fit_time: 1.902285099029541\n", - "compute_auc_time: 0.21264314651489258\n", - "depth: 3 , Auc of digit: 1 is 0.9866666666666666\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3806469440460205\n", + "compute_auc_time: 0.1656959056854248\n", + "depth: 3 , Auc of digit: 1 is 0.9844444444444445\n", "doing digit 2 doing signature level 3\n", - "fit_time: 1.9661970138549805\n", - "compute_auc_time: 0.2668132781982422\n", - "depth: 3 , Auc of digit: 2 is 0.9977777777777778\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.343611240386963\n", + "compute_auc_time: 0.1403639316558838\n", + "depth: 3 , Auc of digit: 2 is 1.0\n", "doing digit 3 doing signature level 3\n", - "fit_time: 1.9230389595031738\n", - "compute_auc_time: 0.16147518157958984\n", - "depth: 3 , Auc of digit: 3 is 0.9955555555555555\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.2466747760772705\n", + "compute_auc_time: 0.1919870376586914\n", + "depth: 3 , Auc of digit: 3 is 1.0\n", "doing digit 4 doing signature level 3\n", - "fit_time: 1.9575071334838867\n", - "compute_auc_time: 0.26868581771850586\n", - "depth: 3 , Auc of digit: 4 is 0.9988888888888889\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3243610858917236\n", + "compute_auc_time: 0.15105414390563965\n", + "depth: 3 , Auc of digit: 4 is 0.9955555555555555\n", "doing digit 5 doing signature level 3\n", - "fit_time: 1.891937017440796\n", - "compute_auc_time: 0.20909786224365234\n", - "depth: 3 , Auc of digit: 5 is 0.9888888888888889\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3371069431304932\n", + "compute_auc_time: 0.10097980499267578\n", + "depth: 3 , Auc of digit: 5 is 1.0\n", "doing digit 6 doing signature level 3\n", - "fit_time: 1.8992087841033936\n", - "compute_auc_time: 0.23921418190002441\n", - "depth: 3 , Auc of digit: 6 is 0.9944444444444445\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.262901782989502\n", + "compute_auc_time: 0.09397101402282715\n", + "depth: 3 , Auc of digit: 6 is 1.0\n", "doing digit 7 doing signature level 3\n", - "fit_time: 1.845163106918335\n", - "compute_auc_time: 0.24655508995056152\n", - "depth: 3 , Auc of digit: 7 is 0.9755555555555555\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.2335212230682373\n", + "compute_auc_time: 0.13829803466796875\n", + "depth: 3 , Auc of digit: 7 is 0.9522222222222223\n", "doing digit 8 doing signature level 3\n", - "fit_time: 1.8408448696136475\n", - "compute_auc_time: 0.23415112495422363\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.2652909755706787\n", + "compute_auc_time: 0.11092400550842285\n", "depth: 3 , Auc of digit: 8 is 1.0\n", "doing digit 9 doing signature level 3\n", - "fit_time: 1.869530200958252\n", - "compute_auc_time: 0.24516701698303223\n", - "depth: 3 , Auc of digit: 9 is 0.9800000000000001\n" + "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3376529216766357\n", + "compute_auc_time: 0.1322460174560547\n", + "depth: 3 , Auc of digit: 9 is 0.9577777777777777\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -250,52 +280,62 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 3 AUC: 0.9858111111111111\n", + "Overall, depth: 3 AUC: 0.9870888888888889\n", "doing digit 0 doing signature level 4\n", - "fit_time: 1.9820890426635742\n", - "compute_auc_time: 0.20805883407592773\n", - "depth: 4 , Auc of digit: 0 is 0.9922222222222222\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.312425136566162\n", + "compute_auc_time: 0.17491698265075684\n", + "depth: 4 , Auc of digit: 0 is 0.99\n", "doing digit 1 doing signature level 4\n", - "fit_time: 1.9823508262634277\n", - "compute_auc_time: 0.19276905059814453\n", - "depth: 4 , Auc of digit: 1 is 0.9888888888888889\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3289391994476318\n", + "compute_auc_time: 0.19739603996276855\n", + "depth: 4 , Auc of digit: 1 is 0.9866666666666667\n", "doing digit 2 doing signature level 4\n", - "fit_time: 1.9892983436584473\n", - "compute_auc_time: 0.2388601303100586\n", - "depth: 4 , Auc of digit: 2 is 0.9966666666666667\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.4418830871582031\n", + "compute_auc_time: 0.1664409637451172\n", + "depth: 4 , Auc of digit: 2 is 1.0\n", "doing digit 3 doing signature level 4\n", - "fit_time: 2.15161395072937\n", - "compute_auc_time: 0.32798099517822266\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.4082059860229492\n", + "compute_auc_time: 0.1421060562133789\n", "depth: 4 , Auc of digit: 3 is 1.0\n", "doing digit 4 doing signature level 4\n", - "fit_time: 1.9887158870697021\n", - "compute_auc_time: 0.2344069480895996\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.493091106414795\n", + "compute_auc_time: 0.1769089698791504\n", "depth: 4 , Auc of digit: 4 is 1.0\n", "doing digit 5 doing signature level 4\n", - "fit_time: 2.098742961883545\n", - "compute_auc_time: 0.2179582118988037\n", - "depth: 4 , Auc of digit: 5 is 0.9922222222222222\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.3259241580963135\n", + "compute_auc_time: 0.18933606147766113\n", + "depth: 4 , Auc of digit: 5 is 0.9933333333333334\n", "doing digit 6 doing signature level 4\n", - "fit_time: 2.0192692279815674\n", - "compute_auc_time: 0.29630589485168457\n", - "depth: 4 , Auc of digit: 6 is 0.9955555555555555\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.4868669509887695\n", + "compute_auc_time: 0.180161714553833\n", + "depth: 4 , Auc of digit: 6 is 1.0\n", "doing digit 7 doing signature level 4\n", - "fit_time: 2.035627841949463\n", - "compute_auc_time: 0.34957003593444824\n", - "depth: 4 , Auc of digit: 7 is 0.9800000000000001\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.5131468772888184\n", + "compute_auc_time: 0.1810131072998047\n", + "depth: 4 , Auc of digit: 7 is 0.9677777777777778\n", "doing digit 8 doing signature level 4\n", - "fit_time: 1.9556260108947754\n", - "compute_auc_time: 0.21259498596191406\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.4616129398345947\n", + "compute_auc_time: 0.15701699256896973\n", "depth: 4 , Auc of digit: 8 is 1.0\n", "doing digit 9 doing signature level 4\n", - "fit_time: 1.9622900485992432\n", - "compute_auc_time: 0.1990797519683838\n", - "depth: 4 , Auc of digit: 9 is 0.9911111111111112\n" + "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.464219093322754\n", + "compute_auc_time: 0.21893668174743652\n", + "depth: 4 , Auc of digit: 9 is 0.9522222222222222\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByXElEQVR4nO3dd1hTZxsG8Dsge6qAIKK4d0Vx1L1QHLV146iide9RrVscVbTuqq1btLVurdaBddZdrYgTN7jBHWRL8n5/nI9oZEgwcIDcv+vKpefNOSdPckLy5J0KIYQAERERkQEykjsAIiIiIrkwESIiIiKDxUSIiIiIDBYTISIiIjJYTISIiIjIYDERIiIiIoPFRIiIiIgMFhMhIiIiMlhMhIiIiMhgMREyQO7u7ujRo4fcYRicBg0aoEGDBnKH8UlTpkyBQqHAixcv5A4l21EoFJgyZYpezhUWFgaFQoGAgAC9nC+n+5y/jx49esDd3f2zY9iyZQvy5cuHqKioT+6rz/eCro4dOwaFQoFt27bJ8vgfCgwMhLW1NZ4/fy53KBnGREjPAgICoFAoNLc8efLA1dUVPXr0wOPHj+UOL1uLjo7G9OnT8cUXX8DS0hJ2dnaoW7cu1q9fj5yyEsz169cxZcoUhIWFyR1KMiqVCmvXrkWDBg2QL18+mJmZwd3dHT179sR///0nd3h68ccff2DhwoVyh6ElK2JKSqqSbsbGxihcuDDatGmD4ODgTH3slPTo0UMrHmtraxQrVgzt27fH9u3boVarM/XxY2JiMGXKFBw7dizdx6hUKvj5+WHIkCGwtrbOvOB0kF3ez+/evUO5cuWgUCgwd+5crfuaNWuGEiVKwN/fX6boPl8euQPIraZNm4aiRYsiLi4OZ8+eRUBAAE6ePImrV6/C3Nxc1thu3rwJI6PslQNHRESgcePGCAkJQadOnTB48GDExcVh+/bt8PX1xb59+7BhwwYYGxvLHWqarl+/jqlTp6JBgwbJfqH+/fff8gQFIDY2Fm3btkVgYCDq1auH8ePHI1++fAgLC8OWLVuwbt06PHjwAIUKFZItRn34448/cPXqVQwfPjxTzh8bG4s8eXT72EwtpiJFiiA2NhYmJiZ6i69z585o0aIFVCoVQkJC8Ouvv2L//v04e/YsPDw89PY46WFmZoZVq1YBkF63+/fv46+//kL79u3RoEED7Nq1C7a2tpr9P+fvY+XKlVrJVUxMDKZOnQoA6a5l+uuvv3Dz5k307ds3w3HoW2a/n9Nr8eLFePDgQar39+vXD6NGjcLUqVNhY2OThZHpiSC9Wrt2rQAgzp8/r1U+ZswYAUBs3rxZpsjkFRsbK1QqVar3e3t7CyMjI7Fr165k940aNUoAELNmzcrMEFMUFRWl0/5bt24VAMTRo0czJ6AMGjRokAAgFixYkOy+xMREMWfOHPHw4UMhhBB+fn4CgHj+/HmmxaNWq0VMTIzez9uyZUtRpEgRvZ5TpVKJ2NjYDB+fGTF9LDQ0VAAQc+bM0SrfvXu3ACD69u2bqY//MV9fX2FlZZXiff7+/gKA6NixY6Y9/vPnzwUA4efnl+5jvv76a1GnTp1076/r+TMitffO0aNHBQCxdevWTH18IYSIiIgQdnZ2Ytq0aSm+x5L2MTY2FqtXr870eDIDEyE9Sy0R2rNnjwAgZs6cqVUeEhIi2rVrJ/LmzSvMzMyEp6dnisnA69evxfDhw0WRIkWEqampcHV1Fd26ddP6soqLixOTJ08WxYsXF6ampqJQoUJi9OjRIi4uTutcRYoUEb6+vkIIIc6fPy8AiICAgGSPGRgYKACIv/76S1P26NEj0bNnT+Hk5CRMTU1FuXLlkr35k/5IN27cKCZMmCAKFiwoFAqFeP36dYqv2ZkzZwQA8d1336V4/7t370TJkiVF3rx5NV+eH37wz58/XxQuXFiYm5uLevXqiStXriQ7R3pe56Rrd+zYMTFgwADh6Ogo7O3thRBChIWFiQEDBohSpUoJc3NzkS9fPtG+fXsRGhqa7PiPb0lJUf369UX9+vWTvU6bN28WP/74o3B1dRVmZmaiUaNG4vbt28mew5IlS0TRokWFubm5qFatmjh+/Hiyc6bk4cOHIk+ePKJJkyZp7pckKRG6ffu28PX1FXZ2dsLW1lb06NFDREdHa+27Zs0a0bBhQ+Ho6ChMTU1F2bJlxS+//JLsnEWKFBEtW7YUgYGBwtPTU5iZmWmSsvSeQwgh9u3bJ+rVqyesra2FjY2NqFq1qtiwYYMQQnp9P37tP/wSSe/fBwAxaNAg8fvvv4ty5cqJPHnyiJ07d2ru+/DLLzIyUgwbNkzzd+no6Ci8vLzEhQsXPhlT0nt47dq1Wo8fEhIiOnToIBwcHIS5ubkoVaqUGD9+fFqXLNVEKCoqSgDQuvZnz54V3t7ewtbWVlhYWIh69eqJkydPah2ny3sgJWklQkII0bRpU6FQKMTNmzc1ZSm9l8PCwkSrVq2EpaWlcHR0FMOHD9d8Ln34Y8PX1zfZ6/rxLa2kJTY2VpiamoopU6Ykuy8uLk4MHz5cODg4CGtra9GqVSvx8OHDFM+py+fjpk2bxLhx40SBAgWEpaWlaNWqlXjw4IHW65Hae0fXz47P0bNnT1G9enVx7969VBMhIYSoXLmy+Prrr/X62FmFTWNZJKnPSN68eTVl165dQ+3ateHq6oqxY8fCysoKW7ZsQevWrbF9+3a0adMGABAVFYW6desiJCQE3333HapUqYIXL15g9+7dePToERwcHKBWq/H111/j5MmT6Nu3L8qWLYsrV65gwYIFuHXrFv78888U46patSqKFSuGLVu2wNfXV+u+zZs3I2/evPD29gYgNV99+eWXUCgUGDx4MBwdHbF//3706tULkZGRyapvp0+fDlNTU4waNQrx8fEwNTVNMYa//voLANC9e/cU78+TJw+6dOmCqVOn4tSpU/Dy8tLct379erx9+xaDBg1CXFwcFi1ahEaNGuHKlSsoUKCATq9zkoEDB8LR0RGTJ09GdHQ0AOD8+fM4ffo0OnXqhEKFCiEsLAy//vorGjRogOvXr8PS0hL16tXD0KFD8fPPP2P8+PEoW7YsAGj+Tc2sWbNgZGSEUaNGQalU4qeffkLXrl3x77//avb59ddfMXjwYNStWxcjRoxAWFgYWrdujbx5836yOWv//v1ITExEt27d0tzvYx07dkTRokXh7++PoKAgrFq1Ck5OTpg9e7ZWXOXLl8fXX3+NPHny4K+//sLAgQOhVqsxaNAgrfPdvHkTnTt3Rr9+/dCnTx+ULl1ap3MEBATgu+++Q/ny5TFu3DjY29vj4sWLCAwMRJcuXTBhwgQolUo8evQICxYsAABNXw9d/z6OHDmCLVu2YPDgwXBwcEi1I27//v2xbds2DB48GOXKlcPLly9x8uRJhISEoEqVKmnGlJLLly+jbt26MDExQd++feHu7o67d+/ir7/+wowZM9J34T5w9+5dAED+/Pk1z6t58+bw9PSEn58fjIyMsHbtWjRq1AgnTpxA9erVtY5Pz3sgI7p164a///4bBw8eRKlSpVLcJzo6Go0aNcLTp08xbNgwODs7448//sDRo0fTPLejoyN+/fVXDBgwAG3atEHbtm0BAF988UWqx1y4cAEJCQmoUqVKsvt69+6N33//HV26dEGtWrVw5MgRtGzZMtl+un4+zpgxAwqFAmPGjMGzZ8+wcOFCeHl5ITg4GBYWFul676TnsyMmJgYxMTFpvmYAYGxsrPX9BADnzp3DunXrcPLkSSgUijSP9/T0TPV7JtuTOxPLbZJqBQ4dOiSeP38uHj58KLZt2yYcHR2FmZmZpvlBCCEaN24sKlasqPWLVK1Wi1q1aomSJUtqyiZPniwAiB07diR7PLVaLYQQ4rfffhNGRkbixIkTWvcvW7ZMABCnTp3SlH1YIySEEOPGjRMmJibi1atXmrL4+Hhhb2+vVUvTq1cv4eLiIl68eKH1GJ06dRJ2dnaa2pqkXyvFihVLV/NH69atBYBUa4yEEGLHjh0CgPj555+FEO9/9VlYWIhHjx5p9vv3338FADFixAhNWXpf56RrV6dOHZGYmKj1+Ck9j6SarPXr12vK0moaS61GqGzZsiI+Pl5TvmjRIgFAU7MVHx8v8ufPL6pVqybevXun2S8gIEAA+GSN0IgRIwQAcfHixTT3S5JUG/BxDV2bNm1E/vz5tcpSel28vb1FsWLFtMqKFCkiAIjAwMBk+6fnHG/evBE2NjaiRo0ayZqpkv4GhEi9KUGXvw8AwsjISFy7di3ZefBRLYCdnZ0YNGhQsv0+lFpMKdUI1atXT9jY2Ij79++n+hxTknSuqVOniufPn4vw8HBx7NgxUblyZQFAbN++XajValGyZEnh7e2tdb6YmBhRtGhRrVojXd4DKflUjdDFixeT/Z1+/Pcxb948AUD8+eefmrLY2FhRpkyZNGuEhNC9aWzVqlVaf3NJgoODBQAxcOBArfIuXbokO7+un4+urq4iMjJSs9+WLVsEALFo0SJN2aeaxj712SHE+2v5qdvHj6NWq0X16tVF586dhRCp1zommTlzpgAgIiIiUrw/O8tePWZzES8vLzg6OsLNzQ3t27eHlZUVdu/erfn1/urVKxw5cgQdO3bE27dv8eLFC7x48QIvX76Et7c3bt++rRlltn37dlSqVClZzQUATZa+detWlC1bFmXKlNGc68WLF2jUqBEApPkrysfHB+/evcOOHTs0ZX///TfevHkDHx8fAIAQAtu3b0erVq0ghNB6DG9vbyiVSgQFBWmd19fXFxYWFp98rd6+fQsAaXayS7ovMjJSq7x169ZwdXXVbFevXh01atTAvn37AOj2Oifp06dPsk7ZHz6Pd+/e4eXLlyhRogTs7e2TPW9d9ezZU6u2rG7dugCAe/fuAQD+++8/vHz5En369NHqqNu1a9dkv+BSkvSa6dqJsX///lrbdevWxcuXL7WuwYevi1KpxIsXL1C/fn3cu3cPSqVS6/iiRYtqahc/lJ5zHDx4EG/fvsXYsWOTDTb41C9VQPe/j/r166NcuXKfPK+9vT3+/fdfPHny5JP7fsrz589x/PhxfPfddyhcuLDWfel5jgDg5+cHR0dHODs7o0GDBrh79y5mz56Ntm3bIjg4GLdv30aXLl3w8uVLzWsQHR2Nxo0b4/jx48lGc6XnPZARSTUbSX/7KQkMDISrqyu+/vprTZm5uTn69OnzWY+dkpcvXwJAsr+npM+RoUOHapV/XLuTkc/H7t27a/1Ntm/fHi4uLprHTI9PfXYkPc7Bgwc/eduwYYPWuQMCAnDlypV01/4lvXY5cdoNNo1lkqVLl6JUqVJQKpVYs2YNjh8/DjMzM839d+7cgRACkyZNwqRJk1I8x7Nnz+Dq6oq7d++iXbt2aT7e7du3ERISAkdHx1TPlZpKlSqhTJky2Lx5M3r16gVAahZzcHDQfFE8f/4cb968wYoVK7BixYp0PUbRokXTjDlJ0ofB27dvYW9vn+I+qSVLJUuWTLZvqVKlsGXLFgC6vc5pxR0bGwt/f3+sXbsWjx8/1hrO//EXvq4+/tJL+kB5/fo1AOD+/fsAgBIlSmjtlydPnnTNnZI0MietLx1d40o656lTp+Dn54czZ84kq35XKpWws7PTbKf2fkjPOZKaeCpUqKDTc0ii699Het+7P/30E3x9feHm5gZPT0+0aNEC3bt3R7FixXSOMenLK6PPEQD69u2LDh06wMjICPb29ihfvrzmc+f27dsAkKwJ/ENKpVIrGUjPeyAjkubpSSs5v3//PooXL54sCfz470CfPvy7TorByMgIxYsX1ypPatZNkpHPx48/uxQKBUqUKKHT1Buf+uwAgGLFiun8foyMjMS4ceMwevRouLm5peuYpNcuvUl7dsJEKJNUr14dVatWBSDVWtSpUwddunTBzZs3YW1trfnlNWrUqBR/JQO6/cGr1WpUrFgR8+fPT/H+T72ZfXx8MGPGDLx48QI2NjbYvXs3OnfurKmBSIr322+/TfWD9OM2+PTUBgFSH5o///wTly9fRr169VLc5/LlywCQrl/pH8rI65xS3EOGDMHatWsxfPhw1KxZE3Z2dlAoFOjUqdNnz4mS2pQAH38oZ1SZMmUAAFeuXNFpCPWn4rp79y4aN26MMmXKYP78+XBzc4OpqSn27duHBQsWJHtdUnpddT1HRun695He927Hjh1Rt25d7Ny5E3///TfmzJmD2bNnY8eOHWjevPlnx62rkiVLavWh+1DSazlnzpxU3wcf90HJrPfm1atXAWRuUqOLpD5Ur1+/ztAUEhn5fNSH9FyfqKiodE0QaWxsrPmhMHfuXCQkJMDHx0eTmD169AiA9BqFhYWhYMGCWrVRScmXg4NDhp6LnJgIZQFjY2P4+/ujYcOGWLJkCcaOHavJ0E1MTFL94EpSvHhxzQdHWvtcunQJjRs3zlBG7uPjg6lTp2L79u0oUKAAIiMj0alTJ839jo6OsLGxgUql+mS8uvrqq6/g7++P9evXp5gIqVQq/PHHH8ibNy9q166tdV/Sr9wP3bp1S1NTosvrnJZt27bB19cX8+bN05TFxcXhzZs3Wvtlxq+hIkWKAJBqtxo2bKgpT0xMRFhY2Cc/YJs3bw5jY2P8/vvvOneYTstff/2F+Ph47N69W+uX6ac6s2bkHEm/yK9evZrml2dqr//n/n2kxcXFBQMHDsTAgQPx7NkzVKlSBTNmzNAkQul9vKT36qf+1jMq6TW0tbXV+9+wrn777TcoFAo0adIk1X2KFCmC69evQwih9RreuXPnk+fX9Ron/VgIDQ1FxYoVtWJQq9W4e/euVi3QzZs3tY7PyOfjx59dQgjcuXNH6+9ZH+/VuXPnauZUSkuRIkU0Sc+DBw/w+vVrlC9fPtl+M2fOxMyZM3Hx4kWthDo0NBQODg6p1rpmZ+wjlEUaNGiA6tWrY+HChYiLi4OTkxMaNGiA5cuX4+nTp8n2/3C68nbt2uHSpUvYuXNnsv2SMv+OHTvi8ePHWLlyZbJ9YmNjNaOfUlO2bFlUrFgRmzdvxubNm+Hi4qKVlBgbG6Ndu3bYvn17ih/UnzO9eq1ateDl5YW1a9diz549ye6fMGECbt26hR9++CHZL/U///xTq4/PuXPn8O+//2q+hHR5ndNibGyc7Ffw4sWLoVKptMqsrKwAIFmC9DmqVq2K/PnzY+XKlUhMTNSUb9iwQasKPDVubm7o06cP/v77byxevDjZ/Wq1GvPmzdP84kuvpF+jHzcTrl27Vu/naNq0KWxsbODv74+4uDit+z481srKKsWmys/9+0iJSqVK9lhOTk4oWLAg4uPjPxnTxxwdHVGvXj2sWbMm2eR1+qgd9PT0RPHixTF37twUawiyaomEWbNm4e+//4aPj0+KTdtJvL298fjxY+zevVtTFhcXl+I1/JilpSWA9P8denp6wtTUNNkM60mfIz///LNW+cezPWfk8zFpxGuSbdu24enTp1o1iel976QlI32Ehg4dip07d2rdli9fDkCaNXznzp3Jmo8vXLiAmjVrflascmGNUBYaPXo0OnTogICAAPTv3x9Lly5FnTp1ULFiRfTp0wfFihVDREQEzpw5g0ePHuHSpUua47Zt24YOHTrgu+++g6enJ169eoXdu3dj2bJlqFSpErp164YtW7agf//+OHr0KGrXrg2VSoUbN25gy5YtOHDggKapLjU+Pj6YPHkyzM3N0atXr2SzT8+aNQtHjx5FjRo10KdPH5QrVw6vXr1CUFAQDh06hFevXmX4tVm/fj0aN26Mb775Bl26dEHdunURHx+PHTt24NixY/Dx8cHo0aOTHVeiRAnUqVMHAwYMQHx8PBYuXIj8+fPjhx9+0OyT3tc5LV999RV+++032NnZoVy5cjhz5gwOHTqkqVJP4uHhAWNjY8yePRtKpRJmZmZo1KgRnJycMvzamJqaYsqUKRgyZAgaNWqEjh07IiwsDAEBASn2oUjJvHnzcPfuXQwdOhQ7duzAV199hbx58+LBgwfYunUrbty4oVUDmB5NmzaFqakpWrVqhX79+iEqKgorV66Ek5NTiknn55zD1tYWCxYsQO/evVGtWjV06dIFefPmxaVLlxATE4N169YBkL7QNm/ejJEjR6JatWqwtrZGq1at9PL38bG3b9+iUKFCaN++PSpVqgRra2scOnQI58+f16o5TC2mlPz888+oU6cOqlSpgr59+6Jo0aIICwvD3r17P3upDCMjI6xatQrNmzdH+fLl0bNnT7i6uuLx48c4evQobG1tNVNZ6ENiYiJ+//13AFICc//+fezevRuXL19Gw4YNU+1Lk6Rfv35YsmQJOnfujGHDhsHFxQUbNmzQdJZP631vYWGBcuXKYfPmzShVqhTy5cuHChUqpNr/ytzcHE2bNsWhQ4cwbdo0TbmHhwc6d+6MX375BUqlErVq1cLhw4dTrJXS9fMxX758qFOnDnr27ImIiAgsXLgQJUqU0OoMrst7JzUZ6SNUpUqVZFMJJNUWlS9fHq1bt9a679mzZ7h8+XKyKTNyjCwdo2YAUptQUQhphtrixYuL4sWLa4Zn3717V3Tv3l04OzsLExMT4erqKr766iuxbds2rWNfvnwpBg8eLFxdXTWTwfn6+moN1UxISBCzZ88W5cuXF2ZmZiJv3rzC09NTTJ06VSiVSs1+Hw+fT3L79m3NUMqPJ1hLEhERIQYNGiTc3NyEiYmJcHZ2Fo0bNxYrVqzQ7JPRWU/fvn0rpkyZIsqXLy8sLCyEjY2NqF27tggICEg2fPjDoZzz5s0Tbm5uwszMTNStW1dcunQp2bnT8zqnde1ev34tevbsqZlUzdvbW9y4cSPF13LlypWiWLFiwtjYOF0TKn78OqU20d7PP/8sihQpIszMzET16tXFqVOnhKenp2jWrFk6Xl1pBulVq1aJunXrCjs7O2FiYiKKFCkievbsqTW0PrWZpZNenw8nkdy9e7f44osvhLm5uXB3dxezZ88Wa9asSbZf0oSKKUnvOZL2rVWrlrCwsBC2traievXqYuPGjZr7o6KiRJcuXYS9vX2yIcHp/fvA/ydUTAk+GDIdHx8vRo8eLSpVqiRsbGyElZWVqFSpUrLJIFOLKbXrfPXqVdGmTRthb28vzM3NRenSpcWkSZNSjCfJp4Y2f+jixYuibdu2In/+/MLMzEwUKVJEdOzYURw+fFizjy7vgZT4+vpqDc22tLQU7u7uol27dmLbtm0pzjKf0oSK9+7dEy1bthQWFhbC0dFRfP/992L79u0CgDh79qzW4308/Pv06dPC09NTmJqapmso/Y4dO4RCodCa1FAIacj+0KFDRf78+YWVlVWaEyrq8vm4ceNGMW7cOOHk5CQsLCxEy5Ytk02bkNp7R9fPDn1I6z3266+/CktLS63pAHIShRA5ZDVLog+EhYWhaNGimDNnDkaNGiV3OLJQq9VwdHRE27Zt09VcQJQbLFy4ECNGjMCjR4+0Rnt+LpVKhXLlyqFjx46YPn263s77sWPHjqFhw4bYunUr2rdvn2mPk5UqV66MBg0aaCZ+zGnYR4goB4iLi0vWT2T9+vV49epVuheVJMppYmNjtbbj4uKwfPlylCxZUq9JECD185k2bRqWLl2arlFWJAkMDMTt27cxbtw4uUPJMPYRIsoBzp49ixEjRqBDhw7Inz8/goKCsHr1alSoUAEdOnSQOzyiTNG2bVsULlwYHh4eUCqV+P3333Hjxo1kk//pi4+Pj2YSWUqfZs2a5fjEkYkQUQ7g7u4ONzc3/Pzzz3j16hXy5cuH7t27Y9asWamu4UaU03l7e2PVqlXYsGGDpulq06ZNTFZIr2TtI3T8+HHMmTMHFy5cwNOnT7Fz585kvdE/duzYMYwcORLXrl2Dm5sbJk6ciB49emRJvERERJS7yNpHKDo6GpUqVcLSpUvTtX9oaChatmyJhg0bIjg4GMOHD0fv3r1x4MCBTI6UiIiIcqNsM2pMoVB8skZozJgx2Lt3r9aEVZ06dcKbN28QGBiYBVESERFRbpKj+gidOXMm2fTl3t7eyVYC/lB8fLzWLK9qtRqvXr1C/vz5c+TicERERIZICIG3b9+iYMGCySb8/Rw5KhEKDw9HgQIFtMqS1sWKjY1NcaFEf3//dK2zQkRERNnfw4cPM7Q4bmpyVCKUEePGjcPIkSM120qlEoULF8bDhw9ha2srY2TyEQKIicncx4iJAbLJwtI6q1gRCAwEWGFIRCQv4z27oGrcBLCwxNu3kShd2g02NjZ6fYwclQg5OzsjIiJCqywiIgK2trYp1gYBgJmZGczMzJKV29raGkwi9GHiIwRQty7wmcsW6SQiAvj/WqQ5gqUlkyAiIllFRwODBgHr1gG9ewMrV2q+R/TdrSVHJUI1a9bEvn37tMoOHjyYY1e81Ze0anjkSHw+VLs24OjIxIKIiNLp6lWgY0cgJAQwMgIKF5a+zDKJrIlQVFSU1iq+oaGhCA4ORr58+VC4cGGMGzcOjx8/xvr16wEA/fv3x5IlS/DDDz/gu+++w5EjR7Blyxbs3btXrqcgO7Ua8PTUPdHx8ABOnMj8BIW1K0RElC5CAGvWAEOGALGxgIsL8McfQCYvIyRrIvTff/+hYcOGmu2kvjy+vr4ICAjA06dP8eDBA839RYsWxd69ezFixAgsWrQIhQoVwqpVq+Dt7Z3lsWcHQqQ/Cfo48WGCQkRE2UZUFNC/P5C0fErTpsBvvwFOTpn+0NlmHqGsEhkZCTs7OyiVyhzZR+jDZrDoaCBpEF3JkkBQUOrJDRMfIiLKth49kn6xv3kD/Pgj8MMPUrPYBzLr+ztH9REydGk1gwUFAdbWWR4SERHR5ytUCNi4EbCwAOrUydKHlnWJDUqbEFKtT3S0VGtYpkzKSVDt2jlrVBYRERm4yEigUyfgzz/flzVpkuVJEMAaoWxLCOn9cPp08vs+bgZjsxcREeUYFy4APj7A3bvA0aNSfyBLS9nCYY1QNhUTk3IS5OEB3LghNYNZWUk3JkFERJTtCQEsXgzUqiUlQUWKALt2yZoEAawRyhE+nJCQtT9ERJTjvHkD9OoF7NghbbduLQ2Vz5tXzqgAMBHKEZJqfoiIiHKcN2+AypWBsDDAxASYO1eaKyib/Kpn0xgRERFlHnt7oHlzoFgxqc/H0KHZJgkCWCOU7STNExQdLXckREREGfTyJZCY+H6yu/nzgfh4wM5O3rhSwBqhbEIIaYh8lSpSR+ik9w4REVGOcvq01BTWuTOgUkll5ubZMgkCmAhlC0lD5W1sks8TVLu27B3qiYiIPk2tBmbPBurVAx4+lG5Pn8od1SexaSwb+Hio/IfrgnGUGBERZXvPnwO+vsD+/dJ2587A8uXSL/xsjolQNvDham8REYCjI5MfIiLKIU6ckGaJfvJEagL7+Wegd+8c80XGRCiLfbhoatJ2lSrvtzlBIhER5RgqFTBwoJQElSkDbNkCVKwod1Q6YSKUCT5Odj4sr1s35fXCAKlJjP2BiIgoxzA2lhZLXbQIWLAgR67+zURIz9JaIywtHh7S8iusDSIiomztyBHg9m2gXz9pu0IFYOVKeWP6DEyE9Cy1NcI+9GFn6CTsFE1ERNmaSgVMmwZMny7VBHl6AlWryh3VZ2MipEdCaE+E+OEaYR9i0kNERDnKkydA167AsWPSdo8eQLlyckakN0yEMiilTs8f9//hGmFERJTjHTgAdOsmDZG3tpaGxXfpIndUesNEKAPUaqlGMLVOzwAnQiQiolxgyhRg6lTp/5UqSaPCSpWSNSR948zSOhIi7STIwwN4+zZ5HyAiIqIcx95e+rd/f+Ds2VyXBAGsEdJZTMz7JKhkSSAoiJ2eiYgoF4mOft+vY9gwad2w+vXljSkTsUZIBx93hg4KkppLk/oCcTJEIiLKsd69A0aPlmb5fftWKlMocnUSBDARSrek+YE+XBWeSQ8REeUK9+9Li6XOnQvcugX8+afcEWUZJkLp9PH8QOwMTUREucKuXVIH17NnATs7YPt2aZSYgWAfoQzgwqhERJTjJSQAP/wgLY8BANWrA5s2AUWLyhtXFmONUAawLxAREeV4Y8a8T4K+/14a7mxgSRDARIiIiMgwjR0LlC8P7N4t9Q0yNZU7IlkwESIiIjIEcXHSSvFJChQALl8GWrWSL6ZsgH2EiIiIcrvbt4GOHd9PhNe5s/SvEetD+AoQERHlZhs3SnMDBQcDDg5AvnxyR5StMBEiIiLKjWJjgb59pQVSo6KkeYKCgwFvb7kjy1aYCBEREeU2N24ANWoAK1dKw5wnTgQOHwZcXeWOLNthHyEiIqLc5u5d4MoVwMkJ2LAB8PKSO6Jsi4lQOgkhdwRERETp1LKlVBvUsiXg4iJ3NNkam8bSQQigbl25oyAiIkrFtWvSF9X9++/LevdmEpQOTITSISbm/YhDDw+uMUZERNmEEMCaNUC1asDJk8Dw4XJHlOOwaUxHJ05weQ0iIsoGoqKA/v2lPkAA0LQpsHy5vDHlQKwR0hGTICIikt2lS4Cnp5QEGRsDM2cC+/dLnaNJJ6wRIiIiyklOnACaNAHi46Xh8Js2AXXqyB1VjsVEiIiIKCepVg0oU0ZKgtatk2aLpgxjIkRERJTdhYQApUpJzWDm5sChQ9JSGVwr7LPxFSQiIsquhACWLJGGLM+Y8b7cwYFJkJ6wRoiIiCg7evMG6NUL2LFD2r50CVCrmQDpGV9NIiKi7ObcOaByZSkJMjEBFi4Etm1jEpQJ+IoSERFlF0IACxZIo8DCwoCiRYFTp4Bhwzh/SyZhIvQJQgDR0XJHQUREBiE0FBg/Hnj3DmjXDggKkkaJUaZhH6E0CCEl5adPyx0JEREZhGLFgKVLgdhYYOBA1gJlASZCaYiJ0U6CatfmOmNERKRHajUwb560YOqXX0pl330nb0wGholQOkVEAI6OTM6JiEhPnj8HfH2lpTGKFAGuXgWsreWOyuAwEUonKysmQUREpCfHjwOdOwNPnkgTJE6YIH3RUJZjZ2kiIqKsolZLEyM2bCglQaVLA//+C/Tpw1/bMmGNEBERUVaIigLatgUOHpS2u3UDfvmFzWEyYyJERESUFaysAAsL6fbLL0CPHnJHRGAiRERElHlUKiAhQUp+FApg7VogPBwoV07uyOj/2EcoBUmTKHIiRSIiyrCnTwEvL6n/jxBSWb58TIKyGdYIfYSTKBIR0Wf7+2/g22+lIfJWVsC9e0Dx4nJHRSlgjdAHhJDesx8nQZxIkYiI0iUxURoK36yZ9IXyxRfAf/8xCcrGWCP0fynVBEVESIm8pSVHNRIR0Sc8egR06QKcOCFt9+snLaBqYSFvXJQmJkJIuSaodm3OJE1EROmkVgPNm0uzQ9vYACtXAj4+ckdF6WDwTWNJNUEFCrwvi4iQEnomQURElC5GRsDChUDVqtKK8UyCcgyDT4RSWliVNUFERPRJDx5InaKTNG4szRJdooR8MZHODL5pLGlEI8CFVYmIKJ1275YmRExMlGqAkpIfI4OvX8hxDPqKCQHUrft+mwurEhFRmhISgBEjgG++AV6/BsqUAfIYfJ1CjiZ7IrR06VK4u7vD3NwcNWrUwLlz59Lcf+HChShdujQsLCzg5uaGESNGIC4uLkOPHRMDBAdL//fw4BB5IiJKQ2io1Kl04UJpe8QI4ORJwN1dzqjoM8maCG3evBkjR46En58fgoKCUKlSJXh7e+PZs2cp7v/HH39g7Nix8PPzQ0hICFavXo3Nmzdj/Pjxnx0LO0cTEVGqtm8HKlcGzp8H8uYFdu0C5s8HTE3ljow+k6yJ0Pz589GnTx/07NkT5cqVw7Jly2BpaYk1a9akuP/p06dRu3ZtdOnSBe7u7mjatCk6d+78yVqk9GASREREqTp9GlAqgZo1paaEr7+WOyLSE9kSoYSEBFy4cAFeXl7vgzEygpeXF86cOZPiMbVq1cKFCxc0ic+9e/ewb98+tGjRItXHiY+PR2RkpNaNiIjokz4cTePvDyxaBPzzD1C4sHwxkd7Jlgi9ePECKpUKBT6cwAdAgQIFEB4enuIxXbp0wbRp01CnTh2YmJigePHiaNCgQZpNY/7+/rCzs9Pc3Nzc9Po8iIgoF9q0CWjRAnj3Tto2NQWGDgVMTOSNi/RO9s7Sujh27BhmzpyJX375BUFBQdixYwf27t2L6dOnp3rMuHHjoFQqNbeHDx9mYcRERJSjxMZKS2N07gwEBkozRFOuJtuYPwcHBxgbGyMiIkKrPCIiAs7OzikeM2nSJHTr1g29e/cGAFSsWBHR0dHo27cvJkyYAKMU5m8wMzODmZmZ/p8AERHlLjdvAh07ApcvSx1Hx48H+vaVOyrKZLLVCJmamsLT0xOHDx/WlKnVahw+fBg1a9ZM8ZiYmJhkyY6xsTEAQHzYlktERKSL338HPD2lJMjJCThwAPjxR84RZABkvcIjR46Er68vqlatiurVq2PhwoWIjo5Gz549AQDdu3eHq6sr/P39AQCtWrXC/PnzUblyZdSoUQN37tzBpEmT0KpVK01CREREpJMZM4CJE6X/N2wIbNgAuLjIGxNlGVkTIR8fHzx//hyTJ09GeHg4PDw8EBgYqOlA/eDBA60aoIkTJ0KhUGDixIl4/PgxHB0d0apVK8yYMUOup0BERDld+/bATz8BI0dKCRF/WBsUhTCwNqXIyEjY2dlBqVTC2NgW1tZSeVSUtMQGERHlckJITWCVKr0ve/kSyJ9fvpjokz78/ra1tdXbeXPUqDEiIqLPEhUFdO8OVKkizQmUhEmQwWIiREREhuHyZaBqValjNABcvSpvPJQtMBEiIqLcTQhgxQqgenVpiLyrK3DsGDBokNyRUTbAcYFERJR7RUZKEyRu2iRtN28OrF8PODjIGxdlG6wRIiKi3GvXLikJMjaWRobt2cMkiLSwRoiIiHKvb78FLl4EOnSQVo4n+ghrhIiIKPd48wYYPBh4/VraViiA+fOZBFGqWCNERES5w/nzgI8PEBoKvHjxvl8QURpYI0RERDmbEMDChUDt2lISVLQo8P33ckdFOQRrhIiIKOd69Qro2RPYvVvabtcOWLUKsLeXNSzKOZgIERFRznTlCvDVV8CDB4CpqdQXaOBAqV8QUToxESIiopypYEGpWax4cWDLFmnZDCIdMREiIqKc4+1bwNpaqvXJnx/Yvx9wcwP0uAgnGRZ2liYiopzhxAmgbFkgIOB9WfnyTILoszARIiKi7E2tBmbOBBo2BB4/BhYvBlQquaOiXIKJEBERZV/PngHNmgETJkjJz7ffAsePS0tmEOkB+wgREVH2dPQo0KULEB4OWFgAS5ZIQ+U5Koz0yGATISGA6Gi5oyAiohTdvw80bQokJgLlykmjwsqXlzsqyoUMNhFq2hQ4d07uKIiIKEVFigDjxgGPHkl9gqys5I6IcimDTYQ+TIJq1wYsLeWLhYiIABw6BLi7AyVKSNtTp7IZjDKdwXeWjoiQRmTyb42ISCaJicDEiVJVvY8PEB8vlfODmbKAwdYIJbGy4t8aEZFsHj8GOneWfpECQLVqUidOoixi8IkQERHJZP9+oHt34MULwMYGWLEC6NRJ7qjIwBh80xgREWWxd++AMWOAFi2kJKhyZeDCBSZBJAsmQkRElLWEkOYIAoBBg4DTp4GSJeWNiQwWm8aIiChrCCF1yjQ1BTZvBoKCgHbt5I6KDBwTISIiylwJCcDYsYC5ubRmGAAULSrdiGTGRIiIiDJPaKjU9+fcOak2qHt3oEwZuaMi0mAfISIiyhw7dkgdoc+dA+ztgZ07mQRRtsNEiIiI9Cs+HhgyROr/o1QCX34JBAcD33wjd2REybBpjIiI9EcIaYbo48el7R9+AH78ETAxkTcuolQwESIiIv1RKIDevYFr14D166W5goiyMTaNERHR54mNBUJC3m936wbcusUkiHIEJkJERJRxN29KfYC8vIDnz9+X58snX0xEOmAiREREGfP774CnJ3D5srRsRmio3BER6YyJEBER6SYmBujVS2oCi44GGjSQRoVVry53ZEQ6YyJERETpd/26lPCsWSN1jPbzAw4dAgoWlDsyogzhqDEiIkq/2bOlEWHOzsCGDUCjRnJHRPRZmAgREVH6/fwzkCePtGZYgQJyR0P02dg0RkREqbtyBRg9WpooEQDs7IDVq5kEUa7BGiEiIkpOCGDVKmDoUCAuDihdWpookSiXYSJERETaIiOBfv2ATZuk7ebNuU4Y5VpsGiMiovcuXpTmBtq0CTA2ljpH79kDODrKHRlRpvisGqG4uDiYm5vrKxYiIpLTb79JzV8JCYCbm5QM1aold1REmUrnGiG1Wo3p06fD1dUV1tbWuHfvHgBg0qRJWL16td4DJCKiLFK0KKBSAa1aSRMkMgkiA6BzIvTjjz8iICAAP/30E0xNTTXlFSpUwKpVq/QaHBERZTKl8v3/69QBzpwBdu3iWmFkMHROhNavX48VK1aga9euMDY21pRXqlQJN27c0GtwRESUSYQAFi0C3N2l2aKTVKsmzRhNZCB0ToQeP36MEiVKJCtXq9V49+6dXoIiIqJM9OoV0KYNMHw48OYNEBAgc0BE8tE5ESpXrhxOnDiRrHzbtm2oXLmyXoIiIqJMcvYsULmy1PxlagosXiyNDCMyUDqPGps8eTJ8fX3x+PFjqNVq7NixAzdv3sT69euxZ8+ezIiRiIg+l1oNzJ8PjBsHJCYCxYsDmzdLQ+WJDJjONULffPMN/vrrLxw6dAhWVlaYPHkyQkJC8Ndff6FJkyaZESMREX2u33+XlspITAQ6dgQuXGASRARAIUTSAjKGITIyEnZ2dgCUAGwRFQVYWckdFRFRJktMBFq2lPoG9evHDtGU4yR9fyuVStja2urtvDrXCBUrVgwvX75MVv7mzRsUK1ZML0EREdFnUqultcLi46XtPHmAwECgf38mQUQf0DkRCgsLg0qlSlYeHx+Px48f6yUoIiL6DM+eSeuD9ekDjBnzvpwJEFEy6e4svXv3bs3/Dxw48P/mJYlKpcLhw4fh7u6u1+CIiEhHx44BXboAT58CFhbAF1/IHRFRtpbuRKh169YAAIVCAV9fX637TExM4O7ujnnz5uk1OCIiSieVCpgxA5g6VWoWK1sW2LoVKF9e7siIsrV0J0JqtRoAULRoUZw/fx4ODg6ZFhQREekgPBzo2hU4ckTa7tlTmh+II0GIPknneYRCQ0MzIw4iIsqomBjgv/8AS0tg2TKgWze5IyLKMXROhAAgOjoa//zzDx48eICEhASt+4YOHaqXwLJC7drS5wYRUY4jxPvOz8WKAVu2AEWKAGXKyBsXUQ6j8zxCFy9eRIsWLRATE4Po6Gjky5cPL168gKWlJZycnHDv3r3MilUvkuYhuHNHiWLFbDmIgohynsePgW+/lWaJbtpU7miIskS2mUdoxIgRaNWqFV6/fg0LCwucPXsW9+/fh6enJ+bOnau3wDKbpSVHkhJRDhQYCHh4SKPDBg6UJkokogzTOREKDg7G999/DyMjIxgbGyM+Ph5ubm746aefMH78+MyIkYiI3r0Dxo6V5gd68UJKhvbtkyZKJKIM0zkRMjExgZGRdJiTkxMePHgAALCzs8PDhw/1Gx0REQEPHwINGrxfJX7gQODMGaBUKVnDIsoNdE6EKleujPPnzwMA6tevj8mTJ2PDhg0YPnw4KlSooHMAS5cuhbu7O8zNzVGjRg2cO3cuzf3fvHmDQYMGwcXFBWZmZihVqhT27dun8+MSEeUIjx9LtT+nTwO2ttLcQEuXAubmckdGlCvonAjNnDkTLi4uAIAZM2Ygb968GDBgAJ4/f47ly5frdK7Nmzdj5MiR8PPzQ1BQECpVqgRvb288e/Ysxf0TEhLQpEkThIWFYdu2bbh58yZWrlwJV1dXXZ8GEVHO4OoKtGoFVK0KXLwItG8vd0REuYqsq8/XqFED1apVw5IlSwBIkza6ublhyJAhGDt2bLL9ly1bhjlz5uDGjRswMTHJ0GMm9Tp/8kQJFxf99TonItKbsDDA2hpImrg2JgYwNgbMzGQNi0hO2WbUWGqCgoLw1VdfpXv/hIQEXLhwAV5eXu+DMTKCl5cXzpw5k+Ixu3fvRs2aNTFo0CAUKFAAFSpUwMyZM1NcBDZJfHw8IiMjtW5ERNnWzp1SU5ivr7RUBiANc2USRJQpdEqEDhw4gFGjRmH8+PGa+YJu3LiB1q1bo1q1applONLjxYsXUKlUKFCggFZ5gQIFEB4enuIx9+7dw7Zt26BSqbBv3z5MmjQJ8+bNw48//pjq4/j7+8POzk5zc3NzS3eMRERZJj4eGDoUaNsWUCqBly+lf4koU6U7EVq9ejWaN2+OgIAAzJ49G19++SV+//131KxZE87Ozrh69Wqmd1pWq9VwcnLCihUr4OnpCR8fH0yYMAHLli1L9Zhx48ZBqVRqbhzZRkTZzt270lT3ixdL26NGASdOAHnzyhsXkQFI9wQUixYtwuzZszF69Ghs374dHTp0wC+//IIrV66gUKFCOj+wg4MDjI2NERERoVUeEREBZ2fnFI9xcXGBiYkJjI2NNWVly5ZFeHg4EhISYGpqmuwYMzMzmLFKmYiyqy1bgN69gbdvgfz5gXXrgJYt5Y6KyGCku0bo7t276NChAwCgbdu2yJMnD+bMmZOhJAgATE1N4enpicOHD2vK1Go1Dh8+jJo1a6Z4TO3atXHnzh2tJrhbt27BxcUlxSSIiChbi4uTlsl4+1aqEQoOZhJElMXSnQjFxsbC8v8rlCoUCpiZmWmG0WfUyJEjsXLlSqxbtw4hISEYMGAAoqOj0bNnTwBA9+7dMW7cOM3+AwYMwKtXrzBs2DDcunULe/fuxcyZMzFo0KDPioOISBbm5sDmzcD48dKSGRn8YUlEGafT3OyrVq2CtbU1ACAxMREBAQFwSBre+X+6rD7v4+OD58+fY/LkyQgPD4eHhwcCAwM1HagfPHigmcUaANzc3HDgwAGMGDECX3zxBVxdXTFs2DCMGTNGl6dBRCSfP/6QhsP37i1tV60q3YhIFumeR8jd3R2KT6xSqlAocszq85xHiIiyVEwMMGwYsGoVYGoqNYOVLSt3VEQ5RmbNI5TuGqGwsDC9PSgRkUEJCQE6dgSuXgUUCqlfENcJI8oWuGwxEVFmWrdOWiQ1JgYoUEBqGmvUSO6oiOj/mAgREWUGIYA+fYDVq6VtLy/g99+lZIiIsg29LbFBREQfUCiAYsUAIyNg+nQgMJBJEFE2xBohIiJ9EUJaFsPeXtoeOxZo1gyoUkXWsIgodawRIiLSh7dvga5dgbp1pf5AgFQbxCSIKFvLUCJ09+5dTJw4EZ07d8azZ88AAPv378e1a9f0GhwRUY4QHAx4egIbN0ojxI4flzsiIkonnROhf/75BxUrVsS///6LHTt2ICoqCgBw6dIl+Pn56T1AIqJsSwjg11+BL78Ebt8G3NykJKhZM7kjI6J00jkRGjt2LH788UccPHhQa32vRo0a4ezZs3oNjogo21IqAR8faWh8fDzQqhVw8SJQq5bckRGRDnROhK5cuYI2bdokK3dycsKLFy/0EhQRUbY3eDCwdSuQJw8wbx6wa5e0ejwR5Sg6J0L29vZ4+vRpsvKLFy/C1dVVL0EREWV7/v5Sv6CTJ4GRI6Xh8kSU4+icCHXq1AljxoxBeHg4FAoF1Go1Tp06hVGjRqF79+6ZESMRkfxev5ZmiU5SqBBw/jxQo4Z8MRHRZ9M5EZo5cybKlCkDNzc3REVFoVy5cqhXrx5q1aqFiRMnZkaMRETy+vdfoHJloEcPqQksCWuBiHI8nSdUNDU1xcqVKzFp0iRcvXoVUVFRqFy5MkqWLJkZ8RERyUcIYP58aWLExESgeHGpJoiIcg2dE6GTJ0+iTp06KFy4MAoXLpwZMRERye/lS6kGaM8eabtjR2DlSsDWVtawiEi/dG4aa9SoEYoWLYrx48fj+vXrmRETEZG8Tp0CPDykJMjMTJoraNMmJkFEuZDOidCTJ0/w/fff459//kGFChXg4eGBOXPm4NGjR5kRHxFR1nvyBHj0CChZEjh7Fujfn/2BiHIphRBCZPTg0NBQ/PHHH9i4cSNu3LiBevXq4ciRI/qMT+8iIyNhZ2eHJ0+UcHHhrzsi+j8htJOddeuAtm0BGxv5YiIijaTvb6VSCVs91s5+1qKrRYsWxdixYzFr1ixUrFgR//zzj77iIiLKOv/8I80J9OEcab6+TIKIDECGE6FTp05h4MCBcHFxQZcuXVChQgXs3btXn7EREWUulQqYPh1o1EhaHmPyZLkjIqIspvOosXHjxmHTpk148uQJmjRpgkWLFuGbb76BpaVlZsRHRJQ5wsOBb78FDh+Wtnv0ABYulDMiIpKBzonQ8ePHMXr0aHTs2BEODg6ZERMRUeY6fBjo2hWIiAAsLaVRYZwZn8gg6ZwInTp1KjPiICLKGjt3Au3aSZ2jK1QAtmwBypaVOyoikkm6EqHdu3ejefPmMDExwe7du9Pc9+uvv9ZLYEREmaJJE6B0aaBuXWDRIsDCQu6IiEhG6Ro+b2RkhPDwcDg5OcHIKPX+1QqFAiqVSq8B6huHzxMZoPPnpVFhSZ9fSiVgZydvTESkE1mHz6vVajg5OWn+n9otuydBRGRgEhOBceOA6tWlNcOSMAkiov/Tefj8+vXrER8fn6w8ISEB69ev10tQRESf7eFDoEEDYNYsaZuz3xNRCnSeWdrY2BhPnz7V1BAlefnyJZycnLJ9rRCbxogMwN690iiwV6+k9cFWrwbat5c7KiL6DNlmZmkhBBQprLnz6NEj2LG6mYjklJAAjBoFfPWVlARVrSpNlMgkiIhSke7h85UrV4ZCoYBCoUDjxo2RJ8/7Q1UqFUJDQ9GsWbNMCZKIKF1CQoCff5b+P2wYMHu2tHo8EVEq0p0ItW7dGgAQHBwMb29vWFtba+4zNTWFu7s72rVrp/cAiYjSrVIlYMkSwMkJ+P9nFhFRWnTuI7Ru3Tr4+PjA3Nw8s2LKVOwjRJSLxMcD48cD3boBHh5yR0NEmSiz+gjpPLO0r6+v3h6ciCjD7t4FfHyACxeAPXuAq1cBExO5oyKiHCZdiVC+fPlw69YtODg4IG/evCl2lk7y6tUrvQVHRJSirVuB3r2ByEggXz5pjiAmQUSUAelKhBYsWAAbGxvN/9NKhIiIMk1cHDBypLRIKgDUrg1s3Ai4uckbFxHlWDr3Ecrp2EeIKId6/hxo2hQIDpa2x40Dpk0D8ujcwk9EOVC2mUcoKCgIV65c0Wzv2rULrVu3xvjx45GQkKC3wIiItOTLBzg4AI6OQGAgMHMmkyAi+mw6J0L9+vXDrVu3AAD37t2Dj48PLC0tsXXrVvzwww96D5CIDFhMDBAbK/3f2BjYsEGqEfL2ljUsIso9dE6Ebt26BY//D1PdunUr6tevjz/++AMBAQHYvn27vuMjIkMVEgLUqAEMH/6+zMkJKFhQtpCIKPfJ0BIbarUaAHDo0CG0aNECAODm5oYXL17oNzoiMkzr1knLY1y9CuzaJfUPIiLKBDonQlWrVsWPP/6I3377Df/88w9atmwJAAgNDUWBAgX0HiARGZDoaKBHD+kWEwM0biw1hTk6yhwYEeVWOidCCxcuRFBQEAYPHowJEyagRIkSAIBt27ahVq1aeg+QiAzE1atAtWpSbZCRETB9OnDgAODsLHdkRJSL6W34fFxcHIyNjWGSzSc14/B5omwoIQEoXhx49EjqA/THH0D9+nJHRUTZSLZZYiPJhQsXEBISAgAoV64cqlSporegiMjAmJoCy5YBS5dKNUJsCiOiLKJzIvTs2TP4+Pjgn3/+gb29PQDgzZs3aNiwITZt2gRHfoARUXpcugQ8ewY0aSJtt2wJtGgBcOZ6IspCOvcRGjJkCKKionDt2jW8evUKr169wtWrVxEZGYmhQ4dmRoxElJsIIdX+1KghLZr64MH7+5gEEVEW07lGKDAwEIcOHULZsmU1ZeXKlcPSpUvRtGlTvQZHRLmMUgn07Qts2SJtN2kCWFnJGxMRGTSda4TUanWKHaJNTEw08wsRESVz4QJQpYqUBOXJA8ybB+zeDeTPL3dkRGTAdE6EGjVqhGHDhuHJkyeassePH2PEiBFo3LixXoMjolxi8WKgVi3g3j2gSBHg5ElpFXk2hRGRzHROhJYsWYLIyEi4u7ujePHiKF68OIoWLYrIyEgsXrw4M2Ikopzu2jVpiHzr1sDFi1L/ICKibEDnPkJubm4ICgrC4cOHNcPny5YtCy8vL70HR0Q5mBDva3wWLJBqhLp1Yy0QEWUrOiVCmzdvxu7du5GQkIDGjRtjyJAhmRUXEeVUQkiJz8GDwJ490qrxFhZA9+5yR0ZElEy6E6Fff/0VgwYNQsmSJWFhYYEdO3bg7t27mDNnTmbGR0Q5ycuX0jphe/ZI2zt2AB06yBoSEVFa0t1HaMmSJfDz88PNmzcRHByMdevW4ZdffsnM2IgoJzl9GqhcWUqCzMyAX38F2reXOyoiojSlOxG6d+8efH19NdtdunRBYmIinj59mimBEVEOoVYDs2cD9eoBDx8CJUsCZ88C/fuzPxARZXvpToTi4+Nh9cHEZ0ZGRjA1NUVsbGymBEZEOcTQocDYsYBKBXTpIs0X5OEhd1REROmiU2fpSZMmwdLSUrOdkJCAGTNmwM7OTlM2f/58/UVHRNlf377Axo3ATz8B333HWiAiylHSnQjVq1cPN2/e1CqrVasW7t27p9lW8AOQKPdTqYD//ns/F9AXXwBhYYCNjaxhERFlRLoToWPHjmViGESUI0REAN9+Cxw7Js0OnZQMMQkiohxK55mlichAHTkCVKoEHDoEmJoCjx7JHRER0WdjIkREaVOpAD8/wMtLqhGqUEFqGmvXTu7IiIg+m85LbBCRAXnyBOjaVWoKA4DevYFFi4APBk0QEeVkTISIKHU7dkhJkLU1sHy5NDyeiCgXyRZNY0uXLoW7uzvMzc1Ro0YNnDt3Ll3Hbdq0CQqFAq1bt87cAIkM1aBBwKhR0txATIKIKBfKUCJ04sQJfPvtt6hZsyYeP34MAPjtt99w8uRJnc+1efNmjBw5En5+fggKCkKlSpXg7e2NZ8+epXlcWFgYRo0ahbp162bkKRBRSh49ktYKe/tW2lYogDlzgFKlZA2LiCiz6JwIbd++Hd7e3rCwsMDFixcRHx8PAFAqlZg5c6bOAcyfPx99+vRBz549Ua5cOSxbtgyWlpZYs2ZNqseoVCp07doVU6dORbFixXR+TCJKwd690ozQ69YB338vdzRERFlC50Toxx9/xLJly7By5UqYmJhoymvXro2goCCdzpWQkIALFy7Ay8vrfUBGRvDy8sKZM2dSPW7atGlwcnJCr169PvkY8fHxiIyM1LoR0QfevQNGjwa++kpaPd7TExgzRu6oiIiyhM6J0M2bN1GvXr1k5XZ2dnjz5o1O53rx4gVUKhUKFCigVV6gQAGEh4eneMzJkyexevVqrFy5Ml2P4e/vDzs7O83Nzc1NpxiJcrX796XFUufOlbaHDgVOnQKKF5c3LiKiLKJzIuTs7Iw7d+4kKz958mSmN1O9ffsW3bp1w8qVK+Hg4JCuY8aNGwelUqm5PXz4MFNjJMoxTpyQmsLOngXs7YGdO6Wh8WZmckdGRJRldB4+36dPHwwbNgxr1qyBQqHAkydPcObMGYwaNQqTJk3S6VwODg4wNjZGRESEVnlERAScnZ2T7X/37l2EhYWhVatWmjK1Wi09kTx5cPPmTRT/6JesmZkZzPjBTpRcyZJS0lOjBrBpE+DuLndERERZTudEaOzYsVCr1WjcuDFiYmJQr149mJmZYdSoURgyZIhO5zI1NYWnpycOHz6sGQKvVqtx+PBhDB48ONn+ZcqUwZUrV7TKJk6ciLdv32LRokVs9iL6lJcvgfz5pf87O0tzBBUrJi2ZQURkgHROhBQKBSZMmIDRo0fjzp07iIqKQrly5WBtbZ2hAEaOHAlfX19UrVoV1atXx8KFCxEdHY2ePXsCALp37w5XV1f4+/vD3NwcFSpU0Dre3t4eAJKVE9FHtm0DevUCVqwAfHyksjJl5I2JiEhmGZ5Z2tTUFOXKlfvsAHx8fPD8+XNMnjwZ4eHh8PDwQGBgoKYD9YMHD2BklC3mfSTKmeLipOHwv/wiba9bB3TsKM0RRERk4BRCCKHLAQ0bNoQijQ/QI0eOfHZQmSkyMhJ2dnZ48kQJFxdbucMhyly3b0tJT3CwtD12LDBtGvDB1BdERDlB0ve3UqmEra3+vr91rhHy8PDQ2n737h2Cg4Nx9epV+Pr66isuIvpcGzcCffsCUVGAgwPw229As2ZyR0VElK3onAgtWLAgxfIpU6YgKirqswMiIj24fPn92mD16gF//AG4usobExFRNqRz01hq7ty5g+rVq+PVq1f6OF2mYdMYGYzRowELC2DyZCBPhrsDEhFlC9mmaSw1Z86cgbm5ub5OR0S62rABqFsXKFxY2v7pJ3aIJiL6BJ0TobZt22ptCyHw9OlT/PfffzpPqEhEehAdDQwZAqxdC9SqJc0NZGLCJIiIKB10ToTs7Oy0to2MjFC6dGlMmzYNTZs21VtgRJQO165Jo8KuXweMjABvb+lfIiJKF50SIZVKhZ49e6JixYrImzdvZsVERJ8ihFQDNHgwEBsLuLhIHaIbNJA7MiKiHEWnn47GxsZo2rSpzqvME5EeRUcD3btLs0THxkq1QMHBTIKIiDJA5zr0ChUq4N69e5kRCxGlh5GRNDze2Bjw9wf27QOcnOSOiogoR9K5j9CPP/6IUaNGYfr06fD09ISVlZXW/foc0kZE/yeEdDMykobEb9kCPH8O1Kkjd2RERDlauucRmjZtGr7//nvY2Ni8P/iDUSlCCCgUCqhUKv1HqUecR4hyHKVSmiG6YkVg4kS5oyEikkVmzSOU7kTI2NgYT58+RUhISJr71a9fXy+BZRYmQpSjXLggrRR/9y5gbg7cuyd1jCYiMjCyT6iYlC9l90SHKFcQAliyBBg1CkhIAIoUATZtYhJERKRnOvURSmvVeSLSkzdvpBFhO3ZI261bA2vWAJyygohI73RKhEqVKvXJZCi7rzVGlK0lJkqzQ4eESLNDz50rzRrNHyFERJlCp0Ro6tSpyWaWJiI9ypMHGDZMWids82agalW5IyIiytXS3VnayMgI4eHhcMrh85WwszRlO69eAU+fAuXLS9tCADExwEdTUxARGbLM6iyd7gkV2T+IKBOcPg14eABffSX1DQKkZjAmQUREWSLdiVA6K46IKD3UamD2bKBePeDhQ6k/0LNnckdFRGRw0t1HSK1WZ2YcRIbj+XPA1xfYv1/a7twZWL4c+GCyUiIiyho6L7FBRJ/h+HEp8XnyRJogcfFiaag8m56JiGTBRIgoK82fLyVBZcpI64VVrCh3REREBo2JEFFWWr0aKFYMmDYNsLaWOxoiIoOX7s7SRJQBR44A338vDYkHgPz5pVohJkFERNkCa4SIMoNKJdX6TJ8uJUE1agAdO8odFRERfYSJEJG+PXkCdO0KHDsmbffqJc0TRERE2Q4TISJ9+vtv4NtvpSHyVlbSsPiuXeWOioiIUsE+QkT6MmcO0KyZlARVqgQEBTEJIiLK5pgIEelL5crSvwMGAGfPAqVKyRsPERF9EpvGiD7Hs2dA0kLEXl7AlSvvF08lIqJsjzVCRBnx7h0werRU63P37vtyJkFERDkKEyEiXd2/D9StC8ydCyiVwF9/yR0RERFlEJvGiHTx559Az57AmzeAnR2wZg3Qtq3cURERUQaxRogoPRISgOHDgTZtpCSoenXg4kUmQUREORwTIaL0WLIEWLRI+v/IkcCJE0DRovLGREREn41NY0TpMXgwcPAgMHAg0KqV3NEQEZGesEaIKCVxcdLiqO/eSdumpsD+/UyCiIhyGdYIEX3s9m3Ax0fqA/T8OeDvL3dERESUSVgjRPShTZuAKlWkJMjBAahXT+6IiIgoEzERIgKA2FigXz+gc2cgKkqaJyg4GGjeXO7IiIgoEzERIrp1C6hRA1ixAlAogIkTgSNHAFdXuSMjIqJMxj5CRGo1cO+etGbYhg3SmmFERGQQmAiRYVKrAaP/V4iWKQPs2AFUrAi4uMgbFxERZSk2jZHhuXYN8PAAjh9/X9a0KZMgIiIDxESIDIcQwOrVQLVqwJUrwPffS2VERGSwmAiRYXj7FujWDejdWxoh1rQpsHev1DmaiIgMFhMhyv0uXQKqVpU6QhsbAzNnSrNEOznJHRkREcmMnaUpdwsJkYbGx8dLw+E3bQLq1JE7KiIiyiaYCFHuVqYM8PXXQHQ0sG6dNFs0ERHR/zERotzn4kWgaFHA3l7qA7RuHWBm9n64PBER0f/xm4FyDyGAJUuAL7+UOkUnjQizsGASREREKWKNEOUOb94AvXpJEyMCQGIiEBcnJUFERESp4M9kyvnOnQMqV5aSIBMTYOFCYOdOJkFERPRJTIQo5xICWLBAGgUWFib1Czp1Chg2jPMDERFRujARopxLqQTmzwfevQPatQOCgqRZo4mIiNKJfYQo57K3BzZulCZMHDiQtUBERKQzJkKUc6jVwNy5gLMz0L27VFanDidIJCKiDGMiRDnD8+eAr6+0NIalJdCwIeDmJndURESUwzERouzvxAmgUyfgyRPA3FwaFVaokNxRERFRLsDO0pR9qdXAjBlAgwZSElS6NPDvv0CfPuwPREREesEaIcqeVCqgZUvgwAFpu1s34JdfAGtreeMiIqJchTVClD0ZGwNVq0r9gdauBdavZxJERER6x0SIsg+VSuoUnWTKFCA4GOjRQ6aAiIgot8sWidDSpUvh7u4Oc3Nz1KhRA+fOnUt135UrV6Ju3brImzcv8ubNCy8vrzT3pxzi6VOgSROgeXMgPl4qy5MHKFlS3riIiChXkz0R2rx5M0aOHAk/Pz8EBQWhUqVK8Pb2xrNnz1Lc/9ixY+jcuTOOHj2KM2fOwM3NDU2bNsXjx4+zOHLSm7//BipVAo4eBW7ckCZIJCIiygIKIYSQM4AaNWqgWrVqWLJkCQBArVbDzc0NQ4YMwdixYz95vEqlQt68ebFkyRJ0T5pkLw2RkZGws7PDkydKuLjYfnb89BkSEwE/P8DfX1o37IsvgC1bpNFhREREH0j6/lYqlbC11d/3t6w1QgkJCbhw4QK8vLw0ZUZGRvDy8sKZM2fSdY6YmBi8e/cO+fLlS/H++Ph4REZGat0oG3j0CGjUCJg5U0qC+vUDzp5lEkRERFlK1kToxYsXUKlUKFCggFZ5gQIFEB4enq5zjBkzBgULFtRKpj7k7+8POzs7zc2NsxFnD336SBMl2tgAmzYBy5YBFhZyR0VERAZG9j5Cn2PWrFnYtGkTdu7cCXNz8xT3GTduHJRKpeb28OHDLI6SUrR0qbRMRlAQ4OMjdzRERGSgZJ1Q0cHBAcbGxoiIiNAqj4iIgLOzc5rHzp07F7NmzcKhQ4fwxRdfpLqfmZkZzMzM9BIvfYYHD6RO0b17S9vFigFHjsgbExERGTxZa4RMTU3h6emJw4cPa8rUajUOHz6MmjVrpnrcTz/9hOnTpyMwMBBVq1bNilDpc+zeDXh4AH37SskQERFRNiH7EhsjR46Er68vqlatiurVq2PhwoWIjo5Gz549AQDdu3eHq6sr/P39AQCzZ8/G5MmT8ccff8Dd3V3Tl8ja2hrWnHk4e0lIAMaMkRZJBYBq1TgvEBERZSuyJ0I+Pj54/vw5Jk+ejPDwcHh4eCAwMFDTgfrBgwcwMnpfcfXrr78iISEB7du31zqPn58fpkyZkpWhU1pCQ6W+P+fPS9sjRgCzZgGmpvLGRURE9AHZ5xHKapxHKAv8+ae0LIZSCeTNCwQEAF9/LXNQRESUk2XWPEKy1whRLhQZKSVBNWtKQ+MLF5Y7IiIiohQxESL9UKmkFeMBoHt3wNwcaNMGMDGRNy4iIqI05Oh5hCib2LQJqFgRePHifVnHjkyCiIgo22MiRBkXGystjdG5MxASAsyfL3dEREREOmHTGGXMjRtSrc+VK4BCAYwfD3DUHhER5TBMhEh3v/0GDBgAREcDTk7A778DTZrIHRUREZHOmAiRbpYvB/r3l/7fsCGwYQPg4iJvTERERBnEPkKkm06dgBIlpGawgweZBBERUY7GGiFKmxDS4qiNGkl9gezsgMuXAQsLuSMjIiL6bKwRotRFRQG+voCXF7Bs2ftyJkFERJRLsEaIUnb5sjQq7OZNwMhI6hhNRESUyzARIm1CACtWAMOGAfHxgKsrsHEjULeu3JERERHpHRMhei8yEujbF9i8Wdpu3hxYvx5wcJA3LiIiokzCPkL03tWrwNat0pphP/0E7NnDJIiIiHI11gjRe7VqAUuWAB4e0srxREREuRxrhAzZmzdAt27SOmFJBgxgEkRERAaDNUKG6vx5wMcHCA0Frl8H/vtPmieIiIjIgLBGyNAIASxcCNSuLSVB7u7SHEFMgoiIyACxRsiQvHoF9OwJ7N4tbbdtC6xeDdjbyxoWERGRXJgIGYrQUKBBA+DBA8DUFJg/Hxg4kDVBRERk0JgIGQo3N6BwYcDEBNiyBahSRe6IiIiIZMdEKDd7+RKwsZFqgPLkkeYIsrQEbG3ljoyIiChbYGfp3OrECaBSJWDMmPdlzs5MgoiIiD7ARCi3UauBmTOBhg2Bx4+BwEAumEpERJQKJkK5ybNnQLNmwIQJgEoFfPutNF+QlZXckREREWVL7COUWxw9CnTpAoSHAxYWwNKlQI8eHBVGRESUBiZCuUFkJNCuHfD6NVCunDQqrHx5uaMiIiLK9pgI5Qa2tsDy5cD+/cDixWwKIyIiSicmQjnVoUOAkRHQqJG03aGDdCMiIqJ0Y2fpnCYxEZg4EWjaFOjcGXj6VO6IiIiIcizWCOUkjx9Lyc+JE9J269ZcJ4yIiOgzMBHKKfbvB7p3B168AKytgZUrgU6d5I6KiIgoR2PTWHanVkuzQ7doISVBlSsDQUFMgoiIiPSAiVB2Z2QkzQ0EAIMGAadPAyVLyhsTERFRLsGmsewqMVFaKBWQJkfs0AH46it5YyIiymQqlQrv3r2TOwySiYmJCYyNjbP0MZkIZTcJCcDYscCdO8CuXdLM0NbWTIKIKNeLiorCo0ePIISQOxSSiUKhQKFChWBtbZ1lj8lEKDsJDQV8fKT1wQDg2DFp8VQiolxOpVLh0aNHsLS0hKOjIxRcHsjgCCHw/PlzPHr0CCVLlsyymiEmQtnFjh3Ad98BSqU0JD4ggEkQERmMd+/eQQgBR0dHWFhYyB0OycTR0RFhYWF49+5dliVC7Cwtt/h4YMgQaa0wpRL48ksgOBj45hu5IyMiynKsCTJsclx/JkJy69oVWLJE+v/o0cDx40CRIvLGREREZCCYCMltzBjAxQXYswf46SfAxETuiIiIiAwGE6GsFhsL/PPP++1q1YB794CWLeWLiYiIPsuZM2dgbGyMlil8lh87dgwKhQJv3rxJdp+7uzsWLlyoVXb06FG0aNEC+fPnh6WlJcqVK4fvv/8ejx8/zqTogbi4OAwaNAj58+eHtbU12rVrh4iIiDSPiYiIQI8ePVCwYEFYWlqiWbNmuH37ttY+d+/eRZs2beDo6AhbW1t07Njxk+fNakyEstLNm1IfIG9vqR9QEnNz2UIiIqLPt3r1agwZMgTHjx/HkydPMnye5cuXw8vLC87Ozti+fTuuX7+OZcuWQalUYt68eXqMWNuIESPw119/YevWrfjnn3/w5MkTtG3bNtX9hRBo3bo17t27h127duHixYsoUqQIvLy8EB0dDQCIjo5G06ZNoVAocOTIEZw6dQoJCQlo1aoV1Gp1pj0XnQkDo1QqBQDx5Ikyax/499+FsLISAhDC0VGIo0ez9vGJiLKx2NhYcf36dREbGyt3KDp7+/atsLa2Fjdu3BA+Pj5ixowZWvcfPXpUABCvX79OdmyRIkXEggULhBBCPHz4UJiamorhw4en+DgpHa8Pb968ESYmJmLr1q2aspCQEAFAnDlzJsVjbt68KQCIq1evaspUKpVwdHQUK1euFEIIceDAAWFkZCSUyvfft2/evBEKhUIcPHgwxfOm9T5I+v7+8Hz6wBqhzBYTA/TuDXz7LRAdDTRoINUGNWggc2BERNmXENJHphw3Xedz3LJlC8qUKYPSpUvj22+/xZo1azI0KeTWrVuRkJCAH374IcX77e3tUz22efPmsLa2TvVWvnz5VI+9cOEC3r17By8vL01ZmTJlULhwYZw5cybFY+Lj4wEA5h+0aBgZGcHMzAwnT57U7KNQKGBmZqbZx9zcHEZGRpp9sgPOI5SZrl8HOnYErl2TZoiePBmYNAnI4unDiYhympgYaVJ9OURFAVZW6d9/9erV+PbbbwEAzZo1g1KpxD///IMGOv7gvX37NmxtbeHi4qLTcQCwatUqxMbGpnq/SRoDccLDw2Fqapos0SpQoADCk9a6/EhSojRu3DgsX74cVlZWWLBgAR49eoSnT58CAL788ktYWVlhzJgxmDlzJoQQGDt2LFQqlWaf7ICJUGbatUtKgpydgQ0bgEaN5I6IiIj06ObNmzh37hx27twJAMiTJw98fHywevVqnRMhIUSG59FxdXXN0HEZZWJigh07dqBXr17Ily8fjI2N4eXlhebNm2tqwxwdHbF161YMGDAAP//8M4yMjNC5c2dUqVIFRkbZp0GKiVBm+uEHqZ51yBCgQAG5oyEiyjEsLaWaGbkeO71Wr16NxMREFCxYUFMmhICZmRmWLFkCOzs72NraAgCUSmWyWpc3b97Azs4OAFCqVCkolUo8ffpU51qh5s2b48SJE6neX6RIEVy7di3F+5ydnZGQkIA3b95oxRcREQFnZ+dUz+np6Yng4GAolUokJCTA0dERNWrUQNWqVTX7NG3aFHfv3sWLFy+QJ08e2Nvbw9nZGcWKFdPp+WUmJkL6dOUKMG0asH49YGEhNYH9+KPcURER5TgKhW7NU3JITEzE+vXrMW/ePDRt2lTrvtatW2Pjxo3o378/SpYsCSMjI1y4cAFFPpgw9969e1AqlShVqhQAoH379hg7dix++uknLFiwINnjfZyofOhzmsY8PT1hYmKCw4cPo127dgCkmq4HDx6gZs2aqR6XJCmRu337Nv777z9Mnz492T4ODg4AgCNHjuDZs2f4+uuvP3nerMJESB+EAFatAoYOBeLigGLFgNmz5Y6KiIgy0Z49e/D69Wv06tVLkwwkadeuHVavXo3+/fvDxsYGvXv3xvfff488efKgYsWKePjwIcaMGYMvv/wStWrVAgC4ublhwYIFGDx4MCIjI9G9e3e4u7vj0aNHWL9+PaytrVMdQv85TWN2dnbo1asXRo4ciXz58sHW1hZDhgxBzZo18eWXX2r2K1OmDPz9/dGmTRsAUuduR0dHFC5cGFeuXMGwYcPQunVrraRw7dq1KFu2LBwdHXHmzBkMGzYMI0aMQOnSpTMcr97pdQxaDqD34fNKpRCdOknD4gEhmjUT4tkz/ZybiMhA5MTh81999ZVo0aJFivf9+++/AoC4dOmSEEJ6fn5+fqJMmTLCwsJCFC1aVPTt21c8f/482bEHDx4U3t7eIm/evMLc3FyUKVNGjBo1Sjx58iTTnktsbKwYOHCgyJs3r7C0tBRt2rQRT58+1doHgFi7dq1me9GiRaJQoULCxMREFC5cWEycOFHEx8drHTNmzBhRoEABYWJiIkqWLCnmzZsn1Gp1mnFk9fB5hRAZGOOXg0VGRsLOzg5Pnijh4mL7eSe7eFEaFXbnjtQMNnMmMGoUkI06gRER5QRxcXEIDQ1F0aJFtYZkk2FJ632Q9P2tVCo1/a70gU1jGbVzJ9CpE5CQALi5AZs2Af+v3iQiIqKcgYlQRlWtKk1yUbs2sHYtkD+/3BERERGRjpgI6eLxYyCpQ5qbG3DunNQxOoPzPhAREZG82JklPYQAFi2Skp7du9+XFy/OJIiIiCgHYyL0Ka9eAW3aAMOHS/2BPkyEiIiIKEdjIpSWs2eBypWlpTJMTYHFi4GVK+WOiogo1zKwgcz0ETmuPxOhlKjVwNy5QN26wIMHUhPY6dPA4MFsCiMiygTG/1+MOiEhQeZISE5J1984CxcnZ2fplBw/DoweLf2/Y0epFkiPcxYQEZG2PHnywNLSEs+fP4eJiUm2WpSTsoZarcbz589haWmJPHmyLj1hIpSSBg2AYcOAMmWAfv1YC0RElMkUCgVcXFwQGhqK+/fvyx0OycTIyAiFCxeGIgu/d5kIAVJT2KJFQOfOQNJKuwsXyhoSEZGhMTU1RcmSJdk8ZsBMTU2zvDYwWyRCS5cuxZw5cxAeHo5KlSph8eLFqF69eqr7b926FZMmTUJYWBhKliyJ2bNno0WLFhl78GfPgG7dgL//BvbsAQ4e5BIZREQyMTIy4hIblKVk/8bfvHkzRo4cCT8/PwQFBaFSpUrw9vbGs2fPUtz/9OnT6Ny5M3r16oWLFy+idevWaN26Na5evar7gx87Bnh4SEmQhQXQtSubwYiIiAyI7Iuu1qhRA9WqVcOSJUsASJ2l3NzcMGTIEIwdOzbZ/j4+PoiOjsaePXs0ZV9++SU8PDywbNmyTz5e0qJtz0eNg8P82VKzWNmywJYtQIUK+ntiREREpDeZteiqrDVCCQkJuHDhAry8vDRlRkZG8PLywpkzZ1I85syZM1r7A4C3t3eq+6fGdK6/lAT17AmcP88kiIiIyADJ2kfoxYsXUKlUKFCggFZ5gQIFcOPGjRSPCQ8PT3H/8PDwFPePj49HfHy8ZlupVEr/mptLHaQ7dQJUKiAy8nOeChEREWWiyP9/T+u7IStbdJbOTP7+/pg6dWqy8sJxcdLQ+H79ZIiKiIiIMuLly5ews7PT2/lkTYQcHBxgbGyMiIgIrfKIiAg4Jw1j/4izs7NO+48bNw4jR47UbL958wZFihTBgwcP9PpCku4iIyPh5uaGhw8f6rW9lzKG1yP74LXIPngtsg+lUonChQsjX758ej2vrImQqakpPD09cfjwYbRu3RqA1Fn68OHDGDx4cIrH1KxZE4cPH8bw4cM1ZQcPHkTNmjVT3N/MzAxmZmbJyu3s7PimziZsbW15LbIRXo/sg9ci++C1yD70Pc+Q7E1jI0eOhK+vL6pWrYrq1atj4cKFiI6ORs+ePQEA3bt3h6urK/z9/QEAw4YNQ/369TFv3jy0bNkSmzZtwn///YcVK1bI+TSIiIgoB5I9EfLx8cHz588xefJkhIeHw8PDA4GBgZoO0Q8ePNDK/mrVqoU//vgDEydOxPjx41GyZEn8+eefqMBRX0RERKQj2RMhABg8eHCqTWHHjh1LVtahQwd06NAhQ49lZmYGPz+/FJvLKGvxWmQvvB7ZB69F9sFrkX1k1rWQfUJFIiIiIrnIvsQGERERkVyYCBEREZHBYiJEREREBouJEBERERmsXJkILV26FO7u7jA3N0eNGjVw7ty5NPffunUrypQpA3Nzc1SsWBH79u3LokhzP12uxcqVK1G3bl3kzZsXefPmhZeX1yevHelG17+NJJs2bYJCodBMfEqfT9dr8ebNGwwaNAguLi4wMzNDqVKl+FmlJ7pei4ULF6J06dKwsLCAm5sbRowYgbi4uCyKNvc6fvw4WrVqhYIFC0KhUODPP//85DHHjh1DlSpVYGZmhhIlSiAgIED3Bxa5zKZNm4SpqalYs2aNuHbtmujTp4+wt7cXERERKe5/6tQpYWxsLH766Sdx/fp1MXHiRGFiYiKuXLmSxZHnPrpeiy5duoilS5eKixcvipCQENGjRw9hZ2cnHj16lMWR5066Xo8koaGhwtXVVdStW1d88803WRNsLqfrtYiPjxdVq1YVLVq0ECdPnhShoaHi2LFjIjg4OIsjz310vRYbNmwQZmZmYsOGDSI0NFQcOHBAuLi4iBEjRmRx5LnPvn37xIQJE8SOHTsEALFz58409793756wtLQUI0eOFNevXxeLFy8WxsbGIjAwUKfHzXWJUPXq1cWgQYM02yqVShQsWFD4+/unuH/Hjh1Fy5Yttcpq1Kgh+vXrl6lxGgJdr8XHEhMThY2NjVi3bl1mhWhQMnI9EhMTRa1atcSqVauEr68vEyE90fVa/Prrr6JYsWIiISEhq0I0GLpei0GDBolGjRpplY0cOVLUrl07U+M0NOlJhH744QdRvnx5rTIfHx/h7e2t02PlqqaxhIQEXLhwAV5eXpoyIyMjeHl54cyZMykec+bMGa39AcDb2zvV/Sl9MnItPhYTE4N3797pfYE9Q5TR6zFt2jQ4OTmhV69eWRGmQcjItdi9ezdq1qyJQYMGoUCBAqhQoQJmzpwJlUqVVWHnShm5FrVq1cKFCxc0zWf37t3Dvn370KJFiyyJmd7T1/d3tphZWl9evHgBlUqlWZ4jSYECBXDjxo0UjwkPD09x//Dw8EyL0xBk5Fp8bMyYMShYsGCyNzrpLiPX4+TJk1i9ejWCg4OzIELDkZFrce/ePRw5cgRdu3bFvn37cOfOHQwcOBDv3r2Dn59fVoSdK2XkWnTp0gUvXrxAnTp1IIRAYmIi+vfvj/Hjx2dFyPSB1L6/IyMjERsbCwsLi3SdJ1fVCFHuMWvWLGzatAk7d+6Eubm53OEYnLdv36Jbt25YuXIlHBwc5A7H4KnVajg5OWHFihXw9PSEj48PJkyYgGXLlskdmsE5duwYZs6ciV9++QVBQUHYsWMH9u7di+nTp8sdGmVQrqoRcnBwgLGxMSIiIrTKIyIi4OzsnOIxzs7OOu1P6ZORa5Fk7ty5mDVrFg4dOoQvvvgiM8M0GLpej7t37yIsLAytWrXSlKnVagBAnjx5cPPmTRQvXjxzg86lMvK34eLiAhMTExgbG2vKypYti/DwcCQkJMDU1DRTY86tMnItJk2ahG7duqF3794AgIoVKyI6Ohp9+/bFhAkTtBYJp8yV2ve3ra1tumuDgFxWI2RqagpPT08cPnxYU6ZWq3H48GHUrFkzxWNq1qyptT8AHDx4MNX9KX0yci0A4KeffsL06dMRGBiIqlWrZkWoBkHX61GmTBlcuXIFwcHBmtvXX3+Nhg0bIjg4GG5ublkZfq6Skb+N2rVr486dO5pkFABu3boFFxcXJkGfISPXIiYmJlmyk5SgCi7dmaX09v2tWz/u7G/Tpk3CzMxMBAQEiOvXr4u+ffsKe3t7ER4eLoQQolu3bmLs2LGa/U+dOiXy5Mkj5s6dK0JCQoSfnx+Hz+uJrtdi1qxZwtTUVGzbtk08ffpUc3v79q1cTyFX0fV6fIyjxvRH12vx4MEDYWNjIwYPHixu3rwp9uzZI5ycnMSPP/4o11PINXS9Fn5+fsLGxkZs3LhR3Lt3T/z999+iePHiomPHjnI9hVzj7du34uLFi+LixYsCgJg/f764ePGiuH//vhBCiLFjx4pu3bpp9k8aPj969GgREhIili5dyuHzSRYvXiwKFy4sTE1NRfXq1cXZs2c199WvX1/4+vpq7b9lyxZRqlQpYWpqKsqXLy/27t2bxRHnXrpciyJFiggAyW5+fn5ZH3gupevfxoeYCOmXrtfi9OnTokaNGsLMzEwUK1ZMzJgxQyQmJmZx1LmTLtfi3bt3YsqUKaJ48eLC3NxcuLm5iYEDB4rXr19nfeC5zNGjR1P8Dkh6/X19fUX9+vWTHePh4SFMTU1FsWLFxNq1a3V+XIUQrMsjIiIiw5Sr+ggRERER6YKJEBERERksJkJERERksJgIERERkcFiIkREREQGi4kQERERGSwmQkRERGSwmAgRkZaAgADY29vLHUaGKRQK/Pnnn2nu06NHD7Ru3TpL4iGi7I2JEFEu1KNHDygUimS3O3fuyB0aAgICNPEYGRmhUKFC6NmzJ549e6aX8z99+hTNmzcHAISFhUGhUCA4OFhrn0WLFiEgIEAvj5eaKVOmaJ6nsbEx3Nzc0LdvX7x69Uqn8zBpI8pcuWr1eSJ6r1mzZli7dq1WmaOjo0zRaLO1tcXNmzehVqtx6dIl9OzZE0+ePMGBAwc++9yprRr+ITs7u89+nPQoX748Dh06BJVKhZCQEHz33XdQKpXYvHlzljw+EX0aa4SIcikzMzM4Oztr3YyNjTF//nxUrFgRVlZWcHNzw8CBAxEVFZXqeS5duoSGDRvCxsYGtra28PT0xH///ae5/+TJk6hbty4sLCzg5uaGoUOHIjo6Os3YFAoFnJ2dUbBgQTRv3hxDhw7FoUOHEBsbC7VajWnTpqFQoUIwMzODh4cHAgMDNccmJCRg8ODBcHFxgbm5OYoUKQJ/f3+tcyc1jRUtWhQAULlyZSgUCjRo0ACAdi3LihUrULBgQa2V3QHgm2++wXfffafZ3rVrF6pUqQJzc3MUK1YMU6dORWJiYprPM0+ePHB2doarqyu8vLzQoUMHHDx4UHO/SqVCr169ULRoUVhYWKB06dJYtGiR5v4pU6Zg3bp12LVrl6Z26dixYwCAhw8fomPHjrC3t0e+fPnwzTffICwsLM14iCg5JkJEBsbIyAg///wzrl27hnXr1uHIkSP44YcfUt2/a9euKFSoEM6fP48LFy5g7NixMDExAQDcvXsXzZo1Q7t27XD58mVs3rwZJ0+exODBg3WKycLCAmq1GomJiVi0aBHmzZuHuXPn4vLly/D29sbXX3+N27dvAwB+/vln7N69G1u2bMHNmzexYcMGuLu7p3jec+fOAQAOHTqEp0+fYseOHcn26dChA16+fImjR49qyl69eoXAwEB07doVAHDixAl0794dw4YNw/Xr17F8+XIEBARgxowZ6X6OYWFhOHDgAExNTTVlarUahQoVwtatW3H9+nVMnjwZ48ePx5YtWwAAo0aNQseOHdGsWTM8ffoUT58+Ra1atfDu3Tt4e3vDxsYGJ06cwKlTp2BtbY1mzZohISEh3TEREZArV58nMnS+vr7C2NhYWFlZaW7t27dPcd+tW7eK/Pnza7bXrl0r7OzsNNs2NjYiICAgxWN79eol+vbtq1V24sQJYWRkJGJjY1M85uPz37p1S5QqVUpUrVpVCCFEwYIFxYwZM7SOqVatmhg4cKAQQoghQ4aIRo0aCbVaneL5AYidO3cKIYQIDQ0VAMTFixe19vH19RXffPONZvubb74R3333nWZ7+fLlomDBgkKlUgkhhGjcuLGYOXOm1jl+++034eLikmIMQgjh5+cnjIyMhJWVlTA3N9espD1//vxUjxFCiEGDBol27dqlGmvSY5cuXVrrNYiPjxcWFhbiwIEDaZ6fiLSxjxBRLtWwYUP8+uuvmm0rKysAUu2Iv78/bty4gcjISCQmJiIuLg4xMTGwtLRMdp6RI0eid+/e+O233zTNO8WLFwcgNZtdvnwZGzZs0OwvhIBarUZoaCjKli2bYmxKpRLW1tZQq9WIi4tDnTp1sGrVKkRGRuLJkyeoXbu21v61a9fGpUuXAEjNWk2aNEHp0qXRrFkzfPXVV2jatOlnvVZdu3ZFnz598Msvv8DMzAwbNmxAp06dYGRkpHmep06d0qoBUqlUab5uAFC6dGns3r0bcXFx+P333xEcHIwhQ4Zo7bN06VKsWbMGDx48QGxsLBISEuDh4ZFmvJcuXcKdO3dgY2OjVR4XF4e7d+9m4BUgMlxMhIhyKSsrK5QoUUKrLCwsDF999RUGDBiAGTNmIF++fDh58iR69eqFhISEFL/Qp0yZgi5dumDv3r3Yv38//Pz8sGnTJrRp0wZRUVHo168fhg4dmuy4woULpxqbjY0NgoKCYGRkBBcXF1hYWAAAIiMjP/m8qlSpgtDQUOzfvx+HDh1Cx44d4eXlhW3btn3y2NS0atUKQgjs3bsX1apVw4kTJ7BgwQLN/VFRUZg6dSratm2b7Fhzc/NUz2tqaqq5BrNmzULLli0xdepUTJ8+HQCwadMmjBo1CvPmzUPNmjVhY2ODOXPm4N9//00z3qioKHh6emoloEmyS4d4opyCiRCRAblw4QLUajXmzZunqe1I6o+SllKlSqFUqVIYMWIEOnfujLVr16JNmzaoUqUKrl+/nizh+hQjI6MUj7G1tUXBggVx6tQp1K9fX1N+6tQpVK9eXWs/Hx8f+Pj4oH379mjWrBlevXqFfPnyaZ0vqT+OSqVKMx5zc3O0bdsWGzZswJ07d1C6dGlUqVJFc3+VKlVw8+ZNnZ/nxyZOnIhGjRphwIABmudZq1YtDBw4ULPPxzU6pqamyeKvUqUKNm/eDCcnJ9ja2n5WTESGjp2liQxIiRIl8O7dOyxevBj37t3Db7/9hmXLlqW6f2xsLAYPHoxjx47h/v37OHXqFM6fP69p8hozZgxOnz6NwYMHIzg4GLdv38auXbt07iz9odGjR2P27NnYvHkzbt68ibFjxyI4OBjDhg0DAMyfPx8bN27EjRs3cOvWLWzduhXOzs4pTgLp5OQECwsLBAYGIiIiAkqlMtXH7dq1K/bu3Ys1a9ZoOkknmTx5MtavX4+pU6fi2rVrCAkJwaZNmzBx4kSdnlvNmjXxxRdfYObMmQCAkiVL4r///sOBAwdw69YtTJo0CefPn9c6xt3dHZcvX8bNmzfx4sULvHv3Dl27doWDgwO++eYbnDhxAqGhoTh27BiGDh2KR48e6RQTkcGTu5MSEelfSh1sk8yfP1+4uLgICwsL4e3tLdavXy8AiNevXwshtDszx8fHi06dOgk3NzdhamoqChYsKAYPHqzVEfrcuXOiSZMmwtraWlhZWYkvvvgiWWfnD33cWfpjKpVKTJkyRbi6ugoTExNRqVIlsX//fs39K1asEB4eHsLKykrY2tqKxo0bi6CgIM39+KCztBBCrFy5Uri5uQkjIyNRv379VF8flUolXFxcBABx9+7dZHEFBgaKWrVqCQsLC2FrayuqV68uVqxYkerz8PPzE5UqVUpWvnHjRmFmZiYePHgg4uLiRI8ePYSdnZ2wt7cXAwYMEGPHjtU67tmzZ5rXF4A4evSoEEKIp0+fiu7duwsHBwdhZmYmihUrJvr06SOUSmWqMRFRcgohhJA3FSMiIiKSB5vGiIiIyGAxESIiIiKDxUSIiIiIDBYTISIiIjJYTISIiIjIYDERIiIiIoPFRIiIiIgMFhMhIiIiMlhMhIiIiMhgMREiIiIig8VEiIiIiAwWEyEiIiIyWP8DOpsxg2c/V0sAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -307,52 +347,62 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 4 AUC: 0.9892111111111112\n", + "Overall, depth: 4 AUC: 0.9868333333333333\n", "doing digit 0 doing signature level 5\n", - "fit_time: 2.3774771690368652\n", - "compute_auc_time: 0.32339024543762207\n", - "depth: 5 , Auc of digit: 0 is 0.9933333333333334\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 2.007327079772949\n", + "compute_auc_time: 0.16542577743530273\n", + "depth: 5 , Auc of digit: 0 is 0.9911111111111112\n", "doing digit 1 doing signature level 5\n", - "fit_time: 2.3257060050964355\n", - "compute_auc_time: 0.4489150047302246\n", - "depth: 5 , Auc of digit: 1 is 0.9911111111111112\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.7294988632202148\n", + "compute_auc_time: 0.18907880783081055\n", + "depth: 5 , Auc of digit: 1 is 0.9922222222222223\n", "doing digit 2 doing signature level 5\n", - "fit_time: 2.6403658390045166\n", - "compute_auc_time: 0.3673131465911865\n", - "depth: 5 , Auc of digit: 2 is 0.9966666666666667\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.8666350841522217\n", + "compute_auc_time: 0.16200900077819824\n", + "depth: 5 , Auc of digit: 2 is 0.9988888888888889\n", "doing digit 3 doing signature level 5\n", - "fit_time: 2.5935380458831787\n", - "compute_auc_time: 0.5372729301452637\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.635429859161377\n", + "compute_auc_time: 0.18326902389526367\n", "depth: 5 , Auc of digit: 3 is 1.0\n", "doing digit 4 doing signature level 5\n", - "fit_time: 2.544213056564331\n", - "compute_auc_time: 0.4548349380493164\n", - "depth: 5 , Auc of digit: 4 is 0.9977777777777778\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.9687061309814453\n", + "compute_auc_time: 0.18990612030029297\n", + "depth: 5 , Auc of digit: 4 is 1.0\n", "doing digit 5 doing signature level 5\n", - "fit_time: 2.757185935974121\n", - "compute_auc_time: 0.566464900970459\n", - "depth: 5 , Auc of digit: 5 is 0.9933333333333333\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 2.0886638164520264\n", + "compute_auc_time: 0.19944500923156738\n", + "depth: 5 , Auc of digit: 5 is 0.9933333333333334\n", "doing digit 6 doing signature level 5\n", - "fit_time: 2.504159927368164\n", - "compute_auc_time: 0.41169309616088867\n", - "depth: 5 , Auc of digit: 6 is 0.9855555555555555\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.9900450706481934\n", + "compute_auc_time: 0.12359023094177246\n", + "depth: 5 , Auc of digit: 6 is 0.9988888888888889\n", "doing digit 7 doing signature level 5\n", - "fit_time: 2.4034860134124756\n", - "compute_auc_time: 0.4391207695007324\n", - "depth: 5 , Auc of digit: 7 is 0.9833333333333334\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.5356130599975586\n", + "compute_auc_time: 0.18652963638305664\n", + "depth: 5 , Auc of digit: 7 is 0.9644444444444445\n", "doing digit 8 doing signature level 5\n", - "fit_time: 2.4482288360595703\n", - "compute_auc_time: 0.43535900115966797\n", + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.723020076751709\n", + "compute_auc_time: 0.16846275329589844\n", "depth: 5 , Auc of digit: 8 is 1.0\n", "doing digit 9 doing signature level 5\n", - "fit_time: 2.3607637882232666\n", - "compute_auc_time: 0.35583996772766113\n", - "depth: 5 , Auc of digit: 9 is 0.9944444444444445\n" + "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", + "fit_time: 1.510901927947998\n", + "compute_auc_time: 0.15943002700805664\n", + "depth: 5 , Auc of digit: 9 is 0.94\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByWElEQVR4nO3dd1hTZxsG8Dsge6qAIKK4d0Vx1L1QtNbWjaOK1lH3qtYtWqto3a221om2DpzVVsU6665WxYkb6gR3kC3J+/1xvkQjQwKBA+T+XVcuPW/OOXmSQ5In71QIIQSIiIiIjJCJ3AEQERERyYWJEBERERktJkJERERktJgIERERkdFiIkRERERGi4kQERERGS0mQkRERGS0mAgRERGR0WIiREREREaLiZAR8vT0RO/eveUOw+g0adIETZo0kTuMD5o2bRoUCgWePXsmdyi5jkKhwLRp0wxyroiICCgUCgQFBRnkfHldVt4fvXv3hqenZ5Zj2Lx5MwoVKoSYmJgP7mvIvwV9HTlyBAqFAlu3bpXl8d8VEhICW1tbPH36VO5QMo2JkIEFBQVBoVBobwUKFIC7uzt69+6Nhw8fyh1erhYbG4sZM2bgo48+grW1NRwcHNCwYUOsW7cOeWUlmGvXrmHatGmIiIiQO5QUVCoV1qxZgyZNmqBQoUKwsLCAp6cn+vTpg3///Vfu8Axiw4YNWLRokdxh6MiJmDRJleZmamqK4sWLo3379ggNDc3Wx05N7969deKxtbVFqVKl0KlTJ2zbtg1qtTpbHz8uLg7Tpk3DkSNHMnyMSqVCQEAAhg0bBltb2+wLTg9y/j2/fw01twoVKujs16pVK5QpUwaBgYGyxGkIBeQOIL/69ttvUbJkSSQkJOD06dMICgrC8ePHceXKFVhaWsoa240bN2Bikrty4KioKDRv3hxhYWHo2rUrhg4dioSEBGzbtg3+/v7Ys2cP1q9fD1NTU7lDTde1a9cwffp0NGnSJMUv1L/++kueoADEx8ejQ4cOCAkJQaNGjTBx4kQUKlQIERER2Lx5M9auXYt79+6hWLFissVoCBs2bMCVK1cwcuTIbDl/fHw8ChTQ72MzrZhKlCiB+Ph4mJmZGSy+bt264ZNPPoFKpUJYWBh+/vln7N27F6dPn4aXl5fBHicjLCwssHLlSgDS6/bff//hjz/+QKdOndCkSRPs3LkT9vb22v2z8v5YsWKFTnIVFxeH6dOnA0CGa5n++OMP3LhxAwMGDMh0HIaW3X/PH/LuNdRwcHBIsd9XX32FMWPGYPr06bCzs8up8AyGiVA2ad26NWrWrAkA6NevH5ycnDBnzhzs2rULXbp0kTU2CwuLHH/MhIQEmJubp5mA+fv7IywsDDt27MBnn32mLR8+fDjGjh2LefPmoXr16hg3blxOhQxAqqWysbExyLnMzc0Ncp7MGDt2LEJCQrBw4cIUH6oBAQFYuHBhjsYjhEBCQgKsrKxy9HEzQ61WIykpCZaWlgb9EaNQKAz+o6hGjRr44osvtNv169fHZ599hp9//hm//PKLQR/rQwoUKKATCwB89913mD17NiZMmID+/fsjODhYe19W3h+GSCbXrFmD+vXrw93dPcvnyi9Su4ap6dixI4YNG4YtW7bgyy+/zIHIDEyQQa1Zs0YAEGfPntUp//PPPwUAMWvWLJ3ysLAw0bFjR1GwYEFhYWEhvL29xc6dO1Oc9+XLl2LkyJGiRIkSwtzcXLi7u4uePXuKp0+favdJSEgQU6dOFaVLlxbm5uaiWLFiYuzYsSIhIUHnXCVKlBD+/v5CCCHOnj0rAIigoKAUjxkSEiIAiD/++ENb9uDBA9GnTx/h4uIizM3NRaVKlcSqVat0jjt8+LAAIDZu3CgmTZokihYtKhQKhXj58mWqr9mpU6cEAPHll1+mev+bN29E2bJlRcGCBUVcXJwQQojw8HABQMydO1csWLBAFC9eXFhaWopGjRqJy5cvpzhHRl5nzbU7cuSIGDRokHB2dhaOjo5CCCEiIiLEoEGDRLly5YSlpaUoVKiQ6NSpkwgPD09x/Pu3w4cPCyGEaNy4sWjcuHGK1yk4OFh89913wt3dXVhYWIhmzZqJW7dupXgOS5YsESVLlhSWlpaiVq1a4ujRoynOmZr79++LAgUKiBYtWqS7n0ZAQIAAIG7duiX8/f2Fg4ODsLe3F7179xaxsbE6+65evVo0bdpUODs7C3Nzc1GxYkXx008/pThniRIlRJs2bURISIjw9vYWFhYWYuHChXqdQwgh9uzZIxo1aiRsbW2FnZ2dqFmzpli/fr0QQnp933/tS5QooT02o+8PAGLIkCHit99+E5UqVRIFChQQO3bs0N4XEBCg3Tc6OlqMGDFC+750dnYWPj4+4ty5cx+MSfM3vGbNGp3HDwsLE507dxZOTk7C0tJSlCtXTkycODG9S6bzfnhXTEyMAKBz7U+fPi18fX2Fvb29sLKyEo0aNRLHjx/XOU6fv4HU+Pv7CxsbmzTvb9mypVAoFOLGjRvastT+liMiIkTbtm2FtbW1cHZ2FiNHjtR+LmneV5rHe/91ff/27nV7X3x8vDA3NxfTpk1LcV9CQoIYOXKkcHJyEra2tqJt27bi/v37qZ5Tn8/HTZs2iQkTJogiRYoIa2tr0bZtW3Hv3j2d1yOtvx19PzsyQ3MNk5OThVKp/OD+1atXF5999plBHjunsUYoh2j6jBQsWFBbdvXqVe0vkPHjx8PGxgabN29Gu3btsG3bNrRv3x4AEBMTg4YNGyIsLAxffvklatSogWfPnmHXrl148OABnJycoFar8dlnn+H48eMYMGAAKlasiMuXL2PhwoW4efMmfv/991TjqlmzJkqVKoXNmzfD399f577g4GAULFgQvr6+AKTmq48//hgKhQJDhw6Fs7Mz9u7di759+yI6OjpFTcOMGTNgbm6OMWPGIDExMc1ffH/88QcAoFevXqneX6BAAXTv3h3Tp0/HiRMn4OPjo71v3bp1eP36NYYMGYKEhAQsXrwYzZo1w+XLl1GkSBG9XmeNwYMHw9nZGVOnTkVsbCwA4OzZszh58iS6du2KYsWKISIiAj///DOaNGmCa9euwdraGo0aNcLw4cPxww8/YOLEiahYsSIAaP9Ny+zZs2FiYoIxY8ZAqVTi+++/R48ePfDPP/9o9/n5558xdOhQNGzYEKNGjUJERATatWuHggULfrA5a+/evUhOTkbPnj3T3e99Xbp0QcmSJREYGIjz589j5cqVcHFxwZw5c3Tiqly5Mj777DMUKFAAf/zxBwYPHgy1Wo0hQ4bonO/GjRvo1q0bvvrqK/Tv3x/ly5fX6xxBQUH48ssvUblyZUyYMAGOjo64cOECQkJC0L17d0yaNAlKpRIPHjzQ1nBp+nro+/44dOgQNm/ejKFDh8LJySnNjrgDBw7E1q1bMXToUFSqVAnPnz/H8ePHERYWhho1aqQbU2ouXbqEhg0bwszMDAMGDICnpyfu3LmDP/74AzNnzszYhXvHnTt3AACFCxfWPq/WrVvD29sbAQEBMDExwZo1a9CsWTMcO3YMtWvX1jk+I38DmdGzZ0/89ddf2L9/P8qVK5fqPrGxsWjWrBkeP36MESNGwNXVFRs2bMDhw4fTPbezszN+/vlnDBo0CO3bt0eHDh0AAB999FGax5w7dw5JSUmoUaNGivv69euH3377Dd27d0e9evVw6NAhtGnTJsV++n4+zpw5EwqFAuPGjcOTJ0+waNEi+Pj4IDQ0FFZWVhn628nIZ0dcXBzi4uLSfc0AwNTUVOf7SXOsvb094uLiULBgQXTr1g1z5sxJ9W/Y29s7ze+ZXE/uTCy/0dQKHDhwQDx9+lTcv39fbN26VTg7OwsLCwtx//597b7NmzcXVatW1flFqlarRb169UTZsmW1ZVOnThUAxPbt21M8nlqtFkII8euvvwoTExNx7NgxnfuXLVsmAIgTJ05oy96tERJCiAkTJggzMzPx4sULbVliYqJwdHTUqaXp27evcHNzE8+ePdN5jK5duwoHBwdtbY3m10qpUqW0Zelp166dAJBmjZEQQmzfvl0AED/88IMQ4u2vPisrK/HgwQPtfv/8848AIEaNGqUty+jrrLl2DRo0EMnJyTqPn9rz0NRkrVu3Tlu2ZcuWFL9WNdKqEapYsaJITEzUli9evFgA0NZsJSYmisKFC4tatWqJN2/eaPcLCgoSAD5YIzRq1CgBQFy4cCHd/TQ0tQHv19C1b99eFC5cWKcstdfF19dXlCpVSqesRIkSAoAICQlJsX9GzvHq1SthZ2cn6tSpI+Lj43X21bwHhBCiTZs2OrVAGvq8PwAIExMTcfXq1RTnwXu1AA4ODmLIkCEp9ntXWjGlViPUqFEjYWdnJ/777780n2NqNOeaPn26ePr0qYiMjBRHjhwR1atXFwDEtm3bhFqtFmXLlhW+vr4654uLixMlS5bUqTXS528gNR+qEbpw4UKK9+n774/58+cLAOL333/XlsXHx4sKFSqkWyMkhBBPnz79YC3Qu1auXKnzntMIDQ0VAMTgwYN1yrt3757i/Pp+Prq7u4vo6Gjtfps3bxYAxOLFi7Vlaf3tZPSzQ4i31/JDt/cfZ/z48WLcuHEiODhYbNy4Ufj7+wsAon79+jqfQxqzZs0SAERUVFSK+3K73NVjNh/x8fGBs7MzPDw80KlTJ9jY2GDXrl3aX+8vXrzAoUOH0KVLF7x+/RrPnj3Ds2fP8Pz5c/j6+uLWrVvaUWbbtm1DtWrVUtRcAFI/AwDYsmULKlasiAoVKmjP9ezZMzRr1gwA0v0V5efnhzdv3mD79u3asr/++guvXr2Cn58fAKlPx7Zt29C2bVsIIXQew9fXF0qlEufPn9c5r7+/f4b6gLx+/RoA0u1kp7kvOjpap7xdu3Y6bfq1a9dGnTp1sGfPHgD6vc4a/fv3T9Ep+93n8ebNGzx//hxlypSBo6Njiuetrz59+ujUljVs2BAAcPfuXQDAv//+i+fPn6N///46HXV79OiR4hdcajSvmb6dGAcOHKiz3bBhQzx//lznGrz7uiiVSjx79gyNGzfG3bt3oVQqdY4vWbKktnbxXRk5x/79+/H69WuMHz8+Rb8azXsgPfq+Pxo3boxKlSp98LyOjo74559/8OjRow/u+yFPnz7F0aNH8eWXX6J48eI692XkOQJSfy9nZ2e4urqiSZMmuHPnDubMmYMOHTogNDQUt27dQvfu3fH8+XPtaxAbG4vmzZvj6NGjKUZzZeRvIDM0NQqa935qQkJC4O7urtNn0NLSEv3798/SY6fm+fPnAJDi/aT5HBk+fLhO+fu1O5n5fOzVq5fOe7JTp05wc3PTPmZGfOizQ/M4+/fv/+Bt/fr1OucODAzE7Nmz0aVLF3Tt2hVBQUGYOXMmTpw4keqwfc1rlxen3WDTWDZZunQpypUrB6VSidWrV+Po0aM6nZRv374NIQSmTJmCKVOmpHqOJ0+ewN3dHXfu3EHHjh3Tfbxbt24hLCwMzs7OaZ4rLdWqVUOFChUQHByMvn37ApCaxZycnLRfFE+fPsWrV6+wfPlyLF++PEOPUbJkyXRj1tB8GLx+/RqOjo6p7pNWslS2bNkU+5YrVw6bN28GoN/rnF7c8fHxCAwMxJo1a/Dw4UOd4fzvf+Hr6/0vPc0HysuXLwEA//33HwCgTJkyOvsVKFAgQ3OnaEbmpPelo29cmnOeOHECAQEBOHXqVIrqd6VSqTPCJK2/h4ycQ9PEU6VKFb2eg4a+74+M/u1+//338Pf3h4eHB7y9vfHJJ5+gV69eKFWqlN4xar68MvscAWDAgAHo3LkzTExM4OjoiMqVK2s/d27dugUAKZrA36VUKnWSgYz8DWSGZp6e9JLz//77D6VLl06RBL7/PjCkd9/XmhhMTExQunRpnXJNs65GZj4f3//sUigUKFOmjF5Tb3zoswMASpUqlam/x9SMGjUKU6ZMwYEDB9C1a1ed+zSvXUaT9tyEiVA2qV27tnbUWLt27dCgQQN0794dN27cgK2trfaX15gxY1L9lQzo94ZXq9WoWrUqFixYkOr9Hh4e6R7v5+eHmTNn4tmzZ7Czs8OuXbvQrVs3bQ2EJt4vvvgizQ/S99vgMzoiqGLFivj9999x6dIlNGrUKNV9Ll26BAAZ+pX+rsy8zqnFPWzYMKxZswYjR45E3bp14eDgAIVCga5du2Z5TpS0pgR4/0M5szTzfly+fFmvIdQfiuvOnTto3rw5KlSogAULFsDDwwPm5ubYs2cPFi5cmOJ1Se111fccmaXv+yOjf7tdunRBw4YNsWPHDvz111+YO3cu5syZg+3bt6N169ZZjltfZcuW1elD9y7Nazl37tw0/w7e7/uRXX+bV65cAZC9SY0+NH2oXr58makpJDLz+WgIGbk+MTExGZog0tTUNM0fChpWVlYoXLgwXrx4keI+TfLl5OT0wcfKbZgI5QBTU1MEBgaiadOmWLJkCcaPH6/N0M3MzNL84NIoXbq09oMjvX0uXryI5s2bZyoj9/Pzw/Tp07Ft2zYUKVIE0dHROhm/s7Mz7OzsoFKpPhivvj799FMEBgZi3bp1qSZCKpUKGzZsQMGCBVG/fn2d+zS/ct918+ZNbU2JPq9zerZu3Qp/f3/Mnz9fW5aQkIBXr17p7Jcdv4ZKlCgBQKrdatq0qbY8OTkZERERH/yAbd26NUxNTfHbb7/p3WE6PX/88QcSExOxa9cunV+mH+rMmplzaH6RX7lyJd0vz7Re/6y+P9Lj5uaGwYMHY/DgwXjy5Alq1KiBmTNnahOhjD6e5m/1Q+/1zNK8hvb29gZ/D+vr119/hUKhQIsWLdLcp0SJErh27RqEEDqv4e3btz94fn2vsebHQnh4OKpWraoTg1qtxp07d3RqgW7cuKFzfGY+H9//7BJC4Pbt2zrvZ0P8rc6bN087p1J6SpQo8cHaKE33gtQSpvDwcDg5OX0wmcqN2EcohzRp0gS1a9fGokWLkJCQABcXFzRp0gS//PILHj9+nGL/d6cr79ixIy5evIgdO3ak2E+T+Xfp0gUPHz7EihUrUuwTHx+vHf2UlooVK6Jq1aoIDg5GcHAw3NzcdJISU1NTdOzYEdu2bUv1gzor06vXq1cPPj4+WLNmDf78888U90+aNAk3b97EN998k+KX+u+//67Tx+fMmTP4559/tF9C+rzO6TE1NU3xK/jHH3+ESqXSKdPMOfR+gpQVNWvWROHChbFixQokJydry9evX69TBZ4WDw8P9O/fH3/99Rd+/PHHFPer1WrMnz8fDx480Csuza/R95sJ16xZY/BztGzZEnZ2dggMDERCQoLOfe8ea2Njk2pTZVbfH6lRqVQpHsvFxQVFixZFYmLiB2N6n7OzMxo1aoTVq1fj3r17OvcZonbQ29sbpUuXxrx581KtIcipJRJmz56Nv/76C35+fqk2bWv4+vri4cOH2LVrl7YsISEh1Wv4PmtrawAZfx96e3vD3Nw8xQzrms+RH374Qaf8/dmeM/P5qBnxqrF161Y8fvxYpyYxo3876clMH6GEhIRUm9JnzJgBIQRatWqV4r5z586hbt26WYpVLqwRykFjx45F586dERQUhIEDB2Lp0qVo0KABqlativ79+6NUqVKIiorCqVOn8ODBA1y8eFF73NatW9G5c2d8+eWX8Pb2xosXL7Br1y4sW7YM1apVQ8+ePbF582YMHDgQhw8fRv369aFSqXD9+nVs3rwZ+/bt0zbVpcXPzw9Tp06FpaUl+vbtm2Lyw9mzZ+Pw4cOoU6cO+vfvj0qVKuHFixc4f/48Dhw4kGp1aUatW7cOzZs3x+eff47u3bujYcOGSExMxPbt23HkyBH4+flh7NixKY4rU6YMGjRogEGDBiExMRGLFi1C4cKF8c0332j3yejrnJ5PP/0Uv/76KxwcHFCpUiWcOnUKBw4c0Fapa3h5ecHU1BRz5syBUqmEhYUFmjVrBhcXl0y/Nubm5pg2bRqGDRuGZs2aoUuXLoiIiEBQUFCqfShSM3/+fNy5cwfDhw/H9u3b8emnn6JgwYK4d+8etmzZguvXr6do8/+Qli1bwtzcHG3btsVXX32FmJgYrFixAi4uLqkmnVk5h729PRYuXIh+/fqhVq1a6N69OwoWLIiLFy8iLi4Oa9euBSB9oQUHB2P06NGoVasWbG1t0bZtW4O8P973+vVrFCtWDJ06dUK1atVga2uLAwcO4OzZszo1h2nFlJoffvgBDRo0QI0aNTBgwACULFkSERER2L17d5aXyjAxMcHKlSvRunVrVK5cGX369IG7uzsePnyIw4cPw97eXjuVhSEkJyfjt99+AyB9sf7333/YtWsXLl26hKZNm6bZl0bjq6++wpIlS9CtWzeMGDECbm5uWL9+vbazfHp/91ZWVqhUqRKCg4NRrlw5FCpUCFWqVEmz/5WlpSVatmyJAwcO4Ntvv9WWe3l5oVu3bvjpp5+gVCpRr149HDx4MNVaKX0/HwsVKoQGDRqgT58+iIqKwqJFi1CmTBmdzuD6/O2kJTN9hCIjI1G9enV069ZNW1u2b98+7NmzB61atcLnn3+us/+TJ09w6dKlFFNm5Bk5OUTNGKQ1oaIQQqhUKlG6dGlRunRp7fDsO3fuiF69eglXV1dhZmYm3N3dxaeffiq2bt2qc+zz58/F0KFDhbu7u3YyOH9/f52hmklJSWLOnDmicuXKwsLCQhQsWFB4e3uL6dOn60yI9f7weY1bt25ph1K+P8GaRlRUlBgyZIjw8PAQZmZmwtXVVTRv3lwsX75cu49maOeWLVv0eu1ev34tpk2bJipXriysrKyEnZ2dqF+/vggKCkoxfPjdCeTmz58vPDw8hIWFhWjYsKG4ePFiinNn5HVO79q9fPlS9OnTRzupmq+vr7h+/Xqqr+WKFStEqVKlhKmpaYYmVHz/dUpror0ffvhBlChRQlhYWIjatWuLEydOCG9vb9GqVasMvLpCJCcni5UrV4qGDRsKBwcHYWZmJkqUKCH69OmjM7ReM9z23ck633193p1EcteuXeKjjz4SlpaWwtPTU8yZM0esXr06xX6aCRVTk9FzaPatV6+esLKyEvb29qJ27dpi48aN2vtjYmJE9+7dhaOjY4ohwRl9f+D/EyqmBu8MmU5MTBRjx44V1apVE3Z2dsLGxkZUq1YtxWSQacWU1nW+cuWKaN++vXB0dBSWlpaifPnyYsqUKanGo5HWhIqpuXDhgujQoYMoXLiwsLCwECVKlBBdunQRBw8e1O6jz99AajRDrTU3a2tr4enpKTp27Ci2bt0qVCpVimNSm1Dx7t27ok2bNsLKyko4OzuLr7/+Wmzbtk0AEKdPn9Z5vPeHf588eVJ4e3sLc3PzDA2l3759u1AoFDqTGgohDdkfPny4KFy4sLCxsUl3QkV9Ph83btwoJkyYIFxcXISVlZVo06ZNimkT0vrb0fezQ18vX74UX3zxhShTpoywtrYWFhYWonLlymLWrFkiKSkpxf4///yzsLa21pkOIC9RCJFHVrMkekdERARKliyJuXPnYsyYMXKHIwu1Wg1nZ2d06NAhQ80FRPnBokWLMGrUKDx48MCgy2GoVCpUqlQJXbp0wYwZMwx23vcdOXIETZs2xZYtW9CpU6dse5ycVL16dTRp0iTHl+oxFPYRIsoDEhISUvQTWbduHV68eJHhRSWJ8pr4+Hid7YSEBPzyyy8oW7aswdcEMzU1xbfffoulS5dmaJQVSUJCQnDr1i1MmDBB7lAyjX2EiPKA06dPY9SoUejcuTMKFy6M8+fPY9WqVahSpQo6d+4sd3hE2aJDhw4oXrw4vLy8oFQq8dtvv+H69espJv8zFD8/P+0kspQxrVq1yvOJIxMhojzA09MTHh4e+OGHH/DixQsUKlQIvXr1wuzZs2Vd1Z4oO/n6+mLlypVYv369tulq06ZNTFbIoGTtI3T06FHMnTsX586dw+PHj7Fjxw60a9cu3WOOHDmC0aNH4+rVq/Dw8MDkyZPRu3fvHImXiIiI8hdZ+wjFxsaiWrVqWLp0aYb2Dw8PR5s2bdC0aVOEhoZi5MiR6NevH/bt25fNkRIREVF+lGtGjSkUig/WCI0bNw67d+/WmbCqa9euePXqFUJCQnIgSiIiIspP8lQfoVOnTqWYvtzX1zfFSsDvSkxM1JnlVa1W48WLFyhcuHCeXByOiIjIGAkh8Pr1axQtWjTFhL9ZkacSocjISBQpUkSnTLMuVnx8fKoLJQYGBmZonRUiIiLK/e7fv5+pxXHTkqcSocyYMGECRo8erd1WKpUoXrw47t+/D3t7exkjMzwhgLi4jO8fFwfkksWfdVStCoSEAKywIyIybqZ/7oSqeQvAyhqvX0ejfHkP2NnZGfQx8lQi5OrqiqioKJ2yqKgo2Nvbp1obBAAWFhawsLBIUW5vb59vEiEhgNhYoGFDILPLEUVFAf9fL1R21tZMgoiIjFpsLDBkCLB2LdCvH7BihfY7ytDdWvJUIlS3bl3s2bNHp2z//v15dsVbQ1CrAW/vzCdAAFC/PuDszOSDiIhygStXgC5dgLAwwMQEKF5c+sWfTWRNhGJiYnRW8Q0PD0doaCgKFSqE4sWLY8KECXj48CHWrVsHABg4cCCWLFmCb775Bl9++SUOHTqEzZs3Y/fu3XI9BVkJkTIJ8vICjh3TL6lhDQwREclOCGD1amDYMCA+HnBzAzZsALJ5GSFZE6F///0XTZs21W5r+vL4+/sjKCgIjx8/xr1797T3lyxZErt378aoUaOwePFiFCtWDCtXroSvr2+Ox54bxMW9TYLKlgXOn5eat5jUEBFRnhITAwwcCGiWT2nZEvj1V8DFJdsfOtfMI5RToqOj4eDgAKVSmSf7CL3bITo2FtAMonv9GrC1lS8uIiKiTHvwQGrSePUK+O474JtvpGaxd2TX93ee6iNk7IQAGjQATp5MeR9rgYiIKM8qVgzYuBGwspK+6HKQrEtskH5iY1NPgurXl/r5EBER5QnR0UDXrsDvv78ta9Eix5MggDVCudb7cwIJAdSo8Xb73eHu7OxMRER5xrlzgJ8fcOcOcPiw1B9Ixl/zTIRyofSawACpGZXD3YmIKE8RAliyBBgzBkhKAkqUADZtkr1Jg4lQLhQXl34SdO4ckyAiIspDXr0C+vYFtm+Xttu1k4bKFywoZ1QAmAjleu/P+MxmMCIiylNevQKqVwciIgAzM2DePGmuoFzyZcZEKJd4f1i8ho1N7ln6goiISG+OjkDr1sC+fUBwMFCzptwR6WAilEPSWxBViKytE0ZERJSrPH8OJCe/nexuwQIgMRFwcJA3rlQwEcpGmuQns4kOh8UTEVGec/KkNDS+TBlg/37A1BSwtJRuuRAToWzyoZFfqXl/nTD2ByIiojxDrQbmzgUmTQJUKsDCAnj8WJosMRdjImRA7/fzeT8J+tCCqEx8iIgoT3r6FPD3B/bulba7dQN++QWws5M3rgxgImQg6dUAaUZ+MdEhIqJ859gxqSns0SOp+euHH4B+/fLMFx4TIQNJa+6f+vU5+SEREeVTKhUweLCUBFWoAGzeDFStKndUemEilA24/AURERkFU1NpsdTFi4GFCwFbW7kj0hsXXc0Gmrl/bGyYBBERUT5z6JDU/0ejShVgxYo8mQQBTISyTAipY/S7kyASERHlOyoVEBAA+PgAQ4cC//4rd0QGwaaxLMjMEHkiIqI859EjoEcP4MgRabt3b6BSJTkjMhgmQlmQWgdpToJIRET5yr59QM+e0hB5W1upWax7d7mjMhgmQpmkaRLT4BB5IiLKd6ZNA6ZPl/5frZo0KqxcOVlDMjT2EcoEtRqoUePtEioAO0cTEVE+5Ogo/TtwIHD6dL5LggDWCOlNCMDbW3fdMDaHERFRvhEb+3YOmBEjgOrVgcaN5Y0pG7FGSE9xcW+ToLJlgdev0182g4iIKE948wYYO1Zq8nj9WipTKPJ1EgQwEcqS8+elfmNMgoiIKE/77z+gUSNg3jzg5k3g99/ljijHMBHKAiZARESU5+3cKa0Kfvo04OAAbNsmjRIzEkyEiIiIjFFSEjByJNCuHfDqFVC7NnDhAtChg8yB5SwmQkRERMZo3DhpjTAA+PprqcNryZLyxiQDJkJERETGaPx4oHJlYNcuqW+QubncEcmCiZAe3p9EkYiIKM9ISJBWitcoUgS4dAlo21a+mHIBJkIZpFlX7N1JFImIiPKEW7eAunWlpTHeTYZMmAbwFcig99cV4ySKRESUJ2zcKM0NFBoKODkBhQrJHVGuwpmlMyEqCnB25vB5IiLKxeLjpZmhV6yQths1AjZsANzd5Y0rl2GNUCZwTTEiIsrVrl8H6tSRkiCFApg8GTh4kElQKlgjRERElN/cuQNcvgy4uADr1wM+PnJHlGsxESIiIspv2rSRaoPatAHc3OSOJldj0xgREVFed/Uq0LChtGaYRr9+TIIygIkQERFRXiUEsHo1UKsWcPy4tGQG6YVNY0RERHlRTAwwcKDUBwgAWrYEfvlF3pjyINYIERER5TUXLwLe3lISZGoKzJoF7N0rdY4mvbBGiIiIKC85dgxo0QJITJSGw2/aJC19QJnCRCiDhJA7AiIiIkj9gSpUkJKgtWul2aIp05gIZYAQUmd8IiIiWYSFAeXKSc1glpbAgQPSUhlcKyzL+ApmQFyctEQLAHh5cY0xIiLKIUIAS5ZIXz4zZ74td3JiEmQgrBHS07FjXF6DiIhywKtXQN++wPbt0vbFi4BazQTIwPhq6olJEBERZbszZ4Dq1aUkyMwMWLQI2LqVSVA24CtKRESUWwgBLFwojQKLiABKlgROnJBWkecv8WzBROgDhABiY+WOgoiIjEJ4ODBxIvDmDdCxI3D+vDRKjLIN+wilQwgpKT95Uu5IiIjIKJQqBSxdCsTHA4MHsxYoBzARSkdcnG4SVL8+R4wREZEBqdXA/PnSHC0ffyyVffmlvDEZGSZCGRQVBTg7MzknIiIDefoU8PeXlsYoUQK4cgWwtZU7KqPDRCiDbGyYBBERkYEcPQp06wY8eiRNkDhpkvRFQzmOnaXTwE7SRERkcGq1NDFi06ZSElS+PPDPP0D//vy1LRPWCKVCrZYW9dXMJk1ERJRlMTFAhw7A/v3Sds+ewE8/sTlMZkyE3iNEyiSInaSJiCjLbGwAKyvp9tNPQO/eckdEYCKUwrvripUtK03hwP5BRESUKSoVkJQkJT8KBbBmDRAZCVSqJHdk9H/sI5SO8+elGksmQUREpLfHjwEfH6n/jxBSWaFCTIJyGdYIpYMJEBERZcpffwFffCENkbexAe7eBUqXljsqSgVrhIiIiAwlOVkaCt+qlZQEffQR8O+/TIJyMdYIERERGcKDB0D37sCxY9L2V19JC6haWckbF6WLiRAREVFWqdVA69bS7NB2dsCKFYCfn9xRUQawaewdnESRiIgyxcQEWLQIqFlTGmnDJCjPYCIEKQGKiQFq1ACKFJE7GiIiyhPu3ZM6RWs0by7NEl2mjHwxkd6MPhFSq6UEyM6OkygSEVEG7doFeHkBnToBt2+/LTcx+q/VPMeor1hqs0h7eQGvX0t93Th8noiIdCQlAaNGAZ9/Drx8CVSoABRgd9u8TPZEaOnSpfD09ISlpSXq1KmDM2fOpLv/okWLUL58eVhZWcHDwwOjRo1CQkJCph77/VmkX7/mJIpERJSG8HCgQQOpLxAgJUTHjwOennJGRVkkayIUHByM0aNHIyAgAOfPn0e1atXg6+uLJ0+epLr/hg0bMH78eAQEBCAsLAyrVq1CcHAwJk6cmOVYmAAREVGatm0DqlcHzp4FChYEdu4EFiwAzM3ljoyySNZEaMGCBejfvz/69OmDSpUqYdmyZbC2tsbq1atT3f/kyZOoX78+unfvDk9PT7Rs2RLdunX7YC1SRjABIiKiNJ08CSiVQN26UlPCZ5/JHREZiGyJUFJSEs6dOwcfH5+3wZiYwMfHB6dOnUr1mHr16uHcuXPaxOfu3bvYs2cPPvnkkzQfJzExEdHR0To3IiKiD9KsDwYAgYHA4sXA338DxYvLFxMZnGyJ0LNnz6BSqVDkvfHqRYoUQWRkZKrHdO/eHd9++y0aNGgAMzMzlC5dGk2aNEm3aSwwMBAODg7am4eHh0GfBxER5UObNgGffAK8eSNtm5sDw4cDZmbyxkUGJ3tnaX0cOXIEs2bNwk8//YTz589j+/bt2L17N2bMmJHmMRMmTIBSqdTe7t+/n4MRExFRnhIfLy2N0a0bEBIizRBN+ZpsY/6cnJxgamqKqKgonfKoqCi4urqmesyUKVPQs2dP9OvXDwBQtWpVxMbGYsCAAZg0aRJMUpm/wcLCAhYWFoZ/AkRElL/cuAF06QJcuiR1HJ04ERgwQO6oKJvJViNkbm4Ob29vHDx4UFumVqtx8OBB1K1bN9Vj4uLiUiQ7pqamAADxblsuERGRPn77TZpY7tIlwMUF2LcP+O47zhFkBGS9wqNHj4a/vz9q1qyJ2rVrY9GiRYiNjUWfPn0AAL169YK7uzsCAwMBAG3btsWCBQtQvXp11KlTB7dv38aUKVPQtm1bbUJERESkl5kzgcmTpf83bQqsXw+4uckbE+UYWRMhPz8/PH36FFOnTkVkZCS8vLwQEhKi7UB97949nRqgyZMnQ6FQYPLkyXj48CGcnZ3Rtm1bzJw5U66nQEREeV2nTsD33wOjR0sJEX9YGxWFMLI2pejoaDg4OECpVMLU1B62tlJ5TAxgYyNvbERElAOEkJrAqlV7W/b8OVC4sHwx0Qe9+/1tb29vsPPmqVFjREREWRITA/TqJa22/fffb8uZBBktJkJERGQcLl0CataUOkYDwJUr8sZDuQITISIiyt+EAJYvB2rXlobIu7sDR44AQ4bIHRnlAhwXSERE+Vd0tDRB4qZN0nbr1sC6dYCTk7xxUa7BGiEiIsq/du6UkiBTU2lk2J9/MgkiHawRIiKi/OuLL4ALF4DOnaWV44newxohIiLKP169AoYOBV6+lLYVCmDBAiZBlCbWCBERUf5w9izg5weEhwPPnr3tF0SUDtYIERFR3iYEsGgRUL++lASVLAl8/bXcUVEewRohIiLKu168APr0AXbtkrY7dgRWrgQcHWUNi/IOJkJERJQ3Xb4MfPopcO8eYG4u9QUaPFjqF0SUQUyEiIgobypaVGoWK10a2LxZWjaDSE9MhIiIKO94/RqwtZVqfQoXBvbuBTw8AAMuwknGhZ2liYgobzh2DKhYEQgKeltWuTKTIMoSJkJERJS7qdXArFlA06bAw4fAjz8CKpXcUVE+wUSIiIhyrydPgFatgEmTpOTniy+Ao0elJTOIDIB9hIiIKHc6fBjo3h2IjASsrIAlS6Sh8hwVRgbERIiIiHKf//4DWrYEkpOBSpWkUWGVK8sdFeVDRpsICQHExsodBRERpapECWDCBODBA6lPkI2N3BFRPmW0iVDLlsCZM3JHQUREWgcOAJ6eQJky0vb06WwGo2xntJ2l302C6tcHrK3li4WIyKglJwOTJ0u/UP38gMREqZxJEOUAo60R0oiKApyd+X4jIpLFw4dAt27SHEEAUKuW1HeBKIcYfSJkY8MkiIhIFnv3Ar16Ac+eAXZ2wPLlQNeuckdFRsZom8aIiEgmb94A48YBn3wiJUHVqwPnzjEJIlkwESIiopwlhDRHEAAMGQKcPAmULStvTGS0jL5pjIiIcogQUl8Ec3MgOBg4fx7o2FHuqMjIMREiIqLslZQEjB8PWFpKa4YBQMmS0o1IZkyEiIgo+4SHS31/zpyRaoN69QIqVJA7KiIt9hEiIqLssX271BH6zBnA0RHYsYNJEOU6TISIiMiwEhOBYcOk/j9KJfDxx0BoKPD553JHRpQCm8aIiMhwhJBmiD56VNr+5hvgu+8AMzN54yJKAxMhIiIyHIUC6NcPuHoVWLdOmiuIKBdj0xgREWVNfDwQFvZ2u2dP4OZNJkGUJzARIiKizLtxQ+oD5OMDPH36trxQIfliItIDEyEiIsqc334DvL2BS5ekZTPCw+WOiEhvTISIiEg/cXFA375SE1hsLNCkiTQqrHZtuSMj0hsTISIiyrhr16SEZ/VqqWN0QABw4ABQtKjckRFlCkeNERFRxs2ZI40Ic3UF1q8HmjWTOyKiLGEiREREGffDD0CBAtKaYUWKyB0NUZaxaYyIiNJ2+TIwdqw0USIAODgAq1YxCaJ8gzVCRESUkhDAypXA8OFAQgJQvrw0USJRPsNEiIiIdEVHA199BWzaJG23bs11wijfYtMYERG9deGCNDfQpk2AqanUOfrPPwFnZ7kjI8oWWaoRSkhIgKWlpaFiISIiOf36q9T8lZQEeHhIyVC9enJHRZSt9K4RUqvVmDFjBtzd3WFra4u7d+8CAKZMmYJVq1YZPEAiIsohJUsCKhXQtq00QSKTIDICeidC3333HYKCgvD999/D3NxcW16lShWsXLnSoMEREVE2Uyrf/r9BA+DUKWDnTq4VRkZD70Ro3bp1WL58OXr06AFTU1NtebVq1XD9+nWDBkdERNlECGDxYsDTU5otWqNWLWnGaCIjoXci9PDhQ5QpUyZFuVqtxps3bwwSFBERZaMXL4D27YGRI4FXr4CgIJkDIpKP3olQpUqVcOzYsRTlW7duRfXq1Q0SFBERZZPTp4Hq1aXmL3Nz4McfpZFhREZK71FjU6dOhb+/Px4+fAi1Wo3t27fjxo0bWLduHf7888/siJGIiLJKrQYWLAAmTACSk4HSpYHgYGmoPJER07tG6PPPP8cff/yBAwcOwMbGBlOnTkVYWBj++OMPtGjRIjtiJCKirPrtN2mpjORkoEsX4Nw5JkFEABRCaBaQMQ7R0dFwcHAAoARgj5gYwMZG7qiIiLJZcjLQpo3UN+irr9ghmvIczfe3UqmEvb29wc6rd41QqVKl8Pz58xTlr169QqlSpQwSFBERZZFaLa0VlpgobRcoAISEAAMHMgkieofeiVBERARUKlWK8sTERDx8+NAgQRERURY8eSKtD9a/PzBu3NtyJkBEKWS4s/SuXbu0/9+3b9//m5ckKpUKBw8ehKenp0GDIyIiPR05AnTvDjx+DFhZAR99JHdERLlahhOhdu3aAQAUCgX8/f117jMzM4Onpyfmz59v0OCIiCiDVCpg5kxg+nSpWaxiRWDLFqByZbkjI8rVMpwIqdVqAEDJkiVx9uxZODk5ZVtQRESkh8hIoEcP4NAhabtPH2l+II4EIfogvecRCg8Pz444iIgos+LigH//BaytgWXLgJ495Y6IKM/QOxECgNjYWPz999+4d+8ekpKSdO4bPny4QQIjIqJ0CPG283OpUsDmzUCJEkCFCvLGRZTH6D2P0IULF/DJJ58gLi4OsbGxKFSoEJ49ewZra2u4uLjg7t272RWrQXAeISLK8x4+BL74QpolumVLuaMhyhG5Zh6hUaNGoW3btnj58iWsrKxw+vRp/Pfff/D29sa8efMMFhgREaUiJATw8pJGhw0eLE2USESZpnciFBoaiq+//homJiYwNTVFYmIiPDw88P3332PixInZESMREb15A4wfL80P9OyZlAzt2SNNlEhEmaZ3ImRmZgYTE+kwFxcX3Lt3DwDg4OCA+/fvGzY6IiIC7t8HmjR5u0r84MHAqVNAuXKyhkWUH+idCFWvXh1nz54FADRu3BhTp07F+vXrMXLkSFSpUkXvAJYuXQpPT09YWlqiTp06OHPmTLr7v3r1CkOGDIGbmxssLCxQrlw57NmzR+/HJSLKEx4+lGp/Tp4E7O2luYGWLgUsLeWOjChf0DsRmjVrFtzc3AAAM2fORMGCBTFo0CA8ffoUv/zyi17nCg4OxujRoxEQEIDz58+jWrVq8PX1xZMnT1LdPykpCS1atEBERAS2bt2KGzduYMWKFXB3d9f3aRAR5Q3u7kDbtkDNmsCFC0CnTnJHRJSvyLr6fJ06dVCrVi0sWbIEgDRpo4eHB4YNG4bx48en2H/ZsmWYO3curl+/DjMzs0w9JkeNEVGuFxEB2NoCmolr4+IAU1PAwkLWsIjklGtGjaXl/Pnz+PTTTzO8f1JSEs6dOwcfH5+3wZiYwMfHB6dOnUr1mF27dqFu3boYMmQIihQpgipVqmDWrFmpLgKrkZiYiOjoaJ0bEVGutWOH1BTm7y8tlQFIEyUyCSLKFnolQvv27cOYMWMwceJE7XxB169fR7t27VCrVi3tMhwZ8ezZM6hUKhQpUkSnvEiRIoiMjEz1mLt372Lr1q1QqVTYs2cPpkyZgvnz5+O7775L83ECAwPh4OCgvXl4eGQ4RiKiHJOYCAwfDnToACiVwPPn0r9ElK0ynAitWrUKrVu3RlBQEObMmYOPP/4Yv/32G+rWrQtXV1dcuXIl2zstq9VquLi4YPny5fD29oafnx8mTZqEZcuWpXnMhAkToFQqtTeObCOiXOfOHaB+fWl9MAAYMwY4dgwoWFDeuIiMQIYnoFi8eDHmzJmDsWPHYtu2bejcuTN++uknXL58GcWKFdP7gZ2cnGBqaoqoqCid8qioKLi6uqZ6jJubG8zMzGBqaqotq1ixIiIjI5GUlARzc/MUx1hYWMCCVcpElFtt3gz06we8fg0ULgysXQu0aSN3VERGI8M1Qnfu3EHnzp0BAB06dECBAgUwd+7cTCVBAGBubg5vb28cPHhQW6ZWq3Hw4EHUrVs31WPq16+P27dv6zTB3bx5E25ubqkmQUREuVpCgrRMxuvXUo1QaCiTIKIcluFEKD4+HtbW1gAAhUIBCwsL7TD6zBo9ejRWrFiBtWvXIiwsDIMGDUJsbCz69OkDAOjVqxcmTJig3X/QoEF48eIFRowYgZs3b2L37t2YNWsWhgwZkqU4iIhkYWkJBAcDEydKS2Zk8oclEWWeXnOzr1y5Era2tgCA5ORkBAUFwUkzvPP/9Fl93s/PD0+fPsXUqVMRGRkJLy8vhISEaDtQ37t3TzuLNQB4eHhg3759GDVqFD766CO4u7tjxIgRGDdunD5Pg4hIPhs2SMPh+/WTtmvWlG5EJIsMzyPk6ekJhUKR/skUCq4+T0SUmrg4YMQIYOVKwNxcagarWFHuqIjyjOyaRyjDNUIREREGe1AiIqMSFgZ06QJcuQIoFFK/IK4TRpQrcNliIqLstHattEhqXBxQpIjUNNasmdxREdH/MREiIsoOQgD9+wOrVknbPj7Ab79JyRAR5RoGW2KDiIjeoVAApUoBJibAjBlASAiTIKJciDVCRESGIoS0LIajo7Q9fjzQqhVQo4asYRFR2lgjRERkCK9fAz16AA0bSv2BAKk2iEkQUa6WqUTozp07mDx5Mrp164YnT54AAPbu3YurV68aNDgiojwhNBTw9gY2bpRGiB09KndERJRBeidCf//9N6pWrYp//vkH27dvR0xMDADg4sWLCAgIMHiARES5lhDAzz8DH38M3LoFeHhISVCrVnJHRkQZpHciNH78eHz33XfYv3+/zvpezZo1w+nTpw0aHBFRrqVUAn5+0tD4xESgbVvgwgWgXj25IyMiPeidCF2+fBnt27dPUe7i4oJnz54ZJCgiolxv6FBgyxagQAFg/nxg505p9XgiylP0ToQcHR3x+PHjFOUXLlyAu7u7QYIiIsr1AgOlfkHHjwOjR0vD5Ykoz9E7EeratSvGjRuHyMhIKBQKqNVqnDhxAmPGjEGvXr2yI0YiIvm9fCnNEq1RrBhw9ixQp458MRFRlumdCM2aNQsVKlSAh4cHYmJiUKlSJTRq1Aj16tXD5MmTsyNGIiJ5/fMPUL060Lu31ASmwVogojwvw6vPv+/evXu4cuUKYmJiUL16dZQtW9bQsWULrj5PRBkmBLBggTQxYnIyULo0EBwsNYkRUY6SffV5jePHj6NBgwYoXrw4ihcvbrBAiIhylefPpRqgP/+Utrt0AVasAAz4AUxE8tO7aaxZs2YoWbIkJk6ciGvXrmVHTERE8jpxAvDykpIgCwtprqBNm5gEEeVDeidCjx49wtdff42///4bVapUgZeXF+bOnYsHDx5kR3xERDnv0SPgwQOgbFng9Glg4ED2ByLKpzLdRwgAwsPDsWHDBmzcuBHXr19Ho0aNcOjQIUPGZ3DsI0REqRJCN9lZuxbo0AGws5MvJiLSyq4+QlladLVkyZIYP348Zs+ejapVq+Lvv/82VFxERDnn77+lDtDvzpHm788kiMgIZDoROnHiBAYPHgw3Nzd0794dVapUwe7duw0ZGxFR9lKpgBkzgGbNpOUxpk6VOyIiymF6jxqbMGECNm3ahEePHqFFixZYvHgxPv/8c1hbW2dHfERE2SMyEvjiC+DgQWm7d29g0SI5IyIiGeidCB09ehRjx45Fly5d4OTklB0xERFlr4MHgR49gKgowNpaGhXGmfGJjJLeidCJEyeyIw4iopyxYwfQsaPUObpKFWDzZqBiRbmjIiKZZCgR2rVrF1q3bg0zMzPs2rUr3X0/++wzgwRGRJQtWrQAypcHGjYEFi8GrKzkjoiIZJSh4fMmJiaIjIyEi4sLTEzS7l+tUCigUqkMGqChcfg8kRE6e1YaFab5/FIqAQcHeWMiIr3IOnxerVbDxcVF+/+0brk9CSIiI5OcDEyYANSuLa0ZpsEkiIj+T+/h8+vWrUNiYmKK8qSkJKxbt84gQRERZdn9+0CTJsDs2dI2Z78nolToPbO0qakpHj9+rK0h0nj+/DlcXFxyfa0Qm8aIjMDu3dIosBcvpPXBVq0COnWSOyoiyoJcM7O0EAKKVNbcefDgwf8TDCIimSQlAWPGAJ9+KiVBNWtKEyUyCSKiNGR4+Hz16tWhUCigUCjQvHlzFCjw9lCVSoXw8HC0atUqW4IkIsqQsDDghx+k/48YAcyZI60eT0SUhgwnQu3atQMAhIaGwtfXF7a2ttr7zM3N4enpiY4dOxo8QCKiDKtWDViyBHBxAf7/mUVElB69+witXbsWfn5+sLS0zK6YshX7CBHlI4mJwMSJQM+egJeX3NEQUTbKrj5CeidCeR0TIaJ84s4dwM8POHcOKFcOuHIFMDOTOyoiyibZlQhlqGmsUKFCuHnzJpycnFCwYMFUO0trvHjxwmDBERGlassWoF8/IDoaKFRImiOISRARZUKGEqGFCxfCzs5O+//0EiEiomyTkACMHi0tkgoA9esDGzcCHh7yxkVEeRabxtg0RpQ3PH0KtGwJhIZK2xMmAN9+CxTQe+1oIsqDcs08QufPn8fly5e12zt37kS7du0wceJEJCUlGSwwIiIdhQoBTk6AszMQEgLMmsUkiIiyTO9E6KuvvsLNmzcBAHfv3oWfnx+sra2xZcsWfPPNNwYPkIiMWFwcEB8v/d/UFFi/XqoR8vWVNSwiyj/0ToRu3rwJr/8PU92yZQsaN26MDRs2ICgoCNu2bTN0fERkrMLCgDp1gJEj35a5uABFi8oWEhHlP5laYkOtVgMADhw4gE8++QQA4OHhgWfPnhk2OiIyTmvXSstjXLkC7Nwp9Q8iIsoGeidCNWvWxHfffYdff/0Vf//9N9q0aQMACA8PR5EiRQweIBEZkdhYoHdv6RYXBzRvLjWFOTvLHBgR5Vd6J0KLFi3C+fPnMXToUEyaNAllypQBAGzduhX16tUzeIBEZCSuXAFq1ZJqg0xMgBkzgH37AFdXuSMjonzMYMPnExISYGpqCrNcPqkZh88T5UJJSUDp0sCDB1IfoA0bgMaN5Y6KiHIRWWeWTs25c+cQFhYGAKhUqRJq1KhhsKBySv36gLW13FEQEczNgWXLgKVLpRohNoURUQ7Ru0boyZMn8PPzw99//w1HR0cAwKtXr9C0aVNs2rQJzrn8A0yTUd6+rUSpUvbgJNlEMrl4EXjyBGjR4m2ZEOCbkohSk2smVBw2bBhiYmJw9epVvHjxAi9evMCVK1cQHR2N4cOHGyyw7GZtzc9bIlkIIdX+1KkjLZp6797b+/imJKIcpnfTWEhICA4cOICKFStqyypVqoSlS5eiZcuWBg2OiPIZpRIYMADYvFnabtGCnfSISFZ61wip1epUO0SbmZlp5xciIkrh3DmgRg0pCSpQAJg/H9i1CyhcWO7IiMiI6Z0INWvWDCNGjMCjR4+0ZQ8fPsSoUaPQvHlzgwZHRPnEjz8C9eoBd+8CJUoAx49Lq8izKYyIZKZ3IrRkyRJER0fD09MTpUuXRunSpVGyZElER0fjxx9/zI4YiSivu3pVGiLfrh1w4YLUP4iIKBfQu4+Qh4cHzp8/j4MHD2qHz1esWBE+Pj4GD46I8rB3R4AtXCjVCPXsyVogIspV9EqEgoODsWvXLiQlJaF58+YYNmxYdsVFRHmVEFLis38/8Oef0qrxVlZAr15yR0ZElEKGE6Gff/4ZQ4YMQdmyZWFlZYXt27fjzp07mDt3bnbGR0R5yfPn0jphf/4pbW/fDnTuLGtIRETpyXAfoSVLliAgIAA3btxAaGgo1q5di59++ik7YyOivOTkSaB6dSkJsrAAfv4Z6NRJ7qiIiNKV4UTo7t278Pf31253794dycnJePz4cbYERkR5hFoNzJkDNGoE3L8PlC0LnD4NDBzI/kBElOtlOBFKTEyEzTsTn5mYmMDc3Bzx8fHZEhgR5RHDhwPjxwMqFdC9uzRfkJeX3FEREWWIXp2lp0yZAut3VilNSkrCzJkz/7+au2TBggWGi46Icr8BA4CNG4Hvvwe+/JK1QESUp2Q4EWrUqBFu3LihU1avXj3cvXtXu63gByBR/qdSAf/++3YuoI8+AiIiADs7WcMiIsqMDCdCR44cycYwiChPiIoCvvgCOHJEmh1akwwxCSKiPErvmaWJyEgdOgRUqwYcOACYmwMPHsgdERFRljERIqL0qVRAQADg4yPVCFWpIjWNdewod2RERFmm9xIbRGREHj0CevSQmsIAoF8/YPFi4J1BE0REeRkTISJK2/btUhJkawv88os0PJ6IKB/JFU1jS5cuhaenJywtLVGnTh2cOXMmQ8dt2rQJCoUC7dq1y94AiYzVkCHAmDHS3EBMgogoH8pUInTs2DF88cUXqFu3Lh4+fAgA+PXXX3H8+HG9zxUcHIzRo0cjICAA58+fR7Vq1eDr64snT56ke1xERATGjBmDhg0bZuYpEFFqHjyQ1gp7/VraViiAuXOBcuVkDYuIKLvonQht27YNvr6+sLKywoULF5CYmAgAUCqVmDVrlt4BLFiwAP3790efPn1QqVIlLFu2DNbW1li9enWax6hUKvTo0QPTp09HqVKl9H5MIkrF7t3SjNBr1wJffy13NEREOULvROi7777DsmXLsGLFCpiZmWnL69evj/Pnz+t1rqSkJJw7dw4+Pj5vAzIxgY+PD06dOpXmcd9++y1cXFzQt2/fDz5GYmIioqOjdW5E9I43b4CxY4FPP5VWj/f2BsaNkzsqIqIcoXcidOPGDTRq1ChFuYODA169eqXXuZ49ewaVSoUiRYrolBcpUgSRkZGpHnP8+HGsWrUKK1asyNBjBAYGwsHBQXvz8PDQK0aifO2//6TFUufNk7aHDwdOnABKl5Y3LiKiHKJ3IuTq6orbt2+nKD9+/Hi2N1O9fv0aPXv2xIoVK+Dk5JShYyZMmAClUqm93b9/P1tjJMozjh2TmsJOnwYcHYEdO6Sh8RYWckdGRJRj9B4+379/f4wYMQKrV6+GQqHAo0ePcOrUKYwZMwZTpkzR61xOTk4wNTVFVFSUTnlUVBRcXV1T7H/nzh1ERESgbdu22jK1Wi09kQIFcOPGDZR+75eshYUFLPjBTpRS2bJS0lOnDrBpE+DpKXdEREQ5Tu9EaPz48VCr1WjevDni4uLQqFEjWFhYYMyYMRg2bJhe5zI3N4e3tzcOHjyoHQKvVqtx8OBBDB06NMX+FSpUwOXLl3XKJk+ejNevX2Px4sVs9iL6kOfPgcKFpf+7ukpzBJUqJS2ZQURkhPROhBQKBSZNmoSxY8fi9u3biImJQaVKlWBra5upAEaPHg1/f3/UrFkTtWvXxqJFixAbG4s+ffoAAHr16gV3d3cEBgbC0tISVapU0Tne0dERAFKUE9F7tm4F+vYFli8H/PyksgoV5I2JiEhmmZ5Z2tzcHJUqVcpyAH5+fnj69CmmTp2KyMhIeHl5ISQkRNuB+t69ezAxyRXzPhLlTQkJ0nD4n36StteuBbp0keYIIiIycgohhNDngKZNm0KRzgfooUOHshxUdoqOjoaDgwMePVLCzc1e7nCIstetW1LSExoqbY8fD3z7LfDO1BdERHmB5vtbqVTC3t5w39961wh5eXnpbL958wahoaG4cuUK/P39DRUXEWXVxo3AgAFATAzg5AT8+ivQqpXcURER5Sp6J0ILFy5MtXzatGmIiYnJckBEZACXLr1dG6xRI2DDBsDdXd6YiIhyIb2bxtJy+/Zt1K5dGy9evDDE6bINm8bIaIwdC1hZAVOnAgUy3R2QiChXyDVNY2k5deoULC0tDXU6ItLX+vVAw4ZA8eLS9vffs0M0EdEH6J0IdejQQWdbCIHHjx/j33//1XtCRSIygNhYYNgwYM0aoF49aW4gMzMmQUREGaB3IuTg4KCzbWJigvLly+Pbb79Fy5YtDRYYEWXA1avSqLBr1wATE8DXV/qXiIgyRK9ESKVSoU+fPqhatSoKFiyYXTER0YcIIdUADR0KxMcDbm5Sh+gmTeSOjIgoT9Hrp6OpqSlatmyp9yrzRGRAsbFAr17SLNHx8VItUGgokyAiokzQuw69SpUquHv3bnbEQkQZYWIiDY83NQUCA4E9ewAXF7mjIiLKk/TuI/Tdd99hzJgxmDFjBry9vWFjY6NzvyGHtBHR/wkh3UxMpCHxmzcDT58CDRrIHRkRUZ6W4XmEvv32W3z99dews7N7e/A7o1KEEFAoFFCpVIaP0oA4jxDlOUqlNEN01arA5MlyR0NEJIvsmkcow4mQqakpHj9+jLCwsHT3a9y4sUECyy5MhChPOXdOWin+zh3A0hK4e1fqGE1EZGRkn1BRky/l9kSHKF8QAliyBBgzBkhKAkqUADZtYhJERGRgevURSm/VeSIykFevpBFh27dL2+3aAatXA5yygojI4PRKhMqVK/fBZCi3rzVGlKslJ0uzQ4eFSbNDz5snzRrNHyFERNlCr0Ro+vTpKWaWJiIDKlAAGDFCWicsOBioWVPuiIiI8rUMd5Y2MTFBZGQkXPL4fCXsLE25zosXwOPHQOXK0rYQQFwc8N7UFERExiy7OktneEJF9g8iygYnTwJeXsCnn0p9gwCpGYxJEBFRjshwIpTBiiMiygi1GpgzB2jUCLh/X+oP9OSJ3FERERmdDPcRUqvV2RkHkfF4+hTw9wf27pW2u3UDfvkFeGeyUiIiyhl6L7FBRFlw9KiU+Dx6JE2Q+OOP0lB5Nj0TEcmCiRBRTlqwQEqCKlSQ1gurWlXuiIiIjBoTIaKctGoVUKoU8O23gK2t3NEQERm9DHeWJqJMOHQI+PpraUg8ABQuLNUKMQkiIsoVWCNElB1UKqnWZ8YMKQmqUwfo0kXuqIiI6D1MhIgM7dEjoEcP4MgRabtvX2meICIiynWYCBEZ0l9/AV98IQ2Rt7GRhsX36CF3VERElAb2ESIylLlzgVatpCSoWjXg/HkmQUREuRwTISJDqV5d+nfQIOD0aaBcOXnjISKiD2LTGFFWPHkCaBYi9vEBLl9+u3gqERHleqwRIsqMN2+AsWOlWp87d96WMwkiIspTmAgR6eu//4CGDYF58wClEvjjD7kjIiKiTGLTGJE+fv8d6NMHePUKcHAAVq8GOnSQOyoiIsok1ggRZURSEjByJNC+vZQE1a4NXLjAJIiIKI9jIkSUEUuWAIsXS/8fPRo4dgwoWVLemIiIKMvYNEaUEUOHAvv3A4MHA23byh0NEREZCGuEiFKTkCAtjvrmjbRtbg7s3cskiIgon2GNENH7bt0C/PykPkBPnwKBgXJHRERE2YQ1QkTv2rQJqFFDSoKcnIBGjeSOiIiIshETISIAiI8HvvoK6NYNiImR5gkKDQVat5Y7MiIiykZMhIhu3gTq1AGWLwcUCmDyZODQIcDdXe7IiIgom7GPEJFaDdy9K60Ztn69tGYYEREZBSZCZJzUasDk/xWiFSoA27cDVasCbm7yxkVERDmKTWNkfK5eBby8gKNH35a1bMkkiIjICDERIuMhBLBqFVCrFnD5MvD111IZEREZLSZCZBxevwZ69gT69ZNGiLVsCezeLXWOJiIio8VEiPK/ixeBmjWljtCmpsCsWdIs0S4uckdGREQyY2dpyt/CwqSh8YmJ0nD4TZuABg3kjoqIiHIJJkKUv1WoAHz2GRAbC6xdK80WTURE9H9MhCj/uXABKFkScHSU+gCtXQtYWLwdLk9ERPR//Gag/EMIYMkS4OOPpU7RmhFhVlZMgoiIKFWsEaL84dUroG9faWJEAEhOBhISpCSIiIgoDfyZTHnfmTNA9epSEmRmBixaBOzYwSSIiIg+iIkQ5V1CAAsXSqPAIiKkfkEnTgAjRnB+ICIiyhAmQpR3KZXAggXAmzdAx47A+fPSrNFEREQZxD5ClHc5OgIbN0oTJg4ezFogIiLSGxMhyjvUamDePMDVFejVSypr0IATJBIRUaYxEaK84elTwN9fWhrD2hpo2hTw8JA7KiIiyuOYCFHud+wY0LUr8OgRYGkpjQorVkzuqIiIKB9gZ2nKvdRqYOZMoEkTKQkqXx745x+gf3/2ByIiIoNgjRDlTioV0KYNsG+ftN2zJ/DTT4CtrbxxERFRvsIaIcqdTE2BmjWl/kBr1gDr1jEJIiIig2MiRLmHSiV1itaYNg0IDQV695YpICIiyu9yRSK0dOlSeHp6wtLSEnXq1MGZM2fS3HfFihVo2LAhChYsiIIFC8LHxyfd/SmPePwYaNECaN0aSEyUygoUAMqWlTcuIiLK12RPhIKDgzF69GgEBATg/PnzqFatGnx9ffHkyZNU9z9y5Ai6deuGw4cP49SpU/Dw8EDLli3x8OHDHI6cDOavv4Bq1YDDh4Hr16UJEomIiHKAQggh5AygTp06qFWrFpYsWQIAUKvV8PDwwLBhwzB+/PgPHq9SqVCwYEEsWbIEvTST7KUjOjoaDg4OePRICTc3+yzHT1mQnAwEBACBgdK6YR99BGzeLI0OIyIieofm+1upVMLe3nDf37LWCCUlJeHcuXPw8fHRlpmYmMDHxwenTp3K0Dni4uLw5s0bFCpUKNX7ExMTER0drXOjXODBA6BZM2DWLCkJ+uor4PRpJkFERJSjZE2Enj17BpVKhSJFiuiUFylSBJGRkRk6x7hx41C0aFGdZOpdgYGBcHBw0N48OBtx7tC/vzRRop0dsGkTsGwZYGUld1RERGRkZO8jlBWzZ8/Gpk2bsGPHDlhaWqa6z4QJE6BUKrW3+/fv53CUlKqlS6VlMs6fB/z85I6GiIiMlKwTKjo5OcHU1BRRUVE65VFRUXB1dU332Hnz5mH27Nk4cOAAPvroozT3s7CwgIWFhUHipSy4d0/qFN2vn7RdqhRw6JC8MRERkdGTtUbI3Nwc3t7eOHjwoLZMrVbj4MGDqFu3bprHff/995gxYwZCQkJQs2bNnAiVsmLXLsDLCxgwQEqGiIiIcgnZl9gYPXo0/P39UbNmTdSuXRuLFi1CbGws+vTpAwDo1asX3N3dERgYCACYM2cOpk6dig0bNsDT01Pbl8jW1ha2nHk4d0lKAsaNkxZJBYBatTgvEBER5SqyJ0J+fn54+vQppk6disjISHh5eSEkJETbgfrevXswMXlbcfXzzz8jKSkJnTp10jlPQEAApk2blpOhU3rCw6W+P2fPStujRgGzZwPm5vLGRURE9A7Z5xHKaZxHKAf8/ru0LIZSCRQsCAQFAZ99JnNQRESUl2XXPEKy1whRPhQdLSVBdetKQ+OLF5c7IiIiolQxESLDUKmkFeMBoFcvwNISaN8eMDOTNy4iIqJ05Ol5hCiX2LQJqFoVePbsbVmXLkyCiIgo12MiRJkXHy8tjdGtGxAWBixYIHdEREREemHTGGXO9etSrc/ly4BCAUycCHDUHhER5TFMhEh/v/4KDBoExMYCLi7Ab78BLVrIHRUREZHemAiRfn75BRg4UPp/06bA+vWAm5u8MREREWUS+wiRfrp2BcqUkZrB9u9nEkRERHkaa4QofUJIi6M2ayb1BXJwAC5dAqys5I6MiIgoy1gjRGmLiQH8/QEfH2DZsrflTIKIiCifYI0Qpe7SJWlU2I0bgImJ1DGaiIgon2EiRLqEAJYvB0aMABITAXd3YONGoGFDuSMjIiIyOCZC9FZ0NDBgABAcLG23bg2sWwc4OckbFxERUTZhHyF668oVYMsWac2w778H/vyTSRAREeVrrBGit+rVA5YsAby8pJXjiYiI8jnWCBmzV6+Anj2ldcI0Bg1iEkREREaDNULG6uxZwM8PCA8Hrl0D/v1XmieIiIjIiLBGyNgIASxaBNSvLyVBnp7SHEFMgoiIyAixRsiYvHgB9OkD7NolbXfoAKxaBTg6yhoWERGRXJgIGYvwcKBJE+DePcDcHFiwABg8mDVBRERk1JgIGQsPD6B4ccDMDNi8GahRQ+6IiIiIZMdEKD97/hyws5NqgAoUkOYIsrYG7O3ljoyIiChXYGfp/OrYMaBaNWDcuLdlrq5MgoiIiN7BRCi/UauBWbOApk2Bhw+BkBAumEpERJQGJkL5yZMnQKtWwKRJgEoFfPGFNF+QjY3ckREREeVK7COUXxw+DHTvDkRGAlZWwNKlQO/eHBVGRESUDiZC+UF0NNCxI/DyJVCpkjQqrHJluaMiIiLK9ZgI5Qf29sAvvwB79wI//simMCIiogxiIpRXHTgAmJgAzZpJ2507SzciIiLKMHaWzmuSk4HJk4GWLYFu3YDHj+WOiIiIKM9ijVBe8vChlPwcOyZtt2vHdcKIiIiygIlQXrF3L9CrF/DsGWBrC6xYAXTtKndUREREeRqbxnI7tVqaHfqTT6QkqHp14Px5JkFEREQGwEQotzMxkeYGAoAhQ4CTJ4GyZeWNiYiIKJ9g01hulZwsLZQKSJMjdu4MfPqpvDEREWUzlUqFN2/eyB0GycTMzAympqY5+phMhHKbpCRg/Hjg9m1g505pZmhbWyZBRJTvxcTE4MGDBxBCyB0KyUShUKBYsWKwtbXNscdkIpSbhIcDfn7S+mAAcOSItHgqEVE+p1Kp8ODBA1hbW8PZ2RkKLg9kdIQQePr0KR48eICyZcvmWM0QE6HcYvt24MsvAaVSGhIfFMQkiIiMxps3byCEgLOzM6ysrOQOh2Ti7OyMiIgIvHnzJscSIXaWlltiIjBsmLRWmFIJfPwxEBoKfP653JEREeU41gQZNzmuPxMhufXoASxZIv1/7Fjg6FGgRAl5YyIiIjISTITkNm4c4OYG/Pkn8P33gJmZ3BEREREZDSZCOS0+Hvj777fbtWoBd+8CbdrIFxMREWXJqVOnYGpqijapfJYfOXIECoUCr169SnGfp6cnFi1apFN2+PBhfPLJJyhcuDCsra1RqVIlfP3113j48GE2RQ8kJCRgyJAhKFy4MGxtbdGxY0dERUWle0xUVBR69+6NokWLwtraGq1atcKtW7d09rlz5w7at28PZ2dn2Nvbo0uXLh88b05jIpSTbtyQ+gD5+kr9gDQsLWULiYiIsm7VqlUYNmwYjh49ikePHmX6PL/88gt8fHzg6uqKbdu24dq1a1i2bBmUSiXmz59vwIh1jRo1Cn/88Qe2bNmCv//+G48ePUKHDh3S3F8IgXbt2uHu3bvYuXMnLly4gBIlSsDHxwexsbEAgNjYWLRs2RIKhQKHDh3CiRMnkJSUhLZt20KtVmfbc9GbMDJKpVIAEI8eKXP2gX/7TQgbGyEAIZydhTh8OGcfn4goF4uPjxfXrl0T8fHxcoeit9evXwtbW1tx/fp14efnJ2bOnKlz/+HDhwUA8fLlyxTHlihRQixcuFAIIcT9+/eFubm5GDlyZKqPk9rxhvDq1SthZmYmtmzZoi0LCwsTAMSpU6dSPebGjRsCgLhy5Yq2TKVSCWdnZ7FixQohhBD79u0TJiYmQql8+3376tUroVAoxP79+1M9b3p/B5rv73fPZwisEcpucXFAv37AF18AsbFAkyZSbVCTJjIHRkSUewkhfWTKcdN3PsfNmzejQoUKKF++PL744gusXr06U5NCbtmyBUlJSfjmm29Svd/R0THNY1u3bg1bW9s0b5UrV07z2HPnzuHNmzfw8fHRllWoUAHFixfHqVOnUj0mMTERAGD5TouGiYkJLCwscPz4ce0+CoUCFhYW2n0sLS1hYmKi3Sc34DxC2enaNaBLF+DqVWmG6KlTgSlTgByePpyIKK+Ji5Mm1ZdDTAxgY5Px/VetWoUvvvgCANCqVSsolUr8/fffaKLnD95bt27B3t4ebm5ueh0HACtXrkR8fHya95ulMxAnMjIS5ubmKRKtIkWKIFKz1uV7NInShAkT8Msvv8DGxgYLFy7EgwcP8PjxYwDAxx9/DBsbG4wbNw6zZs2CEALjx4+HSqXS7pMbMBHKTjt3SkmQqyuwfj3QrJncERERkQHduHEDZ86cwY4dOwAABQoUgJ+fH1atWqV3IiSEyPQ8Ou7u7pk6LrPMzMywfft29O3bF4UKFYKpqSl8fHzQunVrbW2Ys7MztmzZgkGDBuGHH36AiYkJunXrhho1asDEJPc0SDERyk7ffCPVsw4bBhQpInc0RER5hrW1VDMj12Nn1KpVq5CcnIyiRYtqy4QQsLCwwJIlS+Dg4AB7e3sAgFKpTFHr8urVKzg4OAAAypUrB6VSicePH+tdK9S6dWscO3YszftLlCiBq1evpnqfq6srkpKS8OrVK534oqKi4OrqmuY5vb29ERoaCqVSiaSkJDg7O6NOnTqoWbOmdp+WLVvizp07ePbsGQoUKABHR0e4urqiVKlSej2/7MREyJAuXwa+/RZYtw6wspKawL77Tu6oiIjyHIVCv+YpOSQnJ2PdunWYP38+WrZsqXNfu3btsHHjRgwcOBBly5aFiYkJzp07hxLvTJh79+5dKJVKlCtXDgDQqVMnjB8/Ht9//z0WLlyY4vHeT1TelZWmMW9vb5iZmeHgwYPo2LEjAKmm6969e6hbt26ax2loErlbt27h33//xYwZM1Ls4+TkBAA4dOgQnjx5gs8+++yD580pTIQMQQhg5Upg+HAgIQEoVQqYM0fuqIiIKBv9+eefePnyJfr27atNBjQ6duyIVatWYeDAgbCzs0O/fv3w9ddfo0CBAqhatSru37+PcePG4eOPP0a9evUAAB4eHli4cCGGDh2K6Oho9OrVC56ennjw4AHWrVsHW1vbNIfQZ6VpzMHBAX379sXo0aNRqFAh2NvbY9iwYahbty4+/vhj7X4VKlRAYGAg2rdvD0Dq3O3s7IzixYvj8uXLGDFiBNq1a6eTFK5ZswYVK1aEs7MzTp06hREjRmDUqFEoX758puM1OIOOQcsDDD58XqkUomtXaVg8IESrVkI8eWKYcxMRGYm8OHz+008/FZ988kmq9/3zzz8CgLh48aIQQnp+AQEBokKFCsLKykqULFlSDBgwQDx9+jTFsfv37xe+vr6iYMGCwtLSUlSoUEGMGTNGPHr0KNueS3x8vBg8eLAoWLCgsLa2Fu3btxePHz/W2QeAWLNmjXZ78eLFolixYsLMzEwUL15cTJ48WSQmJuocM27cOFGkSBFhZmYmypYtK+bPny/UanW6ceT08HmFEJkY45eHRUdHw8HBAY8eKeHmZp+1k124II0Ku31bagabNQsYMwbIRZ3AiIjygoSEBISHh6NkyZI6Q7LJuKT3d6D5/lYqldp+V4bAprHM2rED6NoVSEoCPDyATZuA/1dvEhERUd7ARCizataUJrmoXx9YswYoXFjuiIiIiEhPTIT08fAhoOmQ5uEBnDkjdYzO5LwPREREJC92ZskIIYDFi6WkZ9eut+WlSzMJIiIiysOYCH3IixdA+/bAyJFSf6B3EyEiIiLK05gIpef0aaB6dWmpDHNz4McfgRUr5I6KiCjfMrKBzPQeOa4/E6HUqNXAvHlAw4bAvXtSE9jJk8DQoWwKIyLKBqb/X4w6KSlJ5khITprrb5qDi5Ozs3Rqjh4Fxo6V/t+li1QLZMA5C4iISFeBAgVgbW2Np0+fwszMLFctykk5Q61W4+nTp7C2tkaBAjmXnjARSk2TJsCIEUCFCsBXX7EWiIgomykUCri5uSE8PBz//fef3OGQTExMTFC8eHEocvB7l4kQIDWFLV4MdOsGaFbaXbRI1pCIiIyNubk5ypYty+YxI2Zubp7jtYG5IhFaunQp5s6di8jISFSrVg0//vgjateuneb+W7ZswZQpUxAREYGyZctizpw5+OSTTzL34E+eAD17An/9Bfz5J7B/P5fIICKSiYmJCZfYoBwl+zd+cHAwRo8ejYCAAJw/fx7VqlWDr68vnjx5kur+J0+eRLdu3dC3b19cuHAB7dq1Q7t27XDlyhX9H/zIEcDLS0qCrKyAHj3YDEZERGREZF90tU6dOqhVqxaWLFkCQOos5eHhgWHDhmH8+PEp9vfz80NsbCz+/PNPbdnHH38MLy8vLFu27IOPp1m07emYCXBaMEdqFqtYEdi8GahSxXBPjIiIiAwmuxZdlbVGKCkpCefOnYOPj4+2zMTEBD4+Pjh16lSqx5w6dUpnfwDw9fVNc/+0mM8LlJKgPn2As2eZBBERERkhWfsIPXv2DCqVCkWKFNEpL1KkCK5fv57qMZGRkanuHxkZmer+iYmJSExM1G4rlUrpX0tLqYN0166ASgVER2flqRAREVE2iv7/97ShG7JyRWfp7BQYGIjp06enKC+ekCANjf/qKxmiIiIiosx4/vw5HBwcDHY+WRMhJycnmJqaIioqSqc8KioKrpph7O9xdXXVa/8JEyZg9OjR2u1Xr16hRIkSuHfvnkFfSNJfdHQ0PDw8cP/+fYO291Lm8HrkHrwWuQevRe6hVCpRvHhxFCpUyKDnlTURMjc3h7e3Nw4ePIh27doBkDpLHzx4EEOHDk31mLp16+LgwYMYOXKktmz//v2oW7duqvtbWFjAwsIiRbmDgwP/qHMJe3t7XotchNcj9+C1yD14LXIPQ88zJHvT2OjRo+Hv74+aNWuidu3aWLRoEWJjY9GnTx8AQK9eveDu7o7AwEAAwIgRI9C4cWPMnz8fbdq0waZNm/Dvv/9i+fLlcj4NIiIiyoNkT4T8/Pzw9OlTTJ06FZGRkfDy8kJISIi2Q/S9e/d0sr969ephw4YNmDx5MiZOnIiyZcvi999/RxWO+iIiIiI9yZ4IAcDQoUPTbAo7cuRIirLOnTujc+fOmXosCwsLBAQEpNpcRjmL1yJ34fXIPXgtcg9ei9wju66F7BMqEhEREclF9iU2iIiIiOTCRIiIiIiMFhMhIiIiMlpMhIiIiMho5ctEaOnSpfD09ISlpSXq1KmDM2fOpLv/li1bUKFCBVhaWqJq1arYs2dPDkWa/+lzLVasWIGGDRuiYMGCKFiwIHx8fD547Ug/+r43NDZt2gSFQqGd+JSyTt9r8erVKwwZMgRubm6wsLBAuXLl+FllIPpei0WLFqF8+fKwsrKCh4cHRo0ahYSEhByKNv86evQo2rZti6JFi0KhUOD333//4DFHjhxBjRo1YGFhgTJlyiAoKEj/Bxb5zKZNm4S5ublYvXq1uHr1qujfv79wdHQUUVFRqe5/4sQJYWpqKr7//ntx7do1MXnyZGFmZiYuX76cw5HnP/pei+7du4ulS5eKCxcuiLCwMNG7d2/h4OAgHjx4kMOR50/6Xg+N8PBw4e7uLho2bCg+//zznAk2n9P3WiQmJoqaNWuKTz75RBw/flyEh4eLI0eOiNDQ0ByOPP/R91qsX79eWFhYiPXr14vw8HCxb98+4ebmJkaNGpXDkec/e/bsEZMmTRLbt28XAMSOHTvS3f/u3bvC2tpajB49Wly7dk38+OOPwtTUVISEhOj1uPkuEapdu7YYMmSIdlulUomiRYuKwMDAVPfv0qWLaNOmjU5ZnTp1xFdffZWtcRoDfa/F+5KTk4WdnZ1Yu3ZtdoVoVDJzPZKTk0W9evXEypUrhb+/PxMhA9H3Wvz888+iVKlSIikpKadCNBr6XoshQ4aIZs2a6ZSNHj1a1K9fP1vjNDYZSYS++eYbUblyZZ0yPz8/4evrq9dj5aumsaSkJJw7dw4+Pj7aMhMTE/j4+ODUqVOpHnPq1Cmd/QHA19c3zf0pYzJzLd4XFxeHN2/eGHyBPWOU2evx7bffwsXFBX379s2JMI1CZq7Frl27ULduXQwZMgRFihRBlSpVMGvWLKhUqpwKO1/KzLWoV68ezp07p20+u3v3Lvbs2YNPPvkkR2Kmtwz1/Z0rZpY2lGfPnkGlUmmX59AoUqQIrl+/nuoxkZGRqe4fGRmZbXEag8xci/eNGzcORYsWTfGHTvrLzPU4fvw4Vq1ahdDQ0ByI0Hhk5lrcvXsXhw4dQo8ePbBnzx7cvn0bgwcPxps3bxAQEJATYedLmbkW3bt3x7Nnz9CgQQMIIZCcnIyBAwdi4sSJOREyvSOt7+/o6GjEx8fDysoqQ+fJVzVClH/Mnj0bmzZtwo4dO2BpaSl3OEbn9evX6NmzJ1asWAEnJye5wzF6arUaLi4uWL58Oby9veHn54dJkyZh2bJlcodmdI4cOYJZs2bhp59+wvnz57F9+3bs3r0bM2bMkDs0yqR8VSPk5OQEU1NTREVF6ZRHRUXB1dU11WNcXV312p8yJjPXQmPevHmYPXs2Dhw4gI8++ig7wzQa+l6PO3fuICIiAm3bttWWqdVqAECBAgVw48YNlC5dOnuDzqcy895wc3ODmZkZTE1NtWUVK1ZEZGQkkpKSYG5unq0x51eZuRZTpkxBz5490a9fPwBA1apVERsbiwEDBmDSpEk6i4RT9krr+9ve3j7DtUFAPqsRMjc3h7e3Nw4ePKgtU6vVOHjwIOrWrZvqMXXr1tXZHwD279+f5v6UMZm5FgDw/fffY8aMGQgJCUHNmjVzIlSjoO/1qFChAi5fvozQ0FDt7bPPPkPTpk0RGhoKDw+PnAw/X8nMe6N+/fq4ffu2NhkFgJs3b8LNzY1JUBZk5lrExcWlSHY0Carg0p05ymDf3/r14879Nm3aJCwsLERQUJC4du2aGDBggHB0dBSRkZFCCCF69uwpxo8fr93/xIkTokCBAmLevHkiLCxMBAQEcPi8geh7LWbPni3Mzc3F1q1bxePHj7W3169fy/UU8hV9r8f7OGrMcPS9Fvfu3RN2dnZi6NCh4saNG+LPP/8ULi4u4rvvvpPrKeQb+l6LgIAAYWdnJzZu3Cju3r0r/vrrL1G6dGnRpUsXuZ5CvvH69Wtx4cIFceHCBQFALFiwQFy4cEH8999/Qgghxo8fL3r27KndXzN8fuzYsSIsLEwsXbqUw+c1fvzxR1G8eHFhbm4uateuLU6fPq29r3HjxsLf319n/82bN4ty5coJc3NzUblyZbF79+4cjjj/0udalChRQgBIcQsICMj5wPMpfd8b72IiZFj6XouTJ0+KOnXqCAsLC1GqVCkxc+ZMkZycnMNR50/6XIs3b96IadOmidKlSwtLS0vh4eEhBg8eLF6+fJnzgeczhw8fTvU7QPP6+/v7i8aNG6c4xsvLS5ibm4tSpUqJNWvW6P24CiFYl0dERETGKV/1ESIiIiLSBxMhIiIiMlpMhIiIiMhoMREiIiIio8VEiIiIiIwWEyEiIiIyWkyEiIiIyGgxESIiHUFBQXB0dJQ7jExTKBT4/fff092nd+/eaNeuXY7EQ0S5GxMhonyod+/eUCgUKW63b9+WOzQEBQVp4zExMUGxYsXQp08fPHnyxCDnf/z4MVq3bg0AiIiIgEKhQGhoqM4+ixcvRlBQkEEeLy3Tpk3TPk9TU1N4eHhgwIABePHihV7nYdJGlL3y1erzRPRWq1atsGbNGp0yZ2dnmaLRZW9vjxs3bkCtVuPixYvo06cPHj16hH379mX53GmtGv4uBweHLD9ORlSuXBkHDhyASqVCWFgYvvzySyiVSgQHB+fI4xPRh7FGiCifsrCwgKurq87N1NQUCxYsQNWqVWFjYwMPDw8MHjwYMTExaZ7n4sWLaNq0Kezs7GBvbw9vb2/8+++/2vuPHz+Ohg0bwsrKCh4eHhg+fDhiY2PTjU2hUMDV1RVFixZF69atMXz4cBw4cADx8fFQq9X49ttvUaxYMVhYWMDLywshISHaY5OSkjB06FC4ubnB0tISJUqUQGBgoM65NU1jJUuWBABUr14dCoUCTZo0AaBby7J8+XIULVpUZ2V3APj888/x5Zdfard37tyJGjVqwNLSEqVKlcL06dORnJyc7vMsUKAAXF1d4e7uDh8fH3Tu3Bn79+/X3q9SqdC3b1+ULFkSVlZWKF++PBYvXqy9f9q0aVi7di127typrV06cuQIAOD+/fvo0qULHB0dUahQIXz++eeIiIhINx4iSomJEJGRMTExwQ8//ICrV69i7dq1OHToEL755ps09+/RoweKFSuGs2fP4ty5cxg/fjzMzMwAAHfu3EGrVq3QsWNHXLp0CcHBwTh+/DiGDh2qV0xWVlZQq9VITk7G4sWLMX/+fMybNw+XLl2Cr68vPvvsM9y6dQsA8MMPP2DXrl3YvHkzbty4gfXr18PT0zPV8545cwYAcODAATx+/Bjbt29PsU/nzp3x/PlzHD58WFv24sULhISEoEePHgCAY8eOoVevXhgxYgSuXbuGX375BUFBQZg5c2aGn2NERAT27dsHc3NzbZlarUaxYsWwZcsWXLt2DVOnTsXEiROxefNmAMCYMWPQpUsXtGrVCo8fP8bjx49Rr149vHnzBr6+vrCzs8OxY8dw4sQJ2NraolWrVkhKSspwTEQE5MvV54mMnb+/vzA1NRU2NjbaW6dOnVLdd8uWLaJw4cLa7TVr1ggHBwfttp2dnQgKCkr12L59+4oBAwbolB07dkyYmJiI+Pj4VI95//w3b94U5cqVEzVr1hRCCFG0aFExc+ZMnWNq1aolBg8eLIQQYtiwYaJZs2ZCrVanen4AYseOHUIIIcLDwwUAceHCBZ19/P39xeeff67d/vzzz8WXX36p3f7ll19E0aJFhUqlEkII0bx5czFr1iydc/z666/Czc0t1RiEECIgIECYmJgIGxsbYWlpqV1Je8GCBWkeI4QQQ4YMER07dkwzVs1jly9fXuc1SExMFFZWVmLfvn3pnp+IdLGPEFE+1bRpU/z888/abRsbGwBS7UhgYCCuX7+O6OhoJCcnIyEhAXFxcbC2tk5xntGjR6Nfv3749ddftc07pUuXBiA1m126dAnr16/X7i+EgFqtRnh4OCpWrJhqbEqlEra2tlCr1UhISECDBg2wcuVKREdH49GjR6hfv77O/vXr18fFixcBSM1aLVq0QPny5dGqVSt8+umnaNmyZZZeqx49eqB///746aefYGFhgfXr16Nr164wMTHRPs8TJ07o1ACpVKp0XzcAKF++PHbt2oWEhAT89ttvCA0NxbBhw3T2Wbp0KVavXo179+4hPj4eSUlJ8PLySjfeixcv4vbt27Czs9MpT0hIwJ07dzLxChAZLyZCRPmUjY0NypQpo1MWERGBTz/9FIMGDcLMmTNRqFAhHD9+HH379kVSUlKqX+jTpk1D9+7dsXv3buzduxcBAQHYtGkT2rdvj5iYGHz11VcYPnx4iuOKFy+eZmx2dnY4f/48TExM4ObmBisrKwBAdHT0B59XjRo1EB4ejr179+LAgQPo0qULfHx8sHXr1g8em5a2bdtCCIHdu3ejVq1aOHbsGBYuXKi9PyYmBtOnT0eHDh1SHGtpaZnmec3NzbXXYPbs2WjTpg2mT5+OGTNmAAA2bdqEMWPGYP78+ahbty7s7Owwd+5c/PPPP+nGGxMTA29vb50EVCO3dIgnyiuYCBEZkXPnzkGtVmP+/Pna2g5Nf5T0lCtXDuXKlcOoUaPQrVs3rFmzBu3bt0eNGjVw7dq1FAnXh5iYmKR6jL29PYoWLYoTJ06gcePG2vITJ06gdu3aOvv5+fnBz88PnTp1QqtWrfDixQsUKlRI53ya/jgqlSrdeCwtLdGhQwesX78et2/fRvny5VGjRg3t/TVq1MCNGzf0fp7vmzx5Mpo1a4ZBgwZpn2e9evUwePBg7T7v1+iYm5uniL9GjRoIDg6Gi4sL7O3tsxQTkbFjZ2kiI1KmTBm8efMGP/74I+7evYtff/0Vy5YtS3P/+Ph4DB06FEeOHMF///2HEydO4OzZs9omr3HjxuHkyZMYOnQoQkNDcevWLezcuVPvztLvGjt2LObMmYPg4GDcuHED48ePR2hoKEaMGAEAWLBgATZu3Ijr16/j5s2b2LJlC1xdXVOdBNLFxQVWVlYICQlBVFQUlEplmo/bo0cP7N69G6tXr9Z2ktaYOnUq1q1bh+nTp+Pq1asICwvDpk2bMHnyZL2eW926dfHRRx9h1qxZAICyZcvi33//xb59+3Dz5k1MmTIFZ8+e1TnG09MTly5dwo0bN/Ds2TO8efMGPXr0gJOTEz7//HMcO3YM4eHhOHLkCIYPH44HDx7oFROR0ZO7kxIRGV5qHWw1FixYINzc3ISVlZXw9fUV69atEwDEy5cvhRC6nZkTExNF165dhYeHhzA3NxdFixYVQ4cO1ekIfebMGdGiRQtha2srbGxsxEcffZSis/O73u8s/T6VSiWmTZsm3N3dhZmZmahWrZrYu3ev9v7ly5cLLy8vYWNjI+zt7UXz5s3F+fPntffjnc7SQgixYsUK4eHhIUxMTETjxo3TfH1UKpVwc3MTAMSdO3dSxBUSEiLq1asnrKyshL29vahdu7ZYvnx5ms8jICBAVKtWLUX5xo0bhYWFhbh3755ISEgQvXv3Fg4ODsLR0VEMGjRIjB8/Xue4J0+eaF9fAOLw4cNCCCEeP34sevXqJZycnISFhYUoVaqU6N+/v1AqlWnGREQpKYQQQt5UjIiIiEgebBojIiIio8VEiIiIiIwWEyEiIiIyWkyEiIiIyGgxESIiIiKjxUSIiIiIjBYTISIiIjJaTISIiIjIaDERIiIiIqPFRIiIiIiMFhMhIiIiMlpMhIiIiMho/Q9dD/QTFszObgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -364,9 +414,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 5 AUC: 0.9895333333333334\n", - "CPU times: user 2min 57s, sys: 2min 20s, total: 5min 17s\n", - "Wall time: 2min 8s\n" + "Overall, depth: 5 AUC: 0.9871222222222222\n", + "CPU times: user 2min 16s, sys: 2min 9s, total: 4min 26s\n", + "Wall time: 1min 35s\n" ] } ], @@ -388,6 +438,7 @@ " knn_library=\"sklearn\",\n", " X_train=data.corpus,\n", " signature_kwargs={\n", + " \"augmentation_list\": None,\n", " \"depth\": depth,\n", " },\n", " )\n", @@ -423,6 +474,23 @@ " depth_to_auc[depth] = auc" ] }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1: 0.9025000000000001, 2: 0.9773777777777778, 3: 0.9870888888888889, 4: 0.9868333333333333, 5: 0.9871222222222222}\n" + ] + } + ], + "source": [ + "print(depth_to_auc)" + ] + }, { "cell_type": "markdown", "id": "79e05b28", @@ -430,12 +498,12 @@ "source": [ "## Can we reproduce distances?\n", "\n", - "For depth 4, digit 0:" + "For depth 2, digit 0, no augmentation_list:" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 65, "id": "a4675b42", "metadata": {}, "outputs": [ @@ -443,14 +511,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "doing digit 0 doing signature level 4\n", - "fit_time: 1.786160945892334\n" + "doing digit 0 doing signature level 2\n", + "fit_time: 1.8162589073181152\n" ] } ], "source": [ "digit = 0\n", - "depth = 4\n", + "depth = 2\n", "data.load_pen_digit(digit=digit)\n", "print(\"doing digit\", digit, \"doing signature level \", depth)\n", "signature_maha_knn = SignatureMahalanobisKNN()\n", @@ -459,9 +527,7 @@ "signature_maha_knn.fit(\n", " knn_library=\"sklearn\",\n", " X_train=data.corpus,\n", - " signature_kwargs={\n", - " \"depth\": depth,\n", - " },\n", + " signature_kwargs={},\n", ")\n", "fit_time = time.time() - start_time\n", "print(f\"fit_time: {fit_time}\")\n", @@ -474,24 +540,31 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Inlier dists" + ] + }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 66, "id": "fa3d0039-5d50-4aa8-ac91-f76a83513315", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.10293763, 0.21655908, 0.17555342, 0.37821957, 2.52220155,\n", - " 0.25794536, 0.19356175, 1.8735614 , 0.21667799, 0.21799781,\n", - " 0.30084204, 0.14079295, 0.19137239, 1.0841934 , 0.20703369,\n", - " 1.16883841, 0.25666209, 4.09705851, 0.28626317, 2.27759731,\n", - " 0.17592573, 0.40444251, 0.22031607, 0.152825 , 0.13235025,\n", - " 0.12575332, 0.14180312, 0.65683611, 0.78451488, 0.23221037])" + "array([0.02203349, 0.02636506, 0.01619603, 0.01555797, 0.11322956,\n", + " 0.03182318, 0.02529738, 0.09760276, 0.01769069, 0.0184093 ,\n", + " 0.03047298, 0.01305365, 0.02557788, 0.07339483, 0.01822537,\n", + " 0.07480418, 0.02407774, 0.17452867, 0.03732281, 0.10320762,\n", + " 0.01851509, 0.01398619, 0.01354817, 0.01247237, 0.02372335,\n", + " 0.01140402, 0.02230902, 0.04476067, 0.0622557 , 0.02477818])" ] }, - "execution_count": 28, + "execution_count": 66, "metadata": {}, "output_type": "execute_result" } @@ -502,7 +575,6 @@ }, { "cell_type": "markdown", - "id": "798d4c01-0fb8-4e38-a5b1-2f2fe8d1a749", "metadata": {}, "source": [ "#### Should be \n", @@ -541,22 +613,182 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "previous_output = np.array(\n", + " [\n", + " [0.00048547],\n", + " [0.00069512],\n", + " [0.00026231],\n", + " [0.00024205],\n", + " [0.01478617],\n", + " [0.00101271],\n", + " [0.00063996],\n", + " [0.01085489],\n", + " [0.00031296],\n", + " [0.0003389],\n", + " [0.0009286],\n", + " [0.0001704],\n", + " [0.00065423],\n", + " [0.0053868],\n", + " [0.00033216],\n", + " [0.00559567],\n", + " [0.00057974],\n", + " [0.03442473],\n", + " [0.00139299],\n", + " [0.01456522],\n", + " [0.00034281],\n", + " [0.00019561],\n", + " [0.00018355],\n", + " [0.00015556],\n", + " [0.0005628],\n", + " [0.00013005],\n", + " [0.00049769],\n", + " [0.00200352],\n", + " [0.00387577],\n", + " [0.00061396],\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.02203338, 0.02636513, 0.01619599, 0.01555796, 0.1215984 ,\n", + " 0.0318231 , 0.02529743, 0.1041868 , 0.01769068, 0.01840924,\n", + " 0.03047294, 0.01305374, 0.02557792, 0.07339482, 0.01822526,\n", + " 0.07480421, 0.02407779, 0.18553903, 0.03732278, 0.12068645,\n", + " 0.01851513, 0.01398606, 0.01354806, 0.01247237, 0.02372341,\n", + " 0.01140395, 0.02230897, 0.0447607 , 0.06225568, 0.02477822])" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(previous_output).reshape(30)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "square root the expected distance array and compare to what we get:" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-1.02955230e-07, 7.06101742e-08, -4.65146504e-08, -1.53675729e-08,\n", + " 8.36883754e-03, -7.65752497e-08, 5.45321150e-08, 6.58404715e-03,\n", + " -1.37017948e-08, -6.32657278e-08, -4.05939281e-08, 8.27130721e-08,\n", + " 4.21097337e-08, -1.14308784e-08, -1.15933769e-07, 3.02990479e-08,\n", + " 4.71664630e-08, 1.10103530e-02, -3.29369544e-08, 1.74788367e-02,\n", + " 3.79573153e-08, -1.22617305e-07, -1.03330218e-07, 2.92517347e-09,\n", + " 5.37633529e-08, -7.02766429e-08, -4.83415681e-08, 3.01917514e-08,\n", + " -1.84955282e-08, 4.06431382e-08])" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(previous_output).reshape(30) - inlier_dists" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-4.53691477e-09, 3.72328764e-09, -1.50670353e-09, -4.78176286e-10,\n", + " 1.96523701e-03, -4.87373026e-09, 2.75904183e-09, 1.32859197e-03,\n", + " -4.84788199e-10, -2.32935153e-09, -2.47403422e-09, 2.15942222e-09,\n", + " 2.15415704e-09, -1.67793471e-09, -4.22585897e-09, 4.53299184e-09,\n", + " 2.27132622e-09, 3.96447245e-03, -2.45859857e-09, 3.91340789e-03,\n", + " 1.40556774e-09, -3.42988212e-09, -2.79985920e-09, 7.29676800e-11,\n", + " 2.55089683e-09, -1.60286712e-09, -2.15690321e-09, 2.70280676e-09,\n", + " -2.30290380e-09, 2.01412728e-09])" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "previous_output.reshape(30) - (inlier_dists**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.00048547, 0.00069512, 0.00026231, 0.00024205, 0.01282093,\n", + " 0.00101271, 0.00063996, 0.0095263 , 0.00031296, 0.0003389 ,\n", + " 0.0009286 , 0.0001704 , 0.00065423, 0.0053868 , 0.00033216,\n", + " 0.00559567, 0.00057974, 0.03046026, 0.00139299, 0.01065181,\n", + " 0.00034281, 0.00019561, 0.00018355, 0.00015556, 0.0005628 ,\n", + " 0.00013005, 0.00049769, 0.00200352, 0.00387577, 0.00061396])" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inlier_dists**2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Outlier dists" + ] + }, + { + "cell_type": "code", + "execution_count": 72, "id": "7b24a162-ab61-42ec-92d0-31067441e1ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([22.91785796, 5.13259221, 3.1411223 , 8.72980904, 4.24595201,\n", - " 2.95224877, 5.04656285, 8.58317299, 25.66333466, 21.39243841,\n", - " 6.60518334, 18.39905365, 8.09815035, 8.45932109, 7.80032309,\n", - " 6.29733469, 21.82005658, 20.12689115, 19.32945792, 8.55422835,\n", - " 5.30316279, 25.21674903, 17.62691334, 19.85905925, 1.38845035,\n", - " 4.07114126, 8.38638713, 13.33983856, 15.38123633, 13.02245564])" + "array([0.67234355, 0.24378292, 0.12239675, 0.25943279, 0.24765937,\n", + " 0.1254194 , 0.21369962, 0.2074082 , 0.70915455, 0.71401428,\n", + " 0.23341584, 0.55010932, 0.183303 , 0.28309619, 0.24274553,\n", + " 0.27733141, 0.74215366, 0.43625736, 0.62571778, 0.26774459,\n", + " 0.22821209, 0.70655546, 0.45673412, 0.43718578, 0.09406633,\n", + " 0.17178055, 0.20218662, 0.50789135, 0.46324354, 0.28108907])" ] }, - "execution_count": 29, + "execution_count": 72, "metadata": {}, "output_type": "execute_result" } @@ -567,7 +799,6 @@ }, { "cell_type": "markdown", - "id": "ec6bff3a-f221-4332-bee7-00eac140a9a3", "metadata": {}, "source": [ "#### Should be\n", @@ -603,21 +834,654 @@ " [0.07901108]])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "square root the expected distance array and compare to what we get:" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "previous_output = np.array(\n", + " [\n", + " [0.51469102],\n", + " [0.05943012],\n", + " [0.01498096],\n", + " [0.06730538],\n", + " [0.06133516],\n", + " [0.01573002],\n", + " [0.04566752],\n", + " [0.04301818],\n", + " [0.5029002],\n", + " [0.56088974],\n", + " [0.05448295],\n", + " [0.39831413],\n", + " [0.03359998],\n", + " [0.08014344],\n", + " [0.05892539],\n", + " [0.07691271],\n", + " [0.67933435],\n", + " [0.20881273],\n", + " [0.42321369],\n", + " [0.07168717],\n", + " [0.05208077],\n", + " [0.51004513],\n", + " [0.29315337],\n", + " [0.21727576],\n", + " [0.00884847],\n", + " [0.02950856],\n", + " [0.04087942],\n", + " [0.33563053],\n", + " [0.26939553],\n", + " [0.07901108],\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.7174197 , 0.24378294, 0.12239673, 0.2594328 , 0.24765936,\n", + " 0.12541938, 0.2136996 , 0.20740824, 0.70915457, 0.74892572,\n", + " 0.23341583, 0.63112133, 0.18330297, 0.28309617, 0.24274553,\n", + " 0.27733141, 0.82421742, 0.45696032, 0.65054876, 0.2677446 ,\n", + " 0.22821212, 0.71417444, 0.5414364 , 0.46612848, 0.09406631,\n", + " 0.17178056, 0.2021866 , 0.57933628, 0.51903326, 0.2810891 ])" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(previous_output).reshape(30)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 4.50761483e-02, 1.41871383e-08, -1.62484084e-08, 1.70116942e-08,\n", + " -1.01572042e-08, -2.02923470e-08, -1.80967602e-08, 4.01072114e-08,\n", + " 1.81668306e-08, 3.49114395e-02, -4.51935286e-09, 8.10120038e-02,\n", + " -2.81344381e-08, -2.32657197e-08, -4.97864919e-09, -3.43226980e-09,\n", + " 8.20637593e-02, 2.07029603e-02, 2.48309856e-02, 1.05995966e-08,\n", + " 2.38833046e-08, 7.61898031e-03, 8.47022778e-02, 2.89426981e-02,\n", + " -2.58176006e-08, 3.81950485e-09, -2.43117602e-08, 7.14449349e-02,\n", + " 5.57897248e-02, 2.18613811e-08])" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(previous_output).reshape(30) - outlier_dists" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 6.26451741e-02, 6.91716428e-09, -3.97750445e-09, 8.82678276e-09,\n", + " -5.03105356e-09, -5.09010742e-09, -7.73454124e-09, 1.66371310e-08,\n", + " 2.57661814e-08, 5.10733416e-02, -2.10977703e-09, 9.56938620e-02,\n", + " -1.03142531e-08, -1.31728727e-08, -2.41708965e-09, -1.90375245e-09,\n", + " 1.28542299e-01, 1.84922500e-02, 3.16909560e-02, 5.67596936e-09,\n", + " 1.09009184e-08, 1.08245131e-02, 8.45473161e-02, 2.61443520e-02,\n", + " -4.85713332e-09, 1.31223333e-09, -9.83102471e-09, 7.76769075e-02,\n", + " 5.48009526e-02, 1.22899913e-08])" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "previous_output.reshape(30) - (outlier_dists**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.45204585, 0.05943011, 0.01498096, 0.06730537, 0.06133517,\n", + " 0.01573003, 0.04566753, 0.04301816, 0.50290017, 0.5098164 ,\n", + " 0.05448295, 0.30262027, 0.03359999, 0.08014345, 0.05892539,\n", + " 0.07691271, 0.55079205, 0.19032048, 0.39152273, 0.07168716,\n", + " 0.05208076, 0.49922062, 0.20860605, 0.19113141, 0.00884847,\n", + " 0.02950856, 0.04087943, 0.25795362, 0.21459458, 0.07901107])" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "outlier_dists**2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Can we reproduce distances?\n", + "\n", + "For depth 4, digit 0, with augmentation_list=None" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "doing digit 0 doing signature level 4\n", + "fit_time: 1.6098101139068604\n" + ] + } + ], + "source": [ + "digit = 0\n", + "depth = 4\n", + "data.load_pen_digit(digit=digit)\n", + "print(\"doing digit\", digit, \"doing signature level \", depth)\n", + "signature_maha_knn = SignatureMahalanobisKNN()\n", + "# Measure the time spent on fit\n", + "start_time = time.time()\n", + "signature_maha_knn.fit(\n", + " knn_library=\"sklearn\",\n", + " X_train=data.corpus,\n", + " signature_kwargs={\n", + " \"augmentation_list\": None,\n", + " \"depth\": depth,\n", + " },\n", + ")\n", + "fit_time = time.time() - start_time\n", + "print(f\"fit_time: {fit_time}\")\n", + "\n", + "inlier_dists = signature_maha_knn.conformance(\n", + " data.test_inlier, n_neighbors=n_neighbours\n", + ")\n", + "outlier_dists = signature_maha_knn.conformance(\n", + " data.test_outlier, n_neighbors=n_neighbours\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Inlier dists" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "f265a90a-0e6a-47b3-9cf2-8942e8bcd63e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.02203349, 0.02636506, 0.01619603, 0.01555797, 0.11322956,\n", + " 0.03182318, 0.02529738, 0.09760276, 0.01769069, 0.0184093 ,\n", + " 0.03047298, 0.01305365, 0.02557788, 0.07339483, 0.01822537,\n", + " 0.07480418, 0.02407774, 0.17452867, 0.03732281, 0.10320762,\n", + " 0.01851509, 0.01398619, 0.01354817, 0.01247237, 0.02372335,\n", + " 0.01140402, 0.02230902, 0.04476067, 0.0622557 , 0.02477818])" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inlier_dists" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Should be \n", + "array([[1.57399406e-03],\n", + " [3.02998419e-03],\n", + " [1.22819305e-03],\n", + " [7.85843469e-04],\n", + " [6.24430478e-01],\n", + " [8.38084612e-03],\n", + " [1.55270391e-03],\n", + " [3.67094040e-01],\n", + " [2.89758784e-03],\n", + " [4.41202335e-03],\n", + " [5.69510600e-03],\n", + " [2.22076988e-03],\n", + " [3.59995430e-03],\n", + " [7.55992085e-02],\n", + " [2.03744438e-03],\n", + " [1.54949293e-01],\n", + " [6.56671124e-03],\n", + " [1.26924562e+00],\n", + " [1.72368567e-02],\n", + " [5.21945238e-01],\n", + " [4.33543418e-03],\n", + " [1.02200045e-03],\n", + " [7.39515584e-04],\n", + " [4.23905114e-03],\n", + " [2.75986036e-03],\n", + " [1.01882860e-03],\n", + " [2.13477737e-03],\n", + " [1.13266921e-02],\n", + " [4.81867641e-02],\n", + " [2.26310734e-03]])" + ] + }, + { + "cell_type": "code", + "execution_count": 82, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "previous_output = np.array(\n", + " [\n", + " [1.57399406e-03],\n", + " [3.02998419e-03],\n", + " [1.22819305e-03],\n", + " [7.85843469e-04],\n", + " [6.24430478e-01],\n", + " [8.38084612e-03],\n", + " [1.55270391e-03],\n", + " [3.67094040e-01],\n", + " [2.89758784e-03],\n", + " [4.41202335e-03],\n", + " [5.69510600e-03],\n", + " [2.22076988e-03],\n", + " [3.59995430e-03],\n", + " [7.55992085e-02],\n", + " [2.03744438e-03],\n", + " [1.54949293e-01],\n", + " [6.56671124e-03],\n", + " [1.26924562e00],\n", + " [1.72368567e-02],\n", + " [5.21945238e-01],\n", + " [4.33543418e-03],\n", + " [1.02200045e-03],\n", + " [7.39515584e-04],\n", + " [4.23905114e-03],\n", + " [2.75986036e-03],\n", + " [1.01882860e-03],\n", + " [2.13477737e-03],\n", + " [1.13266921e-02],\n", + " [4.81867641e-02],\n", + " [2.26310734e-03],\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.03967359, 0.05504529, 0.03504559, 0.0280329 , 0.79020914,\n", + " 0.09154696, 0.03940436, 0.60588286, 0.05382925, 0.06642306,\n", + " 0.07546593, 0.04712505, 0.05999962, 0.2749531 , 0.04513806,\n", + " 0.39363599, 0.08103525, 1.12660802, 0.13128921, 0.72245778,\n", + " 0.06584401, 0.03196874, 0.02719404, 0.065108 , 0.05253437,\n", + " 0.03191909, 0.04620365, 0.10642693, 0.21951484, 0.04757213])" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(previous_output).reshape(30)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "square root the expected distance array and compare to what we get:" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-8.93063967e-08, -2.17409717e-07, -5.66903558e-08, 7.38938851e-08,\n", + " -8.42573458e-08, -5.26114575e-08, -8.64452235e-08, -1.01664387e-07,\n", + " 3.46922363e-08, -3.20217935e-07, -1.55203279e-07, 7.14810783e-08,\n", + " -2.98499856e-08, 3.92668074e-07, 1.52293966e-08, 3.18778138e-07,\n", + " -1.08174473e-07, -1.44161407e-07, -5.46668106e-07, 2.47656750e-07,\n", + " -7.85003826e-09, 7.02585983e-08, 3.99192888e-08, -3.94153994e-08,\n", + " -1.35485741e-07, -2.21287160e-08, -3.94063128e-08, 3.61699707e-08,\n", + " -9.88227740e-08, 3.03806841e-09])" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(previous_output).reshape(30) - inlier_dists" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-7.08621943e-09, -2.39348100e-08, -3.97349662e-09, 4.14291429e-09,\n", + " -1.33161856e-07, -9.63284089e-09, -6.81264560e-09, -1.23193429e-07,\n", + " 3.73491272e-09, -4.25398150e-08, -2.34251424e-08, 6.73709298e-09,\n", + " -3.58197643e-09, 2.15930456e-07, 1.37485058e-09, 2.50964995e-07,\n", + " -1.75319019e-08, -3.24826814e-07, -1.43543547e-07, 3.57843028e-07,\n", + " -1.03375612e-09, 4.49215304e-09, 2.17113154e-09, -5.13251689e-09,\n", + " -1.42353353e-08, -1.41265765e-09, -3.64143261e-09, 7.69891680e-09,\n", + " -4.33861402e-08, 2.89054748e-10])" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "previous_output.reshape(30) - (inlier_dists**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.57400115e-03, 3.03000812e-03, 1.22819702e-03, 7.85839326e-04,\n", + " 6.24430611e-01, 8.38085575e-03, 1.55271072e-03, 3.67094163e-01,\n", + " 2.89758411e-03, 4.41206589e-03, 5.69512943e-03, 2.22076314e-03,\n", + " 3.59995788e-03, 7.55989926e-02, 2.03744301e-03, 1.54949042e-01,\n", + " 6.56672877e-03, 1.26924594e+00, 1.72370002e-02, 5.21944880e-01,\n", + " 4.33543521e-03, 1.02199596e-03, 7.39513413e-04, 4.23905627e-03,\n", + " 2.75987460e-03, 1.01883001e-03, 2.13478101e-03, 1.13266844e-02,\n", + " 4.81868075e-02, 2.26310705e-03])" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inlier_dists**2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Outlier dists" + ] }, { "cell_type": "code", "execution_count": null, - "id": "30c04c72-edb2-4ed7-9f16-2fc27ca864ad", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.67234355, 0.24378292, 0.12239675, 0.25943279, 0.24765937,\n", + " 0.1254194 , 0.21369962, 0.2074082 , 0.70915455, 0.71401428,\n", + " 0.23341584, 0.55010932, 0.183303 , 0.28309619, 0.24274553,\n", + " 0.27733141, 0.74215366, 0.43625736, 0.62571778, 0.26774459,\n", + " 0.22821209, 0.70655546, 0.45673412, 0.43718578, 0.09406633,\n", + " 0.17178055, 0.20218662, 0.50789135, 0.46324354, 0.28108907])" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "outlier_dists" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Should be\n", + "array([[2.46092896e+02],\n", + " [8.34590435e+00],\n", + " [3.10406297e-01],\n", + " [2.27476239e+00],\n", + " [2.45730543e+00],\n", + " [1.01819646e+00],\n", + " [8.47214222e+00],\n", + " [4.20720434e+00],\n", + " [3.47824524e+02],\n", + " [3.05057648e+02],\n", + " [5.35958481e+00],\n", + " [1.25125313e+02],\n", + " [4.36297131e+00],\n", + " [1.28856373e+01],\n", + " [4.30303574e+00],\n", + " [2.90682650e+00],\n", + " [2.62529602e+02],\n", + " [1.28804825e+02],\n", + " [2.02335602e+02],\n", + " [3.20881152e+00],\n", + " [2.98228765e+00],\n", + " [3.03542328e+02],\n", + " [1.09345932e+02],\n", + " [1.23277054e+02],\n", + " [1.62122369e-01],\n", + " [2.75962615e+00],\n", + " [6.11792469e+00],\n", + " [7.73409119e+01],\n", + " [1.08036621e+02],\n", + " [1.42122135e+01]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "square root the expected distance array and compare to what we get:" + ] + }, + { + "cell_type": "code", + "execution_count": 87, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "previous_output = np.array(\n", + " [\n", + " [2.46092896e02],\n", + " [8.34590435e00],\n", + " [3.10406297e-01],\n", + " [2.27476239e00],\n", + " [2.45730543e00],\n", + " [1.01819646e00],\n", + " [8.47214222e00],\n", + " [4.20720434e00],\n", + " [3.47824524e02],\n", + " [3.05057648e02],\n", + " [5.35958481e00],\n", + " [1.25125313e02],\n", + " [4.36297131e00],\n", + " [1.28856373e01],\n", + " [4.30303574e00],\n", + " [2.90682650e00],\n", + " [2.62529602e02],\n", + " [1.28804825e02],\n", + " [2.02335602e02],\n", + " [3.20881152e00],\n", + " [2.98228765e00],\n", + " [3.03542328e02],\n", + " [1.09345932e02],\n", + " [1.23277054e02],\n", + " [1.62122369e-01],\n", + " [2.75962615e00],\n", + " [6.11792469e00],\n", + " [7.73409119e01],\n", + " [1.08036621e02],\n", + " [1.42122135e01],\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([15.68734828, 2.88892789, 0.55714118, 1.50823154, 1.56757948,\n", + " 1.00905721, 2.91069446, 2.05114708, 18.65005426, 17.46589958,\n", + " 2.31507771, 11.18594265, 2.08877268, 3.58965699, 2.07437599,\n", + " 1.70494179, 16.20276526, 11.34922134, 14.22447194, 1.79131558,\n", + " 1.72693012, 17.42246619, 10.45686052, 11.10302004, 0.40264422,\n", + " 1.66121225, 2.47344389, 8.79436819, 10.39406662, 3.76990895])" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(previous_output).reshape(30)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-8.21747985e-07, -2.69834035e-07, -1.48919698e-07, 4.56305748e-07,\n", + " -5.51919370e-07, 1.47626646e-07, -3.51786952e-07, 1.19242829e-06,\n", + " -4.39633794e-07, 6.22026988e-07, -8.38908520e-08, -8.58251527e-07,\n", + " 4.91076205e-07, -2.11618727e-08, -7.59827870e-07, -2.84967868e-07,\n", + " 7.92148022e-07, -7.91957465e-07, -1.30804852e-06, -7.24779423e-07,\n", + " 1.63624314e-06, -1.20129025e-06, 7.00472224e-07, 1.53653374e-08,\n", + " 9.44603640e-08, 2.59341062e-07, -2.26735458e-07, -1.10553937e-06,\n", + " 8.65130316e-07, 1.41124838e-07])" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sqrt(previous_output).reshape(30) - outlier_dists" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-2.57820944e-05, -1.55906221e-06, -1.65938616e-07, 1.37642924e-06,\n", + " -1.73035526e-06, 2.97927442e-07, -2.04788878e-06, 4.89169016e-06,\n", + " -1.63983884e-05, 2.17285215e-05, -3.88427690e-07, -1.92007055e-05,\n", + " 2.05149288e-06, -1.51927727e-07, -3.15233796e-06, -9.71707332e-07,\n", + " 2.56699763e-05, -1.79762017e-05, -3.72126005e-05, -2.59661788e-06,\n", + " 5.65135246e-06, -4.18588791e-05, 1.46494802e-05, 3.41203290e-07,\n", + " 7.60678305e-08, 8.61641034e-07, -1.12163492e-06, -1.94450418e-05,\n", + " 1.79844435e-05, 1.06405556e-06])" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "previous_output.reshape(30) - (outlier_dists**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2.46092922e+02, 8.34590591e+00, 3.10406463e-01, 2.27476101e+00,\n", + " 2.45730716e+00, 1.01819616e+00, 8.47214427e+00, 4.20719945e+00,\n", + " 3.47824540e+02, 3.05057626e+02, 5.35958520e+00, 1.25125332e+02,\n", + " 4.36296926e+00, 1.28856375e+01, 4.30303889e+00, 2.90682747e+00,\n", + " 2.62529576e+02, 1.28804843e+02, 2.02335639e+02, 3.20881412e+00,\n", + " 2.98228200e+00, 3.03542370e+02, 1.09345917e+02, 1.23277054e+02,\n", + " 1.62122293e-01, 2.75962529e+00, 6.11792581e+00, 7.73409313e+01,\n", + " 1.08036603e+02, 1.42122124e+01])" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "outlier_dists**2" + ] }, { "cell_type": "markdown", diff --git a/src/signature_mahalanobis_knn/mahal_distance.py b/src/signature_mahalanobis_knn/mahal_distance.py index 6c9efe7..f4923ef 100644 --- a/src/signature_mahalanobis_knn/mahal_distance.py +++ b/src/signature_mahalanobis_knn/mahal_distance.py @@ -84,7 +84,7 @@ def calc_distance( x2 : np.ndarray One-dimensional array. Vt : np.ndarray - Two-dimensional arrat, truncated right singular matrix transposed of the corpus. + Two-dimensional array, truncated right singular matrix transposed of the corpus. S : np.ndarray One-dimensional array, truncated singular values of the corpus. subspace_thres : float diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index 04730f9..6fdb4ba 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -16,6 +16,7 @@ class SignatureMahalanobisKNN: def __init__( self, n_jobs: int = 1, + random_state: int | None = None, ): """ Parameters @@ -23,12 +24,15 @@ def __init__( n_jobs : int, optional Parameter for joblib, number of parallel processors to use, by default 1. -1 means using all processors, -2 means using all processors but one. + random_state : int | None, optional + Random state for the knn library, by default None. """ self.signature_transform: object | None = None self.n_jobs: int = n_jobs self.mahal_distance: Mahalanobis | None = None self.signatures_train: np.array | None = None self.knn: NearestNeighbors | NNDescent | None = None + self.random_state: int | None = random_state def fit( self, @@ -160,6 +164,7 @@ def fit( data=self.mahal_distance.U, metric="euclidean", n_jobs=self.n_jobs, + random_state=self.random_state, **kwargs, ) self.knn = knn @@ -263,5 +268,5 @@ def conformance( # compute the minimum of the candidate distances for each data point if debug: return np.min(candidate_distances, axis=-1), train_indices - else: - return np.min(candidate_distances, axis=-1) + + return np.min(candidate_distances, axis=-1) From a1c363f2204cbcbc9c83359b43dd604b3e419300 Mon Sep 17 00:00:00 2001 From: rchan Date: Thu, 23 Nov 2023 17:19:54 +0000 Subject: [PATCH 17/22] check reproduce old output --- paper-examples/examples.ipynb | 1 - 1 file changed, 1 deletion(-) diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index 90fd4e7..0588bcc 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -578,7 +578,6 @@ "metadata": {}, "source": [ "#### Should be \n", - "[13]:\t\n", "array([[0.00048547],\n", " [0.00069512],\n", " [0.00026231],\n", From 3d5a07b0b1058a2717a7958f141f1423eb75b42d Mon Sep 17 00:00:00 2001 From: rchan Date: Fri, 24 Nov 2023 08:18:52 +0000 Subject: [PATCH 18/22] run examples notebook fully --- paper-examples/Data.py | 11 +- paper-examples/examples.ipynb | 1874 ++++++++++++++++++++++++++------- 2 files changed, 1484 insertions(+), 401 deletions(-) diff --git a/paper-examples/Data.py b/paper-examples/Data.py index 335df89..23a197b 100644 --- a/paper-examples/Data.py +++ b/paper-examples/Data.py @@ -150,16 +150,21 @@ def sample_data(ais_by_vessel_split, random_state): self.corpus = process_data( sample_data( - ais_by_vessel_split_local.loc[inlier_mmsis_train], random_state=1 + ais_by_vessel_split_local.loc[inlier_mmsis_train], + random_state=self.random_seed, ) ) self.test_inlier = process_data( sample_data( - ais_by_vessel_split_local.loc[inlier_mmsis_test], random_state=2 + ais_by_vessel_split_local.loc[inlier_mmsis_test], + random_state=self.random_seed, ) ) self.test_outlier = process_data( - sample_data(ais_by_vessel_split_local.loc[outlier_mmsis], random_state=3) + sample_data( + ais_by_vessel_split_local.loc[outlier_mmsis], + random_state=self.random_seed, + ) ) if self.if_sample: self.sample() diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index 0588bcc..9017b8b 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "id": "34fc097e-0eb5-4c0d-9973-4dc8810ec398", "metadata": {}, "outputs": [], @@ -38,6 +38,15 @@ "# importlib.reload(SigMahaKNN)" ] }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "seed = 1" + ] + }, { "cell_type": "markdown", "id": "46aff929-3380-43d7-8949-2df9564af3dc", @@ -48,22 +57,23 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "b7a56abc", "metadata": {}, "outputs": [], "source": [ - "n_neighbours = 800" + "n_neighbours = 100" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9", "metadata": {}, "outputs": [], "source": [ - "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n", + "# data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n", + "data = Data.Data(if_sample=False, random_seed=seed)\n", "data.load_pen_digit()\n", "\n", "depths = [1, 2, 3, 4, 5]\n", @@ -72,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 6, "id": "a9b82cb0-4754-409c-891b-b19ec7e9b1a3", "metadata": {}, "outputs": [ @@ -81,60 +91,150 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3241300582885742\n", - "compute_auc_time: 0.15503692626953125\n", - "depth: 1 , Auc of digit: 0 is 0.9522222222222222\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 363\n", + "len(data.test_outlier) 3135\n", + "fit_time: 9.03144884109497\n", + "compute_auc_time: 9.808788061141968\n", + "depth: 1 , Auc of digit: 0 is 0.9236198434980514\n", "doing digit 1 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3169400691986084\n", - "compute_auc_time: 0.13514089584350586\n", - "depth: 1 , Auc of digit: 1 is 0.8288888888888888\n", + "len(data.corpus) 779\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.365417242050171\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 5.99392294883728\n", + "depth: 1 , Auc of digit: 1 is 0.8300113256239612\n", "doing digit 2 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3055970668792725\n", - "compute_auc_time: 0.1642148494720459\n", - "depth: 1 , Auc of digit: 2 is 0.9388888888888889\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.3346378803253174\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 5.971071243286133\n", + "depth: 1 , Auc of digit: 2 is 0.9320068093999173\n", "doing digit 3 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3227732181549072\n", - "compute_auc_time: 0.1321120262145996\n", - "depth: 1 , Auc of digit: 3 is 0.9644444444444444\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.2789149284362793\n", + "compute_auc_time: 5.9304540157318115\n", + "depth: 1 , Auc of digit: 3 is 0.922022303545074\n", "doing digit 4 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3062961101531982\n", - "compute_auc_time: 0.14656996726989746\n", - "depth: 1 , Auc of digit: 4 is 0.9311111111111111\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.2923431396484375\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 5.915146112442017\n", + "depth: 1 , Auc of digit: 4 is 0.9830396151391684\n", "doing digit 5 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3365981578826904\n", - "compute_auc_time: 0.28490185737609863\n", - "depth: 1 , Auc of digit: 5 is 0.9377777777777778\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 335\n", + "len(data.test_outlier) 3163\n", + "fit_time: 1.2285139560699463\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 5.855227947235107\n", + "depth: 1 , Auc of digit: 5 is 0.9057290216637331\n", "doing digit 6 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.345693826675415\n", - "compute_auc_time: 0.17109394073486328\n", - "depth: 1 , Auc of digit: 6 is 0.8455555555555556\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.2346031665802002\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 5.856933832168579\n", + "depth: 1 , Auc of digit: 6 is 0.8962102986355833\n", "doing digit 7 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.301511287689209\n", - "compute_auc_time: 0.14022302627563477\n", - "depth: 1 , Auc of digit: 7 is 0.8955555555555557\n", + "len(data.corpus) 778\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.291642189025879\n", + "compute_auc_time: 5.88370418548584\n", + "depth: 1 , Auc of digit: 7 is 0.8957924255068479\n", "doing digit 8 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3029189109802246\n", - "compute_auc_time: 0.23799824714660645\n", - "depth: 1 , Auc of digit: 8 is 0.9555555555555556\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.2254557609558105\n", + "compute_auc_time: 5.923160076141357\n", + "depth: 1 , Auc of digit: 8 is 0.9399820412035783\n", "doing digit 9 doing signature level 1\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 1, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3173649311065674\n", - "compute_auc_time: 0.15609216690063477\n", - "depth: 1 , Auc of digit: 9 is 0.818888888888889\n" + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.1814749240875244\n", + "compute_auc_time: 5.878723621368408\n", + "depth: 1 , Auc of digit: 9 is 0.8178161049365983\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB7P0lEQVR4nO3dd1hTZxsG8BuQpSwVEEQU95446l4ojtq6cVTROuus1tYtWuuuq9XW1oVa96rWWWfd1ao4ERe4UVwgyEze74/3IxoZEkg4QO7fdXHBOTnn5CEh4ck7ntdECCFAREREZIRMlQ6AiIiISClMhIiIiMhoMREiIiIio8VEiIiIiIwWEyEiIiIyWkyEiIiIyGgxESIiIiKjxUSIiIiIjBYTISIiIjJaTISMkIeHB3r16qV0GEanUaNGaNSokdJhfNTkyZNhYmKC58+fKx1KlmNiYoLJkyfr5VohISEwMTGBv7+/Xq6X3WXk9dGrVy94eHhkOIZNmzYhX758iIyM/Oix+vxb0NXRo0dhYmKCLVu2KHL/77t+/Tpy5cqFq1evKh1KujER0jN/f3+YmJhovnLlygU3Nzf06tULjx49Ujq8LC0qKgpTp05FpUqVkDt3btjb26N+/fpYvXo1sstKMNevX8fkyZMREhKidChJqFQqrFy5Eo0aNUK+fPlgaWkJDw8P9O7dG//995/S4enFunXrsGDBAqXD0JIZMSUmVYlfZmZmKFy4MNq1a4eAgACD3ndyevXqpRWPjY0NihUrho4dO2Lr1q1Qq9UGvf+3b99i8uTJOHr0aJrPUalU8PPzw9ChQ2FjY2O44HSg5N/z2bNnMWjQIHh6esLc3BwmJibJHleuXDm0bt0akyZNyuQI9SeX0gHkVN9//z2KFi2KmJgYnDlzBv7+/jhx4gSuXr0KKysrRWMLCgqCqWnWyoGfPn2Kpk2bIjAwEF26dMGQIUMQExODrVu3wtfXF3v27MHatWthZmamdKipun79OqZMmYJGjRol+YT6999/KxMUgOjoaLRv3x779u1DgwYNMG7cOOTLlw8hISHYtGkTVq1ahfv376NQoUKKxagP69atw9WrV/H1118b5PrR0dHIlUu3t82UYipSpAiio6Nhbm6ut/i6du2KVq1aQaVSITAwEL/++iv27t2LM2fOoEqVKnq7n7SwtLTEsmXLAMjH7d69e/jrr7/QsWNHNGrUCDt27ICdnZ3m+Iy8PpYuXaqVXL19+xZTpkwBgDS3Mv31118ICgpC//790x2Hvhn67zk1e/bswbJly1CpUiUUK1YMN2/eTPHYgQMHolWrVrhz5w6KFy+eiVHqiSC9WrlypQAgzp07p7V/9OjRAoDYuHGjQpEpKzo6WqhUqhRv9/b2FqampmLHjh1Jbhs1apQAIGbOnGnIEJMVGRmp0/GbN28WAMSRI0cME1A6DR48WAAQ8+fPT3JbQkKCmDNnjnjw4IEQQgg/Pz8BQISFhRksHrVaLd6+fav367Zu3VoUKVJEr9dUqVQiOjo63ecbIqYPBQcHCwBizpw5Wvt37twpAIj+/fsb9P4/5OvrK/LkyZPsbTNmzBAAROfOnQ12/2FhYQKA8PPzS/M5n332mahXr16aj9f1+umR0t/OkSNHBACxefNmg913aGio5jWa+P6Rkri4OJE3b14xceJEg8VjSEyE9CylRGjXrl0CgJg+fbrW/sDAQNGhQweRN29eYWlpKTw9PZNNBl69eiW+/vprUaRIEWFhYSHc3NxEjx49tP5ZxcTEiEmTJonixYsLCwsLUahQIfHtt9+KmJgYrWsVKVJE+Pr6CiGEOHfunAAg/P39k9znvn37BADx119/afY9fPhQ9O7dWzg7OwsLCwtRrlw5sXz5cq3zEl+k69evF+PHjxcFCxYUJiYm4tWrV8k+ZqdPnxYAxJdffpns7fHx8aJkyZIib968mhfm+2/88+bNE4ULFxZWVlaiQYMG4sqVK0mukZbHOfG5O3r0qPjqq6+Ek5OTcHBwEEIIERISIr766itRqlQpYWVlJfLlyyc6duwogoODk5z/4VdiUtSwYUPRsGHDJI/Txo0bxQ8//CDc3NyEpaWlaNKkibh161aS32HRokWiaNGiwsrKStSoUUMcO3YsyTWT8+DBA5ErVy7RrFmzVI9LlJgI3bp1S/j6+gp7e3thZ2cnevXqJaKiorSOXbFihWjcuLFwcnISFhYWomzZsuKXX35Jcs0iRYqI1q1bi3379glPT09haWmpScrSeg0hhNizZ49o0KCBsLGxEba2tqJ69epi7dq1Qgj5+H742L//TyStrw8AYvDgweKPP/4Q5cqVE7ly5RLbt2/X3Pb+P7+IiAgxfPhwzevSyclJeHl5ifPnz380psS/4ZUrV2rdf2BgoOjUqZNwdHQUVlZWolSpUmLcuHGpPWUpJkKRkZECgNZzf+bMGeHt7S3s7OyEtbW1aNCggThx4oTWebr8DSQntURICCGaN28uTExMRFBQkGZfcn/LISEhok2bNiJ37tzCyclJfP3115r3pfc/bPj6+iZ5XD/8Si1piY6OFhYWFmLy5MlJbouJiRFff/21cHR0FDY2NqJNmzbiwYMHyV5Tl/fHDRs2iLFjx4oCBQqI3LlzizZt2oj79+9rPR4p/e3o+t6RUR9LhIQQol27dqJSpUp6v+/MwK6xTJI4ZiRv3ryafdeuXUPdunXh5uaGMWPGIE+ePNi0aRPatm2LrVu3ol27dgCAyMhI1K9fH4GBgfjyyy9RrVo1PH/+HDt37sTDhw/h6OgItVqNzz77DCdOnED//v1RtmxZXLlyBfPnz8fNmzfx559/JhtX9erVUaxYMWzatAm+vr5at23cuBF58+aFt7c3ANl99cknn8DExARDhgyBk5MT9u7diz59+iAiIiJJ8+3UqVNhYWGBUaNGITY2FhYWFsnG8NdffwEAevbsmeztuXLlQrdu3TBlyhScPHkSXl5emttWr16NN2/eYPDgwYiJicHChQvRpEkTXLlyBQUKFNDpcU40aNAgODk5YdKkSYiKigIAnDt3DqdOnUKXLl1QqFAhhISE4Ndff0WjRo1w/fp15M6dGw0aNMCwYcPw008/Ydy4cShbtiwAaL6nZObMmTA1NcWoUaMQHh6O2bNno3v37vj33381x/z6668YMmQI6tevjxEjRiAkJARt27ZF3rx5P9qdtXfvXiQkJKBHjx6pHvehzp07o2jRopgxYwYuXLiAZcuWwdnZGbNmzdKKq3z58vjss8+QK1cu/PXXXxg0aBDUajUGDx6sdb2goCB07doVAwYMQL9+/VC6dGmdruHv748vv/wS5cuXx9ixY+Hg4ICLFy9i37596NatG8aPH4/w8HA8fPgQ8+fPBwDNWA9dXx+HDx/Gpk2bMGTIEDg6OqY4EHfgwIHYsmULhgwZgnLlyuHFixc4ceIEAgMDUa1atVRjSs7ly5dRv359mJubo3///vDw8MCdO3fw119/Ydq0aWl74t5z584dAED+/Pk1v1fLli3h6ekJPz8/mJqaYuXKlWjSpAmOHz+OmjVrap2flr+B9OjRowf+/vtvHDhwAKVKlUr2mKioKDRp0gRPnjzB8OHD4eLignXr1uHIkSOpXtvJyQm//vorvvrqK7Rr1w7t27cHAFSqVCnFc86fP4+4uDhUq1YtyW19+/bFH3/8gW7duqFOnTo4fPgwWrduneQ4Xd8fp02bBhMTE4wePRrPnj3DggUL4OXlhYCAAFhbW6fpbyct7x1v377F27dvU33MAMDMzEzr/5OuPD09sWPHDkRERGh1eWYLSmdiOU1iq8DBgwdFWFiYePDggdiyZYtwcnISlpaWmu4HIYRo2rSpqFixotYnUrVaLerUqSNKliyp2Tdp0iQBQGzbti3J/anVaiGEEGvWrBGmpqbi+PHjWrcvWbJEABAnT57U7Hu/RUgIIcaOHSvMzc3Fy5cvNftiY2OFg4ODVitNnz59hKurq3j+/LnWfXTp0kXY29trWmsSP60UK1YsTd0fbdu2FQBSbDESQoht27YJAOKnn34SQrz71GdtbS0ePnyoOe7ff/8VAMSIESM0+9L6OCc+d/Xq1RMJCQla95/c75HYkrV69WrNvtS6xlJqESpbtqyIjY3V7F+4cKEAoGnZio2NFfnz5xc1atQQ8fHxmuP8/f0FgI+2CI0YMUIAEBcvXkz1uESJrQEfttC1a9dO5M+fX2tfco+Lt7e3KFasmNa+IkWKCABi3759SY5PyzVev34tbG1tRa1atZJ0UyW+BoRIuStBl9cHAGFqaiquXbuW5Dr4oBXA3t5eDB48OMlx70sppuRahBo0aCBsbW3FvXv3Uvwdk5N4rSlTpoiwsDARGhoqjh49KqpWrSoAiK1btwq1Wi1KliwpvL29ta739u1bUbRoUa1WI13+BpLzsRahixcvJnmdfvj6mDt3rgAg/vzzT82+6OhoUaZMmVRbhITQvWts2bJlWq+5RAEBAQKAGDRokNb+bt26Jbm+ru+Pbm5uIiIiQnPcpk2bBACxcOFCzb6PdY197L1DiHfP5ce+Uuu+TUuL0Lp16wQA8e+//6Z6XFaUtUbM5iBeXl5wcnKCu7s7OnbsiDx58mDnzp2aT+8vX77E4cOH0blzZ7x58wbPnz/H8+fP8eLFC3h7e+PWrVuaWWZbt25F5cqVk7RcANCM5N+8eTPKli2LMmXKaK71/PlzNGnSBABS/RTl4+OD+Ph4bNu2TbPv77//xuvXr+Hj4wMAEEJg69ataNOmDYQQWvfh7e2N8PBwXLhwQeu6vr6+sLa2/uhj9ebNGwCAra1tisck3hYREaG1v23btnBzc9Ns16xZE7Vq1cKePXsA6PY4J+rXr1+SQdnv/x7x8fF48eIFSpQoAQcHhyS/t6569+6t1VpWv359AMDdu3cBAP/99x9evHiBfv36aQ3U7d69e5o+wSU+Zqk9vskZOHCg1nb9+vXx4sULrefg/cclPDwcz58/R8OGDXH37l2Eh4drnV+0aFFN6+L70nKNAwcO4M2bNxgzZkySyQYpzWZ5n66vj4YNG6JcuXIfva6DgwP+/fdfPH78+KPHfkxYWBiOHTuGL7/8EoULF9a6LS2/IwD4+fnByckJLi4uaNSoEe7cuYNZs2ahffv2CAgIwK1bt9CtWze8ePFC8xhERUWhadOmOHbsWJLZXGn5G0iPxJaNxNd+cvbt2wc3Nzd89tlnmn1WVlbo169fhu47OS9evACAJK+nxPeRYcOGae3/sHUnPe+PPXv21HpNduzYEa6urpr7TIuPvXck3s+BAwc++rV27do0329yEh+77Fh2g11jBrJ48WKUKlUK4eHhWLFiBY4dOwZLS0vN7bdv34YQAhMnTsTEiROTvcazZ8/g5uaGO3fuoEOHDqne361btxAYGAgnJ6cUr5WSypUro0yZMti4cSP69OkDQHaLOTo6av5RhIWF4fXr1/j999/x+++/p+k+ihYtmmrMiRLfDN68eQMHB4dkj0kpWSpZsmSSY0uVKoVNmzYB0O1xTi3u6OhozJgxAytXrsSjR4+0pvN/+A9fVx/+00t8Q3n16hUA4N69ewCAEiVKaB2XK1euNNVOSWymTu2fjq5xJV7z5MmT8PPzw+nTp5M0v4eHh8Pe3l6zndLfQ1qukdjFU6FCBZ1+h0S6vj7S+rc7e/Zs+Pr6wt3dHZ6enmjVqhV69uyJYsWK6Rxj4j+v9P6OANC/f3906tQJpqamcHBwQPny5TXvO7du3QKAJF3g7wsPD9dKBtLyN5AeiXV6UkvO7927h+LFiydJAj98HejT+6/rxBhMTU2TzIRK7NZNlJ73xw/fu0xMTFCiRAmdSm987L0DAIoVK5auv0ddJT52aU3asxImQgZSs2ZNVK9eHYBstahXrx66deuGoKAg2NjYaD55jRo1KtlPyYBuL3i1Wo2KFSti3rx5yd7u7u6e6vk+Pj6YNm0anj9/DltbW+zcuRNdu3bVtEAkxvvFF1+k+Eb6YR98WlqDADmG5s8//8Tly5fRoEGDZI+5fPkyAKTpU/r70vM4Jxf30KFDsXLlSnz99deoXbs27O3tYWJigi5dumS4JkpKJQE+fFNOrzJlygAArly5otMU6o/FdefOHTRt2hRlypTBvHnz4O7uDgsLC+zZswfz589P8rgk97jqeo300vX1kda/3c6dO6N+/frYvn07/v77b8yZMwezZs3Ctm3b0LJlywzHrauSJUtqjaF7X+JjOWfOnBT/Dj4cg2Kov83E4nuGTGp0kTiG6tWrV+kqIZGe90d9SMvzExkZmaYCkWZmZil+UEiLxOTL0dEx3ddQChOhTGBmZoYZM2agcePGWLRoEcaMGaPJ0M3NzVN840pUvHjxj1btLF68OC5duoSmTZumKyP38fHBlClTsHXrVhQoUAARERHo0qWL5nYnJyfY2tpCpVJ9NF5dffrpp5gxYwZWr16dbCKkUqmwbt065M2bF3Xr1tW6LfFT7vtu3rypaSnR5XFOzZYtW+Dr64u5c+dq9sXExOD169daxxni01CRIkUAyNatxo0ba/YnJCQgJCTko2+wLVu2hJmZGf744w+dB0yn5q+//kJsbCx27typ9cn0Y4NZ03ONxE/kV69eTfWfZ0qPf0ZfH6lxdXXFoEGDMGjQIDx79gzVqlXDtGnTNIlQWu8v8W/VUBV6Ex9DOzs7vb+GdbVmzRqYmJigWbNmKR5TpEgRXL9+HUIIrcfw9u3bH72+rs9x4oeF4OBgVKxYUSsGtVqNO3fuaLUCBQUFaZ2fnvfHD9+7hBC4ffu21utZH3+rP/74o6amUmqKFCmSoUKwwcHBMDU1TXHwe1bGMUKZpFGjRqhZsyYWLFiAmJgYODs7o1GjRvjtt9/w5MmTJMeHhYVpfu7QoQMuXbqE7du3JzkuMfPv3LkzHj16hKVLlyY5Jjo6WjP7KSVly5ZFxYoVsXHjRmzcuBGurq5aSYmZmRk6dOiArVu3JvtG/X68uqpTpw68vLywcuVK7Nq1K8nt48ePx82bN/Hdd98l+aT+559/ao3xOXv2LP7991/NPyFdHufUmJmZJfkU/PPPP0OlUmnty5MnDwAkSZAyonr16sifPz+WLl2KhIQEzf61a9dqNYGnxN3dHf369cPff/+Nn3/+OcntarUac+fOxcOHD3WKK/HT6IfdhCtXrtT7NZo3bw5bW1vMmDEDMTExWre9f26ePHmS7arM6OsjOSqVKsl9OTs7o2DBgoiNjf1oTB9ycnJCgwYNsGLFCty/f1/rNn20Dnp6eqJ48eL48ccfk20hyMhrWBczZ87E33//DR8fn2S7thN5e3vj0aNH2Llzp2ZfTExMss/hh3Lnzg0g7a9DT09PWFhYJKmwnvg+8tNPP2nt/7Dac3reHxNnvCbasmULnjx5otWSmNa/ndRk1hih8+fPo3z58lrd4dkFW4Qy0bfffotOnTrB398fAwcOxOLFi1GvXj1UrFgR/fr1Q7FixfD06VOcPn0aDx8+xKVLlzTnbdmyBZ06dcKXX34JT09PvHz5Ejt37sSSJUtQuXJl9OjRA5s2bcLAgQNx5MgR1K1bFyqVCjdu3MCmTZuwf/9+TVddSnx8fDBp0iRYWVmhT58+SapPz5w5E0eOHEGtWrXQr18/lCtXDi9fvsSFCxdw8OBBvHz5Mt2PzerVq9G0aVN8/vnn6NatG+rXr4/Y2Fhs27YNR48ehY+PD7799tsk55UoUQL16tXDV199hdjYWCxYsAD58+fHd999pzkmrY9zaj799FOsWbMG9vb2KFeuHE6fPo2DBw9qmtQTValSBWZmZpg1axbCw8NhaWmJJk2awNnZOd2PjYWFBSZPnoyhQ4eiSZMm6Ny5M0JCQuDv75/sGIrkzJ07F3fu3MGwYcOwbds2fPrpp8ibNy/u37+PzZs348aNG1otgGnRvHlzWFhYoE2bNhgwYAAiIyOxdOlSODs7J5t0ZuQadnZ2mD9/Pvr27YsaNWqgW7duyJs3Ly5duoS3b99i1apVAOQ/tI0bN2LkyJGoUaMGbGxs0KZNG728Pj705s0bFCpUCB07dkTlypVhY2ODgwcP4ty5c1othynFlJyffvoJ9erVQ7Vq1dC/f38ULVoUISEh2L17d4aXyjA1NcWyZcvQsmVLlC9fHr1794abmxsePXqEI0eOwM7OTlPKQh8SEhLwxx9/AJAJzL1797Bz505cvnwZjRs3TnEsTaIBAwZg0aJF6Nq1K4YPHw5XV1esXbtWM1g+tb97a2trlCtXDhs3bkSpUqWQL18+VKhQIcXxV1ZWVmjevDkOHjyI77//XrO/SpUq6Nq1K3755ReEh4ejTp06OHToULKtUrq+P+bLlw/16tVD79698fTpUyxYsAAlSpTQGgyuy99OStI7RujevXtYs2YNAGgSxB9++AGAbD16v3U5Pj4e//zzDwYNGqTz/WQJmTpHzQikVFBRCFmhtnjx4qJ48eKa6dl37twRPXv2FC4uLsLc3Fy4ubmJTz/9VGzZskXr3BcvXoghQ4YINzc3TTE4X19framacXFxYtasWaJ8+fLC0tJS5M2bV3h6eoopU6aI8PBwzXEfTp9PdOvWLc1Uyg8LrCV6+vSpGDx4sHB3dxfm5ubCxcVFNG3aVPz++++aY9Jb9fTNmzdi8uTJonz58sLa2lrY2tqKunXrCn9//yTTh98vIDd37lzh7u4uLC0tRf369cWlS5eSXDstj3Nqz92rV69E7969NUXVvL29xY0bN5J9LJcuXSqKFSsmzMzM0lRQ8cPHKaVCez/99JMoUqSIsLS0FDVr1hQnT54Unp6eokWLFml4dGUF6WXLlon69esLe3t7YW5uLooUKSJ69+6tNbU+pcrSiY/P+0Ukd+7cKSpVqiSsrKyEh4eHmDVrllixYkWS4xILKiYnrddIPLZOnTrC2tpa2NnZiZo1a4r169drbo+MjBTdunUTDg4OSaYEp/X1gf8XVEwO3psyHRsbK7799ltRuXJlYWtrK/LkySMqV66cpBhkSjGl9DxfvXpVtGvXTjg4OAgrKytRunTpj1bsTamgYnIuXrwo2rdvL/Lnzy8sLS1FkSJFROfOncWhQ4c0x+jyN5AcX19franZuXPnFh4eHqJDhw5iy5YtyVaZT66g4t27d0Xr1q2FtbW1cHJyEt98843YunWrACDOnDmjdX8fTv8+deqU8PT0FBYWFmmaSr9t2zZhYmKiVdRQCDllf9iwYSJ//vwiT548qRZU1OX9cf369WLs2LHC2dlZWFtbi9atWycpm5DS346u7x3pkXgfyX19+Dzt3btX4P8FOLMjEyGyyWqWRO8JCQlB0aJFMWfOHIwaNUrpcBShVqvh5OSE9u3bp6m7gCgnWLBgAUaMGIGHDx9qzfbMKJVKhXLlyqFz586YOnWq3q77oaNHj6Jx48bYvHkzOnbsaLD7yUxt27aFiYlJssM3sgOOESLKBmJiYpKME1m9ejVevnyZ5kUlibKb6Ohore2YmBj89ttvKFmypF6TIECO8/n++++xePHiNM2yIikwMBC7du0yaPJoaBwjRJQNnDlzBiNGjECnTp2QP39+XLhwAcuXL0eFChXQqVMnpcMjMoj27dujcOHCqFKlCsLDw/HHH3/gxo0bGR7YmxIfHx9NEVlKm7Jly2pN4siOmAgRZQMeHh5wd3fHTz/9hJcvXyJfvnzo2bMnZs6cmeIabkTZnbe3N5YtW4a1a9dquq42bNjAZIX0StExQseOHcOcOXNw/vx5PHnyBNu3b0fbtm1TPefo0aMYOXIkrl27Bnd3d0yYMAG9evXKlHiJiIgoZ1F0jFBUVBQqV66MxYsXp+n44OBgtG7dGo0bN0ZAQAC+/vpr9O3bF/v37zdwpERERJQTZZlZY4kjzlNrERo9ejR2796tVbCqS5cueP36Nfbt25cJURIREVFOkq3GCJ0+fTpJ+XJvb+8kKwG/LzY2VqvKq1qtxsuXL5E/f/5suTgcERGRMRJC4M2bNyhYsGCSgr8Zka0SodDQUBQoUEBrX+K6WNHR0ckulDhjxow0rbNCREREWd+DBw/StThuSrJVIpQeY8eOxciRIzXb4eHhKFy4MB48eAA7OzsFIyMiIsoaYmOBqCggMhJ4+BC4fBkICgIePQJMTYGTJ4GIiIzdh5kZoFIBdnaAvT1QtChgaQncvw/UqQO8fAl4egJxcfI2lQqocHcHous1g4V9bsTERKBZM3fY2trq55f+v2yVCLm4uODp06da+54+fQo7O7tkW4MAwNLSEpaWlkn229nZMREiIiKjIIRMNHbuBK5dA44dk9sqFZCBRecBAPnyycSmWTMgJgZwcJD7KlQAypYFHB3lPp0qfURFAYMHA6tWAX37AkuXahIxfQ9ryVaJUO3atbFnzx6tfQcOHEDt2rUVioiIiEhZsbGyxeb8eeDNG+DQIcDcHLh3TyY5uXIBaa15+P6x5crJr1KlZAuNjY38uXhxwNZWthQZxNWrQOfOQGCgvJPChWUmZyCKJkKRkZFaq/gGBwcjICAA+fLlQ+HChTF27Fg8evQIq1evBgAMHDgQixYtwnfffYcvv/wShw8fxqZNm7B7926lfgUiIqJMoVIBt27JpOfGDWDdOuDx44+fl1wS1KmTbLEpUQJwc5OJTsGCMhFSjBDAihXA0KFAdDTg6ip/SQMvI6RoIvTff/+hcePGmu3EsTy+vr7w9/fHkydPcP/+fc3tRYsWxe7duzFixAgsXLgQhQoVwrJly+Dt7Z3psRMREelTXBwQFgZcuACsXw9YWQGnTsmxOlZWstspNVZWgLs70LCh7FmqXRtwcQE8POR+Ozsgd+5M+VV0FxkJDBwIJC6f0rw5sGYN4Oxs8LvOMnWEMktERATs7e0RHh7OMUJERGRQKpXsrnryRA5Cvn1btuKcPSuTnly5gHPndL9ukSJA9eoyT2jfXjaaKNqak1EPHwJVqgCvXwM//AB8912SvjdD/f/Ozg8bERFRlvD2rUxoFi4E9uyRrTBBQem/nr09kDcv0L277LIqWVIOlSlWTI7/yXEKFZLNYNbWQL16mXrXTISIiIhSER0NHD0KXLwIXL8uW3muXQPu3pVdUMlJLgkyN5eNHK6uQK1asgXnk0/k4ON8+WTy5Ogop5nneBERQP/+QJcuQOKKEs2aKRIKEyEiIjJaL17IXpl//5XdVgEBsrbNf//J2VivXul+zbJlgdGj5YwrBwfZkpNMFRfjdf484OMD3LkDHDkixwMpOHiJiRAREeVIQgDPngGXLslZVufPy0Tn8WM5FCWtU8rf16iRHHRcr57sxXF3fzfzyt4e4MpNqRACWLQIGDVKjgwvUgTYsEHxEdxMhIiIKNuLjZU1c3buBMaMkS0w0dFpP9/ZGQgPB1q3lv+XGzWSiU6RIvLLzY1JToa8fg306QNs2ya327aVU+Xz5lUyKgBMhIiIKBsRQrbsHD8uu7P++ksOVP7Qh0mQpaVcxiF/frmMQ6lSQOnScoyuvX3mxG60Xr8GqlaVmaq5OfDjj7JWUBbJLJkIERFRlhMdLQcmBwXJr3Pn5PpXjx6lfp6jI/D8uRyDO2WK7LpKYQUmyiwODkDLlsD+/cDGjXLefxbCRIiIiBQRGyuXgwgLk608d+7Ir7ROOy9YEPD2li09jRrJqeUGW/aBdPPihRyEVaCA3J43Tz7hWbD5jYkQERHpVUKCHJB84YJs2blwQS64ee6c7B25dUu36xUrJqeWly4tqyY3bpwpBYcpvU6dkk1yJUoABw7IegBWVvIrC2IiRERE6RIXJ+vprF8PHD4M3L//bkVzXXXqJFuGypaVBYarVAFq1Mgyw0goLdRqYM4cYPx4+UdgaSlLahcqpHRkqWIiREREScTEyMTk2DG5RMTp00B8PLBrl9xOC3NzeU7z5nIpqYYNZQtRyZJymEiRIoCTE7uzcoSwMMDXF9i7V2537Qr89ptcpj6LYyJERGTkTp0Crl6VNXa2bpW1d3Rlawv06wfUrStbdUqXZoJjNI4fl11hjx/L7q+ffgL69s02zXlMhIiIcjAhgHv35Dida9fkcI2//gICA2WLzfPnabvOF1/I5SRq1pQJToMGctxOgQLZ5v8dGYJKBQwaJJOgMmWATZuAihWVjkonTISIiHKQiAjZfdW9u+7nfvqpTI4++QTo1o1FBCkNzMzkILGFC4H58wEbG6Uj0hkTISKibEitljV1bt0Czp6VLT6bN6d+jqWl7LJq1Ehuly8vx+q4ub2b5Uz0UYcPyz+8AQPkdoUKwNKlysaUAUyEiIiyoMRE59o1uRjotWuyi+vgQTkAOS3KlgWWLJEtPBYWho2XjIBKBXz/PTB1qmwJ8vTMcsUR04OJEBGRgmJiZKJz7hxw9CiwerXu13B1lUtHVK4MdO4MtGnDLi3Ss8ePZX/r0aNyu1cvoFw5JSPSGyZCREQG9uoV8OABsGePLCh4/bqcZbVnT9rOt7OTpViKFgUqVZJjUatVk4UGzc0NGjqRXBqjRw85Rd7GRk6L79ZN6aj0hokQEVEGCSH/R9y+Laeh79snW2QSF9pOq3z5gPr1ZctOz55A4cJMdEhhkyfLRdsA+Ye5aZNcsTYHYSJERPQRcXHA06eydyA0VCY9J08CDx/KMTtpZWcnp6D37CmLCdaoIYsLlijBrizKohwc5PeBA+WssCy6TEZGMBEiIqMXFSUTnDt3gH/+AXbvlsnO48e6X8vMTHZZ5csHfPaZ7M7y8pIVlImyhagoIE8e+fPw4UDVqrIseA7FRIiIjMbr18CJE7J68v79MvkRQrdr2NoCuXMDxYvLxUVbtwZq1QLq1Xv3v4MoW4qPB8aNA3buBP77T/6xm5jk6CQIYCJERDlQVJQcr7NvH3DlCrB2rW7nV6kik5tWrWSLToECskWH3VeUY927J5fJOHNGbv/5pxwgbQSYCBFRthMXBwQHy9lXgYHyw+v167LGm1qdtmt4espKyi1byrGfDg5MdMhI7dghp8O/fg3Y2wMrVgDt2ysdVaZhIkREWZoQwIsXwL//ygkrutbZKVxYro9Vq5Z8r3d0NEiYRNlPXBzw3XdyeQxAvlA2bJDNoEaEiRARZRlnzwLr1gGXLsnByteupX58wYKyRk/FioC7u5x6Xq2aXEaCXVlEHzF69Lsk6JtvgOnTjbIEORMhIspU0dEy4dm8GXjzRk5Dv3dPDjxOi4YNAV9fOQXdzMywsRLlaGPGAAcOADNmyHLkRoqJEBHpRUKCrKsTFibH71y6JKej58oFnD8PBAWlfYZW/fpyFlaFCvKrZEnA2tqw8RPleDExwPbtQNeucrtAAeDyZcDUVNm4FMZEiIh0olIBT57IROeXX4DISODYsfRdq2FDoEEDufp5yZJy+QiO4SEygFu35EJ0AQFyOzEZMvIkCGAiREQfiI+Xk0cePgROnZJJzqtXsjsrPDxt13Bzk98LFgTKlJFrM1pZye8lSwIeHhy/Q5Rp1q8H+veXn1ocHWW1T9JgIkRkZBJnYe3fL1vF//1XdmE9fKj7tfLkAZydgREj5HT0mjVlVxgRZQHR0bIy9NKlcrtBAzkbIfGTCgFgIkSUo71+LZeL8PeXBQZDQnQ739QUsLQEWrQAPvlETkWvUEHOyuJioERZ2I0bsivsyhXZ/Dp+PODnx08qyeAjQpQDxMXJLqwdO4Bz52Q31D//pO3cTp3kAqDly8skp0gR2XLOGVlE2didOzIJcnaWpdW9vJSOKMtiIkSUzcTGAtu2AYcPA8uWyZaZ+PjUzzE1lQORBw4EmjYFXF25LhZRjta6tewSa91avuApRUyEiLKw2Fhg1y45nufgQTkt/UPvJ0GWlvID4OefA02ayBaeEiU4MJkox7t2TX7S+eMP2awLAH37KhtTNsFEiEhhQgAXL8qurGvXgOPHgZs3ZfLysbo7bdvKQco9ewKFCnEmLJHREQJYuRIYMkQOjv76a1kriNKMiRBRJouJAX78UY5lPHky5QHMHyZBTZsCdesCHTrIJSXYykNk5CIjZSvQ2rVyu3lz4LfflI0pG2IiRGQAiUtHhITIbq0XL2QdszdvUj+vfHmgWDHZytO4sezasrfnwGUi+sClS3JW2M2b8g1i6lS5dhibhXXGRIhIT4SQ43k++yzt54wZI8fwtGrF8YxElEbHjwPNmslBhG5ucsX4evWUjirbYiJElA4JCXJcz+rVwIoVwNu3KR/r7Q08fiwXCnV3B6pW5QBmIsqAGjVkyXY3N2DVKq5Lk0FMhIjSIDxcLtL8xRfyQ9jHTJsGjBtn+LiIyEgEBgKlSsluMCsrOY00Xz52hekBH0Gi9yQkyNlbw4YBbdrI7ioTE8DBQRYeTC4JsrcHFi8G7t6VtwvBJIiI9EQIYNEioEoV+QkrkaMjkyA9YYsQGa2EBLnW1oEDwIULcimKqKjUz7G1lQuGrlghu7g4iJmIDOb1a6BPH1lBFZADpNVqJkB6xkSIjEZcnCy0umqVXIYiLQYMACpXlmttFS1q2PiIiDTOngV8fOTUU3NzYM4c2VTNwYV6x0SIcpygIGD9evnhycJCbl+6lPo5BQvKZKdiReDLLwE7u8yJlYhIixDAggVyKnx8vPwEtnGjHCBNBsFEiLK9ly+B5cuBX39NfgmK5IwZI0twVK7MVmYiykKCg+Ugw/h4WT112TI5SJEMhokQZTuRkcCff8r3igcPUj6uaFGgZk2gQQPZwlO2rBzXw8SHiLKsYsXk7IvoaGDQIHaFZQImQpQthIYCI0bIumEpqVhRVmb+5Rcgb97Mi42IKN3UamDuXKB+feCTT+S+L79UNiYjw0SIsiQhgIcP5RT21Mb3dOoETJjAtbeIKBsKC5OVVvfulSvGX70K2NgoHZXRYSJEWcKbN3KMz+rVcpJEStPYnZ2B2bNlYUNOXSeibOvYMaBrV1l23soKGD8eyJNH6aiMEhMhUoQQwLVrMvn55ZePH3/yJFC7Nlt9iCibU6uBGTOASZPkz6VLA5s2AZUqKR2Z0WIiRJlCCODRI+CHH+RM0Nevkz+ueHHg889l+YzKlQFLy0wNk4jIcCIjgfbtZRVXAOjRQ34SZHeYopgIkcFERgLffy/r+OzcmfJxVlayeOrChezuIqIcLE8ewNpafv3yC9Crl9IREZgIkR5FRwMnTgATJwL//pvycRYWwOTJwNCh/CBERDmcSiXL2ltby779lSvlNNhy5ZSOjP6PiRBl2JMnsjJzakaPBlq3ljNEiYiMwpMnQLdugJsbsGaNTITy5ZNflGUwEaJ0mzVLVmhOjpub7Opq25bdXURkhP7+W05vDQuTXWJ378pBkJTlMBGiNHvzBvD3B06dSr6wYceOcvIDZ3YRkdFKSAD8/OTMMCHkbLCNG5kEZWFMhChVQshFj0ePTvmY5cvl5Adz88yLi4goy3n4UHaFHT8utwcMAObPl+ODKMtiIkRJvH4tx/NNmiRnfn3IwkJWfK5RA/juO7YAERFBrQZatpTVoW1tgaVLZR0QyvKYCBEA2X09ejSwZUvKx6xcKavBM/EhIvqAqSmwYIEcOLl+PVCihNIRURoxETJiGzYA8+YB584lf3uJEkCrVnKV9wIFMjc2IqIs7/594MYNoHlzud20qawdYmqqbFykEyZCRkQIWdD066+BwMDkjylUSBZB7NWLLT9ERCnauVO+USYkABcuvGsBYhKU7TARyuEiI+Vg5/nz5ayv5AwYAPTvD1SrlrmxERFlO3FxchzBggVyu0YNIBf/lWZniqeuixcvhoeHB6ysrFCrVi2cPXs21eMXLFiA0qVLw9raGu7u7hgxYgRiYmIyKdrsIzpatujY2soWng+TIF9f4M4d2Uq0ZAmTICKijwoOBurVe5cEjRghy+l7eCgZFWWQoonQxo0bMXLkSPj5+eHChQuoXLkyvL298ezZs2SPX7duHcaMGQM/Pz8EBgZi+fLl2LhxI8aNG5fJkWdtBw8CuXNr77OykqUtwsJk8uPvDxQrpkh4RETZz9atQNWqclBl3rzAjh1ykKWFhdKRUQYp2p43b9489OvXD7179wYALFmyBLt378aKFSswJpmSxadOnULdunXRrVs3AICHhwe6du2Kf1Nb2MqIPHwoX6fPn2vvT0hgdWciogw5dQoIDwdq15YzTQoXVjoi0hPFWoTi4uJw/vx5eHl5vQvG1BReXl44ffp0sufUqVMH58+f13Sf3b17F3v27EGrVq1SvJ/Y2FhERERofeU0z57JbjB3d+0kaOJE2frDJIiIKB2EePfzjBly3aB//mESlMMo1iL0/PlzqFQqFPhgXnaBAgVw48aNZM/p1q0bnj9/jnr16kEIgYSEBAwcODDVrrEZM2ZgypQpeo09q1Cpkh+jlyePLGxatWrmx0RElCNs2ACsWiVnh5mbyy6wYcOUjooMQPHB0ro4evQopk+fjl9++QUXLlzAtm3bsHv3bkydOjXFc8aOHYvw8HDN14MHDzIxYsNQq2XZig+TIGdn2XIbGckkiIgoXaKj5VTarl2BfftkhWjK0RRrEXJ0dISZmRmePn2qtf/p06dwcXFJ9pyJEyeiR48e6Nu3LwCgYsWKiIqKQv/+/TF+/HiYJlO/wdLSEpaWlvr/BRTw8qUc5PzNN9r7zcyAt285Zo+IKEOCgoDOnYHLl+V4g3HjZG0RytEUaxGysLCAp6cnDh06pNmnVqtx6NAh1K5dO9lz3r59myTZMfv/ABjxfl9uDqNWA3Z2QP78SZOg69flYGgmQUREGfDHH4Cnp0yCnJ2B/fuBH35gjSAjoGjX2MiRI7F06VKsWrUKgYGB+OqrrxAVFaWZRdazZ0+MHTtWc3ybNm3w66+/YsOGDQgODsaBAwcwceJEtGnTRpMQ5SRCyBpAZmZJ6wCNGSNvL1tWmdiIiHKMadOAHj2AqCigcWMgIABo1kzpqCiTKJrq+vj4ICwsDJMmTUJoaCiqVKmCffv2aQZQ379/X6sFaMKECTAxMcGECRPw6NEjODk5oU2bNpg2bZpSv4LB/PQTMHy49r7SpeWyNkREpEcdOwKzZwMjRwITJnCqrZExETm5TykZERERsLe3R3h4OOzs7JQOR8ujR3K5muQKZW/ZAnTokPkxERHlOELILrDKld/te/FCjj+gLMtQ/7+z1ayxnKxRI7ng6YdJ0HffyTFCTIKIiPQgMhLo2VOuK/TPP+/2MwkyWhwFprATJ4D69bX35ckjB0GzZhcRkR5dvixnhQUFyVXir14FGjZUOipSGBMhhVy7Jhctjo7W3v/oEVCwoDIxERHlSELIekDDhgGxsYCbG7B+fdJPoWSU2DWWyYSQVdorVNBOgkaNkrcxCSIi0qOICKBbN1kkMTYWaNlSzgpjEkT/xxahTBQfn7TeT8eOwPLlsk4QERHp2Y4dcrkMMzO5Xtg338huMaL/YyKUSYRImgRt2gR06qRMPERERuGLL4CLF+WbbQrFesm4MS3OBFFRST+AxMUxCSIi0rvXr4EhQ4BXr+S2iQkwbx6TIEoRW4QM7PFjOS7vfQkJrNdFRKR3584BPj5AcDDw/LnsEiP6CLYIGVCnTkmTICGYBBER6ZUQwIIFQN26MgkqWjTpwoxEKWAiZCBz58pq0IlGjJCvVSIi0qOXL4G2beWbbHy8rD574YKsT0KUBuwaM4CVK+V0+ESXLwMVKyoXDxFRjnTlCvDpp8D9+3I2yrx5wKBBclwQURoxEdKzkiWB27ffbY8bxySIiMggChaUTe3Fi8tpuNWqKR0RZUNMhPTowyRo9mzg22+Vi4eIKMd58wawsZGtPvnzA3v3Au7uLMZG6cYxQnoQGytfk+8nQa9eMQkiItKr48eBsmUBf/93+8qXZxJEGcJEKINCQwErK+19YWGAg4Mi4RAR5TxqNTB9OtC4sVyQ8eefAZVK6agoh2AilAFCAK6u77bt7GShREdH5WIiIspRnj0DWrQAxo+Xyc8XXwDHjrEOCekNE6F0CgjQrhadNy8QHg6YmysWEhFRznLkCFC5MnDgAGBtLRdmXL1ajhEi0hMOlk6H27eBqlXfbbu7y9mbRESkJ/fuAc2by1L85crJWWHlyysdFeVAbBHSkRBydlii6dOZBBER6V2RIsDYsUDv3sDZs0yCyGDYIqSj92sCNWsmX6dERKQHBw8CHh5AiRJye8oUFkckg2OLkA4aNwauXXu3/fffysVCRJRjJCQAEybIrjAfH1mTBGASRJmCLUJpFBAAHD36bvv9hIiIiNLp0SOga1dZIwiQa4RxYUbKREyE0uj9wdEvX8pZYkRElAF79wI9ewLPnwO2tsDvvwNduigdFRkZdo2lQf/+736uXZtJEBFRhsTHA6NHA61aySSoalXg/HkmQaQIJkIfERUFLF36bvvUKeViISLKEYSQNYIAYPBg+cb6/nRcokzErrGPeL9u1+7dysVBRJTtCSEHQFtYABs3AhcuAB06KB0VGTkmQqm4efPdz05OshWXiIh0FBcHjBkjF2acPl3uK1pUfhEpjIlQKvbufffz06fKxUFElG0FB8uxP2fPytagnj2BMmWUjopIg2OEUvH11+9+ZjkLIiIdbdsmB0KfPQs4OADbtzMJoiyHiVAK3m8BqlRJuTiIiLKd2Fhg6FA5/ic8HPjkE1mM7fPPlY6MKAl2jaWga9d3P7OCNBFRGgkhK0QfOya3v/sO+OEHwNxc2biIUsBEKAWJMzutrYECBZSNhYgo2zAxAfr2leX3V6/mLBPK8tg1lowVK9797O+vWBhERNlDdDQQGPhuu0cPOe2WSRBlA0yEktGnz7ufO3dWLg4ioiwvKEiOAfLyAsLC3u3Pl0+5mIh0wEToAyrVu59HjFAuDiKiLO+PPwBPT+DyZblsRnCw0hER6YyJ0AeqVXv3c9++ysVBRJRlvX0rm8579JDrEDVqJGeF1aypdGREOmMi9B4h5AebROXKKRcLEVGWdP26THhWrJADo/38gIMHgYIFlY6MKF04a+w9u3a9+3ntWuXiICLKsmbNkjPCXFzkG2WTJkpHRJQhTITec/Dgu5+7dVMuDiKiLOunn4BcueSaYawtQjkAu8b+T6WSr28AaNhQ2ViIiLKMK1eAb7+VYwcAwN4eWL6cSRDlGGwR+r+ZM9/9PGmScnEQEWUJQgDLlgHDhgExMUDp0pxBQjkSEyHI1/iECe+22eVNREYtIgIYMADYsEFut2zJdcIox2LXGGQZjETr1ysXBxGR4i5elG+KGzYAZmZycPSuXYCTk9KRERlEhhKhmJgYfcWhqBIl3v3cpYtycRARKWrNGlkl+vZtwN1dLpz63XeAKT8zU86l81+3Wq3G1KlT4ebmBhsbG9y9excAMHHiRCxfvlzvAWaGxNXl58xRNg4iIkUVLSpnjrRpIwsk1qmjdEREBqdzIvTDDz/A398fs2fPhoWFhWZ/hQoVsGzZMr0GlxmCg+UYIUAWSyUiMirh4e9+rlcPOH0a2LGDa4WR0dA5EVq9ejV+//13dO/eHWZmZpr9lStXxo0bN/QaXGZ4v3bQoEHKxUFElKmEABYuBDw8ZLXoRDVqyIrRREZC50To0aNHKPH+oJr/U6vViI+P10tQmWn1avm9cmXA0VHZWIiIMsXLl0C7dsDXXwOvXwP+/goHRKQcnROhcuXK4fjx40n2b9myBVWrVtVLUJnpxAn5/do1ZeMgIsoUZ84AVavK7i8LC+Dnn+XMMCIjpXMdoUmTJsHX1xePHj2CWq3Gtm3bEBQUhNWrV2PX+4t1ZTOTJysdARGRAanVwLx5wNixQEICULw4sHGjdv0QIiOkc4vQ559/jr/++gsHDx5Enjx5MGnSJAQGBuKvv/5Cs2bNDBFjpmjaVOkIiIgM6I8/5FIZCQlA587A+fNMgogAmAiRuICMcYiIiIC9vT3Cw8MhhB0cHOT+0FAunUNEOVhCAtC6tRwbNGAAB0RTtvP+/287Ozu9XVfnFqFixYrhxYsXSfa/fv0axYoV00tQmSUu7t3PLJpKRDmKWi3XCouNldu5cgH79gEDBzIJInqPzolQSEgIVCpVkv2xsbF49OiRXoLKLPfuKR0BEZEBPHsm1wfr1w8YPfrdfiZAREmkebD0zp07NT/v378f9vb2mm2VSoVDhw7Bw8NDr8EZWkLCu59ZQZ6IcoSjR4Fu3YAnTwBra6BSJaUjIsrS0pwItW3bFgBgYmICX19frdvMzc3h4eGBuXPn6jW4zJLNevSIiJJSqYBp04ApU2S3WNmywObNQPnySkdGlKWlORFSq9UAgKJFi+LcuXNwzAHVB/fvl9/fbxkiIsp2QkOB7t2Bw4fldu/esj5QnjzKxkWUDRj1rDF7+3ejzo3rUSCiHOXuXVkkMSEBWLIE6NFD6YiI9M5Qs8Z0LqgIAFFRUfjnn39w//59xL0/9QrAsGHD9BKYob2/GsjgwcrFQUSULkK8G/xcrBiwaRNQpAhQpoyycRFlMzq3CF28eBGtWrXC27dvERUVhXz58uH58+fInTs3nJ2dcffuXUPFqheJGWVwcDiKFpUZZWysrDRPRJQtPHoEfPGFrBLdvLnS0RBliixTR2jEiBFo06YNXr16BWtra5w5cwb37t2Dp6cnfvzxR70FlpnMzJSOgIgojfbtA6pUkbPDBg3iIEeiDNI5EQoICMA333wDU1NTmJmZITY2Fu7u7pg9ezbGjRtniBiJiCg+HhgzRtYHev5cJkN79shCiUSUbjonQubm5jD9f9EdZ2dn3L9/HwBgb2+PBw8e6Dc6AwoJefcza4wRUZb24AHQqNG7VeIHDQJOnwZKlVI0LKKcQOdEqGrVqjh37hwAoGHDhpg0aRLWrl2Lr7/+GhUqVNA5gMWLF8PDwwNWVlaoVasWzp49m+rxr1+/xuDBg+Hq6gpLS0uUKlUKe/bs0fl+r1179zOLKRJRlvXokWz9OXUKsLOTtYEWLwasrJSOjChH0DkFmD59OlxdXQEA06ZNQ968efHVV18hLCwMv/32m07X2rhxI0aOHAk/Pz9cuHABlStXhre3N549e5bs8XFxcWjWrBlCQkKwZcsWBAUFYenSpXBzc9P114Clpfxubq7zqUREmcfNDWjTBqheHbh4EejYUemIiHIUResI1apVCzVq1MCiRYsAyKKN7u7uGDp0KMaMGZPk+CVLlmDOnDm4ceMGzNOZwSSOOv/uu3DMnm0HLy/gwIEM/RpERPoVEgLY2ACJhWvfvpWzOhI/wREZoSwzaywlFy5cwKeffprm4+Pi4nD+/Hl4eXm9C8bUFF5eXjh9+nSy5+zcuRO1a9fG4MGDUaBAAVSoUAHTp09PdhHYRLGxsYiIiND6At6NEQoMTHPIRESGt3277Arz9ZVLZQBA7txMgogMRKdEaP/+/Rg1ahTGjRunqRd048YNtG3bFjVq1NAsw5EWz58/h0qlQoECBbT2FyhQAKGhocmec/fuXWzZsgUqlQp79uzBxIkTMXfuXPzwww8p3s+MGTNgb2+v+XJ3dwcAhIfL2z090xwyEZHhxMYCw4YB7dvLN6gXL969URGRwaQ5EVq+fDlatmwJf39/zJo1C5988gn++OMP1K5dGy4uLrh69Wq6Bi3rQq1Ww9nZGb///js8PT3h4+OD8ePHY8mSJSmeM3bsWISHh2u+Eme2nTghby9XzqAhExF93J07QN26cn0wABg1Cjh+HMibV9m4iIxAmgtQLFy4ELNmzcK3336LrVu3olOnTvjll19w5coVFCpUSOc7dnR0hJmZGZ4+faq1/+nTp3BxcUn2HFdXV5ibm8PsvQqIZcuWRWhoKOLi4mCRTHloS0tLWCbTpGxtDURFAba2OodORKQ/mzYBffsCb94A+fMDq1YBrVsrHRWR0Uhzi9CdO3fQqVMnAED79u2RK1cuzJkzJ11JEABYWFjA09MThw4d0uxTq9U4dOgQateunew5devWxe3bt7W64G7evAlXV9dkk6DUPH8uv3NZHiJSTEyMXCbjzRvZIhQQwCSIKJOlORGKjo5G7ty5AQAmJiawtLTUTKNPr5EjR2Lp0qVYtWoVAgMD8dVXXyEqKgq9e/cGAPTs2RNjx47VHP/VV1/h5cuXGD58OG7evIndu3dj+vTpGJyBVVObNs3Qr0BElH5WVsDGjcC4cXLJjHR+sCSi9NOpNvuyZctgY2MDAEhISIC/vz8cE6d3/p8uq8/7+PggLCwMkyZNQmhoKKpUqYJ9+/ZpBlDfv39fU8UaANzd3bF//36MGDEClSpVgpubG4YPH47Ro0fr8mtoFC4M2Nun61QiovRZt05Oh+/bV25Xry6/iEgRaa4j5OHhAZOPrEVhYmKSbVafB8JRuLAd7t1TOiIiMgpv3wLDhwPLlgEWFrIbrGxZpaMiyjYMVUcozS1CIe8vzpVDvH2rdAREZBQCA4HOnYGrV+XihmPHcp0woizCqJctfvVK6QiIKMdbtUoukvr2LVCggOwaa9JE6aiI6P+MOhFq2FDpCIgoxxIC6NcPWL5cbnt5AX/8IZMhIsoyuO46EZEhmJgAxYoBpqbA1KnAvn1MgoiyIKNuESIi0ish5LIYDg5ye8wYoEULoFo1RcMiopSxRYiISB/evAG6dwfq1383E8PUlEkQURaXrkTozp07mDBhArp27Ypnz54BAPbu3Ytr167pNTgiomwhIECu4Lx+vZwhduyY0hERURrpnAj9888/qFixIv79919s27YNkZGRAIBLly7Bz89P7wEaUmCg0hEQUbYmBPDrr8AnnwC3bgHu7jIJatFC6ciIKI10ToTGjBmDH374AQcOHNBa36tJkyY4c+aMXoMzNL5XEVG6hYcDPj5yanxsLNCmDXDxIlCnjtKREZEOdE6Erly5gnbt2iXZ7+zsjOeJK5lmEzqu00pE9M6QIcDmzUCuXMDcucCOHXL1eCLKVnROhBwcHPDkyZMk+y9evAg3Nze9BJVZ0ra4CBFRMmbMkOOCTpwARo6U0+WJKNvRORHq0qULRo8ejdDQUJiYmECtVuPkyZMYNWoUevbsaYgYDebGDaUjIKJs49UrWSU6UaFCwLlzQK1aysVERBmmcyI0ffp0lClTBu7u7oiMjES5cuXQoEED1KlTBxMmTDBEjAazcaPSERBRtvDvv0DVqkCvXrILLBFbgYiyvTSvPv+h+/fv4+rVq4iMjETVqlVRsmRJfcdmEO+vPi+E/lavJaIcSAhg3jxZGDEhASheXH6C8vRUOjIio6P46vOJTpw4gXr16qFw4cIoXLiw3gLJbAULKh0BEWVpL17IFqBdu+R2587A0qWAHt+AiUh5OneNNWnSBEWLFsW4ceNw/fp1Q8RERKSskyeBKlVkEmRpKWsFbdjAJIgoB9I5EXr8+DG++eYb/PPPP6hQoQKqVKmCOXPm4OHDh4aIj4go8z1+DDx8CJQsCZw5AwwcyPFARDlUuscIAUBwcDDWrVuH9evX48aNG2jQoAEOHz6sz/j0LrGPsWDBcDx6xE93RPR/QmgnO6tWAe3bA7a2ysVERBqGGiOUoUVXixYtijFjxmDmzJmoWLEi/vnnH33FRUSUef75Rw6Afr9Gmq8vkyAiI5DuROjkyZMYNGgQXF1d0a1bN1SoUAG7d+/WZ2xERIalUgFTpwJNmsjlMSZNUjoiIspkOs8aGzt2LDZs2IDHjx+jWbNmWLhwIT7//HPkzp3bEPERERlGaCjwxRfAoUNyu1cvYMECJSMiIgXonAgdO3YM3377LTp37gxHR0dDxEREZFiHDgHduwNPnwK5c8tZYdmsMj4R6YfOidDJkycNEQcRUebYvh3o0EEOjq5QAdi0CShbVumoiEghaUqEdu7ciZYtW8Lc3Bw7d+5M9djPPvtML4ERERlEs2ZA6dJA/frAwoWAtbXSERGRgtI0fd7U1BShoaFwdnaGqWnK46tNTEygUqn0GqC+cfo8kRE6d07OCkt8/woPB+ztlY2JiHSi6PR5tVoNZ2dnzc8pfWX1JIiIjExCAjB2LFCzplwzLBGTICL6P52nz69evRqxsbFJ9sfFxWH16tV6CYqIKMMePAAaNQJmzpTbrH5PRMnQubK0mZkZnjx5omkhSvTixQs4Oztn+VYhdo0RGYHdu+UssJcv5fpgy5cDHTsqHRURZUCWqSwthIBJMmvuPHz4EPZsbiYiJcXFAaNGAZ9+KpOg6tVloUQmQUSUgjRPn69atSpMTExgYmKCpk2bIleud6eqVCoEBwejRYsWBgmSiChNAgOBn36SPw8fDsyaJVePJyJKQZoTobZt2wIAAgIC4O3tDRsbG81tFhYW8PDwQIcOHfQeIBFRmlWuDCxaBDg7A/9/zyIiSk2aEyE/Pz8AgIeHB3x8fGBlZWWwoIiI0iQ2Fhg3DujRA6hSRe7r31/RkIgoe9G5srSvr68h4iAi0s2dO4CPD3D+PLBrF3D1KmBurnRURJTNpCkRypcvH27evAlHR0fkzZs32cHSiV6+fKm34IiIkrV5M9C3LxARAeTLJ2sEMQkionRIUyI0f/582Nraan5OLREiIjKYmBhg5Ei5SCoA1K0LrF8PuLsrGxcRZVs61xHK7lhHiCibCgsDmjcHAgLk9tixwPffA7l07uEnomwoy9QRunDhAq5cuaLZ3rFjB9q2bYtx48YhLi5Ob4EREWnJlw9wdAScnIB9+4Dp05kEEVGG6ZwIDRgwADdv3gQA3L17Fz4+PsidOzc2b96M7777Tu8BEpERe/sWiI6WP5uZAWvXyhYhb29FwyKinEPnROjmzZuo8v9pqps3b0bDhg2xbt06+Pv7Y+vWrfqOj4iMVWAgUKsW8PXX7/Y5OwMFCyoWEhHlPOlaYkOtVgMADh48iFatWgEA3N3d8fz5c/1GR0TGadUquTzG1avAjh1yfBARkQHonAhVr14dP/zwA9asWYN//vkHrVu3BgAEBwejQIECeg+QiIxIVBTQq5f8evsWaNpUdoU5OSkcGBHlVDonQgsWLMCFCxcwZMgQjB8/HiVKlAAAbNmyBXXq1NF7gERkJK5eBWrUkK1BpqbA1KnA/v2Ai4vSkRFRDqa36fMxMTEwMzODeRYvasbp80RZUFwcULw48PChHAO0bh3QsKHSURFRFmKo6fPpnnt6/vx5BAYGAgDKlSuHatWq6S0oIjIyFhbAkiXA4sWyRYhdYUSUSXROhJ49ewYfHx/8888/cHBwAAC8fv0ajRs3xoYNG+CUTd7AWPKISGGXLgHPngHNmsnt1q2BVq0AVq4nokyk8xihoUOHIjIyEteuXcPLly/x8uVLXL16FRERERg2bJghYjQITnAjUogQsvWnVi25aOr9++9uYxJERJlM5xahffv24eDBgyhbtqxmX7ly5bB48WI0b95cr8EZUr16SkdAZITCw4H+/YFNm+R2s2ZAnjzKxkRERk3nFiG1Wp3sgGhzc3NNfSEioiTOnweqVZNJUK5cwNy5wM6dQP78SkdGREZM50SoSZMmGD58OB4/fqzZ9+jRI4wYMQJNmzbVa3BElEP8/DNQpw5w9y5QpAhw4oRcRZ5dYUSkMJ0ToUWLFiEiIgIeHh4oXrw4ihcvjqJFiyIiIgI///yzIWIkouzu2jU5Q6FtW+DiRTk+iIgoC9B5jJC7uzsuXLiAQ4cOaabPly1bFl5eXnoPjoiyMSHetfjMny9bhHr0YCsQEWUpOiVCGzduxM6dOxEXF4emTZti6NChhoqLiLIrIWTic+AAsGuXXDXe2hro2VPpyIiIkkhzIvTrr79i8ODBKFmyJKytrbFt2zbcuXMHc+bMMWR8RJSdvHgh1wnbtUtub9sGdOqkaEhERKlJ8xihRYsWwc/PD0FBQQgICMCqVavwyy+/GDI2IspOTp0CqlaVSZClJfDrr0DHjkpHRUSUqjQnQnfv3oWvr69mu1u3bkhISMCTJ08MEhgRZRNqNTBrFtCgAfDgAVCyJHDmDDBwIMcDEVGWl+ZEKDY2FnneK3xmamoKCwsLREdHGyQwIsomhg0DxowBVCqgWzdZL6hKFaWjIiJKE50GS0+cOBG5c+fWbMfFxWHatGmwt7fX7Js3b57+ojOgmzeVjoAoh+jfH1i/Hpg9G/jyS7YCEVG2kuZEqEGDBggKCtLaV6dOHdy9e1ezbZKN3gBbtlQ6AqJsSqUC/vvvXS2gSpWAkBDA1lbRsIiI0iPNidDRo0cNGAYRZQtPnwJffAEcPSqrQycmQ0yCiCib0rmyNBEZqcOHgcqVgYMHAQsL4OFDpSMiIsowJkJElDqVCvDzA7y8ZItQhQqya6xDB6UjIyLKMJ2X2CAiI/L4MdC9u+wKA4C+fYGFC4H3Jk0QEWVnTISIKGXbtskkyMYG+O03OT2eiCgHyRJdY4sXL4aHhwesrKxQq1YtnD17Nk3nbdiwASYmJmjbtq1hAyQyVoMHA6NGydpATIKIKAdKVyJ0/PhxfPHFF6hduzYePXoEAFizZg1OnDih87U2btyIkSNHws/PDxcuXEDlypXh7e2NZ8+epXpeSEgIRo0ahfr166fnVyCi5Dx8KNcKe/NGbpuYAHPmAKVKKRoWEZGh6JwIbd26Fd7e3rC2tsbFixcRGxsLAAgPD8f06dN1DmDevHno168fevfujXLlymHJkiXInTs3VqxYkeI5KpUK3bt3x5QpU1CsWDGd75OIkrF7t6wIvWoV8M03SkdDRJQpdE6EfvjhByxZsgRLly6Fubm5Zn/dunVx4cIFna4VFxeH8+fPw8vL611Apqbw8vLC6dOnUzzv+++/h7OzM/r06fPR+4iNjUVERITWFxG9Jz4e+PZb4NNP5erxnp7A6NFKR0VElCl0ToSCgoLQoEGDJPvt7e3x+vVrna71/PlzqFQqFChQQGt/gQIFEBoamuw5J06cwPLly7F06dI03ceMGTNgb2+v+XJ3d9cpRqIc7d49uVjqjz/K7WHDgJMngeLFlY2LiCiT6JwIubi44Pbt20n2nzhxwuDdVG/evEGPHj2wdOlSODo6pumcsWPHIjw8XPP14MEDg8ZIlG0cPy67ws6cARwcgO3b5dR4S0ulIyMiyjQ6T5/v168fhg8fjhUrVsDExASPHz/G6dOnMWrUKEycOFGnazk6OsLMzAxPnz7V2v/06VO4uLgkOf7OnTsICQlBmzZtNPvUarX8RXLlQlBQEIp/8EnW0tISlnxjJ0qqZEmZ9NSqBWzYAHh4KB0REVGm0zkRGjNmDNRqNZo2bYq3b9+iQYMGsLS0xKhRozB06FCdrmVhYQFPT08cOnRIMwVerVbj0KFDGDJkSJLjy5QpgytXrmjtmzBhAt68eYOFCxey24voY168APLnlz+7uMgaQcWKySUziIiMkM6JkImJCcaPH49vv/0Wt2/fRmRkJMqVKwcbG5t0BTBy5Ej4+vqievXqqFmzJhYsWICoqCj07t0bANCzZ0+4ublhxowZsLKyQoUKFbTOd3BwAIAk+4noA1u2AH36AL//Dvj4yH1lyigbExGRwtJdWdrCwgLlypXLcAA+Pj4ICwvDpEmTEBoaiipVqmDfvn2aAdT379+HqWmWqPtIlD3FxMjp8L/8IrdXrQI6d5Y1goiIjJyJEELockLjxo1hksob6OHDhzMclCFFRETA3t4evr7h8Pe3UzocIsO6dUsmPQEBcnvMGOD774H3Sl8QEWUHif+/w8PDYWenv//fOrcIValSRWs7Pj4eAQEBuHr1Knx9ffUVFxFl1Pr1QP/+QGQk4OgIrFkDtGihdFRERFmKzonQ/Pnzk90/efJkREZGZjggItKDy5ffrQ3WoAGwbh3g5qZsTEREWZDeBt988cUXqS6LQUSZqFIluVjqxInAoUNMgoiIUpDuwdIfOn36NKysrPR1OSLS1dq1QP36QOHCcnv2bA6IJiL6CJ0Tofbt22ttCyHw5MkT/PfffzoXVCQiPYiKAoYOBVauBOrUkbWBzM2ZBBERpYHOiZC9vb3WtqmpKUqXLo3vv/8ezZs311tgRJQG167JWWHXrwOmpoC3t/xORERpolMipFKp0Lt3b1SsWBF58+Y1VExE9DFCyBagIUOA6GjA1VUOiG7USOnIiIiyFZ0+OpqZmaF58+Y6rzJPRHoUFQX07CmrREdHy1aggAAmQURE6aBzG3qFChVw9+5dQ8RCRGlhaiqnx5uZATNmAHv2AM7OSkdFRJQt6TxG6IcffsCoUaMwdepUeHp6Ik+ePFq367PaIxH9nxDyy9QUsLYGNm0CwsKAevWUjoyIKFtLcyL0/fff45tvvkGrVq0AAJ999pnWUhtCCJiYmEClUuk/SiJjFh4uK0RXrAhMmCD3lS4tv4iIKEPSvNaYmZkZnjx5gsDAwFSPa9iwoV4CMxSuNUbZyvnzcqX4O3cAKyvg7l05MJqIyMgovtZYYr6U1RMdohxBCGDRIlkdOi4OKFIE2LCBSRARkZ7pNEYotVXniUhPXr+WM8K2bZPbbdsCK1YALFlBRKR3OiVCpUqV+mgy9PLlywwFRGTUEhJkdejAQFkd+scfZdVofgghIjIInRKhKVOmJKksTUR6lCsXMHy4XCds40agenWlIyIiytF0SoS6dOkCZ9YrIdKvly+BJ0+A8uXldv/+wBdfAB+UpiAiIv1Lc0FFjg8iMoBTp4AqVYBPP5VjgwDZDcYkiIgoU6Q5EUrjLHsiSgu1Gpg1C2jQAHjwQI4HevZM6aiIiIxOmrvG1Gq1IeMgMh5hYYCvL7B3r9zu2hX47TfA1lbZuIiIjJDOS2wQUQYcOyYTn8ePZYHEn3+WU+XZ9UxEpAijTYSio5WOgIzSvHkyCSpTRq4XVrGi0hERERk1o02EzM2VjoCM0vLlQLFiwPffAzY2SkdDRGT00jxYOqcpVUrpCMgoHD4MfPONXDIDAPLnl61CTIKIiLIEo20RIjIolUq2+kydKpOgWrWAzp2VjoqIiD7ARIhI3x4/Brp3B44eldt9+sg6QURElOUwESLSp7//llWhw8JkUcTffpNJERERZUlGO0aISO/mzAFatJBJUOXKwIULTIKIiLI4JkJE+lK1qvz+1VfAmTMckU9ElA2wa4woI549AxIXIvbyAq5cebd4KhERZXlsESJKj/h44NtvZavPnTvv9jMJIiLKVpgIEenq3j2gfn3gxx+B8HDgr7+UjoiIiNKJXWNEuvjzT6B3b+D1a8DeHlixAmjfXumoiIgondgiRJQWcXHA118D7drJJKhmTeDiRSZBRETZHBMhorRYtAhYuFD+PHIkcPw4ULSosjEREVGGsWuMKC2GDAEOHAAGDQLatFE6GiIi0hO2CBElJyZGLo4aHy+3LSyAvXuZBBER5TBsESL60K1bgI+PHAMUFgbMmKF0REREZCBsESJ634YNQLVqMglydAQaNFA6IiIiMiAmQkQAEB0NDBgAdO0KREbKOkEBAUDLlkpHRkREBsREiOjmTaBWLeD33wETE2DCBODwYcDNTenIiIjIwDhGiEitBu7elWuGrV0r1wwjIiKjwESIjJNaDZj+v0G0TBlg2zagYkXA1VXZuIiIKFOxa4yMz7VrQJUqwLFj7/Y1b84kiIjICDERIuMhBLB8OVCjBnDlCvDNN3IfEREZLSZCZBzevAF69AD69pUzxJo3B3bvloOjiYjIaDERopzv0iWgenU5ENrMDJg+XVaJdnZWOjIiIlIYB0tTzhYYKKfGx8bK6fAbNgD16ikdFRERZRFMhChnK1MG+OwzICoKWLVKVosmIiL6PyZClPNcvAgULQo4OMgxQKtWAZaW76bLExER/R//M1DOIQSwaBHwySdyUHTijDBrayZBRESULLYIUc7w+jXQp48sjAgACQlATIxMgoiIiFLAj8mU/Z09C1StKpMgc3NgwQJg+3YmQURE9FFMhCj7EgKYP1/OAgsJkeOCTp4Ehg9nfSAiIkoTJkKUfYWHA/PmAfHxQIcOwIULsmo0ERFRGnGMEGVfDg7A+vWyYOKgQWwFIiIinTERouxDrQZ+/BFwcQF69pT76tVjgUQiIko3JkKUPYSFAb6+cmmM3LmBxo0Bd3eloyIiomyOiRBlfcePA126AI8fA1ZWclZYoUJKR0VERDkAB0tT1qVWA9OmAY0aySSodGng33+Bfv04HoiIiPSCLUKUNalUQOvWwP79crtHD+CXXwAbG2XjIiKiHIUtQpQ1mZkB1avL8UArVwKrVzMJIiIivWMiRFmHSiUHRSeaPBkICAB69VIoICIiyumyRCK0ePFieHh4wMrKCrVq1cLZs2dTPHbp0qWoX78+8ubNi7x588LLyyvV4ymbePIEaNYMaNkSiI2V+3LlAkqWVDYuIiLK0RRPhDZu3IiRI0fCz88PFy5cQOXKleHt7Y1nz54le/zRo0fRtWtXHDlyBKdPn4a7uzuaN2+OR48eZXLkpDd//w1UrgwcOQLcuCELJBIREWUCEyGEUDKAWrVqoUaNGli0aBEAQK1Ww93dHUOHDsWYMWM+er5KpULevHmxaNEi9EwsspeKiIgI2NvbY8SIcMybZ5fh+CkDEhIAPz9gxgy5blilSsCmTXJ2GBER0XsS/3+Hh4fDzk5//78VbRGKi4vD+fPn4eXlpdlnamoKLy8vnD59Ok3XePv2LeLj45EvX75kb4+NjUVERITWFwCULZvx+CkDHj4EmjQBpk+XSdCAAcCZM0yCiIgoUymaCD1//hwqlQoFChTQ2l+gQAGEhoam6RqjR49GwYIFtZKp982YMQP29vaaL/f/VyO2ts5Y7JRB/frJQom2tsCGDcCSJXxSiIgo0yk+RigjZs6ciQ0bNmD79u2wsrJK9pixY8ciPDxc8/XgwYNMjpKStXixXCbjwgXAx0fpaIiIyEgpWlDR0dERZmZmePr0qdb+p0+fwsXFJdVzf/zxR8ycORMHDx5EpUqVUjzO0tISlpaWeomXMuD+fTkoum9fuV2sGHD4sLIxERGR0VO0RcjCwgKenp44dOiQZp9arcahQ4dQu3btFM+bPXs2pk6din379qF69eqZESplxM6dQJUqQP/+MhkiIiLKIhRfYmPkyJHw9fVF9erVUbNmTSxYsABRUVHo3bs3AKBnz55wc3PDjBkzAACzZs3CpEmTsG7dOnh4eGjGEtnY2MCGlYezlrg4YPRouUgqANSowbpARESUpSieCPn4+CAsLAyTJk1CaGgoqlSpgn379mkGUN+/fx+mpu8arn799VfExcWhY8eOWtfx8/PD5MmTMzN0Sk1wsBz7c+6c3B4xApg5E7CwUDYuIiKi9yheRyizJdYhWLMmHF98wTpCBvHnn3JZjPBwIG9ewN8f+OwzhYMiIqLszFB1hBRvEaIcKCJCJkG1a8up8YULKx0RERFRspgIkX6oVHLFeADo2ROwsgLatQPMzZWNi4iIKBXZuo4QZREbNgAVKwLPn7/b17kzkyAiIsrymAhR+kVHy6UxunYFAgOBefOUjoiIiEgn7Bqj9LlxQ7b6XLkCmJgA48YBnLVHRETZDBMh0t2aNcBXXwFRUYCzM/DHH0CzZkpHRUREpDMmQqSb334DBg6UPzduDKxdC7i6KhsTERFROnGMEOmmSxegRAnZDXbgAJMgIiLK1tgiRKkTQi6O2qSJHAtkbw9cvgxYWysdGRERUYaxRYhSFhkJ+PoCXl7AkiXv9jMJIiKiHIItQpS8y5flrLCgIMDUVA6MJiIiymGYCJE2IYDffweGDwdiYwE3N2D9eqB+faUjIyIi0jsmQvRORATQvz+wcaPcbtkSWL0acHRUNi4iIiID4RgheufqVWDzZrlm2OzZwK5dTIKIiChHY4sQvVOnDrBoEVClilw5noiIKIdji5Axe/0a6NFDrhOW6KuvmAQREZHRYIuQsTp3DvDxAYKDgevXgf/+k3WCiIiIjAhbhIyNEMCCBUDdujIJ8vCQNYKYBBERkRFii5AxefkS6N0b2LlTbrdvDyxfDjg4KBoWERGRUpgIGYvgYKBRI+D+fcDCApg3Dxg0iC1BRERk1JgIGQt3d6BwYcDcHNi0CahWTemIiIiIFMdEKCd78QKwtZUtQLlyyRpBuXMDdnZKR0ZERJQlcLB0TnX8OFC5MjB69Lt9Li5MgoiIiN7DRCinUauB6dOBxo2BR4+Affu4YCoREVEKmAjlJM+eAS1aAOPHAyoV8MUXsl5QnjxKR0ZERJQlcYxQTnHkCNCtGxAaClhbA4sXA716cVYYERFRKpgI5QQREUCHDsCrV0C5cnJWWPnySkdFRESU5TERygns7IDffgP27gV+/pldYURERGnERCi7OngQMDUFmjSR2506yS8iIiJKMw6Wzm4SEoAJE4DmzYGuXYEnT5SOiIiIKNtii1B28uiRTH6OH5fbbdtynTAiIqIMYCKUXezdC/TsCTx/DtjYAEuXAl26KB0VERFRtsausaxOrZbVoVu1kklQ1arAhQtMgoiIiPSAiVBWZ2oqawMBwODBwKlTQMmSysZERESUQ7BrLKtKSJALpQKyOGKnTsCnnyobExFRFqBSqRAfH690GGQA5ubmMDMzy9T7ZCKU1cTFAWPGALdvAzt2yMrQNjZMgoiIAERGRuLhw4cQQigdChmAiYkJChUqBBsbm0y7TyZCWUlwMODjI9cHA4CjR+XiqUREBJVKhYcPHyJ37txwcnKCCZcQylGEEAgLC8PDhw9RsmTJTGsZYiKUVWzbBnz5JRAeLqfE+/szCSIiek98fDyEEHBycoK1tbXS4ZABODk5ISQkBPHx8ZmWCHGwtNJiY4GhQ+VaYeHhwCefAAEBwOefKx0ZEVGWxJagnEuJ55aJkNK6dwcWLZI/f/stcOwYUKSIsjEREREZCSZCShs9GnB1BXbtAmbPBszNlY6IiIjIaDARymzR0cA//7zbrlEDuHsXaN1auZiIiMjgTp8+DTMzM7RO5v3+6NGjMDExwevXr5Pc5uHhgQULFmjtO3LkCFq1aoX8+fMjd+7cKFeuHL755hs8evTIQNEDMTExGDx4MPLnzw8bGxt06NABT58+TfWcp0+folevXihYsCBy586NFi1a4NatWwaLMT2YCGWmoCA5BsjbW44DSmRlpVhIRESUOZYvX46hQ4fi2LFjePz4cbqv89tvv8HLywsuLi7YunUrrl+/jiVLliA8PBxz587VY8TaRowYgb/++gubN2/GP//8g8ePH6N9+/YpHi+EQNu2bXH37l3s2LEDFy9eRJEiReDl5YWoqCiDxakrzhrLLGvXAgMGAFFRgJMTkEzWT0REOVNkZCQ2btyI//77D6GhofD398e4ceN0vs7Dhw8xbNgwDBs2DPPnz9fs9/DwQIMGDZJtUdKH8PBwLF++HOvWrUOTJk0AACtXrkTZsmVx5swZfPLJJ0nOuXXrFs6cOYOrV6+ifPnyAIBff/0VLi4uWL9+Pfr27WuQWHXFFiFDe/sW6NsX+OILmQQ1aiRbgxo1UjgwIqLsTQj5tqrEl671HDdt2oQyZcqgdOnS+OKLL7BixYp0FYXcvHkz4uLi8N133yV7u4ODQ4rntmzZEjY2Nil+JSYryTl//jzi4+Ph5eWl2VemTBkULlwYp0+fTvac2NhYAIDVe70epqamsLS0xIkTJ1L7NTMVW4QM6fp1oHNn4No1WSF60iRg4kQgk8uHExHlRG/fysL7SoiMBPLkSfvxy5cvxxdffAEAaNGiBcLDw/HPP/+gkY4fim/dugU7Ozu4urrqdB4ALFu2DNHR0Snebp7KZJ3Q0FBYWFgkSbQKFCiA0MT1MD+QmCiNHTsWv/32G/LkyYP58+fj4cOHePLkic7xGwoTIUPasUMmQS4usmvs/82JRERkPIKCgnD27Fls374dAJArVy74+Phg+fLlOidCQoh019pxc3NL13npZW5ujm3btqFPnz7Ily8fzMzM4OXlhZYtW2apJVKYCBnSd9/JNtShQ4ECBZSOhogoR8mdW7bMKHXfabV8+XIkJCSgYMGCmn1CCFhaWmLRokWwt7eHnZ0dADkW58NWl9evX8Pe3h4AUKpUKYSHh+PJkyc6twq1bNkSx48fT/H2IkWK4Nq1a8ne5uLigri4OLx+/VorvqdPn8LFxSXFa3p6eiIgIADh4eGIi4uDk5MTatWqherVq+sUuyExEdKnK1eA778HVq8GrK1lF9gPPygdFRFRjmRiolv3lBISEhKwevVqzJ07F82bN9e6rW3btli/fj0GDhyIkiVLwtTUFOfPn0eR94rq3r17F+Hh4ShVqhQAoGPHjhgzZgxmz56tNVg60YeJyvsy0jXm6ekJc3NzHDp0CB06dAAgW7ru37+P2rVrp3heosRE7tatW/jvv/8wderUj56TWZgI6YMQwLJlwLBhQEwMUKwYMGuW0lEREZHCdu3ahVevXqFPnz6aZCBRhw4dsHz5cgwcOBC2trbo27cvvvnmG+TKlQsVK1bEgwcPMHr0aHzyySeoU6cOAMDd3R3z58/HkCFDEBERgZ49e8LDwwMPHz7E6tWrYWNjk+IU+ox0jdnb26NPnz4YOXIk8uXLBzs7OwwdOhS1a9fWmjFWpkwZzJgxA+3atQMgB3c7OTmhcOHCuHLlCoYPH462bdsmSQoVJYxMeHi4ACDWrAnX1wWF6NJFCJkOCdGihRDPnunn2kREpBEdHS2uX78uoqOjlQ4lzT799FPRqlWrZG/7999/BQBx6dIlIYT8/fz8/ESZMmWEtbW1KFq0qOjfv78ICwtLcu6BAweEt7e3yJs3r7CyshJlypQRo0aNEo8fPzbY7xIdHS0GDRok8ubNK3Lnzi3atWsnnjx5onUMALFy5UrN9sKFC0WhQoWEubm5KFy4sJgwYYKIjY1N9T5Seo4T/3+Hh+vp//f/mfw/cKMREREBe3t7rFkTji++sMvYxS5elLPCbt+W3WDTpwOjRgGmrEpARKRvMTExCA4ORtGiRbWmZFPOkdpznPj/Ozw8XDOmSh/YNZZe27cDXboAcXGAuzuwYQPw/6ZLIiIiyh6YCKVX9eqygEXdusDKlUD+/EpHRERERDpiIqSLR4+AxMFm7u7A2bNyYHQ6azoQERGRsjiYJS2EABYulEnPzp3v9hcvziSIiIgoG2Mi9DEvXwLt2gFffy3HA72fCBEREVG2xkQoNWfOAFWryqUyLCyAn38Gli5VOioiIqNmZJOdjYoSzy0ToeSo1cCPPwL16wP378susFOngCFD2BVGRKQQs/8vWB0XF6dwJGQoic+tWSYuTs7B0sk5dgz49lv5c+fOshVIjzULiIhId7ly5ULu3LkRFhYGc3NzmLJmW46iVqsRFhaG3LlzI1euzEtPmAglp1EjYPhwoEwZYMAAtgIREWUBJiYmcHV1RXBwMO7du6d0OGQApqamKFy4MEwy8f8uEyFAdoUtXAh07QokrqK7YIGiIRERUVIWFhYoWbIku8dyKAsLi0xv6csSidDixYsxZ84chIaGonLlyvj5559Rs2bNFI/fvHkzJk6ciJCQEJQsWRKzZs1Cq1at0nfnz54BPXoAf/8N7NoFHDjAJTKIiLIwU1NTLrFBeqP4f/yNGzdi5MiR8PPzw4ULF1C5cmV4e3vj2bNnyR5/6tQpdO3aFX369MHFixfRtm1btG3bFlevXtX9zo8eBapUkUmQtTXQvTu7wYiIiIyI4ouu1qpVCzVq1MCiRYsAyMFS7u7uGDp0KMaMGZPkeB8fH0RFRWHXrl2afZ988gmqVKmCJUuWfPT+Ehdt+7f9WNT8c5bsFitbFti0CahQQX+/GBEREemNoRZdVbRFKC4uDufPn4eXl5dmn6mpKby8vHD69Olkzzl9+rTW8QDg7e2d4vEpKbNthkyCevcGzp1jEkRERGSEFB0j9Pz5c6hUKhQoUEBrf4ECBXDjxo1kzwkNDU32+NDQ0GSPj42NRWxsrGY7PDwcAPDS3ApYtFCuIK9SARERGflViIiIyIAi/v9/Wt8dWVlisLQhzZgxA1OmTEmyv2h8jJwaP2CAAlERERFRerx48QL29vZ6u56iiZCjoyPMzMzw9OlTrf1Pnz6FS+I09g+4uLjodPzYsWMxcuRIzfbr169RpEgR3L9/X68PJOkuIiIC7u7uePDggV77eyl9+HxkHXwusg4+F1lHeHg4ChcujHz58un1uoomQhYWFvD09MShQ4fQtm1bAHKw9KFDhzBkyJBkz6lduzYOHTqEr7/+WrPvwIEDqF27drLHW1pawtLSMsl+e3t7/lFnEXZ2dnwushA+H1kHn4usg89F1qHvOkOKd42NHDkSvr6+qF69OmrWrIkFCxYgKioKvXv3BgD07NkTbm5umDFjBgBg+PDhaNiwIebOnYvWrVtjw4YN+O+///D7778r+WsQERFRNqR4IuTj44OwsDBMmjQJoaGhqFKlCvbt26cZEH3//n2t7K9OnTpYt24dJkyYgHHjxqFkyZL4888/UYGzvoiIiEhHiidCADBkyJAUu8KOHj2aZF+nTp3QqVOndN2XpaUl/Pz8ku0uo8zF5yJr4fORdfC5yDr4XGQdhnouFC+oSERERKQUxZfYICIiIlIKEyEiIiIyWkyEiIiIyGgxESIiIiKjlSMTocWLF8PDwwNWVlaoVasWzp49m+rxmzdvRpkyZWBlZYWKFStiz549mRRpzqfLc7F06VLUr18fefPmRd68eeHl5fXR5450o+trI9GGDRtgYmKiKXxKGafrc/H69WsMHjwYrq6usLS0RKlSpfhepSe6PhcLFixA6dKlYW1tDXd3d4wYMQIxMTGZFG3OdezYMbRp0wYFCxaEiYkJ/vzzz4+ec/ToUVSrVg2WlpYoUaIE/P39db9jkcNs2LBBWFhYiBUrVohr166Jfv36CQcHB/H06dNkjz958qQwMzMTs2fPFtevXxcTJkwQ5ubm4sqVK5kcec6j63PRrVs3sXjxYnHx4kURGBgoevXqJezt7cXDhw8zOfKcSdfnI1FwcLBwc3MT9evXF59//nnmBJvD6fpcxMbGiurVq4tWrVqJEydOiODgYHH06FEREBCQyZHnPLo+F2vXrhWWlpZi7dq1Ijg4WOzfv1+4urqKESNGZHLkOc+ePXvE+PHjxbZt2wQAsX379lSPv3v3rsidO7cYOXKkuH79uvj555+FmZmZ2Ldvn073m+MSoZo1a4rBgwdrtlUqlShYsKCYMWNGssd37txZtG7dWmtfrVq1xIABAwwapzHQ9bn4UEJCgrC1tRWrVq0yVIhGJT3PR0JCgqhTp45YtmyZ8PX1ZSKkJ7o+F7/++qsoVqyYiIuLy6wQjYauz8XgwYNFkyZNtPaNHDlS1K1b16BxGpu0JELfffedKF++vNY+Hx8f4e3trdN95aiusbi4OJw/fx5eXl6afaampvDy8sLp06eTPef06dNaxwOAt7d3isdT2qTnufjQ27dvER8fr/cF9oxRep+P77//Hs7OzujTp09mhGkU0vNc7Ny5E7Vr18bgwYNRoEABVKhQAdOnT4dKpcqssHOk9DwXderUwfnz5zXdZ3fv3sWePXvQqlWrTImZ3tHX/+8sUVlaX54/fw6VSqVZniNRgQIFcOPGjWTPCQ0NTfb40NBQg8VpDNLzXHxo9OjRKFiwYJI/dNJdep6PEydOYPny5QgICMiECI1Hep6Lu3fv4vDhw+jevTv27NmD27dvY9CgQYiPj4efn19mhJ0jpee56NatG54/f4569epBCIGEhAQMHDgQ48aNy4yQ6T0p/f+OiIhAdHQ0rK2t03SdHNUiRDnHzJkzsWHDBmzfvh1WVlZKh2N03rx5gx49emDp0qVwdHRUOhyjp1ar4ezsjN9//x2enp7w8fHB+PHjsWTJEqVDMzpHjx7F9OnT8csvv+DChQvYtm0bdu/ejalTpyodGqVTjmoRcnR0hJmZGZ4+faq1/+nTp3BxcUn2HBcXF52Op7RJz3OR6Mcff8TMmTNx8OBBVKpUyZBhGg1dn487d+4gJCQEbdq00exTq9UAgFy5ciEoKAjFixc3bNA5VHpeG66urjA3N4eZmZlmX9myZREaGoq4uDhYWFgYNOacKj3PxcSJE9GjRw/07dsXAFCxYkVERUWhf//+GD9+vNYi4WRYKf3/trOzS3NrEJDDWoQsLCzg6emJQ4cOafap1WocOnQItWvXTvac2rVrax0PAAcOHEjxeEqb9DwXADB79mxMnToV+/btQ/Xq1TMjVKOg6/NRpkwZXLlyBQEBAZqvzz77DI0bN0ZAQADc3d0zM/wcJT2vjbp16+L27duaZBQAbt68CVdXVyZBGZCe5+Lt27dJkp3EBFVw6c5Mpbf/37qN4876NmzYICwtLYW/v7+4fv266N+/v3BwcBChoaFCCCF69OghxowZozn+5MmTIleuXOLHH38UgYGBws/Pj9Pn9UTX52LmzJnCwsJCbNmyRTx58kTz9ebNG6V+hRxF1+fjQ5w1pj+6Phf3798Xtra2YsiQISIoKEjs2rVLODs7ix9++EGpXyHH0PW58PPzE7a2tmL9+vXi7t274u+//xbFixcXnTt3VupXyDHevHkjLl68KC5evCgAiHnz5omLFy+Ke/fuCSGEGDNmjOjRo4fm+MTp899++60IDAwUixcv5vT5RD///LMoXLiwsLCwEDVr1hRnzpzR3NawYUPh6+urdfymTZtEqVKlhIWFhShfvrzYvXt3Jkecc+nyXBQpUkQASPLl5+eX+YHnULq+Nt7HREi/dH0uTp06JWrVqiUsLS1FsWLFxLRp00RCQkImR50z6fJcxMfHi8mTJ4vixYsLKysr4e7uLgYNGiRevXqV+YHnMEeOHEn2f0Di4+/r6ysaNmyY5JwqVaoICwsLUaxYMbFy5Uqd79dECLblERERkXHKUWOEiIiIiHTBRIiIiIiMFhMhIiIiMlpMhIiIiMhoMREiIiIio8VEiIiIiIwWEyEiIiIyWkyEiEiLv78/HBwclA4j3UxMTPDnn3+mekyvXr3Qtm3bTImHiLI2JkJEOVCvXr1gYmKS5Ov27dtKhwZ/f39NPKampihUqBB69+6NZ8+e6eX6T548QcuWLQEAISEhMDExQUBAgNYxCxcuhL+/v17uLyWTJ0/W/J5mZmZwd3dH//798fLlS52uw6SNyLBy1OrzRPROixYtsHLlSq19Tk5OCkWjzc7ODkFBQVCr1bh06RJ69+6Nx48fY//+/Rm+dkqrhr/P3t4+w/eTFuXLl8fBgwehUqkQGBiIL7/8EuHh4di4cWOm3D8RfRxbhIhyKEtLS7i4uGh9mZmZYd68eahYsSLy5MkDd3d3DBo0CJGRkSle59KlS2jcuDFsbW1hZ2cHT09P/Pfff5rbT5w4gfr168Pa2hru7u4YNmwYoqKiUo3NxMQELi4uKFiwIFq2bIlhw4bh4MGDiI6Ohlqtxvfff49ChQrB0tISVapUwb59+zTnxsXFYciQIXB1dYWVlRWKFCmCGTNmaF07sWusaNGiAICqVavCxMQEjRo1AqDdyvL777+jYMGCWiu7A8Dnn3+OL7/8UrO9Y8cOVKtWDVZWVihWrBimTJmChISEVH/PXLlywcXFBW5ubvDy8kKnTp1w4MABze0qlQp9+vRB0aJFYW1tjdKlS2PhwoWa2ydPnoxVq1Zhx44dmtalo0ePAgAePHiAzp07w8HBAfny5cPnn3+OkJCQVOMhoqSYCBEZGVNTU/z000+4du0aVq1ahcOHD+O7775L8fju3bujUKFCOHfuHM6fP48xY8bA3NwcAHDnzh20aNECHTp0wOXLl7Fx40acOHECQ4YM0Skma2trqNVqJCQkYOHChZg7dy5+/PFHXL58Gd7e3vjss89w69YtAMBPP/2EnTt3YtOmTQgKCsLatWvh4eGR7HXPnj0LADh48CCePHmCbdu2JTmmU6dOePHiBY4cOaLZ9/LlS+zbtw/du3cHABw/fhw9e/bE8OHDcf36dfz222/w9/fHtGnT0vw7hoSEYP/+/bCwsNDsU6vVKFSoEDZv3ozr169j0qRJGDduHDZt2gQAGDVqFDp37owWLVrgyZMnePLkCerUqYP4+Hh4e3vD1tYWx48fx8mTJ2FjY4MWLVogLi4uzTEREZAjV58nMna+vr7CzMxM5MmTR/PVsWPHZI/dvHmzyJ8/v2Z75cqVwt7eXrNta2sr/P39kz23T58+on///lr7jh8/LkxNTUV0dHSy53x4/Zs3b4pSpUqJ6tWrCyGEKFiwoJg2bZrWOTVq1BCDBg0SQggxdOhQ0aRJE6FWq5O9PgCxfft2IYQQwcHBAoC4ePGi1jG+vr7i888/12x//vnn4ssvv9Rs//bbb6JgwYJCpVIJIYRo2rSpmD59utY11qxZI1xdXZONQQgh/Pz8hKmpqciTJ4+wsrLSrKQ9b968FM8RQojBgweLDh06pBhr4n2XLl1a6zGIjY0V1tbWYv/+/alen4i0cYwQUQ7VuHFj/Prrr5rtPHnyAJCtIzNmzMCNGzcQERGBhIQExMTE4O3bt8idO3eS64wcORJ9+/bFmjVrNN07xYsXByC7zS5fvoy1a9dqjhdCQK1WIzg4GGXLlk02tvDwcNjY2ECtViMmJgb16tXDsmXLEBERgcePH6Nu3bpax9etWxeXLl0CILu1mjVrhtKlS6NFixb49NNP0bx58ww9Vt27d0e/fv3wyy+/wNLSEmvXrkWXLl1gamqq+T1Pnjyp1QKkUqlSfdwAoHTp0ti5cydiYmLwxx9/ICAgAEOHDtU6ZvHixVixYgXu37+P6OhoxMXFoUqVKqnGe+nSJdy+fRu2trZa+2NiYnDnzp10PAJExouJEFEOlSdPHpQoUUJrX0hICD799FN89dVXmDZtGvLly4cTJ06gT58+iIuLS/Yf+uTJk9GtWzfs3r0be/fuhZ+fHzZs2IB27dohMjISAwYMwLBhw5KcV7hw4RRjs7W1xYULF2BqagpXV1dYW1sDACIiIj76e1WrVg3BwcHYu3cvDh48iM6dO8PLywtbtmz56LkpadOmDYQQ2L17N2rUqIHjx49j/vz5mtsjIyMxZcoUtG/fPsm5VlZWKV7XwsJC8xzMnDkTrVu3xpQpUzB16lQAwIYNGzBq1CjMnTsXtWvXhq2tLebMmYN///031XgjIyPh6emplYAmyioD4omyCyZCREbk/PnzUKvVmDt3rqa1I3E8SmpKlSqFUqVKYcSIEejatStWrlyJdu3aoVq1arh+/XqShOtjTE1Nkz3Hzs4OBQsWxMmTJ9GwYUPN/pMnT6JmzZpax/n4+MDHxwcdO3ZEixYt8PLlS+TLl0/reonjcVQqVarxWFlZoX379li7di1u376N0qVLo1q1aprbq1WrhqCgIJ1/zw9NmDABTZo0wVdffaX5PevUqYNBgwZpjvmwRcfCwiJJ/NWqVcPGjRvh7OwMOzu7DMVEZOw4WJrIiJQoUQLx8fH4+eefcffuXaxZswZLlixJ8fjo6GgMGTIER48exb1793Dy5EmcO3dO0+U1evRonDp1CkOGDEFAQABu3bqFHTt26DxY+n3ffvstZs2ahY0bNyIoKAhjxoxBQEAAhg8fDgCYN28e1q9fjxs3buDmzZvYvHkzXFxcki0C6ezsDGtra+zbtw9Pnz5FeHh4ivfbvXt37N69GytWrNAMkk40adIkrF69GlOmTMG1a9cQGBiIDRs2YMKECTr9brVr10alSpUwffp0AEDJkiXx33//Yf/+/bh58yYmTpyIc+fOaZ3j4eGBy5cvIygoCM+fP0d8fDy6d+8OR0dHfP755zh+/DiCg4Nx9OhRDBs2DA8fPtQpJiKjp/QgJSLSv+QG2CaaN2+ecHV1FdbW1sLb21usXr1aABCvXr0SQmgPZo6NjRVdunQR7u7uwsLCQhQsWFAMGTJEayD02bNnRbNmzYSNjY3IkyePqFSpUpLBzu/7cLD0h1QqlZg8ebJwc3MT5ubmonLlymLv3r2a23///XdRpUoVkSdPHmFnZyeaNm0qLly4oLkd7w2WFkKIpUuXCnd3d2FqaioaNmyY4uOjUqmEq6urACDu3LmTJK59+/aJOnXqCGtra2FnZydq1qwpfv/99xR/Dz8/P1G5cuUk+9evXy8sLS3F/fv3RUxMjOjVq5ewt7cXDg4O4quvvhJjxozROu/Zs2eaxxeAOHLkiBBCiCdPnoiePXsKR0dHYWlpKYoVKyb69esnwsPDU4yJiJIyEUIIZVMxIiIiImWwa4yIiIiMFhMhIiIiMlpMhIiIiMhoMREiIiIio8VEiIiIiIwWEyEiIiIyWkyEiIiIyGgxESIiIiKjxUSIiIiIjBYTISIiIjJaTISIiIjIaDERIiIiIqP1PyTIicpmRzr3AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -146,62 +246,82 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 1 AUC: 0.9025000000000001\n", + "Overall, depth: 1 AUC: 0.9011941225982673\n", "doing digit 0 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3760838508605957\n", - "compute_auc_time: 0.14020204544067383\n", - "depth: 2 , Auc of digit: 0 is 1.0\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 363\n", + "len(data.test_outlier) 3135\n", + "fit_time: 1.372164011001587\n", + "compute_auc_time: 6.132082939147949\n", + "depth: 2 , Auc of digit: 0 is 0.9994156440437432\n", "doing digit 1 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3131299018859863\n", - "compute_auc_time: 0.14356303215026855\n", - "depth: 2 , Auc of digit: 1 is 0.9177777777777778\n", + "len(data.corpus) 779\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.3040940761566162\n", + "compute_auc_time: 5.918816804885864\n", + "depth: 2 , Auc of digit: 1 is 0.882206498032918\n", "doing digit 2 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3730659484863281\n", - "compute_auc_time: 0.1465151309967041\n", - "depth: 2 , Auc of digit: 2 is 0.9588888888888889\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.4281229972839355\n", + "compute_auc_time: 6.078402996063232\n", + "depth: 2 , Auc of digit: 2 is 0.9511227445177669\n", "doing digit 3 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.5481741428375244\n", - "compute_auc_time: 0.1523730754852295\n", - "depth: 2 , Auc of digit: 3 is 1.0\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.1745800971984863\n", + "compute_auc_time: 6.047379970550537\n", + "depth: 2 , Auc of digit: 3 is 0.9886656275413391\n", "doing digit 4 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3711528778076172\n", - "compute_auc_time: 0.14588427543640137\n", - "depth: 2 , Auc of digit: 4 is 0.967777777777778\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.4331169128417969\n", + "compute_auc_time: 6.15405797958374\n", + "depth: 2 , Auc of digit: 4 is 0.9971212578104729\n", "doing digit 5 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.4503920078277588\n", - "compute_auc_time: 0.18131399154663086\n", - "depth: 2 , Auc of digit: 5 is 0.9988888888888889\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 335\n", + "len(data.test_outlier) 3163\n", + "fit_time: 1.2062079906463623\n", + "compute_auc_time: 5.991538047790527\n", + "depth: 2 , Auc of digit: 5 is 0.9647887656249262\n", "doing digit 6 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.417189121246338\n", - "compute_auc_time: 0.10462093353271484\n", - "depth: 2 , Auc of digit: 6 is 1.0\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.3611791133880615\n", + "compute_auc_time: 6.071725130081177\n", + "depth: 2 , Auc of digit: 6 is 0.9924061022258366\n", "doing digit 7 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.4176151752471924\n", - "compute_auc_time: 0.12642884254455566\n", - "depth: 2 , Auc of digit: 7 is 0.9633333333333334\n", + "len(data.corpus) 778\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.2972280979156494\n", + "compute_auc_time: 6.051958084106445\n", + "depth: 2 , Auc of digit: 7 is 0.9607328695554606\n", "doing digit 8 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3452069759368896\n", - "compute_auc_time: 0.14234519004821777\n", - "depth: 2 , Auc of digit: 8 is 0.9977777777777778\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.3206632137298584\n", + "compute_auc_time: 6.074285984039307\n", + "depth: 2 , Auc of digit: 8 is 0.9951771030993043\n", "doing digit 9 doing signature level 2\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 2, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3965299129486084\n", - "compute_auc_time: 0.13335299491882324\n", - "depth: 2 , Auc of digit: 9 is 0.95\n" + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.300351858139038\n", + "compute_auc_time: 5.983568906784058\n", + "depth: 2 , Auc of digit: 9 is 0.8993403813138158\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -213,62 +333,82 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 2 AUC: 0.9773777777777778\n", + "Overall, depth: 2 AUC: 0.964656389818477\n", "doing digit 0 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.4143779277801514\n", - "compute_auc_time: 0.12943410873413086\n", - "depth: 3 , Auc of digit: 0 is 1.0\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 363\n", + "len(data.test_outlier) 3135\n", + "fit_time: 1.4051527976989746\n", + "compute_auc_time: 6.391190767288208\n", + "depth: 3 , Auc of digit: 0 is 0.9978321712119015\n", "doing digit 1 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3806469440460205\n", - "compute_auc_time: 0.1656959056854248\n", - "depth: 3 , Auc of digit: 1 is 0.9844444444444445\n", + "len(data.corpus) 779\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.3406829833984375\n", + "compute_auc_time: 6.211621046066284\n", + "depth: 3 , Auc of digit: 1 is 0.970122092330133\n", "doing digit 2 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.343611240386963\n", - "compute_auc_time: 0.1403639316558838\n", - "depth: 3 , Auc of digit: 2 is 1.0\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.5092599391937256\n", + "compute_auc_time: 6.318360805511475\n", + "depth: 3 , Auc of digit: 2 is 0.9907229815494015\n", "doing digit 3 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.2466747760772705\n", - "compute_auc_time: 0.1919870376586914\n", - "depth: 3 , Auc of digit: 3 is 1.0\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.4253010749816895\n", + "compute_auc_time: 6.349896192550659\n", + "depth: 3 , Auc of digit: 3 is 0.9952787566639559\n", "doing digit 4 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3243610858917236\n", - "compute_auc_time: 0.15105414390563965\n", - "depth: 3 , Auc of digit: 4 is 0.9955555555555555\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.3248441219329834\n", + "compute_auc_time: 6.372351884841919\n", + "depth: 3 , Auc of digit: 4 is 0.9998316935138888\n", "doing digit 5 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3371069431304932\n", - "compute_auc_time: 0.10097980499267578\n", - "depth: 3 , Auc of digit: 5 is 1.0\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 335\n", + "len(data.test_outlier) 3163\n", + "fit_time: 1.2319657802581787\n", + "compute_auc_time: 6.267655849456787\n", + "depth: 3 , Auc of digit: 5 is 0.9819583712798636\n", "doing digit 6 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.262901782989502\n", - "compute_auc_time: 0.09397101402282715\n", - "depth: 3 , Auc of digit: 6 is 1.0\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.255133867263794\n", + "compute_auc_time: 6.341071128845215\n", + "depth: 3 , Auc of digit: 6 is 0.9945587105810065\n", "doing digit 7 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.2335212230682373\n", - "compute_auc_time: 0.13829803466796875\n", - "depth: 3 , Auc of digit: 7 is 0.9522222222222223\n", + "len(data.corpus) 778\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.4977219104766846\n", + "compute_auc_time: 6.289638042449951\n", + "depth: 3 , Auc of digit: 7 is 0.9778264970511301\n", "doing digit 8 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.2652909755706787\n", - "compute_auc_time: 0.11092400550842285\n", - "depth: 3 , Auc of digit: 8 is 1.0\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.249243974685669\n", + "compute_auc_time: 6.3368239402771\n", + "depth: 3 , Auc of digit: 8 is 0.9984290759314479\n", "doing digit 9 doing signature level 3\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 3, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3376529216766357\n", - "compute_auc_time: 0.1322460174560547\n", - "depth: 3 , Auc of digit: 9 is 0.9577777777777777\n" + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.4798219203948975\n", + "compute_auc_time: 6.201497793197632\n", + "depth: 3 , Auc of digit: 9 is 0.9264809418391013\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -280,62 +420,82 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 3 AUC: 0.9870888888888889\n", + "Overall, depth: 3 AUC: 0.9833291298913164\n", "doing digit 0 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.312425136566162\n", - "compute_auc_time: 0.17491698265075684\n", - "depth: 4 , Auc of digit: 0 is 0.99\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 363\n", + "len(data.test_outlier) 3135\n", + "fit_time: 1.5825400352478027\n", + "compute_auc_time: 6.715334177017212\n", + "depth: 4 , Auc of digit: 0 is 0.9949666301993401\n", "doing digit 1 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3289391994476318\n", - "compute_auc_time: 0.19739603996276855\n", - "depth: 4 , Auc of digit: 1 is 0.9866666666666667\n", + "len(data.corpus) 779\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.5532629489898682\n", + "compute_auc_time: 6.574487209320068\n", + "depth: 4 , Auc of digit: 1 is 0.9852398718065597\n", "doing digit 2 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.4418830871582031\n", - "compute_auc_time: 0.1664409637451172\n", - "depth: 4 , Auc of digit: 2 is 1.0\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.321923017501831\n", + "compute_auc_time: 6.628010988235474\n", + "depth: 4 , Auc of digit: 2 is 0.9894510403444672\n", "doing digit 3 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.4082059860229492\n", - "compute_auc_time: 0.1421060562133789\n", - "depth: 4 , Auc of digit: 3 is 1.0\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.2782950401306152\n", + "compute_auc_time: 6.687088966369629\n", + "depth: 4 , Auc of digit: 3 is 0.9959752718291617\n", "doing digit 4 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.493091106414795\n", - "compute_auc_time: 0.1769089698791504\n", - "depth: 4 , Auc of digit: 4 is 1.0\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.6324059963226318\n", + "compute_auc_time: 6.654690980911255\n", + "depth: 4 , Auc of digit: 4 is 0.999876399924262\n", "doing digit 5 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.3259241580963135\n", - "compute_auc_time: 0.18933606147766113\n", - "depth: 4 , Auc of digit: 5 is 0.9933333333333334\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 335\n", + "len(data.test_outlier) 3163\n", + "fit_time: 1.2856931686401367\n", + "compute_auc_time: 6.640314340591431\n", + "depth: 4 , Auc of digit: 5 is 0.9878785018945739\n", "doing digit 6 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.4868669509887695\n", - "compute_auc_time: 0.180161714553833\n", - "depth: 4 , Auc of digit: 6 is 1.0\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.3116629123687744\n", + "compute_auc_time: 6.632941007614136\n", + "depth: 4 , Auc of digit: 6 is 0.9949408526851601\n", "doing digit 7 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.5131468772888184\n", - "compute_auc_time: 0.1810131072998047\n", - "depth: 4 , Auc of digit: 7 is 0.9677777777777778\n", + "len(data.corpus) 778\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.507436990737915\n", + "compute_auc_time: 6.618512868881226\n", + "depth: 4 , Auc of digit: 7 is 0.9857894976752666\n", "doing digit 8 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.4616129398345947\n", - "compute_auc_time: 0.15701699256896973\n", - "depth: 4 , Auc of digit: 8 is 1.0\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.292693853378296\n", + "compute_auc_time: 6.697542190551758\n", + "depth: 4 , Auc of digit: 8 is 0.998694504683594\n", "doing digit 9 doing signature level 4\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 4, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.464219093322754\n", - "compute_auc_time: 0.21893668174743652\n", - "depth: 4 , Auc of digit: 9 is 0.9522222222222222\n" + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.368224859237671\n", + "compute_auc_time: 6.595253944396973\n", + "depth: 4 , Auc of digit: 9 is 0.9442176063973977\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -347,62 +507,82 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 4 AUC: 0.9868333333333333\n", + "Overall, depth: 4 AUC: 0.9873373238881291\n", "doing digit 0 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 2.007327079772949\n", - "compute_auc_time: 0.16542577743530273\n", - "depth: 5 , Auc of digit: 0 is 0.9911111111111112\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 363\n", + "len(data.test_outlier) 3135\n", + "fit_time: 1.6824851036071777\n", + "compute_auc_time: 9.371766090393066\n", + "depth: 5 , Auc of digit: 0 is 0.9947574922781535\n", "doing digit 1 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.7294988632202148\n", - "compute_auc_time: 0.18907880783081055\n", - "depth: 5 , Auc of digit: 1 is 0.9922222222222223\n", + "len(data.corpus) 779\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.7435991764068604\n", + "compute_auc_time: 9.242139101028442\n", + "depth: 5 , Auc of digit: 1 is 0.9900453726235474\n", "doing digit 2 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.8666350841522217\n", - "compute_auc_time: 0.16200900077819824\n", - "depth: 5 , Auc of digit: 2 is 0.9988888888888889\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.6792869567871094\n", + "compute_auc_time: 9.047877073287964\n", + "depth: 5 , Auc of digit: 2 is 0.9912226414300441\n", "doing digit 3 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.635429859161377\n", - "compute_auc_time: 0.18326902389526367\n", - "depth: 5 , Auc of digit: 3 is 1.0\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.5338101387023926\n", + "compute_auc_time: 8.582865953445435\n", + "depth: 5 , Auc of digit: 3 is 0.9964675386283546\n", "doing digit 4 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.9687061309814453\n", - "compute_auc_time: 0.18990612030029297\n", - "depth: 5 , Auc of digit: 4 is 1.0\n", + "len(data.corpus) 780\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.6837000846862793\n", + "compute_auc_time: 9.270012140274048\n", + "depth: 5 , Auc of digit: 4 is 0.9999263659123263\n", "doing digit 5 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 2.0886638164520264\n", - "compute_auc_time: 0.19944500923156738\n", - "depth: 5 , Auc of digit: 5 is 0.9933333333333334\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 335\n", + "len(data.test_outlier) 3163\n", + "fit_time: 1.7708702087402344\n", + "compute_auc_time: 8.772486925125122\n", + "depth: 5 , Auc of digit: 5 is 0.9896433104789049\n", "doing digit 6 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.9900450706481934\n", - "compute_auc_time: 0.12359023094177246\n", - "depth: 5 , Auc of digit: 6 is 0.9988888888888889\n", + "len(data.corpus) 720\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.492610216140747\n", + "compute_auc_time: 9.380972862243652\n", + "depth: 5 , Auc of digit: 6 is 0.9954961823439054\n", "doing digit 7 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.5356130599975586\n", - "compute_auc_time: 0.18652963638305664\n", - "depth: 5 , Auc of digit: 7 is 0.9644444444444445\n", + "len(data.corpus) 778\n", + "len(data.test_inlier) 364\n", + "len(data.test_outlier) 3134\n", + "fit_time: 1.7382721900939941\n", + "compute_auc_time: 9.786658763885498\n", + "depth: 5 , Auc of digit: 7 is 0.9868265110766707\n", "doing digit 8 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.723020076751709\n", - "compute_auc_time: 0.16846275329589844\n", - "depth: 5 , Auc of digit: 8 is 1.0\n", + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.470499038696289\n", + "compute_auc_time: 8.815712928771973\n", + "depth: 5 , Auc of digit: 8 is 0.9993119559651817\n", "doing digit 9 doing signature level 5\n", - "Signature kwargs: {'augmentation_list': None, 'depth': 5, 'window_name': 'global', 'window_depth': None, 'window_length': None, 'window_step': None, 'rescaling': None, 'sig_tfm': 'signature'}\n", - "fit_time: 1.510901927947998\n", - "compute_auc_time: 0.15943002700805664\n", - "depth: 5 , Auc of digit: 9 is 0.94\n" + "len(data.corpus) 719\n", + "len(data.test_inlier) 336\n", + "len(data.test_outlier) 3162\n", + "fit_time: 1.6470270156860352\n", + "compute_auc_time: 8.853724002838135\n", + "depth: 5 , Auc of digit: 9 is 0.9467071774946538\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -414,9 +594,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 5 AUC: 0.9871222222222222\n", - "CPU times: user 2min 16s, sys: 2min 9s, total: 4min 26s\n", - "Wall time: 1min 35s\n" + "Overall, depth: 5 AUC: 0.9887056900094\n", + "CPU times: user 11min 4s, sys: 4min 5s, total: 15min 10s\n", + "Wall time: 7min 26s\n" ] } ], @@ -431,11 +611,14 @@ " for digit in digits:\n", " data.load_pen_digit(digit=digit)\n", " print(\"doing digit\", digit, \"doing signature level \", depth)\n", - " signature_maha_knn = SignatureMahalanobisKNN()\n", + " print(\"len(data.corpus)\", len(data.corpus))\n", + " print(\"len(data.test_inlier)\", len(data.test_inlier))\n", + " print(\"len(data.test_outlier)\", len(data.test_outlier))\n", + " signature_maha_knn = SignatureMahalanobisKNN(random_state=seed)\n", " # Measure the time spent on fit\n", " start_time = time.time()\n", " signature_maha_knn.fit(\n", - " knn_library=\"sklearn\",\n", + " knn_library=\"pynndescent\",\n", " X_train=data.corpus,\n", " signature_kwargs={\n", " \"augmentation_list\": None,\n", @@ -476,14 +659,14 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{1: 0.9025000000000001, 2: 0.9773777777777778, 3: 0.9870888888888889, 4: 0.9868333333333333, 5: 0.9871222222222222}\n" + "{1: 0.9011941225982673, 2: 0.964656389818477, 3: 0.9833291298913164, 4: 0.9873373238881291, 5: 0.9887056900094}\n" ] } ], @@ -503,7 +686,17 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n", + "data.load_pen_digit()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "id": "a4675b42", "metadata": {}, "outputs": [ @@ -512,7 +705,7 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 2\n", - "fit_time: 1.8162589073181152\n" + "fit_time: 1.8434288501739502\n" ] } ], @@ -549,7 +742,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 17, "id": "fa3d0039-5d50-4aa8-ac91-f76a83513315", "metadata": {}, "outputs": [ @@ -564,7 +757,7 @@ " 0.01140402, 0.02230902, 0.04476067, 0.0622557 , 0.02477818])" ] }, - "execution_count": 66, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -612,7 +805,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -654,7 +847,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -668,7 +861,7 @@ " 0.01140395, 0.02230897, 0.0447607 , 0.06225568, 0.02477822])" ] }, - "execution_count": 68, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -686,7 +879,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -702,7 +895,7 @@ " -1.84955282e-08, 4.06431382e-08])" ] }, - "execution_count": 69, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -713,7 +906,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -729,7 +922,7 @@ " -2.30290380e-09, 2.01412728e-09])" ] }, - "execution_count": 70, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -740,7 +933,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -754,7 +947,7 @@ " 0.00013005, 0.00049769, 0.00200352, 0.00387577, 0.00061396])" ] }, - "execution_count": 71, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -772,7 +965,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 23, "id": "7b24a162-ab61-42ec-92d0-31067441e1ea", "metadata": {}, "outputs": [ @@ -787,7 +980,7 @@ " 0.17178055, 0.20218662, 0.50789135, 0.46324354, 0.28108907])" ] }, - "execution_count": 72, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -842,7 +1035,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -884,7 +1077,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -898,7 +1091,7 @@ " 0.17178056, 0.2021866 , 0.57933628, 0.51903326, 0.2810891 ])" ] }, - "execution_count": 74, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -909,7 +1102,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -925,7 +1118,7 @@ " 5.57897248e-02, 2.18613811e-08])" ] }, - "execution_count": 75, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -936,7 +1129,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -952,7 +1145,7 @@ " 5.48009526e-02, 1.22899913e-08])" ] }, - "execution_count": 76, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -963,7 +1156,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -977,7 +1170,7 @@ " 0.02950856, 0.04087943, 0.25795362, 0.21459458, 0.07901107])" ] }, - "execution_count": 77, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -997,7 +1190,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -1005,7 +1198,7 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 4\n", - "fit_time: 1.6098101139068604\n" + "fit_time: 1.430413007736206\n" ] } ], @@ -1045,22 +1238,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.02203349, 0.02636506, 0.01619603, 0.01555797, 0.11322956,\n", - " 0.03182318, 0.02529738, 0.09760276, 0.01769069, 0.0184093 ,\n", - " 0.03047298, 0.01305365, 0.02557788, 0.07339483, 0.01822537,\n", - " 0.07480418, 0.02407774, 0.17452867, 0.03732281, 0.10320762,\n", - " 0.01851509, 0.01398619, 0.01354817, 0.01247237, 0.02372335,\n", - " 0.01140402, 0.02230902, 0.04476067, 0.0622557 , 0.02477818])" + "array([0.03967368, 0.05504551, 0.03504564, 0.02803283, 0.79020922,\n", + " 0.09154701, 0.03940445, 0.60588296, 0.05382921, 0.06642338,\n", + " 0.07546608, 0.04712497, 0.05999965, 0.27495271, 0.04513804,\n", + " 0.39363567, 0.08103536, 1.12660816, 0.13128976, 0.72245753,\n", + " 0.06584402, 0.03196867, 0.027194 , 0.06510804, 0.05253451,\n", + " 0.03191912, 0.04620369, 0.1064269 , 0.21951494, 0.04757212])" ] }, + "execution_count": 30, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ @@ -1106,7 +1300,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -1148,7 +1342,7 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -1162,7 +1356,7 @@ " 0.03191909, 0.04620365, 0.10642693, 0.21951484, 0.04757213])" ] }, - "execution_count": 83, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -1180,7 +1374,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -1196,7 +1390,7 @@ " -9.88227740e-08, 3.03806841e-09])" ] }, - "execution_count": 84, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1207,7 +1401,7 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -1223,7 +1417,7 @@ " -4.33861402e-08, 2.89054748e-10])" ] }, - "execution_count": 85, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -1234,7 +1428,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -1250,7 +1444,7 @@ " 4.81868075e-02, 2.26310705e-03])" ] }, - "execution_count": 86, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -1268,22 +1462,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.67234355, 0.24378292, 0.12239675, 0.25943279, 0.24765937,\n", - " 0.1254194 , 0.21369962, 0.2074082 , 0.70915455, 0.71401428,\n", - " 0.23341584, 0.55010932, 0.183303 , 0.28309619, 0.24274553,\n", - " 0.27733141, 0.74215366, 0.43625736, 0.62571778, 0.26774459,\n", - " 0.22821209, 0.70655546, 0.45673412, 0.43718578, 0.09406633,\n", - " 0.17178055, 0.20218662, 0.50789135, 0.46324354, 0.28108907])" + "array([15.6873491 , 2.88892816, 0.55714133, 1.50823109, 1.56758003,\n", + " 1.00905707, 2.91069481, 2.05114589, 18.6500547 , 17.46589895,\n", + " 2.3150778 , 11.18594351, 2.08877219, 3.58965701, 2.07437675,\n", + " 1.70494207, 16.20276447, 11.34922213, 14.22447325, 1.79131631,\n", + " 1.72692849, 17.42246739, 10.45685982, 11.10302002, 0.40264413,\n", + " 1.66121199, 2.47344412, 8.7943693 , 10.39406576, 3.76990881])" ] }, + "execution_count": 36, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ @@ -1336,7 +1531,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -1378,7 +1573,7 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 38, "metadata": {}, "outputs": [ { @@ -1392,7 +1587,7 @@ " 1.66121225, 2.47344389, 8.79436819, 10.39406662, 3.76990895])" ] }, - "execution_count": 88, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -1403,7 +1598,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -1419,7 +1614,7 @@ " 8.65130316e-07, 1.41124838e-07])" ] }, - "execution_count": 89, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -1430,7 +1625,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -1446,7 +1641,7 @@ " 1.79844435e-05, 1.06405556e-06])" ] }, - "execution_count": 90, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -1457,7 +1652,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -1473,7 +1668,7 @@ " 1.08036603e+02, 1.42122124e+01])" ] }, - "execution_count": 91, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -1494,20 +1689,23 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 42, "id": "9f49674f-86c7-4d6e-88f9-98218ab69be3", "metadata": {}, "outputs": [], "source": [ + "# data = Data.Data(\n", + "# n_samples=(800, 30, 30),\n", + "# if_sample=True,\n", + "# )\n", "data = Data.Data(\n", - " n_samples=(800, 30, 30),\n", - " if_sample=True,\n", + " if_sample=False,\n", ")" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 43, "id": "60165b32-c950-4b0c-9526-3edcb7674e62", "metadata": {}, "outputs": [ @@ -1515,12 +1713,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "fit_time: 2.3705170154571533\n" + "Threshold distance: 4000\n", + "lead_lag: True\n", + "inv_reset: True\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 28.16247797012329\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1532,14 +1736,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.34459805488586426\n", - "lead_lag: True inv_rest: True thres_distance: 4000 auc: 0.8366666666666667\n", - "fit_time: 2.4763379096984863\n" + "compute_auc_time: 334.30816102027893\n", + "lead_lag: True inv_rest: True thres_distance: 4000 auc: 0.58982578\n", + "Threshold distance: 8000\n", + "lead_lag: True\n", + "inv_reset: True\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 19.43948984146118\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1551,14 +1761,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.39705705642700195\n", - "lead_lag: True inv_rest: True thres_distance: 8000 auc: 0.7566666666666667\n", - "fit_time: 2.4723050594329834\n" + "compute_auc_time: 324.3790829181671\n", + "lead_lag: True inv_rest: True thres_distance: 8000 auc: 0.62241958\n", + "Threshold distance: 16000\n", + "lead_lag: True\n", + "inv_reset: True\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 20.56976008415222\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1570,14 +1786,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.361522912979126\n", - "lead_lag: True inv_rest: True thres_distance: 16000 auc: 0.7677777777777778\n", - "fit_time: 2.7211780548095703\n" + "compute_auc_time: 328.6247320175171\n", + "lead_lag: True inv_rest: True thres_distance: 16000 auc: 0.74234436\n", + "Threshold distance: 32000\n", + "lead_lag: True\n", + "inv_reset: True\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 21.32947611808777\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1589,14 +1811,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.41321396827697754\n", - "lead_lag: True inv_rest: True thres_distance: 32000 auc: 0.78\n", - "fit_time: 1.8937711715698242\n" + "compute_auc_time: 328.09489011764526\n", + "lead_lag: True inv_rest: True thres_distance: 32000 auc: 0.8437179\n", + "Threshold distance: 4000\n", + "lead_lag: True\n", + "inv_reset: False\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 15.19601583480835\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAHcCAYAAABxixZDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACbqElEQVR4nOzdd1hT1xsH8C8gG0UUUUQUnLiqFvceVNx1ghuts26te2utOOpondW6a92zrdq6d91a98YNigo42Dm/P84vgZigCQIXwvfzPDzce3Jz8yaXJC/nnvseMyGEABERERGlGXOlAyAiIiLKbJiAEREREaUxJmBEREREaYwJGBEREVEaYwJGRERElMaYgBERERGlMSZgRERERGmMCRgRERFRGmMCRkRERJTGmIARfQYPDw906dJF6TAyndq1a6N27dpKh/FJEydOhJmZGUJDQ5UOJd0xMzPDxIkTU2RfQUFBMDMzw8qVK1Nkf0RpgQkYpVsrV66EmZmZ5idLlixwc3NDly5d8OTJE6XDS9fevXuH77//Hl988QXs7Ozg6OiIGjVqYPXq1cgos49du3YNEydORFBQkNKh6IiPj8eKFStQu3Zt5MiRA9bW1vDw8EDXrl1x9uxZpcNLEb///jvmzp2rdBha0mNMRMmVRekAiD5l8uTJ8PT0RFRUFP7991+sXLkSx44dw5UrV2BjY6NobDdv3oS5efr6PyYkJAT16tXD9evX0bZtW/Tr1w9RUVHYsmULAgICsGvXLqxduxYWFhZKh/pR165dw6RJk1C7dm14eHho3fbPP/8oExSAyMhItGzZEnv27EHNmjUxevRo5MiRA0FBQdi4cSNWrVqFhw8fIl++fIrFmBJ+//13XLlyBYMGDUqV/UdGRiJLFuO+gpKKqUCBAoiMjISlpWUKRkiUupiAUbrXsGFDlC9fHgDQvXt3ODs7Y/r06di5cyf8/PwUjc3a2jrNHzMqKgpWVlZJJn4BAQG4fv06tm3bhmbNmmnaBwwYgGHDhuHHH39EuXLlMGLEiLQKGYDslbO3t0+RfVlZWaXIfpJj2LBh2LNnD+bMmaOTCEyYMAFz5sxJ03iEEIiKioKtrW2aPm5yqFQqxMTEwMbGJkX/eTIzM1P8nzEiowmidGrFihUCgDhz5oxW+59//ikAiKlTp2q1X79+XbRq1Uo4OTkJa2tr4e3tLXbs2KGz39evX4tBgwaJAgUKCCsrK+Hm5iY6deokXrx4odkmKipKjB8/XhQqVEhYWVmJfPnyiWHDhomoqCitfRUoUEAEBAQIIYQ4c+aMACBWrlyp85h79uwRAMQff/yhaXv8+LHo2rWrcHFxEVZWVqJEiRJi2bJlWvc7ePCgACDWrVsnxowZI/LmzSvMzMzE69ev9b5mJ0+eFADEN998o/f22NhYUaRIEeHk5CTev38vhBDi/v37AoCYOXOmmD17tsifP7+wsbERNWvWFJcvX9bZhyGvs/rYHTp0SHz77bciV65cInv27EIIIYKCgsS3334rihYtKmxsbESOHDlE69atxf3793Xu/+HPwYMHhRBC1KpVS9SqVUvnddqwYYOYMmWKcHNzE9bW1qJu3bri9u3bOs9h/vz5wtPTU9jY2IgKFSqII0eO6OxTn0ePHoksWbKIr7766qPbqU2YMEEAELdv3xYBAQHC0dFRZMuWTXTp0kW8e/dOa9vly5eLOnXqiFy5cgkrKytRvHhxsXDhQp19FihQQDRu3Fjs2bNHeHt7C2trazFnzhyj9iGEELt27RI1a9YUDg4OImvWrKJ8+fJi7dq1Qgj5+n742hcoUEBzX0PfHwBE3759xW+//SZKlCghsmTJIrZt26a5bcKECZptIyIixMCBAzXvy1y5cgkfHx9x7ty5T8ak/htesWKF1uNfv35dtGnTRjg7OwsbGxtRtGhRMXr06I8dMqI0wx4wynDUY4KcnJw0bVevXkW1atXg5uaGkSNHwt7eHhs3bkTz5s2xZcsWtGjRAgDw9u1b1KhRA9evX8c333yDL7/8EqGhodi5cyceP34MZ2dnqFQqNGvWDMeOHUPPnj1RvHhxXL58GXPmzMGtW7ewfft2vXGVL18eBQsWxMaNGxEQEKB124YNG+Dk5ARfX18A8jRh5cqVYWZmhn79+iFXrlzYvXs3unXrhoiICJ2ele+//x5WVlYYOnQooqOjk+wB+uOPPwAAnTt31nt7lixZ0L59e0yaNAnHjx+Hj4+P5rbVq1fjzZs36Nu3L6KiovDTTz+hbt26uHz5MnLnzm3U66zWp08f5MqVC+PHj8e7d+8AAGfOnMGJEyfQtm1b5MuXD0FBQVi0aBFq166Na9euwc7ODjVr1sSAAQPw888/Y/To0ShevDgAaH4nZdq0aTA3N8fQoUMRHh6OGTNmoEOHDjh16pRmm0WLFqFfv36oUaMGBg8ejKCgIDRv3hxOTk6fPG24e/duxMXFoVOnTh/d7kN+fn7w9PREYGAgzp8/j19//RUuLi6YPn26VlwlS5ZEs2bNkCVLFvzxxx/o06cPVCoV+vbtq7W/mzdvol27dujVqxd69OiBYsWKGbWPlStX4ptvvkHJkiUxatQoZM+eHRcuXMCePXvQvn17jBkzBuHh4Xj8+LGmR8/BwQEAjH5/HDhwABs3bkS/fv3g7OysczpZrXfv3ti8eTP69euHEiVK4OXLlzh27BiuX7+OL7/88qMx6fPff/+hRo0asLS0RM+ePeHh4YG7d+/ijz/+wA8//GDYgSNKTUpngERJUfeC7Nu3T7x48UI8evRIbN68WeTKlUtYW1uLR48eabatV6+eKF26tNZ/4CqVSlStWlUUKVJE0zZ+/HgBQGzdulXn8VQqlRBCiDVr1ghzc3Nx9OhRrdsXL14sAIjjx49r2hL3gAkhxKhRo4SlpaV49eqVpi06Olpkz55dq1eqW7duwtXVVYSGhmo9Rtu2bYWjo6Omd0rds1OwYEFN28c0b95cAEiyh0wIIbZu3SoAiJ9//lkIkdB7YGtrKx4/fqzZ7tSpUwKAGDx4sKbN0NdZfeyqV68u4uLitB5f3/NQ99ytXr1a07Zp0yatXq/EkuoBK168uIiOjta0//TTTwKApicvOjpa5MyZU1SoUEHExsZqtlu5cqUA8MkesMGDBwsA4sKFCx/dTk3dA/Zhj2SLFi1Ezpw5tdr0vS6+vr6iYMGCWm0FChQQAMSePXt0tjdkH2FhYSJr1qyiUqVKIjIyUmtb9XtACCEaN26s1eulZsz7A4AwNzcXV69e1dkPPugBc3R0FH379tXZLrGkYtLXA1azZk2RNWtW8eDBgySfI5GS0tfoYSI9fHx8kCtXLri7u6N169awt7fHzp07Nb0Vr169woEDB+Dn54c3b94gNDQUoaGhePnyJXx9fXH79m3NVZNbtmxBmTJldHpqADmOBAA2bdqE4sWLw8vLS7Ov0NBQ1K1bFwBw8ODBJGP19/dHbGwstm7dqmn7559/EBYWBn9/fwByzM6WLVvQtGlTCCG0HsPX1xfh4eE4f/681n4DAgIMGuPz5s0bAEDWrFmT3EZ9W0REhFZ78+bN4ebmplmvWLEiKlWqhF27dgEw7nVW69Gjh85g/8TPIzY2Fi9fvkThwoWRPXt2nedtrK5du2r1DtaoUQMAcO/ePQDA2bNn8fLlS/To0UNrAHiHDh20elSTon7NPvb66tO7d2+t9Ro1auDly5daxyDx6xIeHo7Q0FDUqlUL9+7dQ3h4uNb9PT09Nb2piRmyj7179+LNmzcYOXKkzrgp9XvgY4x9f9SqVQslSpT45H6zZ8+OU6dO4enTp5/c9lNevHiBI0eO4JtvvkH+/Pm1bjPkORKlBZ6CpHRvwYIFKFq0KMLDw7F8+XIcOXJEa/D7nTt3IITAuHHjMG7cOL37eP78Odzc3HD37l20atXqo493+/ZtXL9+Hbly5UpyX0kpU6YMvLy8sGHDBnTr1g2APP3o7Oys+YJ68eIFwsLCsGTJEixZssSgx/D09PxozGrqxODNmzfInj273m2SStKKFCmis23RokWxceNGAMa9zh+LOzIyEoGBgVixYgWePHmiVRbjw0TDWB9+2aqTqtevXwMAHjx4AAAoXLiw1nZZsmRJ8tRYYtmyZQOQ8BqmRFzqfR4/fhwTJkzAyZMn8f79e63tw8PD4ejoqFlP6u/BkH3cvXsXAFCqVCmjnoOase8PQ/92Z8yYgYCAALi7u8Pb2xuNGjVC586dUbBgQaNjVCfcyX2ORGmBCRilexUrVtRcBdm8eXNUr14d7du3x82bN+Hg4ACVSgUAGDp0qN5eAUD3C/djVCoVSpcujdmzZ+u93d3d/aP39/f3xw8//IDQ0FBkzZoVO3fuRLt27TQ9Lup4O3bsqDNWTO2LL77QWjf0CrfixYtj+/bt+O+//1CzZk292/z3338AYFCvRGLJeZ31xd2/f3+sWLECgwYNQpUqVeDo6AgzMzO0bdtW8xjJlVRpDZFCtc+8vLwAAJcvX0bZsmUNvt+n4rp79y7q1asHLy8vzJ49G+7u7rCyssKuXbswZ84cnddF3+tq7D6Sy9j3h6F/u35+fqhRowa2bduGf/75BzNnzsT06dOxdetWNGzY8LPjJkpvmIBRhmJhYYHAwEDUqVMH8+fPx8iRIzX/IVtaWmoNKtenUKFCuHLlyie3uXTpEurVq5es0xX+/v6YNGkStmzZgty5cyMiIgJt27bV3J4rVy5kzZoV8fHxn4zXWE2aNEFgYCBWr16tNwGLj4/H77//DicnJ1SrVk3rttu3b+tsf+vWLU3PkDGv88ds3rwZAQEBmDVrlqYtKioKYWFhWtulxqmiAgUKAJC9eXXq1NG0x8XFISgoSCfx/VDDhg1hYWGB3377zeiB+B/zxx9/IDo6Gjt37tTqLfvY6e7k7qNQoUIAgCtXrnz0H5OkXv/PfX98jKurK/r06YM+ffrg+fPn+PLLL/HDDz9oEjBDH0/9t/qp9zqRkjgGjDKc2rVro2LFipg7dy6ioqLg4uKC2rVr45dffsGzZ890tn/x4oVmuVWrVrh06RK2bdums526N8LPzw9PnjzB0qVLdbaJjIzUXM2XlOLFi6N06dLYsGEDNmzYAFdXV61kyMLCAq1atcKWLVv0fkEkjtdYVatWhY+PD1asWIE///xT5/YxY8bg1q1bGD58uE7PxPbt27XGcJ0+fRqnTp3SfPkZ8zp/jIWFhU6P1Lx58xAfH6/Vpq4Z9mFi9jnKly+PnDlzYunSpYiLi9O0r127VnOa8mPc3d3Ro0cP/PPPP5g3b57O7SqVCrNmzcLjx4+NikvdQ/bh6dgVK1ak+D7q16+PrFmzIjAwEFFRUVq3Jb6vvb293lPCn/v+0Cc+Pl7nsVxcXJA3b15ER0d/MqYP5cqVCzVr1sTy5cvx8OFDrdtSqjeU6HOxB4wypGHDhqFNmzZYuXIlevfujQULFqB69eooXbo0evTogYIFCyIkJAQnT57E48ePcenSJc39Nm/ejDZt2uCbb76Bt7c3Xr16hZ07d2Lx4sUoU6YMOnXqhI0bN6J37944ePAgqlWrhvj4eNy4cQMbN27E33//rTklmhR/f3+MHz8eNjY26Natm07R1GnTpuHgwYOoVKkSevTogRIlSuDVq1c4f/489u3bh1evXiX7tVm9ejXq1auHr7/+Gu3bt0eNGjUQHR2NrVu34tChQ/D398ewYcN07le4cGFUr14d3377LaKjozF37lzkzJkTw4cP12xj6Ov8MU2aNMGaNWvg6OiIEiVK4OTJk9i3bx9y5syptV3ZsmVhYWGB6dOnIzw8HNbW1qhbty5cXFyS/dpYWVlh4sSJ6N+/P+rWrQs/Pz8EBQVh5cqVKFSokEE9LLNmzcLdu3cxYMAAbN26FU2aNIGTkxMePnyITZs24caNG1o9noaoX78+rKys0LRpU/Tq1Qtv377F0qVL4eLiojfZ/Zx9ZMuWDXPmzEH37t1RoUIFtG/fHk5OTrh06RLev3+PVatWAQC8vb2xYcMGDBkyBBUqVICDgwOaNm2aIu+PD7158wb58uVD69atUaZMGTg4OGDfvn04c+aMVk9pUjHp8/PPP6N69er48ssv0bNnT3h6eiIoKAh//fUXLl68aFR8RKlCkWsviQyQVCFWIYSIj48XhQoVEoUKFdKUObh7967o3LmzyJMnj7C0tBRubm6iSZMmYvPmzVr3ffnypejXr59wc3PTFJEMCAjQKgkRExMjpk+fLkqWLCmsra2Fk5OT8Pb2FpMmTRLh4eGa7T4sQ6F2+/ZtTbHIY8eO6X1+ISEhom/fvsLd3V1YWlqKPHnyiHr16oklS5ZotlGXV9i0aZNRr92bN2/ExIkTRcmSJYWtra3ImjWrqFatmli5cqXOZfiJC7HOmjVLuLu7C2tra1GjRg1x6dIlnX0b8jp/7Ni9fv1adO3aVTg7OwsHBwfh6+srbty4ofe1XLp0qShYsKCwsLAwqBDrh69TUgU6f/75Z1GgQAFhbW0tKlasKI4fPy68vb1FgwYNDHh1hYiLixO//vqrqFGjhnB0dBSWlpaiQIEComvXrlolKtRlKBIX+U38+iQuPrtz507xxRdfCBsbG+Hh4SGmT58uli9frrOduhCrPobuQ71t1apVha2trciWLZuoWLGiWLduneb2t2/fivbt24vs2bPrFGI19P2B/xdi1QeJylBER0eLYcOGiTJlyoisWbMKe3t7UaZMGZ0isknFlNRxvnLlimjRooXInj27sLGxEcWKFRPjxo3TGw9RWjMTgv2xRJlZUFAQPD09MXPmTAwdOlTpcBShUqmQK1cutGzZUu+pNSKilMYxYESUqURFRemMA1q9ejVevXqF2rVrKxMUEWU6HANGRJnKv//+i8GDB6NNmzbImTMnzp8/j2XLlqFUqVJo06aN0uERUSbBBIyIMhUPDw+4u7vj559/xqtXr5AjRw507twZ06ZNS3KOTSKilMYxYERERERpjGPAiIiIiNIYEzAiIiKiNKZoAnbo0CGYmZlh8+bNSoahkRrxTJw40eDpM8zMzDBx4sRkPY469kOHDmnaunTpYtAEw5TxmJmZYeXKlZ/cTsm/gdq1axt9VWFy7pPZrVy5Mk0+Yyj16fscTyszZsyAl5fXJ+cMDQoKMvjzJzWo/97Pnj2ryOMntmfPHjg4OCR79pIUT8DMzMwM+lHiD4w+7dq1a5g4cSKCgoKUDiXNxMbGokSJEjAzM8OPP/6oc7tKpcKMGTPg6ekJGxsbfPHFF1i3bp3efV2/fh0NGjSAg4MDcuTIgU6dOul9cxqzT0p76i8ZQ34y03vFFE2dOhXbt2//rH2okwJ9PyNHjkyZQFNRREQEpk+fjhEjRujM2qGUhQsXKpbkTZ06FZUrV0auXLlgY2ODIkWKYNCgQTqf5Q0aNEDhwoURGBiYrMdJ8asg16xZo7W+evVq7N27V6e9ePHiuH79eko/PCWydOnST/4386Fr165h0qRJqF27dqbpPZs3b57OfHGJjRkzBtOmTUOPHj1QoUIF7NixA+3bt4eZmZnWlDOPHz9GzZo14ejoiKlTp+Lt27f48ccfcfnyZZw+fVrrCjtD90nKyJUrl85nlnqOxzlz5uhsm1FERkYiSxZe/J7Y1KlT0bp1azRv3vyz9zV58mR4enpqtZUqVeqz95vali9fjri4OLRr107pUDQWLlwIZ2dndOnSJc0f+9y5cyhbtizatm2LrFmz4vr161i6dKlmGiv1PLUA0KtXLwwdOhSTJk1C1qxZjXqcFH8nduzYUWv933//xd69e3XaAXx2Avb+/XvY2dl91j5MmaWlpdIhpHvPnz/H5MmTMWLECIwfP17n9idPnmDWrFno27cv5s+fDwDo3r07atWqpZmPUj0J8tSpU/Hu3TucO3cO+fPnBwBUrFgRX331FVauXImePXsavU9Shr29vc5n1vr16/H69Wu9n2VqQghERUXpTHSeXtjY2Cgdgl6m8lnesGFDo+fBTA9WrFiBZs2apdu/j7S2ZcsWnbYqVaqgdevW+OOPP7T+SW7VqhX69++PTZs24ZtvvjHqcdJFX6NKpcIPP/yAfPnywcbGBvXq1cOdO3e0tqlduzZKlSqFc+fOoWbNmrCzs8Po0aMBANHR0ZgwYQIKFy4Ma2truLu7Y/jw4YiOjtbax969e1G9enVkz54dDg4OKFasmGYfxsYDAJs2bYK3tzdsbW3h7OyMjh074smTJ598vtHR0Rg8eDBy5cqFrFmzolmzZnj8+LHBr9fjx4/RvHlz2Nvbw8XFBYMHD9Z5roD+8T/r16+Ht7c3smbNimzZsqF06dL46aefAMhudHUhyjp16uicLt6xYwcaN26MvHnzwtraGoUKFcL333+P+Ph4rcdQH6tr166hTp06sLOzg5ubG2bMmKETY1RUFCZOnIiiRYvCxsYGrq6uaNmyJe7evavZRqVSYe7cuShZsiRsbGyQO3du9OrVC69fv9baV3h4OG7cuIHw8HCDX8uRI0eiWLFiSX6p7tixA7GxsejTp4+mzczMDN9++y0eP36MkydPatq3bNmCJk2aaJIvAPDx8UHRokWxcePGZO0zNRj6ehp6vAFgyZIlKFSoEGxtbVGxYkUcPXo0RWKNiYnB+PHj4e3tDUdHR9jb26NGjRo4ePCgzrYvX75Ep06dkC1bNmTPnh0BAQG4dOmSzniV2NhY3Lhxw+BJrj/Gw8MDTZo00UxAbWtri19++eWj42T0jcN68uQJvvnmG+TOnRvW1tYoWbIkli9f/tnxfeqx1WNU79y5gy5duiB79uxwdHRE165d8f79e812pUqVQp06dXT2p1Kp4ObmhtatWxscQ1p9lhuyLzMzM7x79w6rVq3SfN4l7nG5cePGR3vHDfXgwQP06dMHxYoVg62tLXLmzIk2bdoYdPr69u3baNWqFfLkyQMbGxvky5cPbdu21fmc++233zTfRzly5EDbtm3x6NGjT+7//v37+O+//+Dj46NzW1hYGLp06QJHR0fNeyosLEzvfm7cuIHWrVsjR44csLGxQfny5bFz506tbdSnao8cOYJevXohZ86cyJYtGzp37qz1+ePh4YGrV6/i8OHDmuPy4djQ6OhoDBkyBLly5YK9vT1atGiR7LFYhlB/l374/F1cXPDFF19gx44dRu8zXfRFT5s2Debm5hg6dCjCw8MxY8YMdOjQAadOndLa7uXLl2jYsCHatm2Ljh07Infu3FCpVGjWrBmOHTuGnj17onjx4rh8+TLmzJmDW7duac7tX716FU2aNMEXX3yByZMnw9raGnfu3MHx48eTFc/KlSvRtWtXVKhQAYGBgQgJCcFPP/2E48eP48KFC8iePXuSz7d79+747bff0L59e1StWhUHDhxA48aNDXqtIiMjUa9ePTx8+BADBgxA3rx5sWbNGhw4cOCT9927dy/atWuHevXqYfr06QBkL+Tx48cxcOBA1KxZEwMGDMDPP/+M0aNHo3jx4gCg+b1y5Uo4ODhgyJAhcHBwwIEDBzB+/HhERERg5syZWo/1+vVrNGjQAC1btoSfnx82b96MESNGoHTp0mjYsCEAID4+Hk2aNMH+/fvRtm1bDBw4EG/evMHevXtx5coVFCpUCIDs4lW/3gMGDMD9+/cxf/58XLhwAcePH9f09G3btg1du3bFihUrDOq2Pn36NFatWoVjx44lOYj5woULsLe317wGahUrVtTcXr16dTx58gTPnz/X+99vxYoVsWvXLqP3mVoMfT0NPd7Lli1Dr169ULVqVQwaNAj37t1Ds2bNkCNHDri7u39WrBEREfj111/Rrl079OjRA2/evMGyZcvg6+uL06dPo2zZsgBkItC0aVOcPn0a3377Lby8vLBjxw4EBATo7PPJkycoXrw4AgICUmSMyc2bN9GuXTv06tULPXr0QLFixYy6f0hICCpXrgwzMzP069cPuXLlwu7du9GtWzdERERg0KBBnx3jp/j5+cHT0xOBgYE4f/48fv31V7i4uGg+J/z9/TFx4kQEBwcjT548mvsdO3YMT58+Nfq0eWp/lhu6rzVr1qB79+6oWLGipoda/bkDyM++WrVqGTxmOTw8HKGhoVptzs7OOHPmDE6cOIG2bdsiX758CAoKwqJFi1C7dm1cu3Ytyd6/mJgY+Pr6Ijo6Gv3790eePHnw5MkT/PnnnwgLC4OjoyMA4IcffsC4cePg5+eH7t2748WLF5g3bx5q1qz5ye+jEydOAAC+/PJLrXYhBL7++mscO3YMvXv3RvHixbFt2za976mrV6+iWrVqcHNzw8iRI2Fvb4+NGzeiefPm2LJlC1q0aKG1fb9+/ZA9e3ZMnDgRN2/exKJFi/DgwQPNRQhz585F//794eDggDFjxgAAcufOrbWP/v37w8nJCRMmTEBQUBDmzp2Lfv36YcOGDZpt3r59i6ioqCSfu5qlpaXmtUz8/F++fIm4uDjcvn0bI0eOhIWFhd6LhLy9vZM3jjC1Z/vu27evSOphDh48KACI4sWLi+joaE37Tz/9JACIy5cva9pq1aolAIjFixdr7WPNmjXC3NxcHD16VKt98eLFAoA4fvy4EEKIOXPmCADixYsXScZqaDwxMTHCxcVFlCpVSkRGRmq2+/PPPwUAMX78eE3bhAkTtJ7/xYsXBQDRp08frcdu3769ACAmTJiQZHxCCDF37lwBQGzcuFHT9u7dO1G4cGEBQBw8eFDTHhAQIAoUKKBZHzhwoMiWLZuIi4tLcv+bNm3S2Y/a+/fvddp69eol7OzsRFRUlKZNfaxWr16taYuOjhZ58uQRrVq10rQtX75cABCzZ8/W2a9KpRJCCHH06FEBQKxdu1br9j179ui0r1ixQgAQK1asSPL5Jd5/xYoVRbt27YQQQty/f18AEDNnztTarnHjxqJgwYI693/37p0AIEaOHCmEEOLMmTM6z1lt2LBhAoDmNTJ0nx9j6PP88G/AmNfTkOOtfi+ULVtW6z2zZMkSAUDUqlXrkzEmVqtWLa37xMXFae1XCCFev34tcufOLb755htN25YtWwQAMXfuXE1bfHy8qFu3rs5rpT7WAQEBRsXWuHFjrddSCCEKFCggAIg9e/ZotasfQ98x+vB93q1bN+Hq6ipCQ0O1tmvbtq1wdHTUexwSU//dG+LDx1Z/PiV+LYUQokWLFiJnzpya9Zs3bwoAYt68eVrb9enTRzg4OHwyxsTS4rPc0H0JIYS9vX2SfwuG/g2rj4G+HyH0v5dOnjyp85mh/g5Sf/5euHBBABCbNm1K8rGDgoKEhYWF+OGHH7TaL1++LLJkyaLT/qGxY8cKAOLNmzda7du3bxcAxIwZMzRtcXFxokaNGjp/2/Xq1ROlS5fW+h5QqVSiatWqokiRIpo29evk7e0tYmJiNO0zZswQAMSOHTs0bSVLltT72qv34ePjo/meEEKIwYMHCwsLCxEWFqZpCwgISPK4JP7R9zjPnj3T2iZfvnxiw4YNel/DqVOnCgAiJCRE7+1JSRenILt27ao1QLlGjRoAgHv37mltZ21tja5du2q1bdq0CcWLF4eXlxdCQ0M1P3Xr1gUAzakK9X8AO3bs+OTA9E/Fc/bsWTx//hx9+vTROmfeuHFjeHl54a+//kpy3+qekAEDBmi1G/pf7q5du+Dq6qrV5W9nZ6f57+1jsmfPjnfv3mHv3r0GPdaHEo9refPmDUJDQ1GjRg28f/8eN27c0NrWwcFB67SelZUVKlasqHVMt2zZAmdnZ/Tv31/nsdQ9Ups2bYKjoyO++uorrePr7e0NBwcHrVNRXbp0gRDCoN6vlStX4vLly5r/8JMSGRkJa2trnXb1cY+MjNT6bei2hmyXGox5PQ053ur3Qu/evbXeM+rTFp/LwsJCs1+VSoVXr14hLi4O5cuXx/nz5zXb7dmzB5aWlujRo4emzdzcHH379tXZp4eHB4QQKXaFlaenJ3x9fZN1XyEEtmzZgqZNm0IIoXVMfH19ER4ervU8U0vv3r211mvUqIGXL18iIiICAFC0aFGULVtWq3chPj4emzdvRtOmTY0e85ban+WG7utThBBGXbG/YMEC7N27V+sH0H4vxcbG4uXLlyhcuDCyZ8/+0eOrfg/9/fffWqeEE9u6dStUKhX8/Py0nmuePHlQpEiRTz7Xly9fIkuWLHBwcNBq37VrF7JkyYJvv/1W02ZhYaHzef3q1SscOHAAfn5+ms+J0NBQvHz5Er6+vrh9+7bO0JyePXtqjVH+9ttvkSVLFq0zBZ/Ss2dPrTMXNWrUQHx8PB48eKBpGz58uM7x0Pcza9Ysnf3nyJEDe/fuxR9//IHJkyfD2dkZb9++1RuLk5MTAOj0fn5KujgFmXjMDJDwZD4ck+Lm5qYzV9vt27dx/fr1JK9Eev78OQDZhf7rr7+ie/fuGDlyJOrVq4eWLVuidevWOpfdfioe9QHWd6rBy8sLx44dS/K5PnjwAObm5lrd3EntK6n7Fy5cWOeUmSH379OnDzZu3IiGDRvCzc0N9evXh5+fHxo0aGDQY1+9ehVjx47FgQMHNB/Mah+OR8iXL59OjE5OTvjvv/8063fv3kWxYsU+elXW7du3ER4eDhcXF723q4+vMSIiIjBq1CgMGzbsk6fIbG1t9Y6vU3drqz9Y1b8N3daQ7VKDMa+nIcdb/V4oUqSI1u2WlpYoWLBgisS8atUqzJo1Czdu3EBsbKymPfHVZg8ePICrq6vOqZzChQunSAwf8+FVb8Z48eIFwsLCsGTJEixZskTvNsn5GzfWxz7zsmXLBkB+ho4ePRpPnjyBm5sbDh06hOfPn8Pf39/ox0vtz3JD95XSKlasqHcYQmRkJAIDA7FixQo8efIEItEMgB8bs+rp6YkhQ4Zg9uzZWLt2LWrUqIFmzZqhY8eOmuTs9u3bEELovAfVknsxlvo99WFi9uF3zZ07dyCEwLhx4zBu3Di9+3r+/Dnc3Nw06x/G6uDgAFdXV6NKuhiSN5QoUQIlSpQweJ+JWVlZacbFNWnSBPXq1UO1atXg4uKCJk2aaG2rPp6G1uNTSxcJWFJXfCX+IwX0fzGpVCqULl0as2fP1rsP9Resra0tjhw5goMHD+Kvv/7Cnj17sGHDBtStWxf//POPVgyGxpPRuLi44OLFi/j777+xe/du7N69GytWrEDnzp2xatWqj943LCwMtWrVQrZs2TB58mQUKlQINjY2OH/+PEaMGKHzn2hKvYYqlQouLi5Yu3at3tuTUwLgxx9/RExMDPz9/TVvePVFEK9fv0ZQUBDy5s0LKysruLq64uDBgxBCaL251AO48+bNCwBwdXXVak/s2bNnyJEjh6bXy9B9pgZDX09jj3dq+e2339ClSxc0b94cw4YNg4uLCywsLBAYGKh1oYaS9H0uJfVB/OEFDOrXsWPHjnrH1gDAF1988ZkRfpoh71d/f3+MGjUKmzZtwqBBg7Bx40Y4Ojoa/A9cYqn9WW7ovtJK//79sWLFCgwaNAhVqlSBo6OjpuTMp95Ls2bNQpcuXbBjxw78888/GDBgAAIDA/Hvv/8iX758UKlUMDMzw+7du/Uexw8TqA/lzJkTcXFxePPmjdFlFICEv+GhQ4cm2ROcGv8IGfI3Gx4ebtAZBSsrK+TIkeOj21StWhWurq5Yu3atTgKmTvqcnZ0/+ViJpYsE7HMUKlQIly5dQr169T6ZfZqbm6NevXqoV68eZs+ejalTp2LMmDE4ePCg3itAklKgQAEAcvCtuktb7ebNm5rbk7qvSqXS9P4kvp+hj33lyhWdL29D729lZYWmTZuiadOmUKlU6NOnD3755ReMGzdOb8+a2qFDh/Dy5Uts3boVNWvW1LTfv3/foMfVp1ChQjh16hRiY2OT/C+tUKFC2LdvH6pVq5ZiPUMPHz7E69evUbJkSZ3bpk6diqlTp+LChQsoW7YsypYti19//RXXr1/X+k9KfUGGehC4m5sbcuXKpbc6c+LB4ur7GLLP1GDo62no8Vb/rd++fVvrvRAbG4v79++jTJkynxXv5s2bUbBgQWzdulXrb3PChAk6cRw8eFCnnIG+q5fTgvq/8Q+vmEp8egSA5kro+Ph4oz6DlODp6YmKFStiw4YN6NevH7Zu3YrmzZvrPZ2eHCn5WW7MvozttUiOzZs3IyAgQOtUV1RUVJJXFH6odOnSKF26NMaOHYsTJ06gWrVqWLx4MaZMmYJChQpBCAFPT08ULVrU6Ni8vLwAyPd24mS/QIEC2L9/P96+fauVxH34XaPu6ba0tDT4b/j27dtaV9W+ffsWz549Q6NGjTRtKXFcBg4c+MnOBQAGX2gRFRWlt8fy/v37cHZ2NrpDIF2MAfscfn5+ePLkCZYuXapzW2RkJN69ewdAnqf+kPqLTt/poI8pX748XFxcsHjxYq377t69G9evX//oFY3qKwB//vlnrfa5c+ca9NiNGjXC06dPtaZLev/+fZKnLxJ7+fKl1rq5ubnmDad+HuoCcx9+MKj/20j830VMTAwWLlxoUNz6tGrVCqGhoZpaWImpH8fPzw/x8fH4/vvvdbaJi4vTitPQMhQDBgzAtm3btH5++eUXAHLs0rZt2zSnlb7++mtYWlpqPU8hBBYvXgw3NzdUrVpV6/n8+eefWpd+79+/H7du3dKU9zB2nynN0NfT0ONdvnx55MqVC4sXL0ZMTIymfeXKlQZ/uXyMvjhOnTqlU6rD19cXsbGxWp8DKpUKCxYs0NlnSpahSEq2bNng7OyMI0eOaLV/+PpZWFigVatW2LJlC65cuaKzn9S8rD45/P398e+//2L58uUIDQ1N1unHpKTkZ7mh+wLkZ97HSiukRBkKCwsLnd7/efPm6S3pklhERATi4uK02kqXLg1zc3PNc23ZsiUsLCwwadIknccQ/7+S72OqVKkCADr/PDZq1AhxcXFYtGiRpi0+Ph7z5s3T2s7FxQW1a9fGL7/8ovc9pe9veMmSJVrDCRYtWoS4uDjN9yPw8eNiqOSMAXv37p3e8XZbtmzB69ev9Z5iPnfunOZ1NEaG7wHr1KkTNm7ciN69e+PgwYOoVq0a4uPjcePGDWzcuFFTn2fy5Mk4cuQIGjdujAIFCuD58+dYuHAh8uXLZ/Ql/5aWlpg+fTq6du2KWrVqoV27dpoyFB4eHhg8eHCS9y1btizatWuHhQsXIjw8HFWrVsX+/fsN/k+9R48emD9/Pjp37oxz587B1dUVa9asMaiIYffu3fHq1SvUrVsX+fLlw4MHDzBv3jyULVtWUxKhbNmysLCwwPTp0xEeHg5ra2vUrVsXVatWhZOTEwICAjBgwACYmZlhzZo1n3VatnPnzli9ejWGDBmC06dPo0aNGnj37h327duHPn364Ouvv0atWrXQq1cvBAYG4uLFi6hfvz4sLS1x+/ZtbNq0CT/99JPmggRDy1B8+eWXOpdcq09FlixZUqsidr58+TBo0CDMnDkTsbGxqFChArZv346jR49i7dq1Wt3go0ePxqZNm1CnTh0MHDgQb9++xcyZM1G6dGmtAcfG7DOlGfp6Gnq8LS0tMWXKFPTq1Qt169aFv78/7t+/jxUrVqTIGLAmTZpg69ataNGiBRo3boz79+9j8eLFKFGihNaA2ObNm6NixYr47rvvcOfOHXh5eWHnzp2aL+vE/02ndBmKpHTv3h3Tpk1D9+7dUb58eRw5cgS3bt3S2W7atGk4ePAgKlWqhB49eqBEiRJ49eoVzp8/j3379ulNOJTi5+eHoUOHYujQociRI0eK9tql5Ge5ofsCZAmBffv2Yfbs2cibNy88PT1RqVIlAMaXoUhKkyZNsGbNGjg6OqJEiRI4efIk9u3bh5w5c370fgcOHEC/fv3Qpk0bFC1aFHFxcVizZo0mcQdkz+GUKVMwatQoBAUFoXnz5siaNSvu37+Pbdu2oWfPnhg6dGiSj1GwYEGUKlUK+/bt0yok2rRpU1SrVg0jR45EUFAQSpQoga1bt+r9B3fBggWoXr06SpcujR49eqBgwYIICQnByZMn8fjxY1y6dElr+5iYGNSrVw9+fn64efMmFi5ciOrVq6NZs2aabby9vbFo0SJMmTIFhQsXhouLi84Zp09Jzhiw27dvw8fHB/7+/vDy8oK5uTnOnj2L3377DR4eHhg4cKDW9s+fP8d///2n94KfTzLqmslkMKQMxYeX2Oq7hLtWrVqiZMmSevcTExMjpk+fLkqWLCmsra2Fk5OT8Pb2FpMmTRLh4eFCCCH2798vvv76a5E3b15hZWUl8ubNK9q1aydu3bqVrHiEEGLDhg2iXLlywtraWuTIkUN06NBBPH78WGubD8tQCCFEZGSkGDBggMiZM6ewt7cXTZs2FY8ePTKoDIUQQjx48EA0a9ZM2NnZCWdnZzFw4EBNGYGPlaHYvHmzqF+/vnBxcRFWVlYif/78olevXuLZs2da+1+6dKkoWLCgsLCw0Nrn8ePHReXKlYWtra3ImzevGD58uPj77791HjepY/VhPELIy7PHjBkjPD09haWlpciTJ49o3bq1uHv3rtZ2S5YsEd7e3sLW1lZkzZpVlC5dWgwfPlw8ffpUs40xZSg+lFQZCiFkOYOpU6eKAgUKCCsrK1GyZEnx22+/6d3PlStXRP369YWdnZ3Inj276NChgwgODv6sfepj6PPU95oLYdjraejxFkKIhQsXCk9PT2FtbS3Kly8vjhw5olNSwhAf3kelUmleJ2tra1GuXDnx559/6n1eL168EO3btxdZs2YVjo6OokuXLuL48eMCgFi/fr1mu5QuQ9G4cWO9279//15069ZNODo6iqxZswo/Pz/x/Plzve/zkJAQ0bdvX+Hu7q55H9SrV08sWbLkk3GlRBmKD0s6qPd5//59nX1Uq1ZNABDdu3c36DE/lBaf5YbuSwghbty4IWrWrClsbW11/i5gZBmKM2fO6L399evXomvXrsLZ2Vk4ODgIX19fcePGDVGgQAGtx/uwDMW9e/fEN998IwoVKiRsbGxEjhw5RJ06dcS+fft0HmPLli2ievXqwt7eXtjb2wsvLy/Rt29fcfPmzU/GP3v2bL3lRF6+fCk6deoksmXLJhwdHUWnTp00pTE+/Py5e/eu6Ny5s8iTJ4+wtLQUbm5uokmTJmLz5s06r9Phw4dFz549hZOTk3BwcBAdOnQQL1++1NpfcHCwaNy4sciaNavWcUjqtf7wtUuuFy9eiJ49ewovLy9hb28vrKysRJEiRcSgQYP0lj5ZtGiRsLOzExEREUY/lpkQGXxkOVEmZGZmZnDB2cxs+/btaNGiBY4dO4Zq1aopHU6qUBfV5Uc5JVd4eDgKFiyIGTNmoFu3bqn2OOq/1TNnzmTIKZv0KVeuHGrXrq0zR6whMvwYMCIiQLd+mnq8SrZs2XROORNRAkdHRwwfPhwzZ85MsyucTcGePXtw+/ZtjBo1Kln3z/BjwIgo/Xvx4sVHBxwbchn4p/Tv3x+RkZGoUqUKoqOjsXXrVpw4cQJTp05Nt5Njm5JXr15pXYjxIQsLi2SVjaG0MWLECIwYMULpMDKUBg0aJFmc1RBMwIgo1VWoUEGnBENiKTHQuW7dupg1axb+/PNPREVFoXDhwpg3bx769ev3Wfslw7Rs2RKHDx9O8vYCBQoYVWiTyNQpOgbsyJEjmDlzJs6dO4dnz55h27ZtWleg6XPo0CEMGTIEV69ehbu7O8aOHctxMETp3PHjxz9aENHJyQne3t5pGBGltHPnzunMXpKYra2tyY7DI0oORXvA3r17hzJlyuCbb75By5YtP7n9/fv30bhxY/Tu3Rtr167F/v370b17d7i6uiZ7LjYiSn384jV9TKCJjJNuroI0MzP7ZA/YiBEj8Ndff2kVLGzbti3CwsKwZ8+eNIiSiIiI6PNlqDFgJ0+e1Cn85+vri0GDBiV5n+joaK1q9SqVCq9evULOnDnTZAoKIiIi+nxCCLx58wZ58+bVTLyekWWoBCw4OBi5c+fWasudOzciIiIQGRmp90qnwMBATJo0Ka1CJCIiolT06NEj5MuXT+kwPluGSsCSY9SoURgyZIhmPTw8HPnz58ejR4+QLVs2BSMjIiKij9qxA/jqK/z8qx3GjYsA4I6sWbMqHVWKyFAJWJ48eRASEqLVFhISgmzZsiVZ58fa2hrW1tY67dmyZWMCRkRElB69ewf07QusWgV0745xvyZMrG4qw4cyVAJWpUoV7Nq1S6tt7969yZqFnIiIiNKhK1cAPz/g+nXA3BxvnPIDSBfXC6YoRUexvX37FhcvXsTFixcByDITFy9exMOHDwHI04edO3fWbN+7d2/cu3cPw4cPx40bN7Bw4UJs3LgRgwcPViJ8IiIiSilCAMuWARUryuTL1RXYvx+/uIwDYBq9XokpmoCdPXsW5cqVQ7ly5QAAQ4YMQbly5TB+/HgAwLNnzzTJGAB4enrir7/+wt69e1GmTBnMmjULv/76K2uAERERZWRv3wKdOgHduwORkUD9+sDFi0Dt2jhxQm7ymbOVpTvppg5YWomIiICjoyPCw8M5BoyIiCg9ePwYKFsWCAsDpkwBhg8H/l9qokMH4PffgYYNI7B7t+l8f2eoMWBERERkgvLlA9atA2xtgerVtW76/Xf5u0YNYPduBWJLJRm/khkRERFlLBERQNu2wPbtCW1ffaWTfAGAlZX8XaRI2oSWVpiAERERUdo5dw748ktgwwagVy/g/fskNw0OBmJi5HKFCmkUXxphAkZERESpTwhg3jygalXg7l2gQAFZaNXOLsm7DBuWsOzomAYxpiGOASMiIqLUFRYGdOsGbN0q15s3B5YvB5ycPnq3/1epgr29Zky+yWACRkRERKknLAwoVw4ICgIsLYEffwT69wcMqGhvby9/z52bmgEqw8TySSIiIkpXsmcHGjYEChYETpwABgwwKPkCgFOn5G8Pj1SLTjHsASMiIqKU9fIlEBcH5M4t12fPBqKjjRrIdeVKwnLRoikcXzrAHjAiIiJKOSdOyFOO7doB8fGyzcbG6FH0ly4lLOfPn4LxpRNMwIiIiOjzqVTA9OlAzZrAo0fy59mzZO8uLk7+NrX6X2pMwIiIiOjzvHgBNGkCjBwpe73atQPOn5cV7pPpyRP5u1SpFIoxneEYMCIiIkq+o0dlVfunT+Wpxp9/lpNqGzjQPik7dsjfn7mbdIsJGBERESVPfDzQp49Mvry8gI0bgdKlU2TXtrbydxYTzVR4CpKIiIiSx8JCTqLdvTtw5kyKJV+AHFIGAM2apdgu0xUmYERERGS4AweAX35JWC9VCli6FHBwSNGHUc8BmTVriu423WACRkRERJ8WHw9MmAD4+AD9+gFnz6bqwwUFyd9WVqn6MIox0TOrRERElGKePgU6dAAOHZLrXboAJUqk6kOGhMjfpjoGzESfFhEREaWIv/8GOnWSpSYcHOTpx/btU/Uh37xJWGYdMCIiIspcJk4EGjSQyVeZMsC5c6mefAHyYdTc3FL94RTBBIyIiIj0y55d/u7dG/j33zSblPGff+TvL7/kKUgiIiLKDN69A+zt5fLAgXJex1q10jSEO3cSQjFV7AEjIiIiIDYWGDZMdjupB2GZmaV58pVY48aKPXSqYwJGRESU2T14ICfR/vFH4NYtYPt2RcNRT0NUsqSiYaQqJmBERESZ2Y4dQNmycoyXoyOwZYu86lFBnp7yt6WlomGkKiZgREREmVFMDDBoENC8ORAWBlSsCFy4ALRsqXBgwM2b8nfx4srGkZqYgBEREWVGI0YAP/0kl7/7Djh6NKHrSUEPHiQsqy/CNEVMwIiIiDKjkSPlIKudO+XYr3Qy58/ffycsFy6sXBypjQkYERFRZhAVBaxbl7CeOzfw339A06bKxaTHpUvyt4+PsnGkNtYBIyIiMnW3bwN+fsDFi3K9XTv52zz99cOcOCF/OzsrG0dqS3+vPBEREaWcdetkba+LF2VWkyOH0hF9lDonLFRI2ThSGxMwIiIiUxQZCfTsKedufPtW1vm6eBHw9VU6siTFxQHnz8vlGjWUjSW1MQEjIiIyNTduAJUqAUuXymr2Y8cC+/en+5mt1ckXAFSrplwcaYFjwIiIiEzN3bvA5cuAiwuwdm2GGdG+cqX8bWkJODgoGkqqYwJGRERkaho3lr1fjRsDrq5KR2Mw9RSU+fIpG0da4ClIIiKijO7qVTloKnEV0+7dM1TyBQC//SZ/9+ypbBxpgQkYERFRRiUEsHw5UKECcOyYnFoog4qPT1guU0a5ONIKT0ESERFlRG/fAr17yzFeAFC/PvDLL8rG9BkSD8CvV0+5ONIKe8CIiIgymkuXAG9vmXxZWABTpwK7d8tB9xnU6NHyd86c6WZWpFTFHjAiIqKM5OhR4KuvgOhoWVZi/XqgenWlo/ps+/bJ3716KRtHWmECRkRElJFUqAB4ecnka9Uqk5izJywsYblZM8XCSFNMwIiIiNK769eBokXl6UYbG9ldlCNHupzLMTlOn05YrlhRuTjSkmkcOSIiIlMkBDB/PlC2LPDDDwntzs4mk3wBcrpKQOaXZmbKxpJW2ANGRESUHoWFAd26AVu3yvVLlwCVyqQSLzV1Bfz69RUNI02Z3lEkIiLK6E6fBsqVk8mXpSUwdy6webNJJl8qVcJyx47KxZHWTO9IEhERZVRCAHPmyKsag4IAT0/g+HFg4ECTPTe3ZUvCcsuWysWR1piAERERpRf378uCWLGxQKtWsjpphQpKR5Wq1q+Xv11d5fUFmQXHgBEREaUXBQsCCxYAkZFAnz4m2+uVmPoKyK++UjaOtMYEjIiISCkqFTBrlpxIu3Jl2fbNN8rGlMbevpW/W7dWNo60xgSMiIhICS9eAAEBcgqhAgWAK1cABwelo0pTMTEJRVhLl1Y0lDTHBIyIiCitHTkCtGsHPH0qBz6NGQPY2ysdVZpTTz8EAO7uysWhBA7CJyIiSisqlSyoWqeOTL6KFQNOnQJ69MgU470+9OhRwrKFhXJxKIE9YERERGnh7VtZZ2HvXrneqROwcGGmO+2Y2OvX8ne7dsrGoQQmYERERGnB3h6wtZU/CxcCXbooHZGi4uKAUaPksq2tsrEogQkYERFRaomPlyPNbW3lKcYVK4DgYKBECaUjU1zTpgnLLi7KxaEUjgEjIiJKDc+eAT4+cnyXELItRw4mXwDu3AH27ElYnzhRsVAUwx4wIiKilPbPP3Jiwxcv5KnHe/eAQoWUjirdGDQoYfnhQ8DaWrFQFMMeMCIiopQSFydLSjRoIJOvL74Azp5l8vWBv/6Sv9u0yXzlJ9TYA0ZERJQSHj8G2rcHjh6V6716yYm1M+MI84/4/feE5c6dlYtDaUzAiIiIPpdKBTRsKKvZZ80KLF0K+PsrHVW6Ex0NdOiQsN6woXKxKI2nIImIiD6XuTkwdy5Qvjxw/jyTryT4+CQsnzmT+YqvJmYmhPrSjMwhIiICjo6OCA8PR7Zs2ZQOh4iIMqqHD4EbN4D69RPaVCqZjJFe9vbA+/dy2djsw9S+v/lXQkREZKydO4GyZYHWrWVNBTUmX0natSsh+Uo8B2Rmxb8UIiIiQ8XEAIMHA19/LefR8fICsnA4tSESl56oVUuxMNINxROwBQsWwMPDAzY2NqhUqRJOnz790e3nzp2LYsWKwdbWFu7u7hg8eDCioqLSKFoiIsq07t8HqleXY70AmYgdOwZ4eCgZVYbwzz/A7dtyOTCQOSugcAK2YcMGDBkyBBMmTMD58+dRpkwZ+Pr64vnz53q3//333zFy5EhMmDAB169fx7Jly7BhwwaMHj06jSMnIqJMZcsWoFw5OXLcyQnYsQOYPRuwslI6sgzB1zdhecgQ5eJITxRNwGbPno0ePXqga9euKFGiBBYvXgw7OzssX75c7/YnTpxAtWrV0L59e3h4eKB+/fpo167dJ3vNiIiIPsuJE0B4OFClCnDxItCsmdIRZRixsQnLo0czZ1VTLAGLiYnBuXPn4JPomlRzc3P4+Pjg5MmTeu9TtWpVnDt3TpNw3bt3D7t27UKjRo2SfJzo6GhERERo/RAREX1S4sv0AgOBn34CDh8G8udXLqYMaN68hOURI5SLI71RLAELDQ1FfHw8cufOrdWeO3duBAcH671P+/btMXnyZFSvXh2WlpYoVKgQateu/dFTkIGBgXB0dNT8uGfWOQ+IiMhw69cDjRoldN9YWQEDBgCWlsrGlcG8eQN8951cLlAAMIHqESlG8UH4xjh06BCmTp2KhQsX4vz589i6dSv++usvfP/990neZ9SoUQgPD9f8PHr0KA0jJiKiDCUyUk4h1K4dsGePrGhPyZY44UpidFGmpdh1CM7OzrCwsEBISIhWe0hICPLkyaP3PuPGjUOnTp3QvXt3AEDp0qXx7t079OzZE2PGjIG5nvor1tbWsM6M06wTEZFxbt4E/PyA//4DzMzkgKWePZWOKsPavz9huWRJoG5d5WJJjxTrAbOysoK3tzf2JzpCKpUK+/fvR5UqVfTe5/379zpJlsX/5zHIZAX9iYgoJf32G+DtLZMvFxfg77+BKVNYLyGZ7t/Xnnbo8mXlYkmvFP3LGjJkCAICAlC+fHlUrFgRc+fOxbt379C1a1cAQOfOneHm5obAwEAAQNOmTTF79myUK1cOlSpVwp07dzBu3Dg0bdpUk4gREREZ5YcfgLFj5XKdOsDatYCrq7IxZWBv3gAFCyasb9ggOxRJm6IJmL+/P168eIHx48cjODgYZcuWxZ49ezQD8x8+fKjV4zV27FiYmZlh7NixePLkCXLlyoWmTZvihx9+UOopEBFRRte6NTBjhixQNXZs5p4hOgU0aZKwvGaNPKtLujgZNxERZS5CyFONZcoktL18CeTMqVxMJqJAATlHOSCnyrxwIeX2bWrf3xnqKkgiIqLP8vYt0Lkz8OWXsqaXGpOvz9aiRULyBQAHDigXS0bABIyIiDKH//4DypeXA+4B4MoVZeMxIZGRwPbtCeuxsXLGJkoaEzAiIjJtQgBLlgAVK8pSE25uwKFDQN++SkdmEpYvB+zsEtaDg3nxqCH4EhERkemKiJCFVdevl+sNGwKrVwPOzsrGZSJWrQK6dUtYb94c+GCCG0oCEzAiIjJdO3bI5MvCQs7n+N13gJ6i3WS858+BLl0S1s+dk0PryDBMwIiIyHR17CgvxWvTBkiiyDcZ79077Z6uw4eZfBmL/wYQEZHpCAsD+vUDXr+W62ZmwOzZTL5SmINDwnLXrkDNmsrFklGxB4yIiEzDmTOAv7+cByc0NGHcF6WYqCjA1jZh3dOTk2wnF3vAiIgoYxMCmDsXqFZNJl+ennKsF6W44sW11+/dUyYOU8AEjIiIMq5Xr+Sld4MHy+JTrVoB588DFSooHZnJmTABCAqSy3nyyLyXko+nIImIKGO6fFlOPPjwIWBlJcd69enDmZ9TwbJlwOTJCetPnigXi6lgAkZERBlT3ryyG6ZQIWDjRl6Glwo+HPMFAA8esJJHSuBLSEREGcebNwnnvnLmBHbvlqccmXyluK1bdZOvAweA/PmVicfUMAEjIqKM4ehROQp85cqEtpIlgWzZFAvJVAkhh9Op1akj2+rUUS4mU8MEjIiI0jeVCpg6VX77P3kCzJsHxMcrHZVJy5cvYXnPHtnzRSmLCRgREaVfz58DDRoAY8bIpKtjR+DIETm1EKW4R4/kNQxPn8p1S0vA11fZmEwVEzAiIkqfDh4EypQB9u6Vg5GWLZMTaScuw04pqkaNhOUcOeSUQ5Q6mIAREVH68+ABUL8+EBwMlCghq9x/8w1LTKSi2bPlyw4AX38NvHwpe8AodbAMBRERpT8FCgCjRgGPH8sxX/b2Skdk0iZPloVW1TZtUi6WzIIJGBERpQ/79gEeHkDhwnJ90iT2eKWy2FjZsfjbbwltt2+z5yst8BQkEREpKy4OGDtWnnL09weio2U7k69UIwSwZo2cQCBx8nXhQkL+S6mLPWBERKScJ0+Adu1kjS9AzuHISQZTlRByvnL1eC8AqFJFlptgSbW0wx4wIiJSxu7dQNmyMvnKmhVYtw5YvBiwsVE6MpO1apWcRihx8vXXX8CJE0y+0hp7wIiIKG3FxspTjjNmyPVy5YANG4AiRZSNy8T98IN82dVy5gRCQ5WLJ7NjDxgREaUtIWSNLwDo21d2vzD5SlVRUdrJ19GjTL6UxgSMiIjShnpsl5WV7PHavBmYP5+nHFPZsGHak2r//TdQvbpy8ZBkJkTmGu0YEREBR0dHhIeHIxtPeBMRpb6YGGDkSJloTZ2qdDSZysuXgLNzwnqePMCzZ8rF8zlM7fubPWBERJR67t+X89vMmQNMmwbcuKF0RJmCEMDOndrJ161bGTf5MkVMwIiIKHVs3SoH2J8+DWTPDmzbBnh5KR2VSbt7F5g4UV7p+PXXCe2tWnGYXXrDqyCJiChlRUcDQ4fK8V0AULkysH69nF6IUtz9+8D588DJk8CsWbq3r1gBdOmS5mHRJzABIyKilCOErGh/5IhcHz4cmDKFc9uksFevgF27gE6d9N/esqXMgatUSdu4yHBMwIiIKOWYmQHduwNXrwKrVwONGikdkUmZPx/o31//bfXqAXnzynITRYumbVxkPCZgRET0eSIjgaAgoHhxud6pE9C4MZAjh6JhmZITJ2QuGx6u3e7sLMd3zZvHTsaMhoPwiYgo+W7elGO8fHyAFy8S2pl8pYiXL4EWLYBq1bSTr/nz5RzmL17I2ZuYfGU8TMCIiCh5fvsN8PYG/vtPTi90/77SEZmUP/+UPVzbtye0TZsmy6r17QtYWCgWGqUAnoIkIiLjvH8vByItXy7Xa9cG1q6VA5AoRVy/DjRtmrBeoYIcdJ+4rhdlbEzAiIjIcNeuAX5+cpC9mRkwfjwwbhy7Y1KIEICdnZy7UW3TJqB1a+ViotTBU5BERGS46dNl8pUnD7Bvn6z6yeTrs8XEAMeOyQKqiZOv9euZfJkq9oAREZHhfv4ZyJJFzumYO7fS0WR4sbFybvIPubkBjx7JTkYyTewBIyKipF2+DAwbJs+NAYCjI7BsGZOvFPD+vf7ka8gQ4PFjJl+mjj1gRESkSwjg11+BAQPkObFixWSBVUoxPj4Jy5Ury1OQPJubeTABIyIibRERQK9ecgASADRsqD2zM322d+/k3I0A4OGRsEyZB09BEhFRggsXZG2v9etld8z06bIgVa5cSkdmUtS5LQCcO6dcHKScz+oBi4qKgo2NTUrFQkRESlqzRp5mjIkB3N1lllC1qtJRmST12dwKFThpQGZldA+YSqXC999/Dzc3Nzg4OODevXsAgHHjxmHZsmUpHiAREaURT08gPl5WAL14kclXKjlxImG5Vy/l4iBlGZ2ATZkyBStXrsSMGTNglejyjVKlSuHXX39N0eCIiCiVJZ5gsHp1ORhpxw52y6SiatUSlrt1Uy4OUpbRCdjq1auxZMkSdOjQARaJLtcoU6YMbty4kaLBERFRKhEC+OknOQL82rWE9goVWP8gFf33X8LyuHHKxUHKMzoBe/LkCQoXLqzTrlKpEBsbmyJBERFRKnr1CmjRAhg0CAgLA1auVDigzKNFi4TliRMVC4PSAaMTsBIlSuDo0aM67Zs3b0a5cuVSJCgiIkol//4LlCsnTzNaWQHz5skrHSnVvXwJ/H/YNEaOlNMOUeZl9FWQ48ePR0BAAJ48eQKVSoWtW7fi5s2bWL16Nf7888/UiJGIiD6XSgXMng2MGgXExQGFCgEbNsiSE5Qm1q1LWObpRzI6//7666/xxx9/YN++fbC3t8f48eNx/fp1/PHHH/jqq69SI0YiIvpcv/0mpxSKiwP8/GTxKSZfaeqPP+TvUqUAOztlYyHlmQmhnuArc4iIiICjoyPCw8ORLVs2pcMhIkobcXFA48ZyEFKvXhxon8aESDjl2KsXsHixsvFkRKb2/W10D1jBggXx8uVLnfawsDAULFgwRYIiIqLPpFLJuRyjo+V6lizAnj1A795MvhSwbVvCcp8+ysVB6YfRCVhQUBDi4+N12qOjo/HkyZMUCYqIiD7D8+dy/sYePYARIxLamXgpQgigVauE9S++UC4WSj8MHoS/c+dOzfLff/8NR0dHzXp8fDz2798PDw+PFA2OiIiMdOgQ0L498OwZYGvLb/t0YMEC/cuUuRk8Bsz8/yevzczM8OFdLC0t4eHhgVmzZqFJkyYpH2UKMrVzyEREAOQUQj/8AEyaJE8/Fi8ObNoElCypdGSZWvfuQOJZ+jLXqOuUZWrf3wb3gKlUKgCAp6cnzpw5A2dn51QLioiIjBAcDHToABw4INe7dpX1veztlY0rk4uK0k6+tm5VLhZKf4yuA3b//v3UiIOIiJLr/Xvg7FlZ22DxYqBTJ6UjIgD79iUsv3zJ6TVJm9EJGAC8e/cOhw8fxsOHDxETE6N124ABA1IkMCIi+gghEgbVFywIbNwIFCgAeHkpGxcBkFU/mjaVy9mzM/kiXUYnYBcuXECjRo3w/v17vHv3Djly5EBoaCjs7Ozg4uLCBIyIKLU9eQJ07Cir2tevL9t8fZWNibQcP56wvHy5cnFQ+mV0GYrBgwejadOmeP36NWxtbfHvv//iwYMH8Pb2xo8//pgaMRIRkdqePUDZsvJqxz59ZFcLpTtBQQnLiSfgJlIzOgG7ePEivvvuO5ibm8PCwgLR0dFwd3fHjBkzMHr06NSIkYiIYmPlDM4NGwKhoTIJ27VLFlildEUIoEsXuZzOCwOQgoxOwCwtLTUlKVxcXPDw4UMAgKOjIx49emR0AAsWLICHhwdsbGxQqVIlnD59+qPbh4WFoW/fvnB1dYW1tTWKFi2KXbt2Gf24REQZxqNHQO3awPTpcr1PH+DkSaBoUUXDIv2KFElYZnlMSorR/zqVK1cOZ86cQZEiRVCrVi2MHz8eoaGhWLNmDUqVKmXUvjZs2IAhQ4Zg8eLFqFSpEubOnQtfX1/cvHkTLi4uOtvHxMTgq6++gouLCzZv3gw3Nzc8ePAA2bNnN/ZpEBFlDE+eyN6uV6+AbNlkXYPWrZWOipLw77/A3bsJ6/PmKRcLpW9GT8Z99uxZvHnzBnXq1MHz58/RuXNnnDhxAkWKFMGyZctQtmxZg/dVqVIlVKhQAfPnzwcga425u7ujf//+GDlypM72ixcvxsyZM3Hjxg1YWloaE7aGqRVyI6JMoEsX4OpVYMMGecUjpVuJZ3sKCwMSTRpDn8nUvr+NTsBSSkxMDOzs7LB582Y0b95c0x4QEICwsDDs2LFD5z6NGjVCjhw5YGdnhx07diBXrlxo3749RowYAQsLC4Me19QOIBGZoKAgwMEBUBe8fv8esLAArK0VDYs+TZ2ADRkCzJqlbCymxtS+v40eA5aU8+fPGzUNUWhoKOLj45E7d26t9ty5cyM4OFjvfe7du4fNmzcjPj4eu3btwrhx4zBr1ixMmTIlyceJjo5GRESE1g8RUbq1bZs85RgQIKcUAmSBVSZf6V7iSvf9+ysXB2UMRiVgf//9N4YOHYrRo0fj3r17AIAbN26gefPmqFChgma6otSiUqng4uKCJUuWwNvbG/7+/hgzZgwWL16c5H0CAwPh6Oio+XF3d0/VGImIkiU6GhgwAGjZEggPl6XTw8OVjoqMMHt2wnKBAsrFQRmDwQnYsmXL0LBhQ6xcuRLTp09H5cqV8dtvv6FKlSrIkycPrly5YtTViM7OzrCwsEBISIhWe0hICPLkyaP3Pq6urihatKjW6cbixYsjODhYpyK/2qhRoxAeHq75Sc6VmkREqeruXaBatYQR20OHAkePAk5OysZFBouMTCi+umyZ9lgwIn0MTsB++uknTJ8+HaGhodi4cSNCQ0OxcOFCXL58GYsXL0bx4sWNemArKyt4e3tj//79mjaVSoX9+/ejSpUqeu9TrVo13LlzR6un7datW3B1dYWVlZXe+1hbWyNbtmxaP0RE6cbGjUC5csC5c0DOnMCffwIzZwLJvNCIlDFsWMKyegoioo8xOAG7e/cu2rRpAwBo2bIlsmTJgpkzZyJfvnzJfvAhQ4Zg6dKlWLVqFa5fv45vv/0W7969Q9euXQEAnTt3xqhRozTbf/vtt3j16hUGDhyIW7du4a+//sLUqVPRt2/fZMdARKSYqCg5ndCbN7IH7OJFoHFjpaMiIwkBLFggl93cgFy5lI2HMgaD64BFRkbCzs4OAGBmZgZra2u4urp+1oP7+/vjxYsXGD9+PIKDg1G2bFns2bNHMzD/4cOHmqKvAODu7o6///4bgwcPxhdffAE3NzcMHDgQI0aM+Kw4iIgUYWMjS0ts2wZMmsSq9hnUd98lLO/Zo1wclLEYXIbC3NwcU6ZMgYODAwBgxIgRGDZsGJzVl0n/X3qfjNvULmMlogzm999lWYnu3ZWOhFLAX38lTDdkaysPLaUOU/v+NjgB8/DwgNknRhWamZlpro5Mr0ztABJRBvH+PTBwIPDrr4CVlTzdaOTYWUp/En8tXr8OeHkpF4upM7Xvb4P7u4MST+1ORESGu34d8PMDrlyR39ijRnEeRxNQu3bC8pIlTL7IOBxwQESUmlatkpNnv38P5M4tT0HWrat0VPSZIiKAw4cT1nlGmYzFBIyIKDUIAfToIYtCAYCPD/DbbzIJowyvRo2E5YcPWfeLjJdiUxEREVEiZmZy4mxzc+D77+XlcUy+TMKZM8B//yWsc4IVSg72gBERpRQh5PRB2bPL9ZEjgQYNgC+/VDQsSjlPnwIVKyas37ihXCyUsbEHjIgoJbx5A3ToIM9NqWsRmJsz+TIxbm4Jy5s3A8WKKRcLZWzJSsDu3r2LsWPHol27dnj+/DkAYPfu3bh69WqKBkdElCFcvAh4ewPr1skrHo8cUToiSgWFCycs9+wJtGqlXCyU8RmdgB0+fBilS5fGqVOnsHXrVrx9+xYAcOnSJUyYMCHFAyQiSreEABYtAipXBm7floOBjhyRpx3JpFy5IudMV1u8WLlYyDQYnYCNHDkSU6ZMwd69e7UmwK5bty7+/fffFA2OiCjdCg8H/P1liYnoaDkD84ULQNWqSkdGqeDvvxOWY2J41SN9PqMTsMuXL6NFixY67S4uLggNDU2RoIiI0r1+/YBNm+T8jbNmATt2ADlzKh0VpYIDB4ChQ+Vy+/aApaWy8ZBpMDoBy549O549e6bTfuHCBbglHp1IRGTKAgPluK9jx4AhQ9glYsLq1UtYZg1dSilGJ2Bt27bFiBEjEBwcDDMzM6hUKhw/fhxDhw5F586dUyNGIiLlvX4tq9qr5csnC0JVqqRcTJTqNmxIWB49GujWTblYyLQYPBm3WkxMDPr27YuVK1ciPj4eWbJkQXx8PNq3b4+VK1fCwsIitWJNEaY2mScRpYFTp+R4rwcPgO3bga+/VjoiSgNCyEoigDzTHBurbDyZnal9fxtdiNXKygpLly7FuHHjcOXKFbx9+xblypVDkSJFUiM+IiLlCAHMni0LqsbFAYUKyZ4vyhQ8PROW16xRLg4yTUYnYMeOHUP16tWRP39+5M+fPzViIiJS3suXQJcuwJ9/ynU/P2DpUsAE/vOmTztwQHZ4qrVtq1wsZJqMHgNWt25deHp6YvTo0bh27VpqxEREpKzjx4GyZWXyZW0ta32tX8/kK5O4cUN74L1KpVwsZLqMTsCePn2K7777DocPH0apUqVQtmxZzJw5E48fP06N+IiI0t7Tp8Djx0CRIsC//wK9e/Mqx0ykadOE5RUreOgpdRg9CD+x+/fv4/fff8e6detw48YN1KxZEwcOHEjJ+FKcqQ3iI6IUIoT2N+2qVUDLlkDWrMrFRGnuxQvAxUUuN20K7NypbDyUwNS+vz9rMm5PT0+MHDkS06ZNQ+nSpXH48OGUiouIKO0cPixreiWucRgQwOQrk/nrr4TkCwCmTlUuFjJ9yU7Ajh8/jj59+sDV1RXt27dHqVKl8Ndff6VkbEREqSs+Hvj+e1ld88IFYPx4pSMihfz2G9CkScJ6/fpAqVLKxUOmz+irIEeNGoX169fj6dOn+Oqrr/DTTz/h66+/hp2dXWrER0SUOoKDgY4dgf375XqXLsDcuUpGRAp5+xbo1Clh/eZNoGhR5eKhzMHoBOzIkSMYNmwY/Pz84OzsnBoxERGlrv37gQ4dgJAQwM5OXuXImTwypXv3ZHk3ta1bmXxR2jA6ATt+/HhqxEFElDa2bQNatZKD7kuVAjZuBIoXVzoqUsDdu0DhwgnrbdoALVooFw9lLgYlYDt37kTDhg1haWmJnZ+4JKRZs2YpEhgRUar46iugWDGgRg3gp58AW1ulIyKFJE6+fHxkLk6UVgwqQ2Fubo7g4GC4uLjA3DzpcftmZmaIj49P0QBTmqldxkpEBjhzRl7lqP78Cg8HHB2VjYkU1bUrsHKlXB45EggMVDQcMoCpfX8bdBWkSqWCy/+vzVWpVEn+pPfki4gymbg4YNQooGJFOaejGpOvTC0uLiH5Aph8kTKMLkOxevVqREdH67THxMRg9erVKRIUEdFne/QIqF0bmDZNrnO2Dvq/vn0TlhPP90iUloyuhG9hYYFnz55pesTUXr58CRcXl3TfC2ZqXZhEpMdff8mrGl+9kvM3LlsGtG6tdFSUDkREJHSA2tvLEhSUMZja97fRPWBCCJjpmRjr8ePHcGS3PhEpKSYGGDpUVtR89QooX14WWGXyRf+X+Gtqxw7l4iAyuAxFuXLlYGZmBjMzM9SrVw9ZsiTcNT4+Hvfv30eDBg1SJUgiIoNcvw78/LNcHjgQmD4dsLZWNiZKNxJP1lKtGlCvnnKxEBmcgDVv3hwAcPHiRfj6+sLBwUFzm5WVFTw8PNCqVasUD5CIyGBlygDz58sJ/f7/mUUEyFmnEk81dOyYcrEQAUYkYBMmTAAAeHh4wN/fHzY2NqkWFBGRQaKjgdGj5TwyZcvKtp49FQ2J0qfE14j9+qtycRCpGT0IP6MztUF8RJnW3buAvz9w7pycO+bKFcDSUumoKJ0qWxa4dEkuZ65vPdNhat/fBvWA5ciRA7du3YKzszOcnJz0DsJXe/XqVYoFR0Sk16ZNQPfu8pK2HDlkjS8mX5SEVq0Skq9BgxQNhUjDoARszpw5yJo1q2b5YwkYEVGqiYoChgyRk2cDciT1unWAu7uycVG6FB0NfDhaZvhwZWIh+hBPQRJRxvDiBVC/PnDxolwfNQqYPBnIYvBQVspEXryQ12Ik9vKl7DCljMnUvr+NrgN2/vx5XL58WbO+Y8cONG/eHKNHj0ZMTEyKBkdEpJEjB+DsDOTKBezZA0ydyuSL9Hr1Sjv5yplTXgXJ5IvSE6MTsF69euHWrVsAgHv37sHf3x92dnbYtGkThrNvl4hS0vv3QGSkXLawANaulT1gvr6KhkXp1/v3MuFS69gRCA1NmIedKL0w+k/y1q1bKPv/y703bdqEWrVq4ffff8fKlSuxZcuWlI6PiDKr69eBSpW0R027uAB58yoWEqVvERFyeiG1ChWAVauUi4foY5I1FZFKpQIA7Nu3D40aNQIAuLu7IzQ0NGWjI6LMadUqOY3QlStyvpgXL5SOiNI5lUp7mqFu3YDTp9nzRemX0X+a5cuXx5QpU7BmzRocPnwYjRs3BgDcv38fuXPnTvEAiSgTefcO6NJF/rx/L+eKuXhRjvsi+oimTROW7exYbJXSP6NHsM6dOxcdOnTA9u3bMWbMGBQuXBgAsHnzZlStWjXFAySiTOLKFcDPT556NDcHJk2SVzpaWCgdGaVjN28CXl7aba9fKxMLkTFSrAxFVFQULCwsYJnOiyGa2mWsRCYhJgYoVAh4/FiO8fr9d6BWLaWjonRu6VLdmadu3pQTI5DpMbXv72Rfw33u3Dlcv34dAFCiRAl8+eWXKRYUEWUyVlbA4sXAggVy/BdPOdInBARoz+/YowewZIly8RAZy+gE7Pnz5/D398fhw4eRPXt2AEBYWBjq1KmD9evXIxc/OInIEJcuAc+fA199JdcbNwYaNQI40wZ9xMWLQLly2m0bNsiz10QZidGD8Pv374+3b9/i6tWrePXqFV69eoUrV64gIiICAwYMSI0YiciUCCF7uypVkpNpP3yYcBuTL/qI7dt1k6+LF5l8UcZkdAK2Z88eLFy4EMWLF9e0lShRAgsWLMDu3btTNDgiMjHh4UDbtsC338qJ+qpV0y7cRJSE69eBFi0S1qdMkbl8mTLKxUT0OYw+BalSqfQOtLe0tNTUByMi0nHunOyquHdPTiE0fToweDB7veiTrl0DSpZMWP/5Z6B/f+XiIUoJRveA1a1bFwMHDsTTp081bU+ePMHgwYNRr169FA2OiEzEvHlA1aoy+SpQADh2DBgyhMkXfVJoqHbyNXkyky8yDUYnYPPnz0dERAQ8PDxQqFAhFCpUCJ6enoiIiMC8efNSI0YiyuiuXpWlJpo3By5ckOO/iD5CCFkKLvF1XStWAOPGKRcTUUpKVh0wIQT279+vKUNRvHhx+Pj4pHhwqcHU6ogQpVtCJPRwRUYCmzYBnTqx14s+Kj5e9nAtWqTd3qWLTMAo8zK172+jxoBt2LABO3fuRExMDOrVq4f+7Acmog8JAcyZA+zdC/z5p6xkb2sLdO6sdGSUzl25ApQurd2WI4e80tHdXZGQiFKNwacgFy1ahHbt2uHs2bO4ffs2+vbti2HDhqVmbESU0bx8CTRrBnz3HbBnD7B1q9IRUQbx+++6ydemTbJUHJMvMkUGJ2Dz58/HhAkTcPPmTVy8eBGrVq3CwoULUzM2IspITpyQRZr+/BOwtpbnkFq3VjoqygBiYoAOHRLW+/QB4uLknw+nAiVTZXACdu/ePQQEBGjW27dvj7i4ODx79ixVAiOiDEKlkiUlatYEHj0CihQB/v0X6N2b473ok/77T+bravv2yRmpmHiRqTM4AYuOjoZ9ooKJ5ubmsLKyQmRkZKoERkQZxIABwMiRcvR0+/ay3lfZskpHRRnA779rF1Lt2xdgNSPKLIwahD9u3DjY2dlp1mNiYvDDDz/A0dFR0zZ79uyUi46I0r+ePYF164AZM4BvvmGvFxnk/n3t045TpwKjRikXD1FaMzgBq1mzJm7evKnVVrVqVdy7d0+zbsYPXiLTFx8PnD2bUMvriy+AoCAga1ZFw6KMY/t27WmFtm8Hvv5aqWiIlGFwAnbo0KFUDIOIMoSQEKBjR+DQIVnNXp2EMfkiA8TFAb16AcuXJ7RNn87kizIno+eCJKJM6sABOcYrJASwswMeP2ZFezLKh9MInzoFVKyoTCxESjN6KiIiymTi44EJEwAfH5l8lSolT0G2aqV0ZJSBJK5a5OoKREUx+aLMjT1gRJS0p0/lSGn1EITu3YGffpI9YEQGatpUlodTe/wYMOe//5TJpYu3wIIFC+Dh4QEbGxtUqlQJp0+fNuh+69evh5mZGZo3b566ARJlVlu3yuTLwQFYuxZYupTJFxmlWjXt5Ov2bSZfREA6SMA2bNiAIUOGYMKECTh//jzKlCkDX19fPH/+/KP3CwoKwtChQ1GjRo00ipQoE+rbFxg6VNb2at9e6WgoAxFC1uY9cSKh7fFjoHBh5WIiSk+SlYAdPXoUHTt2RJUqVfDkyRMAwJo1a3Ds2DGj9zV79mz06NEDXbt2RYkSJbB48WLY2dlheeLLZD4QHx+PDh06YNKkSShYsGByngIR6fP4MdClC/DmjVw3MwNmzgSKFlU0LMo4hJCVSczNgaNHE9ofPwbc3JSLiyi9MToB27JlC3x9fWFra4sLFy4gOjoaABAeHo6pU6cata+YmBicO3cOPj4+CQGZm8PHxwcnT55M8n6TJ0+Gi4sLunXrZmz4RJSUv/6SFexXrZKTaRMZ4d07Of+6uTlw+bL2bW/fMvki+pDRCdiUKVOwePFiLF26FJaJrimuVq0azp8/b9S+QkNDER8fj9y5c2u1586dG8HBwXrvc+zYMSxbtgxLly416DGio6MRERGh9UNEicTGAsOGAU2aAC9fAt7ewIgRSkdFGUREBFCggBwm2LCh9m0PH8oesUSz2BHR/xmdgN28eRM1a9bUaXd0dERYWFhKxJSkN2/eoFOnTli6dCmcnZ0Nuk9gYCAcHR01P+7u7qkaI1GG8uCBHKjz449yfcAA4PhxoFAhZeOiDCEsDHB0lIlWYj/+KBMvftwSJc3oMhR58uTBnTt34OHhodV+7Ngxo8djOTs7w8LCAiEhIVrtISEhyJMnj872d+/eRVBQEJo2bappU6lUAIAsWbLg5s2bKPTBF8eoUaMwZMgQzXpERASTMCJADtBp1kx+i2bPDqxYAfCKYjJQ1qzy1KJaliyytpeFhXIxEWUkRveA9ejRAwMHDsSpU6dgZmaGp0+fYu3atRg6dCi+/fZbo/ZlZWUFb29v7N+/X9OmUqmwf/9+VKlSRWd7Ly8vXL58GRcvXtT8NGvWDHXq1MHFixf1JlbW1tbIli2b1g8RAShSBLC2ltXsL1xg8kWf9PYtMHCgvDYjcfIFAJGRTL6IjGF0D9jIkSOhUqlQr149vH//HjVr1oS1tTWGDh2K/v37Gx3AkCFDEBAQgPLly6NixYqYO3cu3r17h65duwIAOnfuDDc3NwQGBsLGxgalSpXSun/27NkBQKediPR4+RLImVMu58kja3wVLAhYWSkaFqV/deok1ONNTIg0D4XIJBidgJmZmWHMmDEYNmwY7ty5g7dv36JEiRJwcHBIVgD+/v548eIFxo8fj+DgYJQtWxZ79uzRDMx/+PAhzFm1j+jzbd4MdOsGLFkC+PvLNi8vZWOiDKF3b+3kq3hxOSf7qFGKhUSU4ZkJkbn+f4mIiICjoyPCw8N5OpIyh6goWVZCPRlfw4ay5ISZmbJxUbo3a5asw5tYdDQ7TEkZpvb9bXQPWJ06dWD2kQ/uAwcOfFZARJSCbt8G/PyAixfl+siRwOTJTL7ok9at006+ypQBTp9m8kWUUoxOwMqWLau1Hhsbi4sXL+LKlSsICAhIqbiI6HOtWwf07ClHSzs7A2vWAA0aKB0VpWM3bgD9+8trM/76K6H977+B+vWVi4vIFBmdgM2ZM0dv+8SJE/H2w8tiiEgZ//2XMHdjzZrA77+zFDklKSgI8PTUf9u5c8CXX6ZpOESZQoqNAbtz5w4qVqyIV69epcTuUo2pnUMmStKwYYCtLTB+vCzSRPSBdeuADRuAHTt0b1u0SFYqqVcv7eMi0sfUvr9T7FP55MmTsLGxSandEZGx1q4FatQA8ueX6zNmcKwXJUnfn8b33wNjx6Z9LESZkdEJWMuWLbXWhRB49uwZzp49i3HjxqVYYERkoHfv5MCdFSuAqlVlvQBLSyZfpNebN3LO9cS++052lJpApwJRhmF0Aubo6Ki1bm5ujmLFimHy5Mmoz1GaRGnr6lV5leO1a4C5OeDrK38T6bFrF9C4sXabSsVcnUgJRiVg8fHx6Nq1K0qXLg0nJ6fUiomIPkUI2ePVr5+cA8bVVQ60r11b6cgoHYqJAdq1A7ZuTWgrUUJeq8Hki0gZRv2rbGFhgfr16yMsLCyVwiGiT3r3DujcWVa1j4yUvV4XLzL5Ih2RkTLRsrbWTr4OHZKdp5y7kUg5Rp+rKFWqFO7du5casRCRIczNZdeFhQUQGCjPK7m4KB0VpROvXgELFgD58gF2dsD169q3378P1KqlTGxElMDoMWBTpkzB0KFD8f3338Pb2xv29vZat5vCpaFE6Y4Q8sfcXJaW2LgRePECqF5d6cgoHThxQv5JrF8PhITo3+blSyBHjrSNi4iSZnAdsMmTJ+O7775D1qxZE+6caPCAEAJmZmaIj49P+ShTkKnVEaFMIDxcVrQvXZo1AkhDpQJWrpR/Gh9+7GbJAuTJA3TtCrRpI/90iDI6U/v+NjgBs7CwwLNnz3D9w/7sD9RK533bpnYAycSdOwf4+wN37wI2NsC9e3LAPWU6QgCPHsmxXIMH69+mZUt5UayfHwfXk+kxte9vg09BqvO09J5gEZkEIYD58+VsyDExQIEC8vwSk69MJyJC9mZFRia9zdSpwKhRaRcTEX0+owbhm/FfKqLUFxYGtG4NDBggk6/mzYELF4DKlZWOjNJQWBgwcSLg6KibfJUrJ2eaioqSuTqTL6KMx6hB+EWLFv1kEpbe54IkStfi4mQ1++vXZTX7H3+UVe75z0+mIARw6RLQqRNw5Yr2bV9/LedutLVVJjYiSllGJWCTJk3SqYRPRCkoSxZg4EA5j+OGDUD58kpHRGngxg15xnnBAt3b8uQB5s6VQwGJyHQYPAjf3NwcwcHBcMng9YZMbRAfmYBXr4Bnz4CSJeW6EMD798AHJV7I9Aghr1RctUr/7XfuAIUKpW1MROmVqX1/GzwGjOO/iFLBiRNyZuQmTeSgH0CebmTyZdIePJCnFM3NtZMvPz/g9OmEsm9MvohMl9FXQRJRClCpgJkzgTFjZBGnIkWA58+B7NmVjoxS0bVrwLJlwOzZ2u25cwPnzwN58yoTFxGlPYMTMJVKlZpxEGUeL14AAQHA7t1yvV074JdfgERFjsl0vH4N1KkjB9d/qHJlOe7ryy/TPi4iUpbRc0ES0Wc4ckSecty9WxZWXboUWLuWyZeJ+v57Of3Ph8lX+fJyOs+TJ5l8EWVWRs8FSUSfYfZs4OlTwMtLTt7HOWJM0qFDstcrsXLlgOXLZf5NRMQEjCgtLVsGFCwITJ4MODgoHQ2loNhY2bH59de6tx07BlSrlvYxEVH6xVOQRKnpwAHgu+/kJW0AkDOn7AVj8pXhCQFs2SJPJ1auDFhZ6SZfvXoBb94w+SIiXewBI0oN8fGyl+v77+U3daVKssYAZVgqFbBtm5wXfexY2eOVlHnzgH790i42Isp4mIARpbSnT4EOHeRAIADo1k3W+aIM6d07OS3n8uVJb9O9O9C+PVC9upxBiojoU5iAEaWkf/4BOnaUpSbs7WV5iQ4dlI6KjCQEsGKFPMW4a5fu7f7+gJOTLOOWL1/ax0dEGR8TMKKUMnMmMGKE/PYuU0Ze5Vi0qNJRkZFu3QKKFdNtr1kTmDhR9+pGIqLk4CB8opRSrpz8/e23wL//MvnKYISQPVsfJl99+8qpgw4fZvJFRCmHPWBEn+P5c0A9Qb2PD3D5csKk2pRhBAYCo0drt/30kxz7RUSUGpiAESVHbKz8xl66FDh3LmHWZCZfGUpEBFC1KnD1akKbszNw44asGEJElFp4CpLIWA8eADVqAD/+CISHA3/8oXRElAwLFgCOjtrJ15Ur8voJJl9ElNqYgBEZY/t2OZfMqVPy23vLFmDQIIWDImM1a6Zdp6t1a9mpyQ5MIkorPAVJZIiYGGD4cDkwCAAqVgTWrwc8PZWNi4yiUgEWFtpte/YAvr7KxENEmRd7wIgMMX9+QvI1ZAhw9CiTrwzm2jXd5CsigskXESmDCRiRIfr1Axo0AHbuBGbNkhP/UYYxcaLu6cW3b4GsWRUJh4iICRiRXlFRctJs9YR/VlbA7t1A06bKxkVGeftWThE0aVJC27hxsuaXvb1ycRERcQwY0Ydu35YVOS9ckJfEBQYqHREZ6f17oEQJecFqYkePyvkaiYiUxh4wosTWrwe+/FImX87Ocv4ZylBatJC9W4mTr9atgXv3mHwRUfrBHjAiAIiMlOUkliyR6zVqAOvWAW5uioZFxmnVSlYKUStYUNb2srVVLCQiIr2YgBHduiW7SC5fBszMgDFjgAkTgCx8e2Qkhw8DW7cmrL99y3FeRJR+8RuGSKWS56dcXIC1a+WcjpShPHwI1K6dsP76NZMvIkrfmIBR5qRSAeb/HwLp5SW7TkqXBlxdlY2LjHbmjKyLq7Z0KZA9u2LhEBEZhIPwKfO5elVOJ3TkSEJb/fpMvjKgwEDt5GvUKKB7d+XiISIyFHvAKPMQAli+HOjfXw66/+474PRpOe6LMpS3b2W+/PZtQtuUKXL4HhFRRsAEjDKHN2+Ab7+VY7wA2eO1Zg2TrwwoMlK7gn3evMDBg0DRosrFRERkLJ6CJNN36RJQvrxMviwsgKlTZVV7FxelIyMj/fsvYGeXsF65MvDkCZMvIsp42ANGpu36daBSJSA6Wtb0Wr+e1TgzqE2bAD+/hPXSpYGTJ5WLh4joc7AHjEyblxfQrBnQqBFw8SKTrwzo7l2gXDnt5GvKFOC//5SLiYjoc7EHjEzPhQuAp6esRWBmBqxaBVhbJ5SdoAzj4UOgcGHttrt3ZYV7IqKMjN9IZDqEAObPlwODuneX64Cch4bJV4Zx5468wtHMDChQIKG9cmXg0SMmX0RkGtgDRqYhLAzo1i1hLpq4OCAqipMAZjC3b+sfUD9kCDBrVtrHQ0SUWtgtQBnf6dNykNDWrYClJTB3LrBtG5OvDEIIYOdO2eOVOPmqVg14+lTezuSLiEwNe8Ao4xJCJlsjRgCxsXLc14YNQIUKSkdGBoqP1z/necOGwB9/yKohRESmiD1glHGFhwOzZ8vkq1Ur4Px5Jl8ZxIkTcrLsD5Ov8eNlXr1rF5MvIjJt7AGjjCt7dmDdOllotU8fVrVP51QqYOBAeZ1EUrfzEBJRZsEeMMo4VCpgxgxg9eqEturVgb59+c2djj14AFStKnu0Pky+mjcH3r+XvV48hESUmbAHjDKGFy+AgAA5hZCdHVCnDuDurnRUlITYWDnpwIYNwF9/6d4+bRowfDiTLiLKvJiAUfp39CjQtq28JM7GRg68z5dP6agoCYcPA7Vr67bnySOH6bm6pnlIRETpDk9BUvqlUgE//CC/zZ8+BYoVA06dAnr0YNdJOhMdDYwcKQ/Lh8lXly7A48fAs2dMvoiI1NgDRulTfDzQuDHw999yvVMnYOFCwMFB2bhIixDAggVA//66ty1cCHz7bdrHRESUEbAHjNInCwugfHk53mvFCjnwnslXunH5MvD993KGp8TJl4sLsGiR7Lxk8kVElLR0kYAtWLAAHh4esLGxQaVKlXD69Okkt126dClq1KgBJycnODk5wcfH56PbUwYSHy8H26tNnAhcvCjPYVG68Po14OMDfPGFrNmV2NGjQEgI0Ls3zxATEX2K4gnYhg0bMGTIEEyYMAHnz59HmTJl4Ovri+fPn+vd/tChQ2jXrh0OHjyIkydPwt3dHfXr18eTJ0/SOHJKUc+eAV99JUugR0fLtixZgCJFlI0rkxNClpHYvRtwcwNy5AD270+4vVkzWTRVCFkRhIiIDGMmhBBKBlCpUiVUqFAB8/9fIEilUsHd3R39+/fHyJEjP3n/+Ph4ODk5Yf78+ejcufMnt4+IiICjoyPCw8ORLVu2z46fUsA//wAdO8reL3t74MABoGJFpaPKtIQAliwBxo4FQkP1b+PnJ2vgmiv+LxwRZRam9v2t6MdnTEwMzp07Bx8fH02bubk5fHx8cPLkSYP28f79e8TGxiJHjhypFSallrg4YMwYoEEDmXx98QVw7hyTrzT06JFMpIoVk6cNc+aUSVXv3rrJl5sbMGCArPG1YQOTLyKiz6HoVZChoaGIj49H7ty5tdpz586NGzduGLSPESNGIG/evFpJXGLR0dGIVp/SgsygKR14/Bho314OHAKAXr2AOXMAW1tl48oERo0Cjh2TPx969Sph2cwMqFVLll0rUybNwiMiyhQydBmKadOmYf369Th06BBsbGz0bhMYGIhJkyalcWT0ST16yOQra1Zg6VLA31/piExaRIS8OjGps/pVqwJly8pqH3nyALlyybPBRESUOhRNwJydnWFhYYGQkBCt9pCQEOTJk+ej9/3xxx8xbdo07Nu3D1988UWS240aNQpDhgzRrEdERMCdU9gob8ECoHt3OdiocGGlozFZQgCBgfJM74fWrQPq1ZPJFhERpS1FR3FYWVnB29sb+xNdVqVSqbB//35UqVIlyfvNmDED33//Pfbs2YPy5ct/9DGsra2RLVs2rR9SwMOHwK+/JqwXLCgH2zP5ShUxMbLqvLm5bvL1118yMWvblskXEZFSFD8FOWTIEAQEBKB8+fKoWLEi5s6di3fv3qFr164AgM6dO8PNzQ2BgYEAgOnTp2P8+PH4/fff4eHhgeDgYACAg4MDHFioM33auVPW8goLA/LnB+rXVzoikyUEsHmzvEoxscKFZUk1nlYkIkofFE/A/P398eLFC4wfPx7BwcEoW7Ys9uzZoxmY//DhQ5gnutxq0aJFiImJQevWrbX2M2HCBEycODEtQ6dPiYkBRoyQo7gBoEIF1vVKRXv36s9tQ0Pl1Y1ERJR+KF4HLK2ZWh2RdOv+fTmw/swZuT54MDBtGmBlpWxcJuT1a2D5clkk9fp1OV95YpMm6VarJyLKqEzt+1vxHjAyQdu3y1OO4eGAkxOwcqUsmU6fLSREntEdOlRe2ajPrFlAoutOiIgoHWICRikvIkImX1WqAOvXy3FflCxCAM+fA8ePA61a6d+mSBE5kUDp0kCjRoC1ddrGSERExmMCRikjPh6wsJDLnTsDNjZAixaApaWycWVAQUHAtm2yJyupKU6dnWUv2LBhrEhPRJQR8aObPt/69bL7JfHcNX5+TL6MNHWqrD7v6SlPISZOvszNgaZNgdWrZa/Yixfy+gYmX0REGRN7wCj5IiOBQYNkMVUAmD1bZhFksAULZNmIQ4d0b8uTB/juO6BrV17FSERkapiAUfLcuCF7uS5flt02o0cDLAPySQ8eyItB//5bXiiqz8qVQEBAmoZFRERpjAkYGW/NGuDbb4F37wAXF+C334CvvlI6qnQtLu7jZ2QnTpTzkX9iBi4iIjIRTMDIOL/8AvTuLZfr1AHWrpVz3pCW6Gjg55+BXbv0n140M5PjvFq1AipXlutERJR5MAEj47RtC/z4o6x7MHZswpWPmVxIiMxDCxSQVzF+jErFhIuIKLPjNVT0cUIA+/fL3wDg6Aj89x8wYQKTLwDXrgHu7vLUoRD6k69vv5XTBL1/L7dh8kVEROwBo6S9fQv06SPHfC1cKDMJALC1VTaudCAuDihXDrhyRbvdxUUmWzlyyB4x5qhERKQPEzDS77//5FWON2/KYlPv3ikdUbrw/r0c19WmjXZ7uXLAgQNA9uyKhEVERBkMEzDSJoSs6zVwoBxJ7uYGrFsH1KihdGSKGzECmDFDtz08HDCBeWGJiCgNcQwYJYiIANq1k1c5RkcDDRsCFy9m+uRLpQLq1dNNvqZMkfkqky8iIjIWe8AowZUrwKZNcuBSYKAsw55J57oRQhZMvX5dDoFL7PlzIFcuZeIiIiLTwASMElStCsyfD5QtC1SponQ0inj1Kulpf2rWBP75B7C2TtuYiIjI9GTO7g2SwsKATp1kN4/at99myuRLpQK6d9effE2cCDx6BBw+zOSLiIhSBnvAMqszZwB/fzkh4bVrwNmzmbZA1c2bgJeXdlvu3LLd0VGZmIiIyLSxByyzEQKYOxeoVk0mXx4ewOLFmTb5On5cN/kKCgKCg5l8ERFR6mEClpm8egU0bw4MHgzExgItWwIXLgAVKigdWZoLDgYaNwaqV09o691b5qcFCigXFxERZQ5MwDKL+/dltdCdOwErKznYfvPmTFM59P17Wc6sdGnZ2efqKguqqs2aBSxapFx8RESUuXAMWGbh7g7kzw9YWgIbNwJffql0RGlmxw7Z8adP8eLyNKSTU5qGREREmRwTMFP28iWQNavs8cqSRdb4srPLNJVDo6MBT0/g2bOEtixZ5GnHAQPkKUgrK+XiIyKizIunIE3V0aNAmTJy/hy1PHkyRfIVGSkTLBsb7eSrVy95KvLgQaBFCyZfRESkHCZgpkalAqZOBerUAZ48AfbsyTQTaZ87J8d32dkB8+YltLduDcTHy4s9LS2Vi4+IiEiNCZgpef4caNAAGDNGZhwdO8p6X/b2SkeWqh48kCXNypfXbs+bFzh/Xp55zaQzKhERUTrFMWCm4uBBoH17WV/B1hZYsADo0sVk63u9fQs0bSqL+IeEaN/Wpw8wezar1hMRUfrFBMwUREQArVoBr18DJUrIqxxLllQ6qlTz8KH+Wl3OzsCGDUDdumkfExERkTF4YsYUZMsG/PIL0LUrcPq0SSdf165pJ1+VKgG3bgExMcCLF0y+iIgoY2ACllHt2wccOJCw3qYNsHy5yY73evUKcHPTzi0nTgT+/RcoUoSD64mIKGNhApbRxMUBY8cC9esD7dpp11kwMXFxwLRpsl5XzpzA06cJt61ZA0yYoFxsREREn4NjwDKSJ09k0nX0qFxv3twkpxKKjJRXNf7xh+5tNWvKyvYm+LSJiCgTYQKWUezeDXTuDISGAg4OwNKlQNu2SkeVoh4+BCpX1t+pN2AAMGwYkC9f2sdFRESU0piApXcqFTBqFDBjhlwvV05e6lekiLJxpaBXr4Bu3YDt27XbixYFjhwBcudWJCwiIqJUwzFg6Z25uaztBQB9+wInTphE8hUfDyxcKJOrnDm1k69mzYC7d4GbN5l8ERGRaWIPWHoVFydnjgZkUdU2bYAmTZSNKQW8eQP8+CMwebLubV27ArNmAU5OaR8XEaUPQgjExcUhPj5e6VBIAZaWlrCwsFA6jDTBBCy9iYkBRo4E7tyRo83NzOSYrwyefD17JqcG+lCOHEBgoBzeZmOT9nERUfoRExODZ8+e4f3790qHQgoxMzNDvnz54ODgoHQoqY4JWHpy/768/O/MGbl+6JCcVDuDiokBVqyQQ9hev9a+rUYNOTl2iRLKxEZE6YtKpcL9+/dhYWGBvHnzwsrKCmYmOpUa6SeEwIsXL/D48WMUKVLE5HvCmIClF1u3At98A4SHyxoLK1dmyOQrPl7W7ho7Vv/tRYsCV66wcCoRaYuJiYFKpYK7uzvs7OyUDocUkitXLgQFBSE2NtbkEzAOwldadDTQv7+cyzE8XNZhuHgR+PprpSMzyp9/yt6sLFl0k6+sWYHvvweiouTAeiZfRJQUc3N+LWVmmanXkz1gSuvQAdiyRS4PGwb88EOGyVDevpWhd+mie1vJksCYMTKP5D+zRERE2piAKW3ECFlaYulSOedOOiQEsHEjcO8ecOoUkCsXcOwYcOOG7rbt2gG9e8uK9URERKQf+3rTWmQkcPhwwnqFCjKzSafJ16NHshRZ27bA6NHywsxff9VNvvr3B2Jjgd9/Z/JFRJnPyZMnYWFhgcZ6PssPHToEMzMzhIWF6dzm4eGBuXPnarUdPHgQjRo1Qs6cOWFnZ4cSJUrgu+++w5MnT1IpeiAqKgp9+/ZFzpw54eDggFatWiEkJOSj95k4cSK8vLxgb28PJycn+Pj44NSpU5rbg4KC0K1bN3h6esLW1haFChXChAkTEBMTk2rPIyNhApaWbt6UY7x8feU4L7V0WH/hzBmgeHEgf37t9rZtgaZN5ZiubdtkoX4hgJ9/TihbRkSU2Sxbtgz9+/fHkSNH8PTp02Tv55dffoGPjw/y5MmDLVu24Nq1a1i8eDHCw8Mxa9asFIxY2+DBg/HHH39g06ZNOHz4MJ4+fYqWLVt+9D5FixbF/PnzcfnyZRw7dgweHh6oX78+Xrx4AQC4ceMGVCoVfvnlF1y9ehVz5szB4sWLMXr06FR7HhmKyGTCw8MFABEeHp62D/zbb0LY2wsBCJErlxAHD6bt4xvo9WsZ4oc/X3+tdGREZMoiIyPFtWvXRGRkpNKhGO3NmzfCwcFB3LhxQ/j7+4sffvhB6/aDBw8KAOL169c69y1QoICYM2eOEEKIR48eCSsrKzFo0CC9j6Pv/ikhLCxMWFpaik2bNmnarl+/LgCIkydPGrwf9ffrvn37ktxmxowZwtPTM8nbP/Z3oNj3dyphD1hqe/8e6N4d6NgRePcOqF1b9n7Vrq1wYNqePwemTtWtQt+7t6xe/+E8jUREqU0I+bGZ1j9CGBfnxo0b4eXlhWLFiqFjx45Yvnw5hLE7AbBp0ybExMRg+PDhem/Pnj17kvdt2LAhHBwckvwpWbJkkvc9d+4cYmNj4ePjo2nz8vJC/vz5cfLkSYNij4mJwZIlS+Do6IgyZcokuV14eDhy5Mhh0D5NHU8apaZr1wA/P+DqVVnRfvx4YNw4IJ3UNnn9WhZK/e473dsGDQLmzEnzkIiINN6/lxOBpLW3bwF7e8O3X7ZsGTp27AgAaNCgAcLDw3H48GHUNvIf7du3byNbtmxwdXU16n4A8OuvvyIyMjLJ2y0/cnV9cHAwrKysdBK83LlzI1g9F3ES/vzzT7Rt2xbv37+Hq6sr9u7dC2dnZ73b3rlzB/PmzcOPP/740X1mFkzAUtOOHTL5ypMHWLsWqFtX6YgQHw9UqwacPSuXP+TrKxOyr75K+9iIiDKamzdv4vTp09i2bRsAIEuWLPD398eyZcuMTsCEEMmug+Xm5pas+32uOnXq4OLFiwgNDcXSpUvh5+eHU6dOwcXFRWu7J0+eoEGDBmjTpg169OihSKzpDROw1DR8uOzP7t8fyJ1b0VBUKjlQfvBg/bf7+AB//JEurwcgokzKzk72RinxuIZatmwZ4uLikDfRZLdCCFhbW2P+/PlwdHREtmzZAMjTbx/2MoWFhcHR0RGAHNQeHh6OZ8+eGd0L1rBhQxw9ejTJ2wsUKICrV6/qvS1PnjyIiYlBWFiYVnwhISHIkyfPRx/X3t4ehQsXRuHChVG5cmUUKVIEy5Ytw6hRozTbPH36FHXq1EHVqlWxZMkSo56XKWMClpIuXwYmTwZWrwZsbeWpxilTlI4Kv/0GdOqk2751K1C/vnFd7UREacXMLH1/PsXFxWH16tWYNWsW6tevr3Vb8+bNsW7dOvTu3RtFihSBubk5zp07hwIFCmi2uXfvHsLDw1G0aFEAQOvWrTFy5EjMmDEDc/SMAfkwQUrsc05Bent7w9LSEvv370erVq0AyJ69hw8fokqVKkneTx+VSoXo6GjN+pMnT1CnTh14e3tjxYoVnOkgMYUvAkhzqXIVhUolxJIlQtjYyEsGhw9PuX0nw4sXQsyZI0SOHLpXM3p5CXH6tKLhERHpyIhXQW7btk1YWVmJsLAwnduGDx8uypcvr1nv2bOn8PDwEDt27BD37t0Thw8fFpUrVxaVK1cWKpVKs92CBQuEmZmZ+Oabb8ShQ4dEUFCQOHbsmOjZs6cYMmRIqj2X3r17i/z584sDBw6Is2fPiipVqogqVapobVOsWDGxdetWIYQQb9++FaNGjRInT54UQUFB4uzZs6Jr167C2tpaXLlyRQghxOPHj0XhwoVFvXr1xOPHj8WzZ880P0nJTFdBMgH7/B0K0bZtQobToIEQz5+nzL4NcPWqEL//LkTJkkK4u+svIaH+2bkzzcIiIjJKRkzAmjRpIho1aqT3tlOnTgkA4tKlS0II+fwmTJggvLy8hK2trfD09BQ9e/YUL1680Lnv3r17ha+vr3BychI2NjbCy8tLDB06VDx9+jTVnktkZKTo06ePcHJyEnZ2dqJFixY6iRIAsWLFCs32LVq0EHnz5hVWVlbC1dVVNGvWTJxO9B/+ihUrBAC9Px+LI7MkYGZCJONa2QwsIiICjo6OCA8P15yXT7YLF+RVjnfuyNONU6cCQ4fK0vGp4Px54MkTOX/3ihXArl0f397CAmjQAPjxR8DLK1VCIiJKEVFRUbh//z48PT1hw8GomdbH/g5S9Ps7HeAYsOTatk2WhY+JAdzdgfXrgapVP3u3UVHAs2fA48dy/P7168CQIR+/T/78QHg4UKaMHHJWrBjg7JxqeSARERF9JiZgyVW+vCxQU62a7I7KmfOTd4mJkZ1mwcHApUtyWshbt4C4ODm34q1bhj10tWpyjL+tLTB/vu50QURERJS+MQEzxpMngLrWirs7cPo0ULCgvFQnkbg44OFDYO9e4PhxmWxZWgLnzhn+UDlzAi9fAlWqyB6xkiVlKbH/X61MREREGRgTMEOoZ5sePhzYtAlo1gyvXgFTFxXCq1fA0aOyzNfx43Lclb4Cp4l5eMiEzNkZKFdOrru4yB6yChXkqcRk1uIjIiKiDIAJ2Ke8egV8842sag/g/k87UfDrZjqb3bkjf3+YfJUoIZOz2rWBevVkwmVMkT8iIiIyPUzAPuLN3n+h8vOHY9hDRMMK32EWFhzoq7Pd0KFyEuuyZWWy5ekJZM0qe7mIiMhwmezCfPpAZjr+TMASiYsDfvoJ2Pu3CrUvzMZ3oaNgiTjcQSH4YwPOwxsA8OWXMtlatAiwslI2ZiIiU6Cu1P7+/XvY2toqHA0pJSYmBgBgYWGhcCSpjwkY5FxjxYoBT5/K9Vo4gpEYBgDYZOaHbmIpug7IhiWdAW9vBQMlIjJRFhYWyJ49O54/fw4AsLOzS/bE1JQxqVQqvHjxAnZ2dsiSxfTTE9N/hp+wfj3Qrp1222HUxr+VBqJgIy+0GdcLbfghQESU6tQTP6uTMMp8zM3NkT9//kyRfGfqBOy774DZswEzqDAQPyF773YYMScPZPHduQpHR0SUuZiZmcHV1RUuLi6IjY1VOhxSgJWVVaaZsDtdJGALFizAzJkzERwcjDJlymDevHmoWLFikttv2rQJ48aNQ1BQEIoUKYLp06ejUaNGRj3m9u0y+cqF51iDTvDFP8CtPwGrvQAyx8EnIkqPLCwsMsUYIMrcFM80NmzYgCFDhmDChAk4f/48ypQpA19f3yS7oE+cOIF27dqhW7duuHDhApo3b47mzZvjypUrRj1uQABQC4dwEWVl8mVrC3TowAJcRERElOoUn4y7UqVKqFChAubPnw9ADsJzd3dH//79MXLkSJ3t/f398e7dO/z555+atsqVK6Ns2bJYvHjxJx9PPZnncIzCVEyHBVRA8eLAxo1AqVIp98SIiIgoxZjaZNyK9oDFxMTg3Llz8PHx0bSZm5vDx8cHJ0+e1HufkydPam0PAL6+vklun5QxCJTJV9euwJkzTL6IiIgozSg6Biw0NBTx8fHInTu3Vnvu3Llx48YNvfcJDg7Wu31wcLDe7aOjoxEdHa1ZDw8Pl/uBDV5P/wlOvdvK8vUREZ/zVIiIiCgVRfz/e9pUirWmi0H4qSkwMBCTJk3SaS+GKGBEL/lDREREGcLLly/h6OiodBifTdEEzNnZGRYWFggJCdFqDwkJ0dSD+VCePHmM2n7UqFEYMmSIZj0sLAwFChTAw4cPTeIAZmQRERFwd3fHo0ePTOJ8fkbH45F+8FikHzwW6Ud4eDjy58+PHDlyKB1KilA0AbOysoK3tzf279+P5s2bA5CD8Pfv349+/frpvU+VKlWwf/9+DBo0SNO2d+9eVKlSRe/21tbWsLa21ml3dHTkmymdyJYtG49FOsLjkX7wWKQfPBbph6nUCVP8FOSQIUMQEBCA8uXLo2LFipg7dy7evXuHrl27AgA6d+4MNzc3BAYGAgAGDhyIWrVqYdasWWjcuDHWr1+Ps2fPYsmSJUo+DSIiIiKDKZ6A+fv748WLFxg/fjyCg4NRtmxZ7NmzRzPQ/uHDh1rZbtWqVfH7779j7NixGD16NIoUKYLt27ejFK9iJCIiogxC8QQMAPr165fkKcdDhw7ptLVp0wZt2rRJ1mNZW1tjwoQJek9LUtrisUhfeDzSDx6L9IPHIv0wtWOheCFWIiIioszGNEayEREREWUgTMCIiIiI0hgTMCIiIqI0ZpIJ2IIFC+Dh4QEbGxtUqlQJp0+f/uj2mzZtgpeXF2xsbFC6dGns2rUrjSI1fcYci6VLl6JGjRpwcnKCk5MTfHx8PnnsyDjGvjfU1q9fDzMzM029Pvp8xh6LsLAw9O3bF66urrC2tkbRokX5WZVCjD0Wc+fORbFixWBrawt3d3cMHjwYUVFRaRSt6Tpy5AiaNm2KvHnzwszMDNu3b//kfQ4dOoQvv/wS1tbWKFy4MFauXJnqcaYYYWLWr18vrKysxPLly8XVq1dFjx49RPbs2UVISIje7Y8fPy4sLCzEjBkzxLVr18TYsWOFpaWluHz5chpHbnqMPRbt27cXCxYsEBcuXBDXr18XXbp0EY6OjuLx48dpHLlpMvZ4qN2/f1+4ubmJGjVqiK+//jptgjVxxh6L6OhoUb58edGoUSNx7Ngxcf/+fXHo0CFx8eLFNI7c9Bh7LNauXSusra3F2rVrxf3798Xff/8tXF1dxeDBg9M4ctOza9cuMWbMGLF161YBQGzbtu2j29+7d0/Y2dmJIUOGiGvXrol58+YJCwsLsWfPnrQJ+DOZXAJWsWJF0bdvX816fHy8yJs3rwgMDNS7vZ+fn2jcuLFWW6VKlUSvXr1SNc7MwNhj8aG4uDiRNWtWsWrVqtQKMVNJzvGIi4sTVatWFb/++qsICAhgApZCjD0WixYtEgULFhQxMTFpFWKmYeyx6Nu3r6hbt65W25AhQ0S1atVSNc7MxpAEbPjw4aJkyZJabf7+/sLX1zcVI0s5JnUKMiYmBufOnYOPj4+mzdzcHD4+Pjh58qTe+5w8eVJrewDw9fVNcnsyTHKOxYfev3+P2NhYk5n3S0nJPR6TJ0+Gi4sLunXrlhZhZgrJORY7d+5ElSpV0LdvX+TOnRulSpXC1KlTER8fn1Zhm6TkHIuqVavi3LlzmtOU9+7dw65du9CoUaM0iZkSZPTv73RRiDWlhIaGIj4+XlNFXy137ty4ceOG3vsEBwfr3T44ODjV4swMknMsPjRixAjkzZtX5w1GxkvO8Th27BiWLVuGixcvpkGEmUdyjsW9e/dw4MABdOjQAbt27cKdO3fQp08fxMbGYsKECWkRtklKzrFo3749QkNDUb16dQghEBcXh969e2P06NFpETIlktT3d0REBCIjI2Fra6tQZIYxqR4wMh3Tpk3D+vXrsW3bNtjY2CgdTqbz5s0bdOrUCUuXLoWzs7PS4WR6KpUKLi4uWLJkCby9veHv748xY8Zg8eLFSoeW6Rw6dAhTp07FwoULcf78eWzduhV//fUXvv/+e6VDowzGpHrAnJ2dYWFhgZCQEK32kJAQ5MmTR+998uTJY9T2ZJjkHAu1H3/8EdOmTcO+ffvwxRdfpGaYmYaxx+Pu3bsICgpC06ZNNW0qlQoAkCVLFty8eROFChVK3aBNVHLeG66urrC0tISFhYWmrXjx4ggODkZMTAysrKxSNWZTlZxjMW7cOHTq1Andu3cHAJQuXRrv3r1Dz549MWbMGK25iyl1JfX9nS1btnTf+wWYWA+YlZUVvL29sX//fk2bSqXC/v37UaVKFb33qVKlitb2ALB3794ktyfDJOdYAMCMGTPw/fffY8+ePShfvnxahJopGHs8vP7X3v3HRF3/cQB/3qH3o+MORsa4k/MHGNRcSmfShBrhjziXSf5CiykISYNOXE2LNfOgQm0JDZ2V1OSUGL9chYsBxYINzpWoHDTBQxCk5pUrHEiCwN3r+0fjM09+GOr3MHo9ts8fn/fn/X5/Xu/Pezdee3/edzz2GH7++WdYLBbhWL16NcLDw2GxWKDVal0Z/pRyN5+N0NBQtLa2CkkwALS0tECtVnPydQ/uZi5u3LgxIskaToyJ/7OfS/3r/35P9rcA7reCggKSSqVkMpmoqamJEhISyNPTk3777TciItq8eTOlpKQI9c1mM02bNo0OHDhAzc3NZDQa+Wco7pOJzsX+/ftJIpHQiRMnyGazCcf169cnawhTykTn43b8Lcj7Z6Jz0dnZSUqlkgwGA1mtVvr222/J29ubPvjgg8kawpQx0bkwGo2kVCopPz+fLl26RN999x35+/tTVFTUZA1hyrh+/TrV19dTfX09AaDMzEyqr6+ny5cvExFRSkoKbd68Wag//DMUu3btoubmZjp8+DD/DMVkO3ToEM2aNYskEgkFBwfTjz/+KFwLCwujmJgYp/pFRUUUEBBAEomE5s+fT6WlpS6OeOqayFzMnj2bAIw4jEaj6wOfoib62bgVJ2D310Tn4tSpU/T000+TVColPz8/Sk9Pp6GhIRdHPTVNZC4GBwcpNTWV/P39SSaTkVarpaSkJLp27ZrrA59iqqqqRv0bMPz8Y2JiKCwsbESboKAgkkgk5OfnRzk5OS6P+26JiHjNlDHGGGPMlabUHjDGGGOMsX8DTsAYY4wxxlyMEzDGGGOMMRfjBIwxxhhjzMU4AWOMMcYYczFOwBhjjDHGXIwTMMYYY4wxF+MEjDHGGGPMxTgBY4w5MZlM8PT0nOww7ppIJMI333wzbp3Y2Fi89NJLLomHMcZGwwkYY1NQbGwsRCLRiKO1tXWyQ4PJZBLiEYvF8PX1xdatW3H16tX70r/NZsPKlSsBAB0dHRCJRLBYLE51srKyYDKZ7sv9xpKamiqM083NDVqtFgkJCejq6ppQP5wsMjY1TZvsABhj/x96vR45OTlOZY888sgkReNMpVLBarXC4XCgoaEBW7duxZUrV1BRUXHPffv4+NyxjoeHxz3f55+YP38+KisrYbfb0dzcjLi4OHR3d6OwsNAl92eMPbh4BYyxKUoqlcLHx8fpcHNzQ2ZmJp544gkoFApotVokJSWht7d3zH4aGhoQHh4OpVIJlUqFRYsW4cyZM8L12tpaPPvss5DL5dBqtUhOTsZff/01bmwikQg+Pj7QaDRYuXIlkpOTUVlZib6+PjgcDrz33nvw9fWFVCpFUFAQysvLhbYDAwMwGAxQq9WQyWSYPXs29u3b59T38CvIuXPnAgCefPJJiEQiPPfccwCcV5Wys7Oh0WjgcDicYoyMjERcXJxwXlJSAp1OB5lMBj8/P6SlpWFoaGjccU6bNg0+Pj6YOXMmli9fjg0bNuD7778XrtvtdsTHx2Pu3LmQy+UIDAxEVlaWcD01NRXHjh1DSUmJsJpWXV0NAPjll18QFRUFT09PeHl5ITIyEh0dHePGwxh7cHACxth/jFgsxsGDB3H+/HkcO3YMP/zwA956660x60dHR8PX1xd1dXU4e/YsUlJSMH36dABAW1sb9Ho91q1bh8bGRhQWFqK2thYGg2FCMcnlcjgcDgwNDSErKwsZGRk4cOAAGhsbERERgdWrV+PixYsAgIMHD+LkyZMoKiqC1WpFXl4e5syZM2q/p0+fBgBUVlbCZrPhq6++GlFnw4YN+PPPP1FVVSWUdXV1oby8HNHR0QCAmpoabNmyBTt27EBTUxOOHDkCk8mE9PT0fzzGjo4OVFRUQCKRCGUOhwO+vr4oLi5GU1MT9uzZg3feeQdFRUUAgJ07dyIqKgp6vR42mw02mw0hISEYHBxEREQElEolampqYDab4e7uDr1ej4GBgX8cE2NsEhFjbMqJiYkhNzc3UigUwrF+/fpR6xYXF9PDDz8snOfk5JCHh4dwrlQqyWQyjdo2Pj6eEhISnMpqampILBZTX1/fqG1u77+lpYUCAgLoqaeeIiIijUZD6enpTm0WL15MSUlJRES0fft2Wrp0KTkcjlH7B0Bff/01ERG1t7cTAKqvr3eqExMTQ5GRkcJ5ZGQkxcXFCedHjhwhjUZDdrudiIiWLVtGe/fudeojNzeX1Gr1qDEQERmNRhKLxaRQKEgmkxEAAkCZmZljtiEiev3112ndunVjxjp878DAQKdncPPmTZLL5VRRUTFu/4yxBwPvAWNsigoPD8enn34qnCsUCgB/rwbt27cPFy5cQE9PD4aGhtDf348bN27goYceGtHPm2++iVdffRW5ubnCazR/f38Af7+ebGxsRF5enlCfiOBwONDe3o7HH3981Ni6u7vh7u4Oh8OB/v5+PPPMM/jiiy/Q09ODK1euIDQ01Kl+aGgoGhoaAPz9+nDFihUIDAyEXq/HqlWr8Pzzz9/Ts4qOjsa2bdvwySefQCqVIi8vD5s2bYJYLBbGaTabnVa87Hb7uM8NAAIDA3Hy5En09/fjyy+/hMViwfbt253qHD58GEePHkVnZyf6+vowMDCAoKCgceNtaGhAa2srlEqlU3l/fz/a2tru4gkwxlyNEzDGpiiFQoF58+Y5lXV0dGDVqlVITExEeno6vLy8UFtbi/j4eAwMDIyaSKSmpuKVV15BaWkpysrKYDQaUVBQgDVr1qC3txevvfYakpOTR7SbNWvWmLEplUqcO3cOYrEYarUacrkcANDT03PHcel0OrS3t6OsrAyVlZWIiorC8uXLceLEiTu2HcuLL74IIkJpaSkWL16MmpoafPzxx8L13t5epKWlYe3atSPaymSyMfuVSCTCHOzfvx8vvPAC0tLS8P777wMACgoKsHPnTmRkZGDJkiVQKpX46KOP8NNPP40bb29vLxYtWuSU+A57UL5owRgbHydgjP2HnD17Fg6HAxkZGcLqzvB+o/EEBAQgICAAb7zxBl5++WXk5ORgzZo10Ol0aGpqGpHo3YlYLB61jUqlgkajgdlsRlhYmFBuNpsRHBzsVG/jxo3YuHEj1q9fD71ej66uLnh5eTn1N7zfym63jxuPTCbD2rVrkZeXh9bWVgQGBkKn0wnXdTodrFbrhMd5u927d2Pp0qVITEwUxhkSEoKkpCShzu0rWBKJZET8Op0OhYWF8Pb2hkqluqeYGGOTgzfhM/YfMm/ePAwODuLQoUO4dOkScnNz8dlnn41Zv6+vDwaDAdXV1bh8+TLMZjPq6uqEV4tvv/02Tp06BYPBAIvFgosXL6KkpGTCm/BvtWvXLnz44YcoLCyE1WpFSkoKLBYLduzYAQDIzMxEfn4+Lly4gJaWFhQXF8PHx2fUH4/19vaGXC5HeXk5fv/9d3R3d4953+joaJSWluLo0aPC5vthe/bswfHjx5GWlobz58+jubkZBQUF2L1794TGtmTJEixYsAB79+4FADz66KM4c+YMKioq0NLSgnfffRd1dXVObebMmYPGxkZYrVb88ccfGBwcRHR0NGbMmIHIyEjU1NSgvb0d1dXVSE5Oxq+//jqhmBhjk2SyN6Exxu6/0TZuD8vMzCS1Wk1yuZwiIiLo+PHjBICuXbtGRM6b5G/evEmbNm0irVZLEomENBoNGQwGpw32p0+fphUrVpC7uzspFApasGDBiE30t7p9E/7t7HY7paam0syZM2n69Om0cOFCKisrE65nZ2dTUFAQKRQKUqlUtGzZMjp37pxwHbdswici+vzzz0mr1ZJYLKawsLAxn4/dbie1Wk0AqK2tbURc5eXlFBISQnK5nFQqFQUHB1N2dvaY4zAajbRw4cIR5fn5+SSVSqmzs5P6+/spNjaWPDw8yNPTkxITEyklJcWp3dWrV4XnC4CqqqqIiMhms9GWLVtoxowZJJVKyc/Pj7Zt20bd3d1jxsQYe3CIiIgmNwVkjDHGGPtv4VeQjDHGGGMuxgkYY4wxxpiLcQLGGGOMMeZinIAxxhhjjLkYJ2CMMcYYYy7GCRhjjDHGmItxAsYYY4wx5mKcgDHGGGOMuRgnYIwxxhhjLsYJGGOMMcaYi3ECxhhjjDHmYpyAMcYYY4y52P8AsLE2bHhC/jYAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -1608,14 +1836,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.29887914657592773\n", - "lead_lag: True inv_rest: False thres_distance: 4000 auc: 0.8444444444444444\n", - "fit_time: 2.1973140239715576\n" + "compute_auc_time: 264.1860752105713\n", + "lead_lag: True inv_rest: False thres_distance: 4000 auc: 0.32076046\n", + "Threshold distance: 8000\n", + "lead_lag: True\n", + "inv_reset: False\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 15.445886135101318\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1627,14 +1861,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.32749319076538086\n", - "lead_lag: True inv_rest: False thres_distance: 8000 auc: 0.7622222222222221\n", - "fit_time: 2.0311882495880127\n" + "compute_auc_time: 262.2999367713928\n", + "lead_lag: True inv_rest: False thres_distance: 8000 auc: 0.83433212\n", + "Threshold distance: 16000\n", + "lead_lag: True\n", + "inv_reset: False\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 16.100723266601562\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1646,14 +1886,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.3115198612213135\n", - "lead_lag: True inv_rest: False thres_distance: 16000 auc: 0.7611111111111112\n", - "fit_time: 2.1606862545013428\n" + "compute_auc_time: 269.2015371322632\n", + "lead_lag: True inv_rest: False thres_distance: 16000 auc: 0.53346636\n", + "Threshold distance: 32000\n", + "lead_lag: True\n", + "inv_reset: False\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 16.689249992370605\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAHHCAYAAAAPuHTSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8/ElEQVR4nO3dd1hTZxsG8DsgW4aKCCoK7r1wK04qbqkLN26ts1L3Qlv3to66Z7XirNZZ97YOxLon1AmKCsiQlff743xEI0EJBA6Q+3ddufS8OefkSU7GwzsVQggBIiIiIsp0DOQOgIiIiIg0Y6JGRERElEkxUSMiIiLKpJioEREREWVSTNSIiIiIMikmakRERESZFBM1IiIiokyKiRoRERFRJsVEjYiIiCiTynaJmpOTE3r27Cl3GHqnQYMGaNCggdxhfNOUKVOgUCgQEhIidyiZjkKhwJQpU3RyrsDAQCgUCmzYsEEn50sphUKBIUOGZOhjfo2u4zl16hQUCgVOnTr1zX3T+pn88v2wYcMGKBQKBAYGpvqclD0MGjQI33333Tf30+b9mh4y0/f9ihUrUKhQIcTExGh9rFaJWuIHNfGWI0cOFChQAD179sSLFy+0fnB9EhkZiV9++QUVKlSAubk5rK2t4erqik2bNiGrrOJ1584dTJkyJVN+USckJGD9+vVo0KABcufODRMTEzg5OaFXr164evWq3OHpxNatW7Fo0SK5w1CT3jE1aNBA7TsnuZuuEkzSraioKEyZMkW2H+qMcubMGbRu3RqOjo4wNTWFvb09mjZtivPnz6vtFxUVhWXLlqFJkyZwcHCApaUlKleujN9++w0JCQlJzqtUKjFnzhw4OzvD1NQUFSpUwB9//KExhrt376Jp06bImTMncufOje7du+PNmzdpOqcmAQEBWLNmDcaPH5/iY9LbjBkz8Oeff8ry2CNGjECVKlWQO3dumJubo3Tp0pgyZQoiIiLU9uvZsydiY2OxcuVKrR8jR2oC+/nnn+Hs7IyPHz/i0qVL2LBhA86dO4dbt27B1NQ0NafUmfv378PAIHNVFAYHB6Nx48a4e/cuOnXqhCFDhuDjx4/YtWsXvLy8cPDgQWzZsgWGhoZyh/pVd+7cwdSpU9GgQQM4OTmp3ff333/LExSA6OhotG3bFocPH0a9evUwfvx45M6dG4GBgdi+fTs2btyIp0+fomDBgrLFqAtbt27FrVu38OOPP6bL+aOjo5Ejh3ZfCcnFVLhwYURHR8PIyChNMU2YMAF9+/ZVbV+5cgW//vorxo8fj9KlS6vKK1SokKbHoW/r3r07OnXqBBMTkxQfExUVhalTpwJAlqhxT60HDx7AwMAAAwcOhL29Pd6/f4/ff/8d9erVw4EDB9C0aVMAwJMnTzB06FA0btwY3t7esLKywpEjRzBo0CBcunQJGzduVDvvhAkTMGvWLPTr1w/VqlXD3r170aVLFygUCnTq1Em13/Pnz1GvXj1YW1tjxowZiIiIwLx583Dz5k1cvnwZxsbGWp8zOYsXL4azszMaNmyoo1cv7WbMmIH27dvDw8Mjwx/7ypUrcHV1Ra9evWBqaorr169j1qxZOHbsGM6cOaPKR0xNTeHl5YUFCxZg6NChUCgUKX8QoYX169cLAOLKlStq5WPGjBEAhK+vrzanyzaio6NFQkJCsve7u7sLAwMDsXfv3iT3jRw5UgAQs2bNSs8QNYqIiNBq/x07dggA4uTJk+kTUCoNHjxYABALFy5Mcl98fLyYO3euePbsmRBCCB8fHwFAvHnzJt3iUSqVIioqSufnbdGihShcuLBOz5mQkCCio6NTfXx6xPQ133oPAhCDBw9O1bm1/TykRFri0eTkyZMp/gzWr19f1K9fP9WPBUD4+Pik+nghhHjz5o1OzpMVRUZGinz58gl3d3dV2Zs3b8StW7eS7NurVy8BQDx8+FBV9vz5c2FkZKT2/lEqlcLV1VUULFhQxMfHq8p/+OEHYWZmJv777z9V2dGjRwUAsXLlylSdU5PY2Fhha2srJk6cmKLXQJv3a1pYWFgILy+vJOUZ8X2vybx58wQAcfHiRbXyq1evCgDi+PHjWp1PJ1VPrq6uAIDHjx+rld+7dw/t27dH7ty5YWpqiqpVq2Lfvn1Jjg8NDcWIESPg5OQEExMTFCxYED169FBrV46JiYGPjw+KFSsGExMTODo6YvTo0Unaez/vo3b16lUoFIokf6UAwJEjR6BQKLB//35V2YsXL9C7d2/ky5cPJiYmKFu2LNatW6d2XGKb+7Zt2zBx4kQUKFAA5ubmCA8P1/jaXLp0CUeOHEHPnj3RunXrJPfPnDkTxYsXx+zZsxEdHQ3gU/+eefPmYeHChShcuDDMzMxQv3593Lp1K8k5UvI6JzZbnz59GoMGDYKdnZ2qhum///7DoEGDULJkSZiZmSFPnjzo0KGDWhPnhg0b0KFDBwBAw4YNVU1OiU0aX/aHSXydtm/fjunTp6NgwYIwNTVF48aN8ejRoyTPYdmyZShSpAjMzMxQvXp1nD17NkV9bJ4/f46VK1fiu+++01jTZGhoiJEjRyapTQsNDUXPnj1hY2MDa2tr9OrVC1FRUWr7rF+/Ho0aNYKdnR1MTExQpkwZ/Pbbb0kew8nJCS1btsSRI0dQtWpVmJmZqaq3U3oOADh06BDq168PS0tLWFlZoVq1ati6dSsA6fU9cOAA/vvvP9Vr/3mtZko/H4l9prZs2YKyZcvCxMQEhw8fVt33eRPihw8f8OOPP6o+l3Z2dvjuu+/g5+f3zZiS66N27949dOzYEXnz5oWZmRlKliyJCRMmaHw90uLPP/9EuXLlVJ/jxOeYKLHvyp07d9ClSxfkypULdevWVd3/+++/w8XFBWZmZsidOzc6deqEZ8+eqZ3j4cOHaNeuHezt7WFqaoqCBQuiU6dOCAsL0zoeALh+/TqaNWsGKysr5MyZE40bN8alS5dS9HxXrVqFokWLqn1+UiomJgYjRoxA3rx5YWlpidatW+P58+dJ9tPUR+3q1atwd3eHra0tzMzM4OzsjN69ewOQ3gN58+YFAEydOjVJM/W///6Lnj17okiRIqrmwt69e+Pt27dqj5t4rR49evTNzywgXbvq1avD3NwcuXLlQr169ZLU+B86dAiurq6wsLCApaUlWrRogdu3b6vtExcXh3v37uHVq1cpfi0/Z25ujrx58yI0NFRVZmtri7JlyybZ9/vvvwcgNV8m2rt3L+Li4jBo0CBVmUKhwA8//IDnz5/j4sWLqvJdu3ahZcuWKFSokKrMzc0NJUqUwPbt21N1Tk3OnTuHkJAQuLm5Jbnv+fPn8PDwgIWFBezs7DBixIhk+2P9888/aNq0KaytrWFubo769esnaSZOvO6J3xlWVlbIkycPhg8fjo8fP6rFHxkZiY0bN6reY1/2U0/J970uJX4Pfn7tAcDFxQW5c+fG3r17tTpfqpo+v5T4wc2VK5eq7Pbt26hTpw4KFCiAsWPHwsLCAtu3b4eHhwd27dqlemNGRETA1dUVd+/eRe/evVGlShWEhIRg3759eP78OWxtbaFUKtG6dWucO3cO/fv3R+nSpXHz5k0sXLgQDx48SLZtumrVqihSpAi2b98OLy8vtft8fX2RK1cuuLu7A5CaJ2vWrKn6IcubNy8OHTqEPn36IDw8PEkS8Msvv8DY2BgjR45ETEyMWtXy5/766y8AQI8ePTTenyNHDnTp0gVTp07F+fPn1T4AmzZtwocPHzB48GB8/PgRixcvRqNGjXDz5k3ky5dPq9c50aBBg5A3b15MnjwZkZGRAKSq2wsXLqBTp04oWLAgAgMD8dtvv6FBgwa4c+cOzM3NUa9ePQwbNixJs9PnzU+azJo1CwYGBhg5ciTCwsIwZ84cdO3aFf/8849qn99++w1DhgyBq6srRowYgcDAQHh4eCBXrlzfbK48dOgQ4uPj0b1796/u96WOHTvC2dkZM2fOhJ+fH9asWQM7OzvMnj1bLa6yZcuidevWyJEjB/766y8MGjQISqUSgwcPVjvf/fv30blzZwwYMAD9+vVDyZIltTrHhg0b0Lt3b5QtWxbjxo2DjY0Nrl+/jsOHD6NLly6YMGECwsLC8Pz5cyxcuBAAkDNnTgDQ+vNx4sQJbN++HUOGDIGtrW2SZuxEAwcOxM6dOzFkyBCUKVMGb9++xblz53D37l1UqVLlqzFp8u+//8LV1RVGRkbo378/nJyc8PjxY/z111+YPn16yi5cCpw7dw67d+/GoEGDYGlpiV9//RXt2rXD06dPkSdPHrV9O3TogOLFi2PGjBmqvqLTp0/HpEmT0LFjR/Tt2xdv3rzBkiVLUK9ePVy/fh02NjaIjY2Fu7s7YmJiMHToUNjb2+PFixfYv38/QkNDYW1trVU8t2/fhqurK6ysrDB69GgYGRlh5cqVaNCgAU6fPo0aNWok+3zXrl2LAQMGoHbt2vjxxx/x5MkTtG7dGrlz54ajo+M3X6++ffvi999/R5cuXVC7dm2cOHECLVq0+OZxr1+/RpMmTZA3b16MHTsWNjY2CAwMxO7duwEAefPmxW+//YYffvgB33//Pdq2bQvgUzP10aNH8eTJE/Tq1Qv29va4ffs2Vq1ahdu3b+PSpUtJmoZS8pmdOnUqpkyZgtq1a+Pnn3+GsbEx/vnnH5w4cQJNmjQBAGzevBleXl5wd3fH7NmzERUVhd9++w1169bF9evXVZ+HFy9eoHTp0vDy8krxoJjw8HDExsYiJCQEmzZtwq1bt1LUlysoKAiAlMglun79OiwsLJJ8x1avXl11f926dfHixQu8fv0aVatWTXLe6tWr4+DBg1qfMzkXLlyAQqFA5cqV1cqjo6PRuHFjPH36FMOGDUP+/PmxefNmnDhxIsk5Tpw4gWbNmsHFxQU+Pj4wMDBQ/UF79uxZVSyJOnbsCCcnJ8ycOROXLl3Cr7/+ivfv32PTpk0ApOvZt29fVK9eHf379wcAFC1aNMk5vvXeCQsLQ1xcXLLPPZGpqWmS77n4+HiEhoYiNjYWt27dwsSJE2FpaZnkuQBAlSpVkiSl36RN9Vti0+exY8fEmzdvxLNnz8TOnTtF3rx5hYmJiap5SQghGjduLMqXLy8+fvyoKlMqlaJ27dqiePHiqrLJkycLAGL37t1JHk+pVAohhNi8ebMwMDAQZ8+eVbt/xYoVAoA4f/68qqxw4cJqVaDjxo0TRkZG4t27d6qymJgYYWNjI3r37q0q69Onj3BwcBAhISFqj9GpUydhbW2taspKrMotUqRIipq3PDw8BADx/v37ZPfZvXu3ACB+/fVXIYQQAQEBAoAwMzMTz58/V+33zz//CABixIgRqrKUvs6J165u3bpJqrc1PY+LFy8KAGLTpk2qsq81O33ZzJL4OpUuXVrExMSoyhcvXiwAiJs3bwohpGuRJ08eUa1aNREXF6fab8OGDQLAN5tuRowYIQCI69evf3W/RIlV4Z9feyGE+P7770WePHnUyjS9Lu7u7qJIkSJqZYULFxYAxOHDh5Psn5JzhIaGCktLS1GjRo0kzZCJnwEhkm9m1ObzAUAYGBiI27dvJzkPvmiisra2/mazXXIxJb6H169fryqrV6+esLS0VGue+fI5fktKmj6NjY3Fo0ePVGU3btwQAMSSJUtUZYnvg86dO6sdHxgYKAwNDcX06dPVym/evCly5MihKr9+/boAIHbs2PHVeFMaj4eHhzA2NhaPHz9Wlb18+VJYWlqKevXqqcq+bEqKjY0VdnZ2olKlSmqfs1WrVqXo8+Pv7y8AiEGDBqmVd+nSJcn7IfE7JCAgQAghxJ49ezR2hfnc15o+NX02/vjjDwFAnDlzRlWW0s/sw4cPhYGBgfj++++TdEVJfI99+PBB2NjYiH79+qndHxQUJKytrdXKE9/DmprUkuPu7i4AqK77gAEDvtm1ICYmRpQpU0Y4OzurfQe2aNEiyXeNEFKTKgAxduxYIYQQV65cSfJdnWjUqFECgOr3IaXnTE63bt2SfE8KIcSiRYsEALF9+3a1cxYrVkzt/apUKkXx4sWFu7u72uc+KipKODs7i++++05VlnjdW7durfZYgwYNEgDEjRs3VGXfavpMyfd9/fr1VdfuazdNj5P4e5l4K1myZLLfUf379xdmZmYa70tOqpo+3dzckDdvXjg6OqJ9+/awsLDAvn37VLUf7969w4kTJ9CxY0d8+PABISEhCAkJwdu3b+Hu7o6HDx+qRonu2rULFStWTFLzA0D1F9WOHTtQunRplCpVSnWukJAQNGrUCABw8uTJZGP19PREXFyc6q88QOr4HhoaCk9PTwCAEAK7du1Cq1atIIRQewx3d3eEhYWpmnsSeXl5wczM7Juv1YcPHwAAlpaWye6TeN+XzaceHh4oUKCAart69eqoUaOG6i8kbV7nRP369UsyaOHz5xEXF4e3b9+iWLFisLGxSfK8tdWrVy+12sbEZvInT54AkJpO3r59i379+ql1ZO/atataDW1yEl+zr72+mgwcOFBt29XVFW/fvlW7Bp+/LmFhYQgJCUH9+vXx5MmTJM1bzs7OqtrZz6XkHEePHsWHDx8wduzYJINxUtLhVNvPR/369VGmTJlvntfGxgb//PMPXr58+c19v+XNmzc4c+YMevfurdY8A6TsOWrDzc1N7S/qChUqwMrKSvWe+9yX74Pdu3dDqVSiY8eOaq+lvb09ihcvrnotE2vMjhw58s0mlG/Fk5CQgL///hseHh4oUqSIaj8HBwd06dIF586dS7ZrxdWrV/H69WsMHDhQ7XPWs2dPtVq95CR+lwwbNkytPCUDVmxsbAAA+/fvT1FNxJc+/2x8/PgRISEhqFmzJgBo/N751mf2zz//hFKpxOTJk5MMKEt8jx09ehShoaHo3Lmz2vU1NDREjRo11D4rTk5OEEJoNcXMrFmz8Pfff2Pt2rWoWbMmYmNjER8f/9VjhgwZgjt37mDp0qVq34HR0dEaB24kfkckdpVJ/Del+6Zkv+S8fftW4/fywYMH4eDggPbt26vKzM3NVTVcifz9/fHw4UN06dIFb9++Vb3+kZGRaNy4Mc6cOQOlUql2zJetF0OHDlU9Zkql5Pt+/vz5OHr06Ddvo0ePTnL+MmXK4OjRo/jzzz8xevRoWFhYJBn1mShXrlyIjo7Wquk1VU2fy5YtQ4kSJRAWFoZ169bhzJkzahf/0aNHEEJg0qRJmDRpksZzvH79GgUKFMDjx4/Rrl27rz7ew4cPcffuXVV/B03nSk7FihVRqlQp+Pr6ok+fPgCkZk9bW1vVD9mbN28QGhqKVatWYdWqVSl6DGdn56/GnCgxgfjw4YPqi+1LySVzxYsXT7Lv530OtHmdvxZ3dHQ0Zs6cifXr1+PFixdq04Vo6m+jjS9/lBM/5O/fvwcg9Y8DgGLFiqntlyNHjmSb5D5nZWUF4NNrqIu4Es95/vx5+Pj44OLFi0k+VGFhYWo/hMm9H1JyjsS+neXKldPqOSTS9vOR0vfunDlz4OXlBUdHR7i4uKB58+bo0aOHWjKRUolJSWqfoza+vLaAdH0T33Of+/K1ePjwIYQQGj97AFSjWJ2dneHt7Y0FCxZgy5YtcHV1RevWrdGtW7ckCdK34nnz5g2ioqJUzeWfK126NJRKJZ49e6axb1Pi5+fLeI2MjFJ0nf777z8YGBgkaSrSFMuX6tevj3bt2mHq1KlYuHAhGjRoAA8PD3Tp0iVFI0PfvXuHqVOnYtu2bUneo5q+d771mX38+DEMDAy++kfIw4cPAUD13f+lxM9+alWqVEn1/27duqFKlSro2bMndu7cqXH/uXPnYvXq1fjll1/QvHlztfvMzMw09vFK7J+VmOgm/pvSfVOy39d8/vuQ6L///kOxYsWS/NH15fso8fX/sivS58LCwtSSwS/f20WLFoWBgYFW00Sl5PvexcUlxef7kpWVlarbUps2bbB161a0adMGfn5+qFixotq+ia+fNn+gpipRq169uqo93MPDA3Xr1kWXLl1w//595MyZU5URjxw5UmMtA5D0h/lrlEolypcvjwULFmi8/1v9MDw9PTF9+nSEhITA0tIS+/btQ+fOnVV/vSTG261bt2TfQF8O/0/JGxqQvmj//PNP/Pvvv6hXr57Gff79918ASFEtx+dS8zprinvo0KFYv349fvzxR9SqVQvW1taqodpf/nWjreSmHNH0YU+NUqVKAQBu3ryp9iX5Ld+K6/Hjx2jcuDFKlSqFBQsWwNHREcbGxjh48CAWLlyY5HXR9Lpqe47U0vbzkdL3bseOHeHq6oo9e/bg77//xty5czF79mzs3r0bzZo1S3Pc6UWb99yXr4VSqYRCocChQ4c0nufzvinz589Hz549sXfvXvz9998YNmyYqh/N530r0/szIBeFQoGdO3fi0qVL+Ouvv3DkyBH07t0b8+fPx6VLl77aXxGQ3l8XLlzAqFGjUKlSJdVvR9OmTTV+NnTxOiaed/PmzbC3t09yv7bT03yNsbExWrdujVmzZiE6OjrJe23Dhg0YM2YMBg4ciIkTJyY53sHBASdPnoQQQu1HPXFwQ/78+VX7fV7+uVevXqnmldTmnMnJkyePxj94Uirx9Z87d26y39ffet+kpgY+Je+dd+/eITY29pvnMjMz+2Ztddu2bdG9e3ds27YtSaL2/v17mJubp/h7GNDBYAJDQ0PMnDkTDRs2xNKlSzF27FjVX3JGRkYaR4d8rmjRohpHMn65z40bN9C4ceNUXSRPT09MnToVu3btQr58+RAeHq42X0ziaKeEhIRvxqutli1bYubMmdi0aZPGRC0hIQFbt25Frly5UKdOHbX7Ev/6+NyDBw9UNU3avM5fs3PnTnh5eWH+/Pmqso8fPyYZsaLrJipAmm8LkGoHP5+XJz4+HoGBgd+cH6tZs2YwNDTE77//rvWAgq/566+/EBMTg3379qn9Nfa1ZvbUniOxNuPWrVtf/QMmudc/rZ+Pr3FwcMCgQYMwaNAgvH79GlWqVMH06dNViVpKHy/xvfqtz7rcihYtCiEEnJ2dUaJEiW/uX758eZQvXx4TJ07EhQsXUKdOHaxYsQLTpk1L8WPmzZsX5ubmuH//fpL77t27BwMDg2T/GE38/Dx8+FCtliguLg4BAQFJfiQ0Ha9UKvH48WO12g9NsSSnZs2aqFmzJqZPn46tW7eia9eu2LZtG/r27Zvs++P9+/c4fvw4pk6dismTJ6vKNX3npVTRokWhVCpx586dZJOAxM+anZ2dzr/rNYmOjoYQAh8+fFD7Yd67dy/69u2Ltm3bYtmyZRqPrVSpEtasWYO7d++q/RGfOBAr8TkWKFAAefPm1Tix9+XLl9Vei5SeMzmlSpXCli1bkrQoFC5cGLdu3UqSAH75Pkp8/T+vgfqWhw8fqtV8P3r0CEqlUq3FRRffe23btsXp06e/uV9KBpfExMRAqVRqrBkOCAj45iC8L+lkeo4GDRqgevXqWLRoET5+/Ag7Ozs0aNAAK1eu1Jjlfz5bcrt27XDjxg3s2bMnyX6J2W7Hjh3x4sULrF69Osk+0dHRqtGLySldujTKly8PX19f+Pr6wsHBQS1pMjQ0RLt27bBr1y6NPySaZndOqdq1a8PNzQ3r169Xmwok0YQJE/DgwQOMHj06SYb9559/qvUxu3z5Mv755x/Vj6Q2r/PXGBoaJvmrdMmSJUlmyrawsACQdMhxWlStWhV58uTB6tWr1fpybNmyJUV/uTk6OqJfv374+++/sWTJkiT3K5VKzJ8/X+N0A1+T+BfYl83A69ev1/k5mjRpAktLS8ycOVNt2PmXx1pYWGj84Kf186FJQkJCkseys7ND/vz51ZpOkovpS3nz5kW9evWwbt06PH36VO2+zFSz1LZtWxgaGmLq1KlJ4hJCqKaOCA8PT9L3qHz58jAwMNB6iRhDQ0M0adIEe/fuVWvOCQ4OxtatW1G3bt1km+SqVq2KvHnzYsWKFWq1ARs2bEjR5zTxu+TXX39VK0/JahPv379P8hol/tAnvgbm5uYAkn5naPpspPRxk+Ph4QEDAwP8/PPPSWrkEh/H3d0dVlZWmDFjhsZ+dZ9/Z2ozPYem7jehoaHYtWsXHB0dYWdnpyo/c+YMOnXqhHr16mHLli3JTtDepk0bGBkZYfny5WrPY8WKFShQoABq166tKm/Xrh3279+vNoXM8ePH8eDBA9W0StqeU5NatWpBCIFr166plTdv3hwvX75Ua+KNiopK0pXIxcUFRYsWxbx58zT24dL0m/VlIpv4Pf95rb6FhUWaf5dS00ctNDRU4/tozZo1AKBxJK6fn983X+cv6ayed9SoUejQoQM2bNiAgQMHYtmyZahbty7Kly+Pfv36oUiRIggODsbFixfx/Plz3LhxQ3Xczp070aFDB/Tu3RsuLi549+4d9u3bhxUrVqBixYro3r07tm/fjoEDB+LkyZOoU6cOEhIScO/ePWzfvl01f9XXeHp6YvLkyTA1NUWfPn2SfDhmzZqFkydPokaNGujXrx/KlCmDd+/ewc/PD8eOHcO7d+9S/dps2rQJjRs3Rps2bdClSxe4uroiJiYGu3fvxqlTp+Dp6YlRo0YlOa5YsWKoW7cufvjhB8TExGDRokXIkyeP2hslpa/z17Rs2RKbN2+GtbU1ypQpg4sXL+LYsWNJpjKoVKkSDA0NMXv2bISFhcHExEQ1R1hqGRsbY8qUKRg6dCgaNWqEjh07IjAwEBs2bEDRokVT9JfS/Pnz8fjxYwwbNgy7d+9Gy5YtkStXLjx9+hQ7duzAvXv3UjTj9ueaNGkCY2NjtGrVCgMGDEBERARWr14NOzu7FM+rlNJzWFlZYeHChejbty+qVaummtfrxo0biIqKUs0D6OLiAl9fX3h7e6NatWrImTMnWrVqpZPPx5c+fPiAggULon379qhYsSJy5syJY8eO4cqVK2o1r8nFpMmvv/6KunXrokqVKujfvz+cnZ0RGBiIAwcOwN/fX6v40kvRokUxbdo0jBs3TjVNjKWlJQICArBnzx70798fI0eOxIkTJzBkyBB06NABJUqUQHx8PDZv3qz6o09b06ZNw9GjR1G3bl0MGjQIOXLkwMqVKxETE4M5c+Yke5yRkRGmTZuGAQMGoFGjRvD09ERAQADWr1+foj5qlSpVQufOnbF8+XKEhYWhdu3aOH78uMa5Dr+0ceNGLF++HN9//z2KFi2KDx8+YPXq1bCyslL1tzIzM0OZMmXg6+uLEiVKIHfu3ChXrhzKlSuHevXqYc6cOYiLi0OBAgXw999/IyAgIOUv2heKFSuGCRMm4JdffoGrqyvatm0LExMTXLlyBfnz58fMmTNhZWWF3377Dd27d0eVKlXQqVMn5M2bF0+fPsWBAwdQp04dLF26FIB203M0a9YMBQsWRI0aNWBnZ4enT59i/fr1ePnyJXx9fVX7/ffff2jdujUUCgXat2+PHTt2qJ2nQoUKqlaEggUL4scff8TcuXMRFxeHatWq4c8//8TZs2eTrGQzfvx47NixAw0bNsTw4cMRERGBuXPnonz58ujVq5dqP23OqUndunWRJ08eHDt2TK0Gt1+/fli6dCl69OiBa9euwcHBAZs3b1Yl6okMDAywZs0aNGvWDGXLlkWvXr1QoEABvHjxAidPnoSVlZVqSqtEAQEBaN26NZo2bYqLFy+qppL5vLbYxcUFx44dw4IFC5A/f344Ozt/dUobTVLTR+3UqVMYNmwY2rdvj+LFiyM2NhZnz57F7t27UbVqVXTr1k1t/2vXruHdu3do06aNdg+kzRDR5FYmEEKa4bxo0aKiaNGiqukfHj9+LHr06CHs7e2FkZGRKFCggGjZsqXYuXOn2rFv374VQ4YMEQUKFBDGxsaiYMGCwsvLS22qjNjYWDF79mxRtmxZYWJiInLlyiVcXFzE1KlTRVhYmGq/L6fnSPTw4UPV0Nlz585pfH7BwcFi8ODBwtHRURgZGQl7e3vRuHFjsWrVKtU+icPjvzUs/0sfPnwQU6ZMEWXLlhVmZmbC0tJS1KlTR2zYsCHJ9ASJw8Lnzp0r5s+fLxwdHYWJiYlwdXVVG5KcKCWv89eu3fv370WvXr2Era2tyJkzp3B3dxf37t3T+FquXr1aFClSRBgaGqoNu05ueo4vXydN0zYIIcSvv/4qChcuLExMTET16tXF+fPnhYuLi2jatGkKXl1pBYI1a9YIV1dXYW1tLYyMjEThwoVFr1691KbuSG6m6i+nHhBCiH379okKFSoIU1NT4eTkJGbPni3WrVuXZL/ChQuLFi1aaIwrpedI3Ld27drCzMxMWFlZierVq4s//vhDdX9ERITo0qWLsLGxEQDUpsVI6ecDX5kpH59NoxATEyNGjRolKlasKCwtLYWFhYWoWLGiWL58udoxycWU3HW+deuW+P7774WNjY0wNTUVJUuWFJMmTdIYjyapXZngy/fyt2Ys37Vrl6hbt66wsLAQFhYWolSpUmLw4MHi/v37Qgghnjx5Inr37i2KFi0qTE1NRe7cuUXDhg3FsWPHUhWPEEL4+fkJd3d3kTNnTmFubi4aNmwoLly4oLZPcjO9L1++XDg7OwsTExNRtWpVcebMmRSvTBAdHS2GDRsm8uTJIywsLESrVq3Es2fPvjk9h5+fn+jcubMoVKiQMDExEXZ2dqJly5bi6tWraue/cOGCcHFxEcbGxmrnfP78ueq9YG1tLTp06CBevnyZ5HG1+cwKIcS6detE5cqVVZ+D+vXri6NHjyZ5Hd3d3YW1tbUwNTUVRYsWFT179lSLXZvpOZYuXSrq1q0rbG1tRY4cOUTevHlFq1at1KYZSXzcxN8hTbcvpzFJSEgQM2bMEIULFxbGxsaibNmy4vfff9cYw61bt0STJk2Eubm5sLGxEV27dhVBQUFJ9tPmnJoMGzZMFCtWLEn5f//9J1q3bi3Mzc2Fra2tGD58uDh8+LDG9+v169dF27ZtRZ48eYSJiYkoXLiw6Nixo9qM/YnX/c6dO6J9+/bC0tJS5MqVSwwZMiTJlCf37t0T9erVE2ZmZmrXTNv3jrYePXokevToIYoUKSLMzMyEqampKFu2rPDx8dG40smYMWNEoUKFtJqSSAghFEJkonYHAiBNIOzs7Iy5c+di5MiRcocjC6VSibx586Jt27Yam/SIiCjjPXnyBKVKlcKhQ4fQuHHjdHucKVOmYOrUqXjz5o3aRMBZVUxMDJycnDB27FgMHz5cq2Mz1+rlpJc+fvyYpK/Kpk2b8O7du2y9kDMRUVZTpEgR9OnTB7NmzZI7lCxl/fr1MDIySjKnW0robiwyUSpdunQJI0aMQIcOHZAnTx74+flh7dq1KFeunFpHWCIikl9y6xVT8gYOHJiqJA1gokaZgJOTExwdHfHrr7/i3bt3yJ07N3r06IFZs2Ylu4YqERGRPpC1j9qZM2cwd+5cXLt2Da9evcKePXvg4eHx1WNOnToFb29v3L59G46Ojpg4cSJ69uyZIfESERERZSRZ+6hFRkaiYsWKyU7496WAgAC0aNECDRs2hL+/P3788Uf07dsXR44cSedIiYiIiDJephn1qVAovlmjNmbMGBw4cEBtUtpOnTohNDQUhw8fzoAoiYiIiDJOluqjdvHixSTLTri7u+PHH39M9piYmBi1mcKVSiXevXuHPHnypMuSSERERKR74v/LceXPnz/ZFR2yoyyVqAUFBSFfvnxqZYlrd2pa9BYAZs6cialTp2ZUiERERJSOnj17hoIFC8odRobJUolaaowbNw7e3t6q7bCwMBQqVAjPnj1Ldv08Isp4kZFA/vzS/x89Ar5YfYaI9JDh/r1IaPwdYGaODx/CUbKkIywtLeUOK0NlqUTN3t4ewcHBamXBwcGwsrLSWJsGACYmJjAxMUlSbmVlxUSNKBP5fJlBe3vAwkK+WIhIZpGRwODBwMaNQN++wOrVqu8Efeu2lKUStVq1auHgwYNqZUePHkWtWrVkioiIiIh06tYtoGNH4O5dwMAAKFQIyBzjHmUha2+8iIgI+Pv7w9/fH4A0/Ya/vz+ePn0KQGq27NGjh2r/gQMH4smTJxg9ejTu3buH5cuXY/v27RgxYoQc4RMREZGuCAGsXQtUry4laQ4OwPHjwKRJgJ7Von1O1kTt6tWrqFy5MipXrgwA8Pb2RuXKlTF58mQAwKtXr1RJGwA4OzvjwIEDOHr0KCpWrIj58+djzZo1cHd3lyV+IiIi0oGICKB7d6mZMzoaaNIE8PcHuN5z5plHLaOEh4fD2toaYWFh7KNGlIlERgI5c0r/j4hgHzUivfL8OVCpEhAaCkybBoweLTV7fkZff7+zVB81IiIiyoYKFgT++AMwMwPq1pU7mkxFf2aMIyIioswhPBzo1An4889PZd99xyRNAyZqRERElHGuXQOqVAF8fYEBA4CoKLkjytSYqBEREVH6EwJYsgSoXRt4/BgoXBjYu5ezW38D+6gRERFR+goNBfr0AXbvlrY9PIB164BcueSMKktgokZERETpJzQUqFwZCAwEjIyAefOAoUP1em40bbDpk4iIiNKPjQ3QrBlQpAhw4QIwbBiTNC2wRo2IiIh06+1bID4eyJdP2l6wAIiJAayt5Y0rC2KNGhEREenOhQtSU2fnzkBCglRmasokLZWYqBEREVHaKZXA7NlAvXrAs2fS7dUruaPK8pioERERUdq8eQO0bAmMHSvVonXuDPj5SSsOUJqwjxoRERGl3tmz0ioDL19KTZy//iotrs4BAzrBRI2IiIhSJyEBGDRIStJKlQK2bwfKl5c7qmyFTZ9ERESUOoaG0mLqffsCV64wSUsHTNSIiIgo5U6cAFau/LRdrhywejWQM6d8MWVjTNSIiIjo2xISAB8fwM0NGDIEuHpV7oj0AvuoERER0de9fAl07QqcOiVt9+wJlCkjZ0R6g4kaERERJe/IEaB7d2kKjpw5pWbPLl3kjkpvsOmTiIiINJsyBWjaVErSKlYErl1jkpbBmKgRERGRZjY20r8DBwKXLgElSsgajj5i0ycRERF9EhkJWFhI/x8+XFq3s359eWPSY6xRIyIiIiAuDhg1CqhSBfjwQSpTKJikyYyJGhERkb777z9pMfV584AHD4A//5Q7Ivo/JmpERET6bO9eoFIlqQ+atTWwa5c0ypMyBSZqRERE+ig2FvjxR8DDAwgNBapXB65fB9q2lTkw+hwTNSIiIn00ZgyweLH0/59+As6eBZyd5Y2JkmCiRkREpI/GjgXKlgX27ZP6phkbyx0RacBEjYiISB98/Aj88cen7Xz5gH//BVq1ki8m+ibOo0ZERJTdPXwIdOwI+PtL2507S/8asL4ms+MVIiIiys7++EOaG83fH7C1BXLnljsi0gITNSIiouwoOhro319amzMiQponzd8fcHeXOzLSAhM1IiKi7ObePaBGDWD1aml1gYkTgePHgQIF5I6MtMQ+akRERNnN48fAzZuAnR2wZQvg5iZ3RJRKTNSIiIiymxYtpNq0Fi0ABwe5o6E0YNMnERFRVnf7NuDqKq3ZmahvXyZp2QATNSIioqxKCGDdOqBaNeDcOWlJKMpW2PRJRESUFUVEAAMHSn3QAKBJE2DlSnljIp1jjRoREVFWc+MG4OIiJWmGhsCMGcChQ9LgAcpWWKNGRESUlZw9C3z3HRATI023sW0bULeu3FFROmGiRkRElJVUqwaUKiUlaRs3SqsNULbFRI0oGxACiIqSO4q0iYyUOwKiTOzuXaBECamZ09QUOHZMWgqKa3Vme0zUiLI4IaRWjwsX5I6EiHROCGDZMuCnn4AJE4DJk6Vy1qLpDSZqRFlcVFT2StLq1AHMzeWOgigTCA0F+vQBdu+Wtm/cAJRK1qLpGSZqRNlIcDBgYSF3FGljbi4tTUik1y5fBjw9gcBAwMgImDsXGDaMHw49xESNKBuxsMj6iRqRXhMCWLQIGDMGiIsDnJ0BX19pAAHpJdafEhERZRYBAcD48VKS1q4d4OfHJE3PsUaNiIgosyhSRBo8EB0NDBrEpk5iokZERCQbpRKYP19aUL1mTamsd295Y6JMhYkaERGRHN68Aby8pKWfChcGbt0CcuaUOyrKZJioERERZbQzZ4DOnYGXL6UJbCdM4Egg0oiDCYiIiDKKUglMnw40bCglaSVLAv/8A/Trx/5opBFr1IiIiDJCRATQti1w9Ki03b07sHw5mzvpq5ioERERZQQLC8DMTLotXw707Cl3RJQFMFEjIiJKLwkJQGyslJwpFMD69UBQEFCmjNyRURbBPmpERETp4dUrwM1N6n8mhFSWOzeTNNIKa9SIiIh07e+/gW7dpCk4LCyAJ0+AokXljoqyINaoERER6Up8vDTVRtOmUpJWoQJw9SqTNEo11qgRERHpwvPnQJcuwNmz0vaAAcDChVL/NKJUYqJGRESUVkol0KyZtLqApSWwejXg6Sl3VJQNsOmTiIgorQwMgEWLgKpVAT8/JmmkM0zUiIiIUuPpU2nQQKLGjaVVBooVky8mynaYqBEREWlr3z6gUiWgfXvg0aNP5Qb8WSXd4juKiIgopWJjgREjgDZtgPfvgVKlgBzs7k3pR/ZEbdmyZXBycoKpqSlq1KiBy5cvf3X/RYsWoWTJkjAzM4OjoyNGjBiBjx8/ZlC0RESktwICgLp1pb5ogJSwnTsHODnJGRVlc7Imar6+vvD29oaPjw/8/PxQsWJFuLu74/Xr1xr337p1K8aOHQsfHx/cvXsXa9euha+vL8aPH5/BkRMRkV7ZtQuoXBm4cgXIlQvYuxdYsAAwNpY7MsrmZK2vXbBgAfr164devXoBAFasWIEDBw5g3bp1GDt2bJL9L1y4gDp16qBLly4AACcnJ3Tu3Bn//PNPhsZNpGtCAFFRqTs2MlK3sRCRBhcuAGFhQK1awLZtQKFCckdEekK2GrXY2Fhcu3YNbm5un4IxMICbmxsuXryo8ZjatWvj2rVrqubRJ0+e4ODBg2jevHmyjxMTE4Pw8HC1G1FmIoTUmpIzZ+pu+fLJ/QyIsqnE9TkBYOZMYPFi4PRpJmmUoWRL1EJCQpCQkIB8X/zK5MuXD0FBQRqP6dKlC37++WfUrVsXRkZGKFq0KBo0aPDVps+ZM2fC2tpadXN0dNTp8yBKq6go6Y/1tKpTBzA3T/t5iAhSrVnz5kBcnLRtbAwMGwYYGckbF+kd2QcTaOPUqVOYMWMGli9fDj8/P+zevRsHDhzAL7/8kuwx48aNQ1hYmOr27NmzDIyYSDvBwUBEROpuZ88CCoXcz4Aoi4uOlpZ+6twZOHxYWmGASEay9VGztbWFoaEhgoOD1cqDg4Nhb2+v8ZhJkyahe/fu6Nu3LwCgfPnyiIyMRP/+/TFhwgQYaJi/xsTEBCYmJrp/AkTpwMJCuhGRDO7fBzp2BP79V/qrZ/x4oH9/uaMiPSdbjZqxsTFcXFxw/PhxVZlSqcTx48dRq1YtjcdERUUlScYMDQ0BAOLzvgRERETa+P13wMVFStLs7IAjR4Bp0zhHGslO1negt7c3vLy8ULVqVVSvXh2LFi1CZGSkahRojx49UKBAAcycORMA0KpVKyxYsACVK1dGjRo18OjRI0yaNAmtWrVSJWxERERamT4dmDhR+n/DhsCWLYCDg7wxEf2frImap6cn3rx5g8mTJyMoKAiVKlXC4cOHVQMMnj59qlaDNnHiRCgUCkycOBEvXrxA3rx50apVK0yfPl2up0BERFld+/bAnDmAt7eUsPEPf8pEFELP2gzDw8NhbW2NsLAwWFlZyR0OESIjpWk2AGlQAPuoEaUzIaQmzooVP5W9fQvkySNfTPRN+vr7naVGfRIREaVJRATQowdQpYo0J1oiJmmUSTFRIyIi/fDvv0DVqtLAAQC4dUveeIhSgIkaERFlb0IAq1YB1atLU3AUKACcOgUMHix3ZETfxHHHRESUfYWHSxPYbtsmbTdrBmzaBNjayhsXUQqxRo2IiLKvvXulJM3QUBrZuX8/kzTKUlijRkRE2Ve3bsD160CHDkAyk6kTZWasUSMiouwjNBQYMgR4/17aViiABQuYpFGWxRo1IiLKHq5cATw9gYAAICTkU780oiyMNWpERJS1CQEsWgTUqSMlac7OwE8/yR0VkU6wRo2IiLKud++AXr2Affuk7XbtgDVrABsbWcMi0hUmakRElDXdvAm0bAk8fQoYG0t90QYNkvqlEWUTTNSIiChryp9favYsWhTYvl1aFooom2GiRkREWceHD0DOnFKtWZ48wKFDgKMjoEeLdJN+4WACIiLKGs6eBUqXBjZs+FRWtiyTNMrWmKgREVHmplQCM2YADRsCL14AS5YACQlyR0WUIZioERFR5vX6NdC0KTBhgpScdesGnDkjLQlFpAfYR40ojYQAoqJSf3xkpO5iIcpWTp4EunQBgoIAMzNg6VJpKg6O6iQ9wkSNKA2EAOrWBS5ckDsSomzmv/+AJk2A+HigTBlpVGfZsnJHRZThmKgRpUFUlO6StDp1AHNz3ZyLKMsrXBgYNw54/lzqk2ZhIXdERLJgokakI8HBafstMTdniw7puWPHACcnoFgxaXvqVH4oSO8xUSPSEQsL/tFPlCrx8cCUKdLIzsqVpWpqExMmaURgokZERHJ68QLo3FmaIw0AqlWTOn8SEQAmakREJJdDh4AePYCQEMDSEli1CujUSe6oiDIVzqNGREQZKy4OGDMGaN5cStIqVwauXWOSRqQBEzUiIspYQkhzpAHA4MFSn7TixeWNiSiTYtMnERFlDCGkAQLGxoCvL+DnB7RrJ3dURJkaEzUiIkpfsbHA2LGAqak0shMAnJ2lGxF9FRM1IiJKPwEBUt+zy5el2rQePYBSpeSOiijLYB81IiJKH7t3SwMFLl8GbGyAPXuYpBFpiYkaERHpVkwMMHSo1P8sLAyoWRPw9wfatJE7MqIsh02fRESkO0JIi6mfOSNtjx4NTJsGGBnJGxdRFsVEjYiIdEehAPr2BW7fBjZtkuZKI6JUY9MnERGlTXQ0cPfup+3u3YEHD5ikEekAEzUiIkq9+/elPmhubsCbN5/Kc+eWLyaibISJGhERpc7vvwMuLsC//0rLQgUEyB0RUbbDRI2IiLQTFQX06SM1cUZGAg0aSKM6q1eXOzKibIeJGhERpdydO1JCtm6dNHDAxwc4dgzIn1/uyIiyJY76JCKilJs9WxrRaW8PbNkCNGokd0RE2RoTNSIiSrlffwVy5JDW7MyXT+5oiLI9Nn0SEVHybt4ERo2SJrIFAGtrYO1aJmlEGYQ1akRElJQQwJo1wLBhwMePQMmS0kS2RJShmKgREZG68HBgwABg2zZpu1kzrtNJJBM2fRIR0SfXr0tzo23bBhgaSoMH9u8H8uaVOzIivZSmGrWPHz/C1NRUV7EQEZGcNm+WmjdjYwFHRylZq11b7qiI9JrWNWpKpRK//PILChQogJw5c+LJkycAgEmTJmHt2rU6D5CIiDKIszOQkAC0aiVNYMskjUh2Widq06ZNw4YNGzBnzhwYGxurysuVK4c1a9boNDgiIkpnYWGf/l+3LnDxIrB3L9fqJMoktE7UNm3ahFWrVqFr164wNDRUlVesWBH37t3TaXBERJROhAAWLwacnKTVBhJVqyatOEBEmYLWidqLFy9QrFixJOVKpRJxcXE6CYqIiNLRu3fA998DP/4IhIYCGzbIHBARJUfrRK1MmTI4e/ZskvKdO3eicuXKOgmKiIjSyaVLQOXKUvOmsTGwZIk0spOIMiWtR31OnjwZXl5eePHiBZRKJXbv3o379+9j06ZN2L9/f3rESEREaaVUAgsWAOPGAfHxQNGigK+vNBUHEWVaWteotWnTBn/99ReOHTsGCwsLTJ48GXfv3sVff/2F7777Lj1iJCKitPr9d2kpqPh4oGNH4No1JmlEWYBCiMQF3PRDeHg4rK2tERYWBisrK7nDoSwuMhLImVP6f0QEYGEhbzxEyYqPB1q0kPqmDRjAAQOU5ejr77fWNWpFihTB27dvk5SHhoaiSJEiOgmKiIjSSKmU1uqMiZG2c+QADh8GBg5kkkaUhWidqAUGBiIhISFJeUxMDF68eKGToIiIKA1ev5bW5+zXDxgz5lM5EzSiLCfFgwn27dun+v+RI0dgbW2t2k5ISMDx48fh5OSk0+CIiEhLp04BXboAr14BZmZAhQpyR0REaZDiRM3DwwMAoFAo4OXlpXafkZERnJycMH/+fJ0GR0REKZSQAEyfDkydKjV7li4N7NgBlC0rd2RElAYpTtSUSiUAwNnZGVeuXIGtrW26BUVERFoICgK6dgVOnJC2e/WS5kfj6BaiLE/redQCAgLSIw4iIkqtqCjg6lXA3BxYsQLo3l3uiIhIR7RO1AAgMjISp0+fxtOnTxEbG6t237Bhw3QSGBERfYUQnwYHFCkCbN8OFC4MlColb1xEpFNaJ2rXr19H8+bNERUVhcjISOTOnRshISEwNzeHnZ0dEzUiovT24gXQrZu0ykCTJlKZu7u8MRFRutB6eo4RI0agVatWeP/+PczMzHDp0iX8999/cHFxwbx589IjRiIiSnT4MFCpkjS6c9AgaSJbIsq2tE7U/P398dNPP8HAwACGhoaIiYmBo6Mj5syZg/Hjx6dHjEREFBcHjB0rzY8WEiIlawcPShPZElG2pXWiZmRkBAMD6TA7Ozs8ffoUAGBtbY1nz57pNjoiIgKePQMaNABmz5a2Bw0CLl4ESpSQNSwiSn9aJ2qVK1fGlStXAAD169fH5MmTsWXLFvz4448oV66c1gEsW7YMTk5OMDU1RY0aNXD58uWv7h8aGorBgwfDwcEBJiYmKFGiBA4ePKj14xIRZQkvXki1ZxcuAFZW0txoy5YBpqZyR0ZEGUDrRG3GjBlwcHAAAEyfPh25cuXCDz/8gDdv3mDlypVancvX1xfe3t7w8fGBn58fKlasCHd3d7x+/Vrj/rGxsfjuu+8QGBiInTt34v79+1i9ejUKFCig7dMgIsoaChQAWrUCqlYFrl8H2reXOyIiykAKIYSQ68Fr1KiBatWqYenSpQCkSXUdHR0xdOhQjB07Nsn+K1aswNy5c3Hv3j0YGRml6jHDw8NhbW2NsLAwWFlZpSl+oshIIGdO6f8REZxflHQkMFB6YyVOLB4VBRgaAiYmsoZFJCd9/f3WukYtOX5+fmjZsmWK94+NjcW1a9fg5ub2KRgDA7i5ueHixYsaj9m3bx9q1aqFwYMHI1++fChXrhxmzJihcZH4RDExMQgPD1e7ERFlWnv2SE2dXl7SUlCANJEtkzQivaRVonbkyBGMHDkS48ePx5MnTwAA9+7dg4eHB6pVq6ZaZiolQkJCkJCQgHz58qmV58uXD0FBQRqPefLkCXbu3ImEhAQcPHgQkyZNwvz58zFt2rRkH2fmzJmwtrZW3RwdHVMcIxFRhomJAYYNA9q2BcLCgLdvpX+JSK+lOFFbu3YtmjVrhg0bNmD27NmoWbMmfv/9d9SqVQv29va4detWunfqVyqVsLOzw6pVq+Di4gJPT09MmDABK1asSPaYcePGISwsTHXjyFQiynQePwbq1JHW5wSAkSOBs2eBXLnkjYuIZJfiCXgWL16M2bNnY9SoUdi1axc6dOiA5cuX4+bNmyhYsKDWD2xrawtDQ0MEBwerlQcHB8Pe3l7jMQ4ODjAyMoKhoaGqrHTp0ggKCkJsbCyMjY2THGNiYgITNhkQUWa1fTvQty/w4QOQJw+wcSPQooXcURFRJpHiGrXHjx+jQ4cOAIC2bdsiR44cmDt3bqqSNAAwNjaGi4sLjh8/ripTKpU4fvw4atWqpfGYOnXq4NGjR2pNrA8ePICDg4PGJI2IKFP7+FFaBurDB6lGzd+fSRoRqUlxohYdHQ1zc3MAgEKhgImJiWqajtTy9vbG6tWrsXHjRty9exc//PADIiMj0atXLwBAjx49MG7cONX+P/zwA969e4fhw4fjwYMHOHDgAGbMmIHBgwenKQ4iIlmYmgK+vsD48dKSUKn8w5eIsi+t1h5Zs2YNcv5/LoL4+Hhs2LABtonDx/9Pm0XZPT098ebNG0yePBlBQUGoVKkSDh8+rBpg8PTpU9UqCADg6OiII0eOYMSIEahQoQIKFCiA4cOHY8yYMdo8DSIi+WzdKk230bevtF21qnQjItIgxfOoOTk5QaFQfP1kCoVqNGhmpa/zsFD64DxqlGJRUcDw4cCaNYCxsdTMWbq03FERZRn6+vud4hq1wMDAdAyDiCgbu3sX6NgRuHULUCikfmlcp5OIUkCrpk8iItLSxo3SIupRUUC+fFLTZ6NGckdFRFkEEzUiovQgBNCvH7B2rbTt5gb8/ruUrBERpRATNdJ7QkiVHakRGanbWCgbUSiAIkUAAwNg6lSpufOzOSCJiFKCiRrpNSGAunWBCxfkjoSyBSGkZZ9sbKTtsWOBpk2BKlVkDYuIsi6dLcpOlBVFRekmSatTR1o3m/TYhw9A166Aq+unKloDAyZpRJQmqapRe/z4MdavX4/Hjx9j8eLFsLOzw6FDh1CoUCGULVtW1zESZYjg4NRPr2FuLrV0kZ7y95dGdT58KDVvnjkj1aQREaWR1jVqp0+fRvny5fHPP/9g9+7diIiIAADcuHEDPj4+Og+QKKNYWKT+xiRNTwkB/PYbULOmlKQ5OjJJIyKd0jpRGzt2LKZNm4ajR4+qra/ZqFEjXLp0SafBERFlWmFhgKenNPVGTAzQqhVw/TpQu7bckRFRNqJ1onbz5k18//33Scrt7OwQEhKik6CIiDK9IUOAHTuAHDmA+fOBvXuBPHnkjoqIshmtEzUbGxu8evUqSfn169dRoEABnQRFRJTpzZwJuLgA584B3t5s/yaidKF1otapUyeMGTMGQUFBUCgUUCqVOH/+PEaOHIkePXqkR4xERPJ7/15aZSBRwYLAlStAjRryxURE2Z7WidqMGTNQqlQpODo6IiIiAmXKlEG9evVQu3ZtTJw4MT1iJCKS1z//AJUrAz17Sk2ciViLRkTpTOvpOYyNjbF69WpMmjQJt27dQkREBCpXrozixYunR3xERPIRAliwQJq4Nj4eKFpUqkkjIsogWidq586dQ926dVGoUCEUKlQoPWIiIpLf27dSDdr+/dJ2x47A6tWAlZWsYRGRftG66bNRo0ZwdnbG+PHjcefOnfSIiYhIXufPA5UqSUmaiYk0V9q2bUzSiCjDaZ2ovXz5Ej/99BNOnz6NcuXKoVKlSpg7dy6eP3+eHvEREWW8ly+B58+B4sWBS5eAgQPZH42IZKEQQojUHhwQEICtW7fijz/+wL1791CvXj2cOHFCl/HpXHh4OKytrREWFgYr/nWs9yIjgZw5pf9HRKR+CSnKBoRQT8Y2bgTatgUsLeWLiYhU9PX3O02Lsjs7O2Ps2LGYNWsWypcvj9OnT+sqLiKijHP6tDQn2udzRHp5MUkjItmlOlE7f/48Bg0aBAcHB3Tp0gXlypXDgQMHdBkbEVH6SkgAfvkFaNRIWv5p8mS5IyIiUqP1qM9x48Zh27ZtePnyJb777jssXrwYbdq0gbm5eXrER0SUPoKCgG7dgOPHpe2ePYFFi+SMiIgoCa0TtTNnzmDUqFHo2LEjbG1t0yMmIqL0dfw40LUrEBwMmJtLozq5sgoRZUJaJ2rnz59PjziIiDLGnj1Au3bS4IFy5YDt24HSpeWOiohIoxQlavv27UOzZs1gZGSEffv2fXXf1q1b6yQwIqJ08d13QMmSgKsrsHgxYGYmd0RERMlK0fQcBgYGCAoKgp2dHQwMkh9/oFAokJCQoNMAdU1fh/eSZpyeQ09cuSKN6kz8/goLA6yt5Y2JiLSir7/fKRr1qVQqYWdnp/p/crfMnqQRkZ6JjwfGjQOqV5fW7EzEJI2Isgitp+fYtGkTYmJikpTHxsZi06ZNOgmKiCjNnj0DGjQAZs2Strl6ChFlQVonar169UJYWFiS8g8fPqBXr146CYqIKE0OHJDW6jx/Xlqfc8cOTr1BRFmS1qM+hRBQaFjz7vnz57BmcwJlMCGAqKjUHx8ZqbtYKBOIjQXGjwfmz5e2q1YFfH2BIkXkjYuIKJVSnKhVrlwZCoUCCoUCjRs3Ro4cnw5NSEhAQEAAmjZtmi5BEmkiBFC3LnDhgtyRUKZx9y7w66/S/4cPB2bPBkxM5I2JiCgNUpyoeXh4AAD8/f3h7u6OnIlD5QAYGxvDyckJ7dq103mARMmJitJdklanjjTvKWVxFSsCS5cCdnbA/7+ziIiyshQnaj4+PgAAJycneHp6wtTUNN2CItJWcHDaptYwNwc0tOhTZhcTIzV1du8u9UkDgP79ZQ2JiEiXtO6j5uXllR5xEKWJhQXnQNM7jx8Dnp7AtWvA/v3ArVuAkZHcURER6VSKErXcuXPjwYMHsLW1Ra5cuTQOJkj07t07nQVHRKTRjh1A375AeDiQO7c0RxqTNCLKhlKUqC1cuBCWlpaq/38tUSMiSjcfPwLe3tIi6oDUufCPPwBHR3njIiJKJylaQio70dclKLIjLv+kZ968AZo0Afz9pe1x44CffwZyaN2Dg4iyIH39/dZ6wls/Pz/cvHlTtb137154eHhg/PjxiI2N1WlwREQquXMDtrZA3rzA4cPAjBlM0ogo29M6URswYAAePHgAAHjy5Ak8PT1hbm6OHTt2YPTo0ToPkIj0WFQUEB0t/d/QENiyRapRc3eXNSwiooyidaL24MEDVPr/MPgdO3agfv362Lp1KzZs2IBdu3bpOj4i0ld37wI1agA//vipzM4OyJ9ftpCIiDKa1omaEAJKpRIAcOzYMTRv3hwA4OjoiJCQEN1GR0T6aeNGafmnW7eAvXul/mlERHpI60StatWqmDZtGjZv3ozTp0+jRYsWAICAgADky5dP5wESkR6JjAR69pRuUVFA48ZSU2fevDIHRkQkD60TtUWLFsHPzw9DhgzBhAkTUKxYMQDAzp07Ubt2bZ0HSER64tYtoFo1qTbNwAD45RfgyBHA3l7uyIiIZKOz6Tk+fvwIQ0NDGGXySSf1dXhvdsTpObKR2FigaFHg+XOpD9rWrUD9+nJHRUSZiL7+fqd6bPu1a9dw9+5dAECZMmVQpUoVnQVFRHrG2BhYsQJYtkyqUWNTJxERgFQkaq9fv4anpydOnz4NGxsbAEBoaCgaNmyIbdu2IS+/YIkoJW7cAF6/Br77Ttpu0QJo3hzgyidERCpa91EbOnQoIiIicPv2bbx79w7v3r3DrVu3EB4ejmHDhqVHjESUnQgh1Z7VqCEtqv706af7mKQREanRukbt8OHDOHbsGEqXLq0qK1OmDJYtW4YmTZroNDgiymbCwoD+/YHt26Xt775j50Iioq/QukZNqVRqHDBgZGSkml+NiCiJa9eAKlWkJC1HDmD+fGDfPiBPHrkjIyLKtLRO1Bo1aoThw4fj5cuXqrIXL15gxIgRaNy4sU6DI6JsYskSoHZt4MkToHBh4Nw5wNubTZ1ERN+gdaK2dOlShIeHw8nJCUWLFkXRokXh7OyM8PBwLFmyJD1iJKKs7vZtaQoODw/g+nWpfxoREX2T1n3UHB0d4efnh+PHj6um5yhdujTc3Nx0HhwRZWFCfKoxW7hQqlHr3p21aEREWtAqUfP19cW+ffsQGxuLxo0bY+jQoekVFxFlVUJIidnRo8D+/YChIWBmBvToIXdkRERZTooTtd9++w2DBw9G8eLFYWZmht27d+Px48eYO3duesZHRFnJ27fSOp3790vbu3cDHTrIGhIRUVaW4iWkypYti44dO8LHxwcA8Pvvv2PAgAGIjIxM1wB1TV+XoMiMhJDW3U6tyEggXz7p/1xCKhO4cAHo1Al49gwwMQEWLQIGDGBTJxHphL7+fqc4UTMzM8Pdu3fh5OQEQJqmw8zMDIGBgXBwcEjPGHVKXy90ZiMEULeu9NuuC0zUZKRUAnPnAhMmAAkJQPHi0hQclSrJHRkRZSP6+vud4lGfMTExsPjsl9DAwADGxsaIjo5Ol8Aoe4uK0l2SVqcOYG6um3NRKgwbBowdKyVpXbpI86UxSSMi0gmtBhNMmjQJ5p/9IsbGxmL69OmwtrZWlS1YsEB30ZFeCA5OW22YuTlb12TVvz/wxx/AnDlA7968GEREOpTiRK1evXq4f/++Wlnt2rXx5MkT1baCX9CUChYWbLbMUhISgKtXP82FVqECEBgIWFrKGhYRUXaU4kTt1KlT6RgGEWUJwcFAt27AqVPS6gKJyRqTNCKidKH1ygREpKdOnAAqVgSOHQOMjYHnz+WOiIgo22OiRkRfl5AA+PgAbm5SjVq5clLTZ7t2ckdGRJTtab2EFBHpkZcvga5dpaZOAOjbF1i8mMNsiYgyCBM1Ikre7t1SkpYzJ7BypTT9BhERZZhM0fS5bNkyODk5wdTUFDVq1MDly5dTdNy2bdugUCjg4eGRvgES6avBg4GRI6W50ZikERFluFQlamfPnkW3bt1Qq1YtvHjxAgCwefNmnDt3Tutz+fr6wtvbGz4+PvDz80PFihXh7u6O169ff/W4wMBAjBw5Eq6urql5CkSkyfPn0lqdHz5I2wqFtOpAiRKyhkVEpK+0TtR27doFd3d3mJmZ4fr164iJiQEAhIWFYcaMGVoHsGDBAvTr1w+9evVCmTJlsGLFCpibm2PdunXJHpOQkICuXbti6tSpKFKkiNaPSbohhLTeZmpvlMkcOCCtKLBxI/DTT3JHQ0RESEWiNm3aNKxYsQKrV6+GkZGRqrxOnTrw8/PT6lyxsbG4du0a3NzcPgVkYAA3NzdcvHgx2eN+/vln2NnZoU+fPt98jJiYGISHh6vdKO0S1+rMmTN1t8TF1CkTiIsDRo0CWrYE3r4FXFyAMWPkjoqIiJCKRO3+/fuoV69eknJra2uEhoZqda6QkBAkJCQg3xe/2vny5UNQUJDGY86dO4e1a9di9erVKXqMmTNnwtraWnVzdHTUKkbSTFdrdXKdTpn99x9Qrx4wb560PWwYcP48ULSovHERERGAVIz6tLe3x6NHj+Dk5KRWfu7cuXRvhvzw4QO6d++O1atXw9bWNkXHjBs3Dt7e3qrt8PBwJms6lpa1OrlOp4zOngVatwZCQwEbG2D9eoADc4iIMhWtE7V+/fph+PDhWLduHRQKBV6+fImLFy9i5MiRmDRpklbnsrW1haGhIYKDg9XKg4ODYW9vn2T/x48fIzAwEK1atVKVKZVK6YnkyIH79++j6Bc1ASYmJjAxMdEqLtIO1+rMoooXB0xMpGWgtm0Dvvjji4iI5Kd1ojZ27FgolUo0btwYUVFRqFevHkxMTDBy5EgMHTpUq3MZGxvDxcUFx48fV02xoVQqcfz4cQwZMiTJ/qVKlcLNmzfVyiZOnIgPHz5g8eLFrCkj+pa3b4E8eaT/29tLc6QVKSItCUVERJmO1omaQqHAhAkTMGrUKDx69AgREREoU6YMcubMmaoAvL294eXlhapVq6J69epYtGgRIiMj0atXLwBAjx49UKBAAcycOROmpqYoV66c2vE2NjYAkKSciL6wcyfQpw+wahXg6SmVlSolb0xERPRVqV6ZwNjYGGXKlElzAJ6ennjz5g0mT56MoKAgVKpUCYcPH1YNMHj69CkMDDLFvLxEWdPHj9J0G8uXS9sbNwIdO7JzIBFRFqAQQghtDmjYsCEUX/mCP3HiRJqDSk/h4eGwtrZGWFgYrKys5A4ny4qMlKbZAICICPZRy7QePpSSMn9/aXvsWODnn4HPptYhIsoK9PX3W+satUqVKqltx8XFwd/fH7du3YKXl5eu4iKitPrjD6B/fymTtrUFNm8GmjaVOyoiItKC1onawoULNZZPmTIFERERaQ6IiHTg338/rc1Zrx6wdStQoIC8MRERkda0bvpMzqNHj1C9enW8e/dOF6dLN/padaprbPrMAkaNAszMgMmTgRyp7o5KRJQp6Ovvt86+vS9evAhTU1NdnY6ItLVlC+DqChQqJG3PmcMBA0REWZzWiVrbtm3VtoUQePXqFa5evar1hLdEpAORkcDQodLKArVrS3OjGRkxSSMiyga0TtSsra3Vtg0MDFCyZEn8/PPPaNKkic4CI6IUuH1bGtV55w5gYAC4u0v/EhFRtqBVopaQkIBevXqhfPnyyJUrV3rFRETfIoRUgzZkCBAdDTg4SAMGGjSQOzIiItIhrf70NjQ0RJMmTRAaGppO4RDRN0VGAj16SKsMREdLtWj+/kzSiIiyIa3bSMqVK4cnT56kRyxElBIGBtL0G4aGwMyZwMGDgJ2d3FEREVE60LqP2rRp0zBy5Ej88ssvcHFxgcUX8zLo05BZogwjhHQzMJCm3Ni+HXjzBqhbV+7IiIgoHaV4HrWff/4ZP/30EywtLT8d/NmoMiEEFAoFEhISdB+lDunrPCy6xnnUMlBYmLTCQPnywMSJckdDRCQLff39TnGiZmhoiFevXuHu3btf3a9+/fo6CSy96OuF1jUmahnk2jXA0xN4/BgwNQWePJEGDhAR6Rl9/f1OcdNnYj6X2RMxomxBCGDpUmDkSCA2FihcGNi2jUkaEZGe0aqPmoITaBKlv9BQaUTn7t3StocHsG4dwClxiIj0jlaJWokSJb6ZrGX2tT6JMrX4eGl1gbt3pdUF5s2TVh3gH0lERHpJq0Rt6tSpSVYmICIdypEDGD5cWqfT1xeoWlXuiIiISEYpHkxgYGCAoKAg2GXx+Zr0tTPil4QAoqJSf3xkJJAvn/R/DiZIo3fvgFevgLJlpe3Ei8MXlYhIRV9/v1Nco8b+admHENL0WxcuyB0J4cIFoFMnafLa69cBGxupmZNJGhERQYuVCVJY8UZZQFSU7pK0OnUAc3PdnEuvKJXA7NlAvXrAs2dSf7TXr+WOioiIMpkU16gplcr0jINkEhyctsobc3P2c9famzeAlxdw6JC03bkzsHIl8Nlk0kREREAqlpCi7MXCgq1sGerMGSkxe/lSmsB2yRJpKg5mu0REpAETNaKMtGCBlKSVKiWt11m+vNwRERFRJsZEjSgjrV0LFCkC/PzzpzW4iIiIkpHiwQRElAonTgA//SQNtQWAPHmkWjUmaURElAKsUSNKDwkJUq3ZL79ISVqNGkDHjnJHRUREWQwTNSJde/kS6NoVOHVK2u7TB2jZUtaQiIgoa2KiRqRLf/8NdOsmTcFhYSFNu9G1q9xRERFRFsU+akS6Mncu0LSplKRVrAj4+TFJIyKiNGGiRqQrlStL//7wA3DpElCihLzxEBFRlsemT6K0eP0asLOT/u/mBty8+WlxdSIiojRijRpRasTFAaNGSbVmjx9/KmeSRkREOsREjUhb//0HuLoC8+YBYWHAX3/JHREREWVTbPok0saffwK9egGhoYC1NbBuHdC2rdxRERFRNsUaNaKUiI0FfvwR+P57KUmrXh24fp1JGhERpSsmakQpsXQpsHix9H9vb+DsWcDZWd6YiIgo22PTJ1FKDBkCHD0KDBoEtGoldzRERKQnWKNGpMnHj9Li6XFx0raxMXDoEJM0IiLKUKxRI/rSw4eAp6fUB+3NG2DmTLkjIiIiPcUaNaLPbdsGVKkiJWm2tkC9enJHREREeoyJGhEAREcDAwYAnTsDERHSPGn+/kCzZnJHRkREeoxNn6kgBBAVJXcUqRcZKXcEmcyDB0D79tLyTwoFMGEC4OMD5ODHg4iI5MVfIi0JAdStC1y4IHckpDNKJfDkibRm55Yt0pqdREREmQATNS1FRWWfJK1OHcDcXO4oZKJUAgb/b/kvVQrYvRsoXx5wcJA3LiIios8wUUuD4GDAwkLuKFLP3Fxq6dM7t29LfdGWLv00WKBJE3ljIiIi0oCJWhpYWGTtRE3vCCGtzTl0qDR44KefgMuX9TRbJSKirICjPkk/fPgAdO8O9O0rJWlNmgAHDjBJIyKiTI2JGmV/N24AVatKAwUMDYEZM6RVBuzs5I6MiIjoq9j0Sdnb3btAjRpATAxQoIA0oW3dunJHRURElCJM1Ch7K1UKaN1amjxu40ZptQEiIqIsgokaZT/XrwPOzoCNjdQHbeNGwMTk03QcREREWQR/uSj7EEKacqNmTWnQgBBSuZkZkzQiIsqSWKNG2UNoKNCnjzRxLQDExwMfP0pJGhERURbFagbK+i5fBipXlpI0IyNg0SJgzx4maURElOUxUaOsSwhg4UJpFGdgoNQv7fx5YPhwzo9GRETZAhM1yrrCwoAFC4C4OKBdO8DPD6hWTe6oiIiIdIZ91CjrsrEB/vhDmtB20CDWohERUbbDRI2yDqUSmDcPsLcHevSQyurW5QS2RESUbTFRo6zhzRvAy0ta+sncHGjYEHB0lDsqIiKidMVEjTK/s2eBTp2Aly8BU1NpVGfBgnJHRURElO44mIAyL6USmD4daNBAStJKlgT++Qfo14/90YiISC+wRo0yp4QEoEUL4MgRabt7d2D5ciBnTnnjIiIiykCsUaPMydAQqFpV6o+2fj2waROTNCIi0jtM1CjzSEiQBg0kmjIF8PcHevaUKSAiIiJ5ZYpEbdmyZXBycoKpqSlq1KiBy5cvJ7vv6tWr4erqily5ciFXrlxwc3P76v6URbx6BXz3HdCsGRATI5XlyAEULy5vXERERDKSPVHz9fWFt7c3fHx84Ofnh4oVK8Ld3R2vX7/WuP+pU6fQuXNnnDx5EhcvXoSjoyOaNGmCFy9eZHDkpDN//w1UrAicPAncuydNYEtERERQCCGEnAHUqFED1apVw9KlSwEASqUSjo6OGDp0KMaOHfvN4xMSEpArVy4sXboUPRInQf2K8PBwWFtbIywsDFZWVlrHGxn5qatURARgYaH1KShRfDzg4wPMnCmt21mhArB9uzS6k4iI6DNp/f3OqmStUYuNjcW1a9fg5uamKjMwMICbmxsuXryYonNERUUhLi4OuXPn1nh/TEwMwsPD1W6UCTx/DjRqBMyYISVpAwYAly4xSSMiIvqMrIlaSEgIEhISkC9fPrXyfPnyISgoKEXnGDNmDPLnz6+W7H1u5syZsLa2Vt0cOZt95tCvnzSRraUlsG0bsGIFYGYmd1RERESZiux91NJi1qxZ2LZtG/bs2QNTU1ON+4wbNw5hYWGq27NnzzI4StJo2TJpGSg/P8DTU+5oiIiIMiVZJ7y1tbWFoaEhgoOD1cqDg4Nhb2//1WPnzZuHWbNm4dixY6hQoUKy+5mYmMDExEQn8VIaPH0qDRro21faLlIEOHFC3piIiIgyOVlr1IyNjeHi4oLjx4+rypRKJY4fP45atWole9ycOXPwyy+/4PDhw6hatWpGhEppsW8fUKkS0L+/lKwRERFRisi+hJS3tze8vLxQtWpVVK9eHYsWLUJkZCR69eoFAOjRowcKFCiAmTNnAgBmz56NyZMnY+vWrXByclL1ZcuZMydycub6zCU2FhgzRlpEHQCqVeO8aERERFqQPVHz9PTEmzdvMHnyZAQFBaFSpUo4fPiwaoDB06dPYWDwqeLvt99+Q2xsLNq3b692Hh8fH0yZMiUjQ6evCQiQ+p5duSJtjxgBzJoFGBvLGxcREVEWIvs8ahmN86hlgD//lJZ9CgsDcuUCNmwAWreWOSgiIsrK9HUeNdlr1CgbCg+XkrRataSpNwoVkjsiIiKiLImJGulGQgJgaCj9v0cPwNQU+P57wMhI3riIiIiysCw9jxplEtu2AeXLAyEhn8o6dmSSRkRElEZ6W6MWGfmpAkjb4+j/oqOBH38EVq2SthcskJaEIiIiIp3Q20Qtf365I8ji7t2Tas1u3gQUCmD8eICjbomIiHRKbxO1tKpTBzA3lzsKmWzeDPzwg1S9aGcH/P478N13ckdFRESU7ehtovboEfCNVaq+ytxcqkjSOytXAgMHSv9v2BDYsgVwcJA3JiIiomxKbxM1c3POgZYqnToB8+YB3boBEyemrqMfERERpYjeJmqUQkJIi6c3aiRVIVpbA//+C5iZyR0ZERFRtsfpOSh5ERGAlxfg5gasWPGpnEkaERFRhmCNGmn277/SqM779wEDA85LQkREJAMmaqROCGletOHDgZgYoEAB4I8/AFdXuSMjIiLSO0zU6JPwcKB/f8DXV9pu1gzYtAmwtZU3LiIiIj3FPmr0ya1bwI4d0kjOOXOA/fuZpBEREcmINWr0Se3awNKlQKVKQK1ackdDRESk91ijps9CQ4Hu3YG7dz+V/fADkzQiIqJMgjVq+urKFcDTEwgIAO7cAa5e1dOlFoiIiDIv1qjpGyGARYukxUoDAgAnJ2mONCZpREREmQ5r1PTJu3dAr17Avn3Sdtu2wNq1gI2NrGERERGRZkzU9EVAANCgAfD0KWBsDCxYAAwaxJo0IiKiTIyJmr5wdAQKFQKMjIDt24EqVeSOiIiIiL6BiVp29vYtYGkp1aDlyCHNkWZuDlhZyR0ZERERpQAHE2RXZ88CFSsCY8Z8KrO3Z5JGRESUhTBRy26USmDGDKBhQ+DFC+DwYS6oTkRElEUxUctOXr8GmjYFJkwAEhKAbt2k+dIsLOSOjIiIiFKBfdSyi5MngS5dgKAgwMwMWLYM6NmTozqJiIiyMCZq2UF4ONCuHfD+PVCmjDSqs2xZuaMiIiKiNGKilh1YWQErVwKHDgFLlrCpk4iIKJtgopZVHTsGGBgAjRpJ2x06SDciIiLKNjiYIKuJjwcmTgSaNAE6dwZevZI7IiIiIkonrFHLSl68kJKzs2elbQ8PrtNJRESUjTFRyyoOHQJ69ABCQoCcOYHVq4FOneSOioiIiNIRmz4zO6VSWl2geXMpSatcGfDzY5JGRESkB5ioZXYGBtLcaAAweDBw4QJQvLi8MREREVGGYNNnZhUfLy2kDkiT13boALRsKW9MRETpTAiB+Ph4JCQkyB0KycDIyAiGhoZyh5GpMFHLbGJjgbFjgUePgL17pZUFcuZkkkZE2V5sbCxevXqFqKgouUMhmSgUChQsWBA5c+aUO5RMg4laZhIQAHh6SutzAsCpU9Li6kRE2ZxSqURAQAAMDQ2RP39+GBsbQ8El8PSKEAJv3rzB8+fPUbx4cdas/R8Ttcxi926gd28gLEyacmPDBiZpRKQ3YmNjoVQq4ejoCHNzc7nDIZnkzZsXgYGBiIuLY6L2fxxMILeYGGDoUGmtzrAwoGZNwN8faNNG7siIiDKcgQF/lvQZa1GT4idCbl27AkuXSv8fNQo4cwYoXFjemIiIiChTYKImtzFjAAcHYP9+YM4cwMhI7oiIiIgok2CiltGio4HTpz9tV6sGPHkCtGghX0xERJQmFy9ehKGhIVpo+C4/deoUFAoFQkNDk9zn5OSERYsWqZWdPHkSzZs3R548eWBubo4yZcrgp59+wosXL9IpeuDjx48YPHgw8uTJg5w5c6Jdu3YIDg7+6jEKhULjbe7cuap9Hjx4gDZt2sDW1hZWVlaoW7cuTp48mW7PIztiopaR7t+X+qC5u0v90BKZmsoWEhERpd3atWsxdOhQnDlzBi9fvkz1eVauXAk3NzfY29tj165duHPnDlasWIGwsDDMnz9fhxGrGzFiBP766y/s2LEDp0+fxsuXL9G2bduvHvPq1Su127p166BQKNCuXTvVPi1btkR8fDxOnDiBa9euoWLFimjZsiWCEidyp2/iqM+MsmULMGAAEBkJ5M0LaPjLioiIsp6IiAj4+vri6tWrCAoKwoYNGzB+/Hitz/P8+XMMGzYMw4YNw8KFC1XlTk5OqFevnsYaOV0ICwvD2rVrsXXrVjRq1AgAsH79epQuXRqXLl1CzZo1NR5nb2+vtr137140bNgQRYoUAQCEhITg4cOHWLt2LSpUqAAAmDVrFpYvX45bt24lOZ40Y41aeouKAvr2Bbp1k5K0Bg2k2rQGDWQOjIgo8xJC+sqU4yaEdrFu374dpUqVQsmSJdGtWzesW7cOQtuTANixYwdiY2MxevRojffb2Ngke2yzZs2QM2fOZG9ly5ZN9thr164hLi4Obm5uqrJSpUqhUKFCuHjxYopiDw4OxoEDB9CnTx9VWZ48eVCyZEls2rQJkZGRiI+Px8qVK2FnZwcXF5cUnZdYo5a+7twBOnYEbt+WVhiYPBmYNAng3DBERF8VFSUtyiKHiAjAwiLl+69duxbdunUDADRt2hRhYWE4ffo0Gmj5B/nDhw9hZWUFBwcHrY4DgDVr1iA6OjrZ+42+MlAtKCgIxsbGSRLBfPnypbiJcuPGjbC0tFRrLlUoFDh27Bg8PDxgaWkJAwMD2NnZ4fDhw8iVK1eKzktM1NLX3r1SkmZvLzV9/r9KmYiIsof79+/j8uXL2LNnDwAgR44c8PT0xNq1a7VO1IQQqZ5HrECBAqk6TlfWrVuHrl27wvSzPtdCCAwePBh2dnY4e/YszMzMsGbNGrRq1QpXrlxJVUKqj5iopafRo6V69KFDgXz55I6GiCjLMDeXarbkeuyUWrt2LeLj45E/f35VmRACJiYmWLp0KaytrWFlZQVA6gv2Za1VaGgorK2tAQAlSpRAWFgYXr16pXUS06xZM5w9ezbZ+wsXLozbt29rvM/e3h6xsbEIDQ1Viy84ODhF/cjOnj2L+/fvw9fXV638xIkT2L9/P96/f696DZYvX46jR49i48aNGDt2bAqeGTFR06WbN4GffwY2bQLMzKQmzmnT5I6KiCjLUSi0a36UQ3x8PDZt2oT58+ejSZMmavd5eHjgjz/+wMCBA1G8eHEYGBjg2rVrKPzZhOZPnjxBWFgYSpQoAQBo3749xo4dizlz5qgNJkj0ZSL1ubQ0fbq4uMDIyAjHjx9Xjdi8f/8+nj59ilq1aiV7XKK1a9fCxcUFFStWVCuPiooCkHS1CQMDAyiVym+el/5P6JmwsDABQLx8Gaa7kyqVQqxaJYSpqRCAEKNH6+7cRER6IDo6Wty5c0dER0fLHUqK7dmzRxgbG4vQ0NAk940ePVpUrVpVtd2/f3/h5OQk9u7dK548eSJOnz4tatasKWrWrCmUSqVqv2XLlgmFQiF69+4tTp06JQIDA8W5c+dE//79hbe3d7o9l4EDB4pChQqJEydOiKtXr4patWqJWrVqqe1TsmRJsXv3brWysLAwYW5uLn777bck53zz5o3IkyePaNu2rfD39xf3798XI0eOFEZGRsLf319jHF97HyT+foeF6fD3Owtgopb2EwrRqZOUoAFCNG0qxOvXujk3EZGeyIqJWsuWLUXz5s013vfPP/8IAOLGjRtCCOn5+fj4iFKlSgkzMzPh7Ows+vfvL968eZPk2KNHjwp3d3eRK1cuYWpqKkqVKiVGjhwpXr58mW7PJTo6WgwaNEjkypVLmJubi++//168evVKbR8AYv369WplK1euFGZmZhqTVSGEuHLlimjSpInInTu3sLS0FDVr1hQHDx78ahxM1NQphEjFGOIsLDw8HNbW1nj5MgwODlZpO9n169KozkePpGbOGTOAkSMBLipMRKSVjx8/IiAgAM7Ozmod0km/fO19kPj7HRYWpurzpg/YRy219uwBOnUCYmMBR0dg2zagdm25oyIiIqJshIlaalWtKk3yU6cOsH49kCeP3BERERFRNsNETRsvXgCJc9U4OgKXLwNFikjDk4iIiIh0jJ2pUkIIYPFiKSnbt+9TedGiTNKIiIgo3TBR+5Z374Dvvwd+/FHqj/Z5okZERESUjpiofc2lS0DlytJSUMbGwJIlwOrVckdFRJRt6dlEBPQFXv+kmKhpolQC8+YBrq7A06dSE+eFC8CQIWzqJCJKB4kz5yfOZk/6KTY2FgBgaGgocySZBwcTaHLmDDBqlPT/jh2lWjQ9mrOFiCijGRoawsbGBq9fvwYAmJubp3qBcsqalEol3rx5A3Nzc+TIwfQkEV8JTRo0AIYPB0qVAgYMYC0aEVEGSFwAPDFZI/1jYGCAQoUKMUn/DBM1QGrqXLwY6NwZ+P8XBRYtkjUkIiJ9o1Ao4ODgADs7O8TFxckdDsnA2Ng4ySLu+i5TJGrLli3D3LlzERQUhIoVK2LJkiWoXr16svvv2LEDkyZNQmBgIIoXL47Zs2ejefPmqXvw16+B7t2Bv/8G9u8Hjh7lElBERDIyNDRkHyWi/5M9I/H19YW3tzd8fHzg5+eHihUrwt3dPdmq7wsXLqBz587o06cPrl+/Dg8PD3h4eODWrVvaP/ipU0ClSlKSZmYGdO3KZk4iIiLKNGRflL1GjRqoVq0ali5dCkDqTOjo6IihQ4di7NixSfb39PREZGQk9u/fryqrWbMmKlWqhBUrVnzz8RIXdX0zchxsF8yWmj1Llwa2bwfKldPdEyMiIiKd0ddF2WWtUYuNjcW1a9fg5uamKjMwMICbmxsuXryo8ZiLFy+q7Q8A7u7uye6fHON5M6UkrVcv4MoVJmlERESU6cjaRy0kJAQJCQnIly+fWnm+fPlw7949jccEBQVp3D8oKEjj/jExMYiJiVFth4WFSf+amkoDCDp1AhISgPDwtDwVIiIiSkfh//+d1rdJcTPFYIL0NHPmTEydOjVJeaGPH6WpNwYMkCEqIiIiSo23b9/C2tpa7jAyjKyJmq2tLQwNDREcHKxWHhwcrJpP50v29vZa7T9u3Dh4e3urtkNDQ1G4cGE8ffpUry50ZhQeHg5HR0c8e/ZMr/obZFa8HpkHr0XmwWuReYSFhaFQoULInTu33KFkKFkTNWNjY7i4uOD48ePw8PAAIA0mOH78OIYMGaLxmFq1auH48eP48ccfVWVHjx5FrVq1NO5vYmICExOTJOXW1tb80GUSVlZWvBaZCK9H5sFrkXnwWmQe+jbPmuxNn97e3vDy8kLVqlVRvXp1LFq0CJGRkejVqxcAoEePHihQoABmzpwJABg+fDjq16+P+fPno0WLFti2bRuuXr2KVatWyfk0iIiIiHRO9kTN09MTb968weTJkxEUFIRKlSrh8OHDqgEDT58+Vcuea9euja1bt2LixIkYP348ihcvjj///BPlOGqTiIiIshnZEzUAGDJkSLJNnadOnUpS1qFDB3To0CFVj2ViYgIfHx+NzaGUsXgtMhdej8yD1yLz4LXIPPT1Wsg+4S0RERERaaZfPfKIiIiIshAmakRERESZFBM1IiIiokyKiRoRERFRJpUtE7Vly5bByckJpqamqFGjBi5fvvzV/Xfs2IFSpUrB1NQU5cuXx8GDBzMo0uxPm2uxevVquLq6IleuXMiVKxfc3Ny+ee1IO9p+NhJt27YNCoVCNTE1pZ221yI0NBSDBw+Gg4MDTExMUKJECX5X6Yi212LRokUoWbIkzMzM4OjoiBEjRuDjx48ZFG32debMGbRq1Qr58+eHQqHAn3/++c1jTp06hSpVqsDExATFihXDhg0b0j3ODCeymW3btgljY2Oxbt06cfv2bdGvXz9hY2MjgoODNe5//vx5YWhoKObMmSPu3LkjJk6cKIyMjMTNmzczOPLsR9tr0aVLF7Fs2TJx/fp1cffuXdGzZ09hbW0tnj9/nsGRZ0/aXo9EAQEBokCBAsLV1VW0adMmY4LN5rS9FjExMaJq1aqiefPm4ty5cyIgIECcOnVK+Pv7Z3Dk2Y+212LLli3CxMREbNmyRQQEBIgjR44IBwcHMWLEiAyOPPs5ePCgmDBhgti9e7cAIPbs2fPV/Z88eSLMzc2Ft7e3uHPnjliyZIkwNDQUhw8fzpiAM0i2S9SqV68uBg8erNpOSEgQ+fPnFzNnztS4f8eOHUWLFi3UymrUqCEGDBiQrnHqA22vxZfi4+OFpaWl2LhxY3qFqFdScz3i4+NF7dq1xZo1a4SXlxcTNR3R9lr89ttvokiRIiI2NjajQtQb2l6LwYMHi0aNGqmVeXt7izp16qRrnPomJYna6NGjRdmyZdXKPD09hbu7ezpGlvGyVdNnbGwsrl27Bjc3N1WZgYEB3NzccPHiRY3HXLx4UW1/AHB3d092f0qZ1FyLL0VFRSEuLk7vFuBND6m9Hj///DPs7OzQp0+fjAhTL6TmWuzbtw+1atXC4MGDkS9fPpQrVw4zZsxAQkJCRoWdLaXmWtSuXRvXrl1TNY8+efIEBw8eRPPmzTMkZvpEX36/M8XKBLoSEhKChIQE1fJTifLly4d79+5pPCYoKEjj/kFBQekWpz5IzbX40pgxY5A/f/4kH0TSXmqux7lz57B27Vr4+/tnQIT6IzXX4smTJzhx4gS6du2KgwcP4tGjRxg0aBDi4uLg4+OTEWFnS6m5Fl26dEFISAjq1q0LIQTi4+MxcOBAjB8/PiNCps8k9/sdHh6O6OhomJmZyRSZbmWrGjXKPmbNmoVt27Zhz549MDU1lTscvfPhwwd0794dq1evhq2trdzh6D2lUgk7OzusWrUKLi4u8PT0xIQJE7BixQq5Q9M7p06dwowZM7B8+XL4+flh9+7dOHDgAH755Re5Q6NsKlvVqNna2sLQ0BDBwcFq5cHBwbC3t9d4jL29vVb7U8qk5lokmjdvHmbNmoVjx46hQoUK6Rmm3tD2ejx+/BiBgYFo1aqVqkypVAIAcuTIgfv376No0aLpG3Q2lZrPhoODA4yMjGBoaKgqK126NIKCghAbGwtjY+N0jTm7Ss21mDRpErp3746+ffsCAMqXL4/IyEj0798fEyZMgIEB6z8ySnK/31ZWVtmmNg3IZjVqxsbGcHFxwfHjx1VlSqUSx48fR61atTQeU6tWLbX9AeDo0aPJ7k8pk5prAQBz5szBL7/8gsOHD6Nq1aoZEape0PZ6lCpVCjdv3oS/v7/q1rp1azRs2BD+/v5wdHTMyPCzldR8NurUqYNHjx6pkmUAePDgARwcHJikpUFqrkVUVFSSZCwxgRZcOjtD6c3vt9yjGXRt27ZtwsTERGzYsEHcuXNH9O/fX9jY2IigoCAhhBDdu3cXY8eOVe1//vx5kSNHDjFv3jxx9+5d4ePjw+k5dETbazFr1ixhbGwsdu7cKV69eqW6ffjwQa6nkK1oez2+xFGfuqPttXj69KmwtLQUQ4YMEffv3xf79+8XdnZ2Ytq0aXI9hWxD22vh4+MjLC0txR9//CGePHki/v77b1G0aFHRsWNHuZ5CtvHhwwdx/fp1cf36dQFALFiwQFy/fl38999/Qgghxo4dK7p3767aP3F6jlGjRom7d++KZcuWcXqOrGLJkiWiUKFCwtjYWFSvXl1cunRJdV/9+vWFl5eX2v7bt28XJUqUEMbGxqJs2bLiwIEDGRxx9qXNtShcuLAAkOTm4+OT8YFnU9p+Nj7HRE23tL0WFy5cEDVq1BAmJiaiSJEiYvr06SI+Pj6Do86etLkWcXFxYsqUKaJo0aLC1NRUODo6ikGDBon3799nfODZzMmTJzX+BiS+/l5eXqJ+/fpJjqlUqZIwNjYWRYoUEevXr8/wuNObQgjW1RIRERFlRtmqjxoRERFRdsJEjYiIiCiTYqJGRERElEkxUSMiIiLKpJioEREREWVSTNSIiIiIMikmakRERESZFBM1IlKzYcMG2NjYyB1GqikUCvz5559f3adnz57w8PDIkHiIiNKCiRpRNtSzZ08oFIokt0ePHskdGjZs2KCKx8DAAAULFkSvXr3w+vVrnZz/1atXaNasGQAgMDAQCoUC/v7+avssXrwYGzZs0MnjJWfKlCmq52loaAhHR0f0798f79690+o8TCqJ9FsOuQMgovTRtGlTrF+/Xq0sb968MkWjzsrKCvfv34dSqcSNGzfQq1cvvHz5EkeOHEnzue3t7b+5j7W1dZofJyXKli2LY8eOISEhAXfv3kXv3r0RFhYGX1/fDHl8Isr6WKNGlE2ZmJjA3t5e7WZoaIgFCxagfPnysLCwgKOjIwYNGoSIiIhkz3Pjxg00bNgQlpaWsLKygouLC65evaq6/9y5c3B1dYWZmRkcHR0xbNgwREZGfjU2hUIBe3t75M+fH82aNcOwYcNw7NgxREdHQ6lU4ueff0bBggVhYmKCSpUq4fDhw6pjY2NjMWTIEDg4OMDU1BSFCxfGzJkz1c6d2PTp7OwMAKhcuTIUCgUaNGgAQL2WatWqVcifPz+USqVajG3atEHv3r1V23v37kWVKlVgamqKIkWKYOrUqYiPj//q88yRIwfs7e1RoEABuLm5oUOHDjh69Kjq/oSEBPTp0wfOzs4wMzNDyZIlsXjxYtX9U6ZMwcaNG7F3715V7dypU6cAAM+ePUPHjh1hY2OD3Llzo02bNggMDPxqPESU9TBRI9IzBgYG+PXXX3H79m1s3LgRJ06cwOjRo5Pdv2vXrihYsCCuXLmCa9euYezYsTAyMgIAPH78GE2bNkW7du3w77//wtfXF+fOncOQIUO0isnMzAxKpRLx8fFYvHgx5s+fj3nz5uHff/+Fu7s7WrdujYcPHwIAfv31V+zbtw/bt2/H/fv3sWXLFjg5OWk87+XLlwEAx44dw6tXr7B79+4k+3To0AFv377FyZMnVWXv3r3D4cOH0bVrVwDA2bNn0aNHDwwfPhx37tzBypUrsWHDBkyfPj3FzzEwMBBHjhyBsbGxqkypVKJgwYLYsWMH7ty5g8mTJ2P8+PHYvn07AGDkyJHo2LEjmjZtilevXuHVq1eoXbs24uLi4O7uDktLS5w9exbnz59Hzpw50bRpU8TGxqY4JiLKAuReFZ6IdM/Ly0sYGhoKCwsL1a19+/Ya992xY4fIkyePanv9+vXC2tpatW1paSk2bNig8dg+ffqI/v37q5WdPXtWGBgYiOjoaI3HfHn+Bw8eiBIlSoiqVasKIYTInz+/mD59utox1apVE4MGDRJCCDF06FDRqFEjoVQqNZ4fgNizZ48QQoiAgAABQFy/fl1tHy8vL9GmTRvVdps2bUTv3r1V2ytXrhT58+cXCQkJQgghGjduLGbMmKF2js2bNwsHBweNMQghhI+PjzAwMBAWFhbC1NRUABAAxIIFC5I9RgghBg8eLNq1a5dsrImPXbJkSbXXICYmRpiZmYkjR4589fxElLWwjxpRNtWwYUP89ttvqm0LCwsAUu3SzJkzce/ePYSHhyM+Ph4fP35EVFQUzM3Nk5zH29sbffv2xebNm1XNd0WLFgUgNYv++++/2LJli2p/IQSUSiUCAgJQunRpjbGFhYUhZ86cUCqV+PjxI+rWrYs1a9YgPDwcL1++RJ06ddT2r1OnDm7cuAFAarb87rvvULJkSTRt2hQtW7ZEkyZN0vRade3aFf369cPy5cthYmKCLVu2oFOnTjAwMFA9z/Pnz6vVoCUkJHz1dQOAkiVLYt++ffj48SN+//13+Pv7Y+jQoWr7LFu2DOvWrcPTp08RHR2N2NhYVKpU6avx3rhxA48ePYKlpaVa+cePH/H48eNUvAJElFkxUSPKpiwsLFCsWDG1ssDAQLRs2RI//PADpk+fjty5c+PcuXPo06cPYmNjNSYcU6ZMQZcuXXDgwAEcOnQIPj4+2LZtG77//ntERERgwIABGDZsWJLjChUqlGxslpaW8PPzg4GBARwcHGBmZgYACA8P/+bzqlKlCgICAnDo0CEcO3YMHTt2hJubG3bu3PnNY5PTqlUrCCFw4MABVKtWDWfPnsXChQtV90dERGDq1Klo27ZtkmNNTU2TPa+xsbHqGsyaNQstWrTA1KlT8csvvwAAtm3bhpEjR2L+/PmoVasWLC0tMXfuXPzzzz9fjTciIgIuLi5qCXKizDJghIh0g4kakR65du0alEol5s+fr6otSuwP9TUlSpRAiRIlMGLECHTu3Bnr16/H999/jypVquDOnTtJEsJvMTAw0HiMlZUV8ufPj/Pnz6N+/fqq8vPnz6N69epq+3l6esLT0xPt27dH06ZN8e7dO+TOnVvtfIn9wRISEr4aj6mpKdq2bYstW7bg0aNHKFmyJKpUqaK6v0qVKrh//77Wz/NLEydORKNGjfDDDz+onmft2rUxaNAg1T5f1ogZGxsnib9KlSrw9fWFnZ0drKys0hQTEWVuHExApEeKFSuGuLg4LFmyBE+ePMHmzZuxYsWKZPePjo7GkCFDcOrUKfz33384f/48rly5omrSHDNmDC5cuIAhQ4bA398fDx8+xN69e7UeTPC5UaNGYfbs2fD19cX9+/cxduxY+Pv7Y/jw4QCABQsW4I8//sC9e/fw4MED7NixA/b29hon6bWzs4OZmRkOHz6M4OBghIWFJfu4Xbt2xYEDB7Bu3TrVIIJEkydPxqZNmzB16lTcvn0bd+/exbZt2zBx4kStnlutWrVQoUIFzJgxAwBQvHhxXL16FUeOHMGDBw8wadIkXLlyRe0YJycn/Pvvv7h//z5CQkIQFxeHrl27wtbWFm3atMHZs2cREBCAU6dOYdiwYXj+/LlWMRFR5sZEjUiPVKxYEQsWLMDs2bNRrlw5bNmyRW1qiy8ZGhri7du36NGjB0qUKIGOHTuiWbNmmDp1KgCgQoUKOH36NB48eABXV1dUrlwZkydPRv78+VMd47Bhw+Dt7Y2ffvoJ5cuXx+HDh7Fv3z4UL14cgNRsOmfOHFStWhXVqlVDYGAgDh48qKoh/FyOHDnw66+/YuXKlcifPz/atGmT7OM2atQIuXPnxv3799GlSxe1+9zd3bF//378/fffqFatGmrWrImFCxeicOHCWj+/ESNGYM2aNXj27BkGDBiAtm3bwtPTEzVq1MDbt2/VatcAoF+/fihZsiSqVq2KvHnz4vz58zA3N8eZM2dQqFAhtG3bFqVLl0afPn3w8eNH1rARZTMKIYSQOwgiIiIiSoo1akRERESZFBM1IiIiokyKiRoRERFRJsVEjYiIiCiTYqJGRERElEkxUSMiIiLKpJioEREREWVSTNSIiIiIMikmakRERESZFBM1IiIiokyKiRoRERFRJsVEjYiIiCiT+h9U1HleyPPgkgAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmUAAAHcCAYAAACXot0HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACc0ElEQVR4nOzdd1gUVxcG8BeQjhRFUBFBsXfFrlhRLNEYG3Y01tg1dmNPNMYeS4y9JnajscYae+/d2BsqKqDS2fv9cb9dWJq7tAH2/T0Pz87Mzs4etp69c++5RkIIASIiIiJSlLHSARARERERkzIiIiKiDIFJGREREVEGwKSMiIiIKANgUkZERESUATApIyIiIsoAmJQRERERZQBMyoiIiIgyACZlRERERBkAkzKiFHB3d0fXrl2VDsPg1KlTB3Xq1FE6jC+aOHEijIyMEBAQoHQoGY6RkREmTpyYKsd6/PgxjIyMsGrVqlQ5HpFSmJRRhrVq1SoYGRlp/rJlywYXFxd07doVL168UDq8DO3z58+YMmUKypQpAysrK9jZ2cHLywtr1qxBZplZ7datW5g4cSIeP36sdCjxREdHY+XKlahTpw5y5MgBc3NzuLu7o1u3brhw4YLS4aWKP/74A3PnzlU6DC0ZMSai1JRN6QCIvmTy5MkoUKAAwsLCcObMGaxatQonTpzAjRs3YGFhoWhsd+/ehbFxxvpt8/r1a9SvXx+3b99Gu3bt0L9/f4SFhWHr1q3w8/PDnj17sH79epiYmCgdapJu3bqFSZMmoU6dOnB3d9e67p9//lEmKAChoaFo2bIl9u3bh1q1amHMmDHIkSMHHj9+jE2bNmH16tV4+vQp8uXLp1iMqeGPP/7AjRs3MHjw4DQ5fmhoKLJl0+8rKLGY3NzcEBoaClNT01SMkCj9MSmjDK9x48aoWLEiAKBHjx5wdHTE9OnTsXPnTrRt21bR2MzNzdP9PsPCwmBmZpZoMujn54fbt29j+/btaN68uWb7wIEDMXz4cMycORPly5fHyJEj0ytkALL1ztraOlWOZWZmlirHSY7hw4dj3759mDNnTrzkYMKECZgzZ066xiOEQFhYGCwtLdP1fpNDpVIhIiICFhYWqfqDysjISPEfaESpQhBlUCtXrhQAxPnz57W279q1SwAQU6dO1dp++/Zt0apVK+Hg4CDMzc2Fp6en2LFjR7zjfvjwQQwePFi4ubkJMzMz4eLiIjp37izevn2r2ScsLEyMHz9eeHh4CDMzM5EvXz4xfPhwERYWpnUsNzc34efnJ4QQ4vz58wKAWLVqVbz73LdvnwAg/v77b82258+fi27dugknJydhZmYmSpQoIZYvX651uyNHjggA4s8//xRjx44VefPmFUZGRuLDhw8JPmanT58WAMS3336b4PWRkZGicOHCwsHBQYSEhAghhHj06JEAIGbMmCFmz54t8ufPLywsLEStWrXE9evX4x1Dl8dZ/dwdPXpUfPfddyJXrlzC3t5eCCHE48ePxXfffSeKFCkiLCwsRI4cOUTr1q3Fo0eP4t0+7t+RI0eEEELUrl1b1K5dO97jtHHjRvHjjz8KFxcXYW5uLurVqyfu378f739YsGCBKFCggLCwsBCVKlUSx44di3fMhDx79kxky5ZNNGjQIMn91CZMmCAAiPv37ws/Pz9hZ2cnbG1tRdeuXcXnz5+19l2xYoWoW7euyJUrlzAzMxPFixcXixYtindMNzc30bRpU7Fv3z7h6ekpzM3NxZw5c/Q6hhBC7NmzR9SqVUvY2NiI7Nmzi4oVK4r169cLIeTjG/exd3Nz09xW1/cHANGvXz+xbt06UaJECZEtWzaxfft2zXUTJkzQ7BscHCwGDRqkeV/mypVLeHt7i4sXL34xJvVreOXKlVr3f/v2bdGmTRvh6OgoLCwsRJEiRcSYMWOSesqIFMWWMsp01H2MHBwcNNtu3ryJGjVqwMXFBaNGjYK1tTU2bdqEFi1aYOvWrfjmm28AAJ8+fYKXlxdu376Nb7/9FhUqVEBAQAB27tyJ58+fw9HRESqVCs2bN8eJEyfQq1cvFC9eHNevX8ecOXNw7949/PXXXwnGVbFiRRQsWBCbNm2Cn5+f1nUbN26Eg4MDfHx8AMhTjFWrVoWRkRH69++PXLlyYe/evejevTuCg4PjtcBMmTIFZmZmGDZsGMLDwxNtKfr7778BAF26dEnw+mzZsqFDhw6YNGkSTp48CW9vb811a9aswcePH9GvXz+EhYVh3rx5qFevHq5fvw5nZ2e9Hme1vn37IleuXBg/fjw+f/4MADh//jxOnTqFdu3aIV++fHj8+DF+++031KlTB7du3YKVlRVq1aqFgQMH4tdff8WYMWNQvHhxANBcJubnn3+GsbExhg0bhqCgIPzyyy/o2LEjzp49q9nnt99+Q//+/eHl5YUhQ4bg8ePHaNGiBRwcHL54ynHv3r2IiopC586dk9wvrrZt26JAgQKYNm0aLl26hGXLlsHJyQnTp0/XiqtkyZJo3rw5smXLhr///ht9+/aFSqVCv379tI539+5dtG/fHr1790bPnj1RtGhRvY6xatUqfPvttyhZsiRGjx4Ne3t7XL58Gfv27UOHDh0wduxYBAUF4fnz55qWPxsbGwDQ+/1x+PBhbNq0Cf3794ejo2O8U9Fqffr0wZYtW9C/f3+UKFEC7969w4kTJ3D79m1UqFAhyZgScu3aNXh5ecHU1BS9evWCu7s7Hjx4gL///hs//fSTbk8cUXpTOiskSoy6teTgwYPi7du34tmzZ2LLli0iV65cwtzcXDx79kyzb/369UXp0qW1fqmrVCpRvXp1UbhwYc228ePHCwBi27Zt8e5PpVIJIYRYu3atMDY2FsePH9e6fvHixQKAOHnypGZb7JYyIYQYPXq0MDU1Fe/fv9dsCw8PF/b29lqtV927dxd58uQRAQEBWvfRrl07YWdnp2nFUrcAFSxYULMtKS1atBAAEm1JE0KIbdu2CQDi119/FULEtDJYWlqK58+fa/Y7e/asACCGDBmi2abr46x+7mrWrCmioqK07j+h/0PdwrdmzRrNts2bN2u1jsWWWEtZ8eLFRXh4uGb7vHnzBABNi194eLjImTOnqFSpkoiMjNTst2rVKgHgiy1lQ4YMEQDE5cuXk9xPTd1SFrfl8ptvvhE5c+bU2pbQ4+Lj4yMKFiyotc3NzU0AEPv27Yu3vy7HCAwMFNmzZxdVqlQRoaGhWvuq3wNCCNG0aVOt1jE1fd4fAISxsbG4efNmvOMgTkuZnZ2d6NevX7z9YksspoRaymrVqiWyZ88unjx5kuj/SJTRZKweykQJ8Pb2Rq5cueDq6orWrVvD2toaO3fu1LRqvH//HocPH0bbtm3x8eNHBAQEICAgAO/evYOPjw/u37+vGa25detWlC1bNl6LDiD7pQDA5s2bUbx4cRQrVkxzrICAANSrVw8AcOTIkURj9fX1RWRkJLZt26bZ9s8//yAwMBC+vr4AZB+grVu3olmzZhBCaN2Hj48PgoKCcOnSJa3j+vn56dRn6OPHjwCA7NmzJ7qP+rrg4GCt7S1atICLi4tmvXLlyqhSpQr27NkDQL/HWa1nz57xBhTE/j8iIyPx7t07FCpUCPb29vH+b31169ZNqxXRy8sLAPDw4UMAwIULF/Du3Tv07NlTq5N5x44dtVpeE6N+zJJ6fBPSp08frXUvLy+8e/dO6zmI/bgEBQUhICAAtWvXxsOHDxEUFKR1+wIFCmhaXWPT5RgHDhzAx48fMWrUqHj9sNTvgaTo+/6oXbs2SpQo8cXj2tvb4+zZs3j58uUX9/2St2/f4tixY/j222+RP39+ret0+R+JlMLTl5ThLVy4EEWKFEFQUBBWrFiBY8eOaXWw/++//yCEwLhx4zBu3LgEj/HmzRu4uLjgwYMHaNWqVZL3d//+fdy+fRu5cuVK9FiJKVu2LIoVK4aNGzeie/fuAOSpS0dHR82X1tu3bxEYGIglS5ZgyZIlOt1HgQIFkoxZTZ0sfPz4Efb29gnuk1jiVrhw4Xj7FilSBJs2bQKg3+OcVNyhoaGYNm0aVq5ciRcvXmiV6IibfOgr7hewOtH68OEDAODJkycAgEKFCmntly1btkRPq8Vma2sLIOYxTI241Mc8efIkJkyYgNOnTyMkJERr/6CgINjZ2WnWE3s96HKMBw8eAABKlSql1/+gpu/7Q9fX7i+//AI/Pz+4urrC09MTTZo0QZcuXVCwYEG9Y1Qn4cn9H4mUwqSMMrzKlStrRl+2aNECNWvWRIcOHXD37l3Y2NhApVIBAIYNG5Zg6wEQ/0s4KSqVCqVLl8bs2bMTvN7V1TXJ2/v6+uKnn35CQEAAsmfPjp07d6J9+/aalhl1vJ06dYrX90ytTJkyWuu6jqwrXrw4/vrrL1y7dg21atVKcJ9r164BgE6tF7El53FOKO4BAwZg5cqVGDx4MKpVqwY7OzsYGRmhXbt2mvtIrsTKfIhUqs1WrFgxAMD169dRrlw5nW/3pbgePHiA+vXro1ixYpg9ezZcXV1hZmaGPXv2YM6cOfEel4QeV32PkVz6vj90fe22bdsWXl5e2L59O/755x/MmDED06dPx7Zt29C4ceMUx02UGTApo0zFxMQE06ZNQ926dbFgwQKMGjVK80va1NRUq+N6Qjw8PHDjxo0v7nP16lXUr18/Wac6fH19MWnSJGzduhXOzs4IDg5Gu3btNNfnypUL2bNnR3R09Bfj1ddXX32FadOmYc2aNQkmZdHR0fjjjz/g4OCAGjVqaF13//79ePvfu3dP04Kkz+OclC1btsDPzw+zZs3SbAsLC0NgYKDWfmlxmsnNzQ2AbPWrW7euZntUVBQeP34cLxmOq3HjxjAxMcG6dev07uyflL///hvh4eHYuXOnVqtaUqfKk3sMDw8PAMCNGzeS/LGS2OOf0vdHUvLkyYO+ffuib9++ePPmDSpUqICffvpJk5Tpen/q1+qX3utEGQ37lFGmU6dOHVSuXBlz585FWFgYnJycUKdOHfz+++949epVvP3fvn2rWW7VqhWuXr2K7du3x9tP3WrRtm1bvHjxAkuXLo23T2hoqGYUYWKKFy+O0qVLY+PGjdi4cSPy5MmjlSCZmJigVatW2Lp1a4JfGrHj1Vf16tXh7e2NlStXYteuXfGuHzt2LO7du4cRI0bEa8H466+/tPqEnTt3DmfPntV8IerzOCfFxMQkXsvV/PnzER0drbVNXdMsbrKWEhUrVkTOnDmxdOlSREVFabavX79ec4ozKa6urujZsyf++ecfzJ8/P971KpUKs2bNwvPnz/WKS92SFvdU7sqVK1P9GA0bNkT27Nkxbdo0hIWFaV0X+7bW1tYJnk5O6fsjIdHR0fHuy8nJCXnz5kV4ePgXY4orV65cqFWrFlasWIGnT59qXZdaraZEaYEtZZQpDR8+HG3atMGqVavQp08fLFy4EDVr1kTp0qXRs2dPFCxYEK9fv8bp06fx/PlzXL16VXO7LVu2oE2bNvj222/h6emJ9+/fY+fOnVi8eDHKli2Lzp07Y9OmTejTpw+OHDmCGjVqIDo6Gnfu3MGmTZuwf/9+zenUxPj6+mL8+PGwsLBA9+7d4xV6/fnnn3HkyBFUqVIFPXv2RIkSJfD+/XtcunQJBw8exPv375P92KxZswb169fH119/jQ4dOsDLywvh4eHYtm0bjh49Cl9fXwwfPjze7QoVKoSaNWviu+++Q3h4OObOnYucOXNixIgRmn10fZyT8tVXX2Ht2rWws7NDiRIlcPr0aRw8eBA5c+bU2q9cuXIwMTHB9OnTERQUBHNzc9SrVw9OTk7JfmzMzMwwceJEDBgwAPXq1UPbtm3x+PFjrFq1Ch4eHjq1xMyaNQsPHjzAwIEDsW3bNnz11VdwcHDA06dPsXnzZty5c0erZVQXDRs2hJmZGZo1a4bevXvj06dPWLp0KZycnBJMgFNyDFtbW8yZMwc9evRApUqV0KFDBzg4OODq1asICQnB6tWrAQCenp7YuHEjhg4dikqVKsHGxgbNmjVLlfdHXB8/fkS+fPnQunVrlC1bFjY2Njh48CDOnz+v1aKaWEwJ+fXXX1GzZk1UqFABvXr1QoECBfD48WPs3r0bV65c0Ss+onSjyJhPIh0kVjxWCCGio6OFh4eH8PDw0JRcePDggejSpYvInTu3MDU1FS4uLuKrr74SW7Zs0brtu3fvRP/+/YWLi4um8KWfn59WeYqIiAgxffp0UbJkSWFubi4cHByEp6enmDRpkggKCtLsF7ckhtr9+/c1BS5PnDiR4P/3+vVr0a9fP+Hq6ipMTU1F7ty5Rf369cWSJUs0+6hLPWzevFmvx+7jx49i4sSJomTJksLS0lJkz55d1KhRQ6xatSpeSYDYxWNnzZolXF1dhbm5ufDy8hJXr16Nd2xdHueknrsPHz6Ibt26CUdHR2FjYyN8fHzEnTt3Enwsly5dKgoWLChMTEx0Kh4b93FKrKjor7/+Ktzc3IS5ubmoXLmyOHnypPD09BSNGjXS4dEVIioqSixbtkx4eXkJOzs7YWpqKtzc3ES3bt20ymWoS2LELkwc+/GJXTB3586dokyZMsLCwkK4u7uL6dOnixUrVsTbT108NiG6HkO9b/Xq1YWlpaWwtbUVlStXFn/++afm+k+fPokOHToIe3v7eMVjdX1/4P/FYxOCWCUxwsPDxfDhw0XZsmVF9uzZhbW1tShbtmy8wreJxZTY83zjxg3xzTffCHt7e2FhYSGKFi0qxo0bl2A8RBmBkRBsyyUyZI8fP0aBAgUwY8YMDBs2TOlwFKFSqZArVy60bNkywdNyRETpgX3KiMighIWFxetXtGbNGrx//x516tRRJigiIrBPGREZmDNnzmDIkCFo06YNcubMiUuXLmH58uUoVaoU2rRpo3R4RGTAmJQRkUFxd3eHq6srfv31V7x//x45cuRAly5d8PPPPyc6pygRUXpgnzIiIiKiDIB9yoiIiIgyACZlRERERBlAuiVlR48ehZGREbZs2ZJed5mktIhn4sSJOk8DYmRkhIkTJybrftSxHz16VLOta9euOk2oTFmX+nXx+PHjL+7r7u6Orl27pnlMCUnOaz8l7xdD1bVrV51Gkyb0eUIZiz7fLamtSZMm6Nmz5xf3W7Vqlc6fP2mha9eusLGxUeS+4xo1ahSqVKmSrNumKCkzMjLS6Y9v9ozp1q1bmDhxomJvovSydOlS1K5dG87OzjA3N0eBAgXQrVu3eP/3s2fPMGnSJFSuXBkODg5wdHREnTp1cPDgwQSPGxgYiF69eiFXrlywtrZG3bp1cenSpQT33blzJypUqAALCwvkz58fEyZM0JrmJznHpPSn/uL50h9/IGVuL1++xMSJE1Nc+b9r166Jvkb27duXOsGmoZMnT+Kff/7ByJEjlQ4FABASEoKJEycqklOEhoaie/fuKFWqFOzs7GBjY4OyZcti3rx5iIyM1Np38ODBuHr1Knbu3Kn3/aRo9OXatWu11tesWYMDBw7E2168eHHcvn07JXdFX7B06VKoVCq9bnPr1i1MmjQJderUydJfIpcvX0aBAgXQvHlzODg44NGjR1i6dCl27dqFq1evIm/evACAHTt2YPr06WjRogX8/PwQFRWFNWvWoEGDBlixYgW6deumOaZKpULTpk1x9epVDB8+HI6Ojli0aBHq1KmDixcvonDhwpp99+7dixYtWqBOnTqYP38+rl+/jh9//BFv3rzBb7/9lqxjkjJq1aoV7/OtR48eqFy5Mnr16qXZllF+seuiVq1aCA0N5cjTWF6+fIlJkybB3d0d5cqVS9GxzM3NsWzZsnjby5Ytm6LjpocZM2agfv36SU5cn55CQkIwadIkAEj3moKhoaG4efMmmjRpAnd3dxgbG+PUqVMYMmQIzp49iz/++EOzb+7cufH1119j5syZaN68uV73k6KkrFOnTlrrZ86cwYEDB+JtB5DipCwkJARWVlYpOkZWZmpqqnQIGdaiRYvibWvRogUqVqyINWvWYNSoUQCAunXr4unTp3B0dNTs16dPH5QrVw7jx4/XSsq2bNmCU6dOYfPmzWjdujUAOVFzkSJFMGHCBK036LBhw1CmTBn8888/yJZNvuVsbW0xdepUDBo0CMWKFdP7mKSMggULomDBglrb+vTpg4IFCyb4uacWFRUFlUqVIRMfY2NjWFhYKB1GPCqVChERERkyNn1ky5YtyddGRvXmzRvs3r0bixcvVjqUDCFHjhw4c+aM1rY+ffrAzs4OCxYswOzZs5E7d27NdW3btkWbNm3w8OHDeJ8ZSUn3jv4qlQo//fQT8uXLBwsLC9SvXx///fef1j516tRBqVKlcPHiRdSqVQtWVlYYM2YMACA8PBwTJkxAoUKFYG5uDldXV4wYMQLh4eFaxzhw4ABq1qwJe3t72NjYoGjRoppj6BsPAGzevBmenp6wtLSEo6MjOnXqhBcvXnzx/w0PD8eQIUOQK1cuZM+eHc2bN8fz5891fryeP3+OFi1awNraGk5OThgyZEi8/xVIuE/Zhg0b4OnpiezZs8PW1halS5fGvHnzAMjTMOpCmXXr1o13qnnHjh1o2rQp8ubNC3Nzc3h4eGDKlCmIjo7Wug/1c3Xr1i3UrVsXVlZWcHFxwS+//BIvxrCwMEycOBFFihSBhYUF8uTJg5YtW+LBgweafVQqFebOnYuSJUvCwsICzs7O6N27Nz58+KB1rKCgINy5cwdBQUE6P5axqR+rwMBAzbaSJUtqJWSA/JXbpEkTPH/+HB8/ftRs37JlC5ydndGyZUvNtly5cqFt27bYsWOH5jm6desWbt26hV69emkSMgDo27cvhBBafRp1PWZaCQwMxODBg+Hq6gpzc3MUKlQI06dPj9cCO3PmTFSvXh05c+aEpaUlPD09E+ybmdLXflKePHmCvn37omjRorC0tETOnDnRpk2bBE/FX7t2DbVr14alpSXy5cuHH3/8EStXrozX/yWlrym1x48fw8jICDNnzsTcuXPh4eEBc3Nz3Lp1K9F+N4n16zp79iwaNWoEOzs7WFlZoXbt2jh58mSK4osrofvW5X39+vVrZMuWTdNyEdvdu3dhZGSEBQsW6ByHkZER+vfvj/Xr16NkyZIwNzfXnOJ78eIFvv32W00XhJIlS2LFihXxjjF//nyULFkSVlZWcHBwQMWKFeP9mPnSsY4ePYpKlSoBALp166b5bFy1ahUA2UBw584dBAQE6Py/Jeb48eNo06YN8ufPr/k+GzJkCEJDQ794W12+43T9vkzI7t27ERUVBW9v73jX3bx5E/Xq1dN6TyV2pmbv3r3w8vKCtbU1smfPjqZNm+LmzZta+6j7gz18+BA+Pj6wtrZG3rx5MXnyZM3sG48fP0auXLkAAJMmTdI8L3H7mr548QItWrSAjY0NcuXKhWHDhsX73kpNCX2XANA8bjt27NDreOlePPbnn3+GsbExhg0bhqCgIPzyyy/o2LEjzp49q7Xfu3fv0LhxY7Rr1w6dOnWCs7MzVCoVmjdvjhMnTqBXr14oXrw4rl+/jjlz5uDevXv466+/AMgXzFdffYUyZcpg8uTJMDc3x3///Zfgh5ku8axatQrdunVDpUqVMG3aNLx+/Rrz5s3DyZMncfnyZdjb2yf6//bo0QPr1q1Dhw4dUL16dRw+fBhNmzbV6bEKDQ1F/fr18fTpUwwcOBB58+bF2rVrcfjw4S/e9sCBA2jfvj3q16+P6dOnA5CtlSdPnsSgQYNQq1YtDBw4EL/++ivGjBmD4sWLA4DmctWqVbCxscHQoUNhY2ODw4cPY/z48QgODsaMGTO07uvDhw9o1KgRWrZsibZt22LLli0YOXIkSpcujcaNGwMAoqOj8dVXX+HQoUNo164dBg0ahI8fP+LAgQO4ceMGPDw8AAC9e/fWPN4DBw7Eo0ePsGDBAly+fBknT57UtAhu374d3bp1w8qVK3XusP7u3TtER0fj6dOnmDx5MgCgfv36X7ydv78/rKystFpqL1++jAoVKsDYWPt3TeXKlbFkyRLcu3cPpUuXxuXLlwEAFStW1Novb968yJcvn+Z6fY6ZFkJCQlC7dm28ePECvXv3Rv78+XHq1CmMHj0ar169wty5czX7zps3D82bN0fHjh0RERGBDRs2oE2bNti1a5fWazslr/0vOX/+PE6dOoV27dohX758ePz4MX777TfUqVMHt27d0jxXL1680PzoGD16NKytrbFs2TKYm5vHO2ZyXlNJWblyJcLCwtCrVy+Ym5sjR44cet3+8OHDaNy4MTw9PTFhwgQYGxtj5cqVqFevHo4fP47KlSunOMakfOl97ezsjNq1a2PTpk2YMGGC1m03btwIExMTvWdIOHz4MDZt2oT+/fvD0dER7u7ueP36NapWrapJ2nLlyoW9e/eie/fuCA4OxuDBgwHILhwDBw5E69atMWjQIISFheHatWs4e/YsOnToAAA6Hat48eKYPHkyxo8fj169esHLywsAUL16dQDAuXPnULduXUyYMEHnwSdxEzhTU1PY2dlh8+bNCAkJwXfffYecOXPi3LlzmD9/Pp4/f47NmzcnejxdvuN0/b5MzKlTp5AzZ064ublpbff390fdunURFRWFUaNGwdraGkuWLIGlpWW8Y6xduxZ+fn7w8fHB9OnTERISgt9++w01a9bE5cuXtRoSoqOj0ahRI1StWhW//PIL9u3bp+l7O3nyZOTKlQu//fYbvvvuO3zzzTeaH69lypTROoaPjw+qVKmCmTNn4uDBg5g1axY8PDzw3Xffafb78OGDTola3M99AIiIiEBwcDBCQ0Nx4cIFzJw5E25ubvFO8drZ2cHDwwMnT57EkCFDvnhfGqk5u3m/fv1EYoc8cuSIACCKFy8uwsPDNdvnzZsnAIjr169rttWuXVsAEIsXL9Y6xtq1a4WxsbE4fvy41vbFixcLAOLkyZNCCCHmzJkjAIi3b98mGquu8URERAgnJydRqlQpERoaqtlv165dAoAYP368ZtuECRO0/v8rV64IAKJv375a992hQwcBQEyYMCHR+IQQYu7cuQKA2LRpk2bb58+fRaFChQQAceTIEc12Pz8/4ebmplkfNGiQsLW1FVFRUYkef/PmzfGOoxYSEhJvW+/evYWVlZUICwvTbFM/V2vWrNFsCw8PF7lz5xatWrXSbFuxYoUAIGbPnh3vuCqVSgghxPHjxwUAsX79eq3r9+3bF2/7ypUrBQCxcuXKRP+/uMzNzQUAAUDkzJlT/Prrr1+8zf3794WFhYXo3Lmz1nZra2vx7bffxtt/9+7dAoDYt2+fEEKIGTNmCADi6dOn8fatVKmSqFq1qt7HTIz6Nf3o0aMv/l9ubm7Cz89Psz5lyhRhbW0t7t27p7XfqFGjhImJiVb8cV8bERERolSpUqJevXqabSl97ccV9zYJvT5Pnz4d77U4YMAAYWRkJC5fvqzZ9u7dO5EjR454j1VyXlNCyOct9mP56NEjAUDY2tqKN2/eaO2rvo+4z5H6uVO/F1UqlShcuLDw8fHRvD/U/3eBAgVEgwYNvhiXn5+fqF279hf3i3vfQuj+vv7999/jfX4LIUSJEiW0Xg+6ACCMjY3FzZs3tbZ3795d5MmTRwQEBGhtb9eunbCzs9O8Fr7++mtRsmTJJO9D12OdP38+0deC+vHS5TXs5+en+cyJ/ad+XhJ6HU+bNk0YGRmJJ0+eaLbF/W7R5TtO1+/LxNSsWVN4enrG2z548GABQJw9e1az7c2bN8LOzk7rtf3x40dhb28vevbsqXV7f39/YWdnp7Vd/TgNGDBAs02lUommTZsKMzMzzf/59u3bRB979TEmT56stb18+fLx/g83N7cEn5e4fwndz59//qm1T8WKFcW1a9cSfAwbNmwoihcvnuB1iUn305fdunXT6leh/hXy8OFDrf3Mzc21+vAA8hRi8eLFUaxYMQQEBGj+6tWrBwA4cuQIAGharnbs2PHFzu9fiufChQt48+YN+vbtq9W3oWnTpihWrBh2796d6LH37NkDABg4cKDWdvUvuy/Zs2cP8uTJo+lfBMjMPXaH4sTY29vj8+fPOHDggE73FVfsXz0fP35EQEAAvLy8NE33sdnY2Gj1mTAzM0PlypW1ntOtW7fC0dERAwYMiHdf6qHemzdvhp2dHRo0aKD1/Hp6esLGxkbz/AKyuVsIoVeLxt69e7Fnzx7MmjUL+fPnx+fPn5PcPyQkBG3atIGlpSV+/vlnretCQ0MTbG1Rv0bUpx/Ul4ntG/s0ha7HTAubN2+Gl5cXHBwctB57b29vREdH49ixY5p9Y782Pnz4gKCgIHh5eWmNEk3pa/9LYscQGRmJd+/eoVChQrC3t9eKY9++fahWrZpWZ+0cOXKgY8eO8Y6ZnNdUUlq1aqU53aKvK1eu4P79++jQoQPevXuneT4+f/6M+vXr49ixY3oP7NGXLu/rli1bIlu2bNi4caNm240bN3Dr1i34+vrqfZ+1a9dGiRIlNOtCCGzduhXNmjWDEELrtenj44OgoCDN821vb4/nz5/j/PnzCR5bn2MlpU6dOhBC6NxKZmFhgQMHDmj9zZo1C4D26/jz588ICAhA9erVIYTQakWPS5fvOF2/LxPz7t07ODg4xNu+Z88eVK1aVaulNleuXPHeUwcOHEBgYCDat2+vdf8mJiaoUqVKgvffv39/zbK6NTMiIiLREfAJ6dOnj9a6l5dXvPxi/fr18Z6ThP66dOkS7/h169bFgQMHsHnzZvTp0wempqaJfpeoP0/1ke6nL/Pnz6+1rn7S4/YZcnFxidcp9v79+7h9+3aiH3Rv3rwBAPj6+mLZsmXo0aMHRo0ahfr166Nly5Zo3bp1vFNDX4rnyZMnAICiRYvGu79ixYrhxIkTif6vT548gbGxsebUnFpCx0rs9oUKFYpXn0aX2/ft2xebNm1C48aN4eLigoYNG6Jt27Zo1KiRTvd98+ZN/PDDDzh8+DCCg4O1rovb5yZfvnzxYnRwcMC1a9c06w8ePEDRokW1+lXFdf/+fQQFBcHJySnB69XPb3LVrVsXANC4cWN8/fXXKFWqFGxsbLQ+CNSio6PRrl073Lp1C3v37tWM0FSztLRMsF9GWFiY5vrYl4ntG/tDWddjpoX79+/j2rVrX3xvAcCuXbvw448/4sqVK1rxxn4NpPS1/yWhoaGYNm0aVq5ciRcvXmj6nQDar88nT56gWrVq8W6fHqPJChQokOzb3r9/HwDg5+eX6D5BQUEJfmmmFl3e146Ojqhfvz42bdqEKVOmAJCnLrNly6bVN1JXcR+zt2/fIjAwEEuWLMGSJUsSvI36tTly5EgcPHgQlStXRqFChdCwYUN06NABNWrU0PtYqcnExCTBflkA8PTpU4wfPx47d+5MsN9sYnT5jtP1+zIpsd9Xak+ePEmwBlfc97b6NaxOAuOytbXVWjc2No7XIb5IkSIAoHPZJgsLi3j/r4ODQ7zHVv2aSA5nZ2c4OzsDAFq3bo2pU6eiQYMGuH//vlZHf0A+fvrWl0v3pMzExCTB7XGf/IS+gFQqFUqXLo3Zs2cneAxXV1fNbY8dO4YjR45g9+7d2LdvHzZu3Ih69erhn3/+0YpB13gyGycnJ1y5cgX79+/H3r17sXfvXqxcuRJdunTB6tWrk7xtYGAgateuDVtbW0yePBkeHh6wsLDApUuXMHLkyHi/zFLrMVSpVHBycsL69esTvD65rQ4J8fDwQPny5bF+/foEk7KePXti165dWL9+fYIfKnny5MGrV6/ibVdvUydxefLk0WxXvz5j7xv716aux0wLKpUKDRo0wIgRIxK8Xv3hePz4cTRv3hy1atXCokWLkCdPHpiammLlypXpOjp0wIABWLlyJQYPHoxq1arBzs4ORkZGaNeuXZq3IOkqoc+wxD6g4/ZvUf8PM2bMSLQkQ1qX3dD1fd2uXTt069YNV65cQbly5bBp0ybUr18/3qAZXcR9zNSPQ6dOnRJNUNV9iooXL467d+9i165d2LdvH7Zu3YpFixZh/PjxmDRpkl7HSg/R0dFo0KAB3r9/j5EjR6JYsWKwtrbGixcv0LVr1yRfx7p8x+n6fZmYnDlzxktm9KGOf+3atfGSFQBJ/kBPrsRes3G9fftWpz5lNjY2X3yftW7dGmPHjsWOHTvQu3dvres+fPig9/sg3ZOylPDw8MDVq1dRv379L2afxsbGqF+/PurXr4/Zs2dj6tSpGDt2LI4cOZLor5aEqDs53r17N96X8927d+N1gox7W5VKpWklin07Xe/7xo0b8bJtXW9vZmaGZs2aoVmzZlCpVOjbty9+//13jBs3LsEWOLWjR4/i3bt32LZtG2rVqqXZ/ujRI53uNyEeHh44e/YsIiMjEy3f4eHhgYMHD6JGjRpp2iqkFhoammDL1PDhw7Fy5UrMnTsX7du3T/C25cqVw/Hjx6FSqbRaX8+ePQsrKytNEqP+Qr1w4YJWAvby5Us8f/5c61S0rsdMCx4eHvj06dMX3xtbt26FhYUF9u/fr3WqdeXKlVr7pfS1/yVbtmyBn5+f5jQQIFsU446AcnNzS3A0dULb0oO6ZStunOoWeTV1C6Otra1en1dKaNGiBXr37q05hXnv3j2MHj06VY6tHrkbHR2t0+NgbW0NX19f+Pr6IiIiAi1btsRPP/2E0aNH63Ws9Kief/36ddy7dw+rV6/WOk2ma5eTL33H6fN9mZBixYph69at8ba7ublpWsFii/veVr+GnZycdHruVCoVHj58qPU5d+/ePQAxIxxT63mpVKlSvPdcQnQZzKHuVpJQy+ajR4/0rkeXqea+bNu2LV68eIGlS5fGuy40NFRzXvf9+/fxrld/OepbVqBixYpwcnLC4sWLtW67d+9e3L59O8nRZOqRh7/++qvW9tgj2ZLSpEkTvHz5UqvcQEhISKJN77G9e/dOa93Y2FjzK1D9f1hbWwOI/wWh/rUR+xdxREREgvW+dNWqVSsEBAQkOERefT9t27ZFdHS05jRIbFFRUVpx6lq+ICoqKsFfe+fOncP169fjjYqcMWMGZs6ciTFjxmDQoEGJHrd169Z4/fo1tm3bptkWEBCAzZs3o1mzZpqEpWTJkihWrBiWLFmi9cvst99+g5GRkVZ/QV2PmRbatm2L06dPY//+/fGuCwwM1Mw+YGJiAiMjI63/5fHjx/FGcqX0tf8lJiYm8Vps5s+fH+/Xr4+PD06fPq1Vmf39+/cJtsamVkmMpKi/qGL30YuOjo73nvb09ISHhwdmzpyJT58+xTvO27dv0yxGfdnb28PHxwebNm3Chg0bYGZmhhYtWqTKsU1MTNCqVSts3boVN27ciHd97Mch7meemZkZSpQoASEEIiMj9TpWYp+NQOqVxEjoc1YIoSlblBRdvuN0/b5MTLVq1fDhw4d4/bGaNGmCM2fO4Ny5c5ptb9++jfee8vHx0dRjjFvxXn2buGJ/PwghsGDBApiammpGyatHQib0vOgjOX3KAgICEjz7oy4MHPe7JCgoCA8ePNCM2tVVpmop69y5MzZt2oQ+ffrgyJEjqFGjBqKjo3Hnzh1s2rQJ+/fvR8WKFTF58mQcO3YMTZs2hZubG968eYNFixYhX758qFmzpl73aWpqiunTp6Nbt26oXbs22rdvrymJ4e7unuRQ13LlyqF9+/ZYtGgRgoKCUL16dRw6dEjnX+k9e/bEggUL0KVLF1y8eBF58uTB2rVrdSqi26NHD7x//x716tVDvnz58OTJE8yfPx/lypXTlL0oV64cTExMMH36dAQFBcHc3Bz16tVD9erV4eDgAD8/PwwcOBBGRkZYu3Ztik7pdunSBWvWrMHQoUNx7tw5eHl54fPnzzh48CD69u2Lr7/+GrVr10bv3r0xbdo0XLlyBQ0bNoSpqSnu37+PzZs3Y968eZokRtfyBZ8+fYKrqyt8fX1RsmRJWFtb4/r161i5ciXs7Owwbtw4zb7bt2/HiBEjULhwYRQvXhzr1q3TOlaDBg20+hJUrVoV3bp1w61btzTV96Ojo+PVbZoxYwaaN2+Ohg0bol27drhx4wYWLFiAHj16aJ4LfY+Z2oYPH46dO3fiq6++QteuXeHp6YnPnz/j+vXr2LJlCx4/fgxHR0c0bdoUs2fPRqNGjdChQwe8efMGCxcuRKFChbT6GqX0tf8lX331FdauXQs7OzuUKFECp0+fxsGDB5EzZ06t/UaMGIF169ahQYMGGDBggKYkRv78+fH+/XutX96pXRIjISVLlkTVqlUxevRovH//Hjly5MCGDRviTbllbGyMZcuWoXHjxihZsiS6desGFxcXvHjxAkeOHIGtrS3+/vvvNIkxOXx9fdGpUycsWrQIPj4+SZYJ0tfPP/+MI0eOoEqVKujZsydKlCiB9+/f49KlSzh48KAmQWnYsCFy586NGjVqwNnZGbdv38aCBQvQtGlTZM+eXa9jeXh4wN7eHosXL0b27NlhbW2NKlWqoECBAskqiZGQYsWKwcPDA8OGDcOLFy9ga2uLrVu36nTKUJfvOF2/LxPTtGlTZMuWDQcPHtRq0R8xYgTWrl2LRo0aYdCgQZqSGG5ublqfAba2tvjtt9/QuXNnVKhQAe3atUOuXLnw9OlT7N69GzVq1NBKwiwsLLBv3z74+fmhSpUq2Lt3L3bv3o0xY8Zouq5YWlqiRIkS2LhxI4oUKYIcOXKgVKlSKFWqlF6PfXL6lK1btw6LFy9GixYtULBgQXz8+BH79+/HgQMH0KxZs3hn0g4ePAghBL7++mv97kivsZpfoEtJjM2bN2ttVw8fjz30uHbt2okObY6IiBDTp08XJUuWFObm5sLBwUF4enqKSZMmiaCgICGEEIcOHRJff/21yJs3rzAzMxN58+YV7du31xrur088QgixceNGUb58eWFubi5y5MghOnbsKJ4/f661T9xhy0IIERoaKgYOHChy5swprK2tRbNmzcSzZ890HlL95MkT0bx5c2FlZSUcHR3FoEGDNCUikiqJsWXLFtGwYUPh5OQkzMzMRP78+UXv3r3Fq1evtI6/dOlSUbBgQWFiYqJ1zJMnT4qqVasKS0tLkTdvXjFixAixf//+BIfOJ/RcxY1HCDn8e+zYsaJAgQLC1NRU5M6dW7Ru3Vo8ePBAa78lS5YIT09PYWlpKbJnzy5Kly4tRowYIV6+fKnZR9fyBeHh4WLQoEGiTJkywtbWVpiamgo3NzfRvXv3eGUJ1M9fYn9xS4e8f/9edO/eXeTMmVNYWVmJ2rVri/PnzycYx/bt20W5cuWEubm5yJcvn/jhhx9EREREvP30OWZcKSmJIYQcwj569GhRqFAhYWZmJhwdHUX16tXFzJkztWJdvny5KFy4sDA3NxfFihUTK1euTJPXfmxxb/PhwwfRrVs34ejoKGxsbISPj4+4c+dOgv/X5cuXhZeXl+axnzZtmvj1118FAOHv76/ZL7VLYsyYMSPB/R88eCC8vb2Fubm5cHZ2FmPGjBEHDhxI8DV2+fJl0bJlS5EzZ05hbm4u3NzcRNu2bcWhQ4e+GFdKS2Lo+r4WQojg4GBhaWkpAIh169Z98T4TAkD069cvwetev34t+vXrJ1xdXTWfHfXr1xdLlizR7PP777+LWrVqaR4rDw8PMXz4cM33gj7HEkKIHTt2iBIlSohs2bJpvS70LYlhbW2d6PW3bt0S3t7ewsbGRjg6OoqePXuKq1evxnsdxn1/6fIdJ4Ru35dJad68uahfv3687deuXRO1a9cWFhYWwsXFRUyZMkUsX7480XIvPj4+ws7OTlhYWAgPDw/RtWtXceHChXiP04MHD0TDhg2FlZWVcHZ2FhMmTBDR0dFaxzt16pTw9PQUZmZmWs9DYo91Qp9NyXH+/HnRpk0bkT9/fmFubi6sra1FhQoVxOzZs0VkZGS8/X19fUXNmjX1vh8jITJ5j3YiAiD7AtatWxePHj3K0nOZpobBgwfj999/x6dPn3TuHJzZdO3aFY8fP1Zk8mbKGo4fP446dergzp07aTr3bteuXbFly5YET9VnRv7+/ihQoAA2bNigd0tZpupTRkSkr7j13d69e4e1a9eiZs2aWTYhI0oNXl5eaNiwYYLT5lHi5s6di9KlS+t/6hKZrE8ZEWUd0dHRX+ywrsuQ9C+pVq0a6tSpg+LFi+P169dYvnw5goODtfoTUtrx9/dP8npLS0vY2dmlUzSkr7179yodQqYTt9i4PpiUEZEinj179sUCqyntTA3I0WJbtmzBkiVLYGRkhAoVKmD58uVa5V4o7ahr9SXGz89PM9k3kaFTtE/ZsWPHMGPGDFy8eBGvXr3C9u3bvziU+ujRoxg6dChu3rwJV1dX/PDDD2k2UoqI0k5YWFiSM2IAQMGCBeNV+abM5UtT5OTNm1draiUiQ6ZoS9nnz59RtmxZfPvttzpNyfHo0SM0bdoUffr0wfr163Ho0CH06NEDefLkgY+PTzpETESpxcLCIsMXRqWU43NMpLsMM/rSyMjoiy1lI0eOxO7du7UK/7Vr1w6BgYHYt29fOkRJRERElDYyVZ+y06dPx/vV5ePjg8GDByd6m/DwcK1K/CqVCu/fv0fOnDnTZSoNIiIiSjkhBD5+/Ii8efNqTUWXlWSqpMzf319TUV3N2dkZwcHBCA0NTXC+xGnTpqV5NXQiIiJKH8+ePUO+fPmUDiNNZKqkLDlGjx6NoUOHataDgoKQP39+PHv2DLa2tgpGRkREhu7DByAwEIiKAgICgGfP5PboaLntxg0ge3bg5Engv/+AvHkBIeT1kZFAnHnA9VaqFGBsLP9MTAAjI3lpbAzcugXUri2XjYxi9jMyivmLfd2HD0DBgjJGE5OY46lUgKtrzH2o/7JlA740I5fN4R34XK0BhKUVPn0KRv36rppps7KiTJWU5c6dG69fv9ba9vr1a9ja2ibYSgYA5ubmCU7kbGtry6SMiIjSxMuXwIMHwL17MomaPRuwsAAsLWUydf588o775k3S11evLhMeLy+gQQPA1FT+mZsDjo4yETI1lfvY2sqkKUP6/Bno1w9YvRro0QNYuhTBwfKqrNz1KFMlZdWqVcOePXu0th04cADVqlVTKCIiIjJkkZHAp09AWBiwfDlw8CDw77/6H8feXiZLb98C5csDzs4ygcqWDXjyRLZYBQUB+fIB1arFXGdiAjg4yBavLJOr3LgBtG0L3L4tm9fy55eZrQFQNCn79OkT/vvvP836o0ePcOXKFeTIkQP58+fH6NGj8eLFC6xZswYA0KdPHyxYsAAjRozAt99+i8OHD2PTpk3YvXu3Uv8CERFlUVFRssXr0iV5Ci4iQp4uNDcHwsMBXeoaFysGPH8ONG0qTwcOGyaTKFNTwNpanu5zcUnzfyVzEAJYsQIYMAAIDQXy5AH++AOoU0fpyNKNoknZhQsXULduXc26uu+XusLzq1ev8PTpU831BQoUwO7duzFkyBDMmzcP+fLlw7Jly1ijjIiIdBYZKc+ORUTIflDBwXL56VPgyBFg6VL9j2lkFNOY06ED0KWLPH2YRQcJpr5Pn4A+fYD16+V6w4bA2rWAk5OycaWzDFOnLL0EBwfDzs4OQUFB7FNGRJSF3LkDHDsGHDgA2NnJlq6oKNkp/t9/ZTIWEJC8YxsZyQYbMzPZT8zbW7Z2vX8PLFgA5MiRhU4fKuH5c6BcOTnq4ccfgREj4mW0hvD9nan6lBEREalFRspk6/ffZUK0ebP+xzA1lccpXFgmXE+eyOWWLQFfX8DdXe5DaSxfPuDPP+VIiJo1lY5GMUzKiIgowxECuH9fnlo8elT26Xr2DHj4EIgz3iueZs3k6clGjWJKL2TLBoSEAEWLyvIMJUrIZIutWwoJDgZ69QLatQPUM/k0aKBoSBkBkzIiIko34eFyUN3u3bJExMWLsg7X4cOAm5tstXryRP7po1Qp2brl7S3LQVAGdvGibIZ88EB24mvYELCyUjqqDIFJGRERpYmHD2XB0+3b5YjFefOS3j/WYHwtBQvKY339NWBjA1SqJPuMffWVLCWRjd9kmYMQsgPesGFyZIWbG7BhAxOyWPhSJiKiFIuKAn77DfjpJyBOje9E5csnTzG+egXUqiVPL5YsKU8rRkfLU4zFi6dt3JROAgOB7t2BbdvkeosWsvyFg4OSUWU4TMqIiChJKpXso/XyZUzZiKtX5YjD69dlMnX/fuK39/SUjSQtWgC5cgFdu8pTl2QgAgNlRdzHj2XGPXOmrEXGDn3xMCkjIqJ4hJCtX7/8Avzwg363/fVXOd2PiwuQO3faxEeZiL090LgxsH8/sHEjULGi0hFlWEzKiIgMVHi4LA/1zz+yz9by5fJs0sOHid/G0lJ2qg8LA8qUkclXjhyAh4esUF+8OBtACMC7dzKrd3aW67NnyxecnZ2ycWVwTMqIiAyAEHIS7LNngYEDE9/vw4eEt589Kxs4WKGevujUKVnqolAhWcnXxESer+Y56y9iUkZElImFhMiO9e/eAdeuyfJPV6/K665cAT5+lJUHvsTZGahbV5aUKF9eFlJ1cZHfo5aWafovUFahUgEzZgBjx8qRGubmchRHvnxKR5ZpMCkjIsoEAgPl9IAbNgAnTwJ//ZX8Yzk5AQUKAFu2ALa28o8oRd6+Bfz8gL175Xr79nKqhezZlY0rk2FSRkSUwahUQP/+8pThvXsyGfuSHDnkPIwA0KmTbOVSz8dYr55s7XJ3Z0koSgPHj8vTlS9fyqbVX38FevRg58JkYFJGRKQglUqe7bl1C7hxQ/b9evQo8f1tbWWy9c03QOvWsmO9vT2//0gh0dFA374yIStWDNi0CShdWumoMi0mZURE6UwIYN064LvvZP2vpEyaJEc4liwJ5MmTPvER6czERE4kPm8eMGeOnHKBko1JGRFROrlxQ875OG0aEBQU//ru3YHChWVH+woVAEfH9I+R6IsOH5bVgnv3luulSgFLlyobUxbBpIyIKJU8fw6sXg3cvStLS/j7AxcuyFOOJiYJl5vo3BmYPFn29yLK0KKj5Yt1yhT5gvb0ZCHYVMakjIhID0LIv8BA4N9/ZR/n3btlR3p1KYq4goO11xs0kCUn5s6VpZyIMryXL4GOHYGjR+V6165yclJKVUzKiIi+ICxM1gLbtg0YOvTL+5cuDdSoAeTNK8tP5MsXk3y5uLDbDWUy+/fLJt23b+WL9/ffgQ4dlI4qS2JSRkQUx+nTshTF+PGyX9elS4nva2sL5MwpO+17egLVqrHYKmUhEyfK0SYAULasHF1ZpIiiIWVlTMqIiCAbAVq1kqcjY3v6NGbZ0hIIDQV27ABq1pTzRLIUBWVp9vbysk8fObqSUyWlKSZlRGRwoqJkodV792TS1atXwqUpmjaVM8X06gVUqRLz/USUpX3+LGeXB4BBg+Rw4Nq1lY3JQDApI6IsLyIC+O8/OZJ/wICk97WykgXJu3dPn9iIMozISGDMGGDnTjlsOHt22RTMhCzdMCkjoixFCFmK4s0bOUdkdDQwcGDSt6lRQ5axOHZMVsgnMjhPnsipks6cket//SU791O6YlJGRJna+/eyL7K1NfDzz7rd5ptvgLVrY87QEBm0HTtkiYvAQMDODlixAmjZUumoDBKTMiLKFIQA/PzkmRV7e9np/s6dL9+uSBHZH6x2bZ6SJNISEQGMGCGnSAKAypWBDRuAAgWUjcuAMSkjogzl+nVg9mxg1Sq5bmEhu7pER8fsk9AURebmsobYhw/AL7/I7jBElISRI2MSsu+/B6ZOlVWNSTFMyogo3UVFyU73Hz8C588D164Be/cmvG9YWPxtc+YAZcrImV5y5ZL9wFiagkhPo0YBBw7IyVibNVM6GgKTMiJKJ0LI+Yt375YztnxJ9+7ylGO1anJEpKmp/GNZCqJkCgsDtm8H2reX687O8heRsbGycZEGkzIiSnVPnsiRj+fPy/W5cxPf18sLePUKqFMH+Oor2a3FyUm2ghFRKrl/H2jbFrhyRa6rEzMmZBkKkzIiShVv3wKTJwMLFnx531mzgMaNWX6CKF38+aesgPzpk5w3LEcOpSOiRDApI6Jke/oU+PZb2SqWUN8vb2/gxQtZGd/UVBYHd3ZO/ziJDFJoqHzTLV0q12vVAv74A3BxUTYuShSTMiL6oo8f5Y/tRYtkkpUrF3D7dsL7FigA/P47UK8eT0ESKebOHXm68vp1OQpm7FhgwgQgG7/2MzI+O0Sk5e1bYNw42bK1fj0QHg6EhGjvExCgvd64MTB8uOwfxs98ogzgwQOZkDk5yTeyt7fSEZEO+PFJRACAW7eA1q0TbwEDZO2v3LmBIUOAcuXkqciCBdMtRCLSVdOm8rRl06ZAnjxKR0M6YlJGZKDCw4HNm4GVK2XNsLisreUZDyMjoGZNoEQJ9g8myrBu3gT69AHWrQPc3OS2Hj2UjYn0xqSMyICcOSM/u6dOBR4+THgfZ2fg6FGgWLF0DY2IkkMI+cuqf3/ZsX/wYFmLjDIlJmVEBmDTJsDXN+HrChYEPD2BNm2AFi1kXzIiygQ+fZKtY+vXy/WGDeUoG8q0mJQRZTGPHwMXL8q5hs+dS7hwa+XKwOvXwL59bBEjypSuXpWjK+/dk8Ocp0yRc1myGGymxqSMKIsQQn5Gb9mS+D5//y2r5hNRJnb8ONCggewY6uICbNggO35SpsekjCgLGD4cmDlTe1udOoCFBXDjBtCzJzB+vCKhEVFqq1RJNnG7uACrV8sq/ZQlMCkjyoSiouTE3h06xK8hBgDv3wMODukfFxGlkdu3gSJF5KlKCwvg4EE5HJqnK7MUPptEmUhQENCpk+yM36JF/ITs1i15GpMJGVEWIYScULZcOeCnn2K2OzoyIcuC2FJGlEk8fw64usbfXqsWsG0bkDNn+sdERGkoMBDo3l2+wQHZuV+lYjKWhfGZJcrgwsNl7bDYCZmTE7B3r/x8/vdfJmREWc65c0D58jIhMzWVw6i3bGFClsXx2SXKgE6flhX0jYxk95E3b2KumzlTlrNo1EheT0RZiBDAnDlyNOXjx0CBAsDJk8CgQXzDGwCeviRSUESErLC/Zo2cpi57dsDfP+F9vbxkqxg/l4mysEePgDFjgMhIoFUrYNkywN5e6agonTApI0pn794BkyYBV67IckOxff6svT51KvDNN0ChQkA2vluJsr6CBYGFC+WUSX378leYgeHHPFE6CA0FTpyQs6Akxs4OGDYMaNJEzidsby9HvxNRFqZSAbNmyabwqlXltm+/VTYmUgyTMqI0EBEhT0kuWhQzYCohCxcCrVvLjvtEZGDevgX8/OSoHTc3WenZxkbpqEhBTMqIUlF0NPDrr8DQoYnvM2wYMGNG+sVERBnQsWNA+/bAy5dyNM/YsYC1tdJRkcKYlBGlknnzgMGD428fMED+GC5XjqcjiQyeSgVMmybnPVOpgKJFgU2bgDJllI6MMgAmZUTJJISc+WTJEpmQxbV0qewawrJCRAQA+PQJaNkSOHBArnfuLPs48JQl/R+TMiIdqFSy+0dUlBypfu0a8PXXCe/75AmQP3/6xkdEmYC1NWBpKf8WLQK6dlU6IspgmJQRJeL5c2DHDtkZ//btpPc1MgL27AF8fDiCnYhiiY6WI38sLeWHw8qVshhhiRJKR0YZEJMyov/bv1+eVbh4ETh6NOF91BX2TU3lacmZM+XUdERE8bx6BXToALi4AGvXyg+QHDnkH1ECmJSRQQsIkAW0a9UCwsIS3qdECaBCBTn1HOeYJCKd/PMP0KmT7PdgbQ08fAh4eCgdFWVwTMrI4OzfL+eNTMyYMbJ6fteucto5IiKdRUUBEybIEZZCyFGVGzcyISOdMCkjgxIUlHhC5u4OPHjA0ZJElEzPn8vTler503r3lpOLW1oqGxdlGvz6IYMRGak9r+/UqbK/rRDy79EjJmRElEwqFdC4sUzIsmcHNmwAFi9mQkZ64VcQZXn+/kDx4oCZWcy2EiWA0aMBZ2fl4iKiLMTYWHY8rVgRuHQJ8PVVOiLKhJiUUZZ19qwc7JQnD3DnTsz2KlWAmzeVi4uIsoinT2WHfrX69eUHT6FCysVEmRqTMsqSBgwAqlbV3ta6NRAYCJw5o0hIRJSV7Nwp505r3Rr477+Y7ewDQSnAVw9lKeryFgsWxGzr2VPO+bt5M2Bnp1xsRJQFREQAQ4bIKT0+fACKFZPDtYlSgeJJ2cKFC+Hu7g4LCwtUqVIF586dS3L/uXPnomjRorC0tISrqyuGDBmCsMQKTJFBUKmAf/8FcuUCChaMGfgEyNqNS5bIU5hERCny6BFQs6bsOwbI5OzECTl0mygVKJqUbdy4EUOHDsWECRNw6dIllC1bFj4+Pnjz5k2C+//xxx8YNWoUJkyYgNu3b2P58uXYuHEjxowZk86RU0bxzz+AiQlQp44sBKuWLx9w6xaQO7dioRFRVrJ1K1C+PHD+PODgIOdgmz1bewQRUQopmpTNnj0bPXv2RLdu3VCiRAksXrwYVlZWWLFiRYL7nzp1CjVq1ECHDh3g7u6Ohg0bon379l9sXaOsRQjg2DE5ctLHR/u6Vq1kZf5nz+SISyKiVHHqlCx0WK0acOUK0Ly50hFRFqRYUhYREYGLFy/C29s7JhhjY3h7e+P06dMJ3qZ69eq4ePGiJgl7+PAh9uzZgyZNmiR6P+Hh4QgODtb6o8wlIkLWXzQykmcJjI2B2rWB2A2qq1bJZG3LFsDcXKlIiShLESJmedo0YN482Vcif37lYqIsTbHeiQEBAYiOjoZznEJRzs7OuBO7fkEsHTp0QEBAAGrWrAkhBKKiotCnT58kT19OmzYNkyZNStXYKf1ERckBTrdvy/UnT7SvnzkTGDpUJmxERKlmwwZg9Wo5ytLUVJ6mHDhQ6agoi1O8o78+jh49iqlTp2LRokW4dOkStm3bht27d2PKlCmJ3mb06NEICgrS/D179iwdI6bkevAAsLKSn4XqhAwABg8Grl6Vg56EAL7/ngkZEaWi0FA5PVL79sC+fcDSpUpHRAZEsZYyR0dHmJiY4PXr11rbX79+jdyJ9M4eN24cOnfujB49egAASpcujc+fP6NXr14YO3YsjBOoD2Nubg5zns/KNG7eBOrV0z41qXb9OlCqVPrHREQG4u5doG1b4No1+WtvzBigVy+loyIDolhLmZmZGTw9PXHo0CHNNpVKhUOHDqFatWoJ3iYkJCRe4mViYgIAELHP/VOmFBwsk67YCVnnzsDnz7JVjAkZEaWZdesAT0+ZkDk5Afv3Az/+yBpklK4UPX05dOhQLF26FKtXr8bt27fx3Xff4fPnz+jWrRsAoEuXLhg9erRm/2bNmuG3337Dhg0b8OjRIxw4cADjxo1Ds2bNNMkZZU5Nm2oXdu3aVZ5FWLNGnsYkIkozP/0U8wuwbl05urJBA6WjIgOk6E8AX19fvH37FuPHj4e/vz/KlSuHffv2aTr/P336VKtl7IcffoCRkRF++OEHvHjxArly5UKzZs3w008/KfUvUAoFBABFisg+YmpFigArVyoXExEZmNatgV9+kaOGfvhBFj8kUoCRMLDzfsHBwbCzs0NQUBBsbW2VDsdg+fvLmmKnTmlvDw4GsmdXJiYiMhBCyNOUZcvGbHv3DsiZU7mY6IsM4fs7U42+pKzh4UM57VHshOybb4BPn5iQEVEa+/QJ6NIFqFBB1hxTY0JGGQCTMkpXnz4BHh4x615eMknbtg2wtlYuLiIyANeuARUryk79AHDjhrLxEMXBpIzSRWSknMs3dkvY6NFyuqQCBZSLi4gMgBDAkiVA5cqy7IWLC3D0KNCvn9KREWlhUkZp7vx5WQy7YMGYbe7uwNSpioVERIYiOBjo0EEWhA0PBxo3lqMrvbyUjowoHiZllGZUKuDCBfnjNLbSpeUpSyKiNLdjh5wyycREjrDctQtwdFQ6KqIEsSoepbpjx+SE4XFNmSJHmxMRpZtOnYDLl4E2bYBECpMTZRRsKaNU8/ChPE0ZNyEzNpZnCsaOVSYuIjIggYFA//4xxQ+NjIDZs5mQUabAljJKsY8fgYRKxlSvDuzZo12pn4gozZw/D/j6ylFFAQHytCVRJsKWMkqRN2/iJ2SenkBICHDyJBMyIkoHQgBz5wI1asiErEAB4PvvlY6KSG9sKaNk+/QJ+P+MWABkchYUpFw8RGSA3r8HunUDdu6U661aAcuWAfb2ioZFlBxsKaNk2btXu+aYr6/2/JVERGnu+nWgfHmZkJmZAQsWAJs3MyGjTIstZaQ3IYAmTWLWf/0VGDBAuXiIyEDlzSs/kDw8gE2b5NRJRJkYkzLSixCy3I/a8uXAt98qFw8RGZiPHwEbGzmqMmdO2Wzv6prwaCOiTIanL0kvJ07IxEyta1fFQiEiQ3P8OFC8OLBqVcy2kiWZkFGWwaSM9DJ5csxyVJSsQUZElKZUKjkvW926wIsXwPz5QHS00lERpTp+pZLOhAAOHpTLjRppn8YkIkoTb97ID5yxY2Ui1qmTnDaEH0CUBTEpI528e6fdKjZvnnKxEJGBOHIEKFsWOHAAsLSUnVjXrJF9yoiyIHb0J514esYsu7oCRYooFwsRGYAnT4CGDWU/iRIl5OjKkiWVjoooTTEpoy+aMUN+PgJAqVLAtWvKxkNEBsDNDRg9Gnj+XPYhs7ZWOiKiNGckROyxdFlfcHAw7OzsEBQUBFuO2PmiuPNaRkQApqbKxUNEWdjBg4C7O1CokFwXQpa+IIJhfH+zTxklqVmzmOV795iQEVEaiIoCfvhBnq709QXCw+V2JmRkYHj6khK1axfw779y2cMDKFxY2XiIKAt68QJo317WIAOASpW0iyESGRAmZZSo2K1kR44oFwcRZVF79wJdugABAXIy3SVLgHbtlI6KSDE8fUlf1KaNHHFJRJQqIiOBkSPlJLoBAXJS8YsXmZCRwWNSRgnq3z9mefhw5eIgoixIiJjm9379gFOn2D+CCBx9qXQ4GZaZmfwxC8g+uCyeTUQpFns05aNHwKVLQKtWysZEmYYhfH+zTxnFs3ZtTEJ28CATMiJKoYgIYNQowMJCzmEJAAUKyD8i0mBLGWmJitIuexEZCWRj6k5EyfXokewrdu6cbCW7dQsoVkzpqCgTMoTvb/YpIy3du8csnzrFhIyIUmDbNtmJ/9w5wN4e2L6dCRlREpiUkcapU3KuX0D2KatWTdl4iCiTCg8HBgyQ/cWCgoCqVYErV4Cvv1Y6MqIMje0gpFGjRszy7dvKxUFEmZgQsjL/sWNyfcQI4McfOR0IkQ6YlBEA4MyZmOVvvwUKFlQuFiLKxIyMgB49gJs3ZdN7kyZKR0SUabCjPyEyUp5V2LtXrhvWK4KIUiw0FHj8GChePGbb+/dAjhyKhURZjyF8f7NPGaFv35iErH17ZWMhokzm7l3ZZ8zbG3j7NmY7EzIivTEpM3BCAMuWxayPGqVcLESUyaxbB3h6AteuySb3R4+UjogoU2NSZuCWL49Z3r4dKFNGuViIKJMICZH1czp3Bj5/BurUkaMrK1dWOjKiTI1JmYHr2TNmuUULxcIgoszi1i2ZfK1YITv1T5ggp/7Im1fpyIgyPY6+NGAPHsQs79mjXBxElIlMny5HVubODaxfD9Srp3RERFkGkzIDFR4OFCoUs964sXKxEFEm8uuvcqqPqVMBZ2eloyHKUnj60kCp5wQGgG++US4OIsrgrl8Hhg+PqZVjZyc7ozIhI0p1bCkzUI8fy8vy5eX0dEREWtRDswcOBMLCgKJFZVFYIkozTMoMkEoVM8dl7AnIiYgAAMHBQO/ewIYNcr1xY85bSZQOePrSAH37bcyyq6tycRBRBnT5sqw9tmEDYGIiO/bv2gXkyqV0ZERZXopaysLCwmBhYZFasVA62LsXWL06Zr1pU+ViIaIMZu1aeYoyIkL+YtuwAaheXemoiAyG3i1lKpUKU6ZMgYuLC2xsbPDw4UMAwLhx47A8diVSypBizw18+7b8IUxEBAAoUACIjgaaNZPFYJmQEaUrvZOyH3/8EatWrcIvv/wCMzMzzfZSpUphWez5eijDuXo1Zvmvv4BixRQLhYgyiqCgmOWaNYHTp4EdOzh3JZEC9E7K1qxZgyVLlqBjx44widXMUrZsWdy5cydVg6PUNXp0zDL77BIZOCGAefMAd3dZpV+tUiVZqZ+I0p3eSdmLFy9QKHbV0f9TqVSIjIxMlaAo9UVFyf5kAPuRERm89+9lgcLBg4HAQGDVKoUDIiIgGUlZiRIlcPz48Xjbt2zZgvLly6dKUJT6tmyJWZ49W7k4iEhhZ87IAoU7dgBmZsD8+XKEJREpTu/Rl+PHj4efnx9evHgBlUqFbdu24e7du1izZg127dqVFjFSKjh5Mma5SBHl4iAihahU8hfZ6NGy6dzDA9i4UZa/IKIMQe+Wsq+//hp///03Dh48CGtra4wfPx63b9/G33//jQYNGqRFjJQKFiyQl97eysZBRApZt05OlxQVBbRtC1y8yISMKINJVp0yLy8vHDhwILVjoTRy7VrMcv36ysVBRArq0AFYv172Jevdm535iTIgvVvKChYsiHfv3sXbHhgYiIIFC6ZKUJS6nj2LWR4xQrk4iCgdqVRy7srwcLmeLRuwbx/Qpw8TMqIMSu+k7PHjx4iOjo63PTw8HC9evEiVoCh1nT0rL2vVAow5sRZR1vfmjZyvsmdPYOTImO1MxogyNJ1PX+7cuVOzvH//ftjZ2WnWo6OjcejQIbi7u6dqcJQ61ElZWJiycRBROjh6VJ6qfPUKsLQEypRROiIi0pHOSVmLFi0AAEZGRvDz89O6ztTUFO7u7pg1a1aqBkep459/5GXr1srGQURpKDoa+OknYNIkeeqyeHFg82agZEmlIyMiHemclKlUKgBAgQIFcP78eTg6OqZZUJR6IiJilr28lIuDiNKQvz/QsSNw+LBc79ZN1h+ztlY2LiLSi96jLx89epQWcVAaUZ+6BDj6nSjLCgkBLlwArKyAxYuBzp2VjoiIkiFZJTE+f/6Mf//9F0+fPkVE7KYYAAMHDkyVwCh1TJ4sL42NAVNTZWMholQkREzH/YIFgU2bADc3oFgxZeMiomQzEkIIfW5w+fJlNGnSBCEhIfj8+TNy5MiBgIAAWFlZwcnJCQ8fPkyrWFNFcHAw7OzsEBQUBFtbW6XDSXPqz+zq1bWr+hNRJvbiBdCpk6zO37Ch0tEQpQtD+P7Wu0DCkCFD0KxZM3z48AGWlpY4c+YMnjx5Ak9PT8ycOTMtYqRkun07Zjn23JdElInt2weUKydHWfbtKyv0E1GWoHdSduXKFXz//fcwNjaGiYkJwsPD4erqil9++QVjxoxJixgpGUJCgBIlYtbz5FEuFiJKBZGRwKhRsv5YQIBMzPbskUVhiShL0DspMzU1hfH/K5A6OTnh6dOnAAA7Ozs8i106XkcLFy6Eu7s7LCwsUKVKFZw7dy7J/QMDA9GvXz/kyZMH5ubmKFKkCPbs2aP3/WZ1Fy7ELP/wg3JxEFEqePYMqFMHmD5drvftC5w+DRQpomhYRJS69P6JVb58eZw/fx6FCxdG7dq1MX78eAQEBGDt2rUoVaqUXsfauHEjhg4disWLF6NKlSqYO3cufHx8cPfuXTg5OcXbPyIiAg0aNICTkxO2bNkCFxcXPHnyBPb29vr+G1le7dry0t4emDJF0VCIKCVevJCtYu/fA7a2wPLlLDpIlEXp3dH/woUL+PjxI+rWrYs3b96gS5cuOHXqFAoXLozly5ejXLlyOh+rSpUqqFSpEhYsWABA1kJzdXXFgAEDMGrUqHj7L168GDNmzMCdO3dgmsyhhIbQUTAyEjAzk8v16gGHDikbDxGlUNeuwM2bwMaNcqQlkQEyhO9vvZOy1BIREQErKyts2bJFM1sAAPj5+SEwMBA7duyId5smTZogR44csLKywo4dO5ArVy506NABI0eOhImJiU73awhPasOGwIEDcvnTJ9aPJMp0Hj8GbGwAdZHukBDAxAQwN1c0LCIlGcL3d6pNT33p0iV89dVXOu8fEBCA6OhoODs7a213dnaGv79/grd5+PAhtmzZgujoaOzZswfjxo3DrFmz8OOPPyZ6P+Hh4QgODtb6y+piz3HJhIwok9m+XZ6u9POT0yUBsigsEzKiLE+vpGz//v0YNmwYxowZo6lHdufOHbRo0QKVKlXSTMWUVlQqFZycnLBkyRJ4enrC19cXY8eOxeLFixO9zbRp02BnZ6f5c3V1TdMYlaZSAcePy+Xly5WNhYj0EB4ODBwItGwJBAUB797JSyIyGDonZcuXL0fjxo2xatUqTJ8+HVWrVsW6detQrVo15M6dGzdu3NBrFKSjoyNMTEzw+vVrre2vX79G7ty5E7xNnjx5UKRIEa1TlcWLF4e/v3+8mQXURo8ejaCgIM1fckaIZia//hqzXKuWcnEQkR4ePABq1JDzVQLAsGHy15WDg7JxEVG60jkpmzdvHqZPn46AgABs2rQJAQEBWLRoEa5fv47FixejePHiet2xmZkZPD09cShWL3SVSoVDhw6hWrVqCd6mRo0a+O+//7Ra5O7du4c8efLATN2zPQ5zc3PY2tpq/WVlf/8tL42MgEKFlI2FiHSwaRNQvjxw8SKQMyewaxcwYwbnRSMyQDonZQ8ePECbNm0AAC1btkS2bNkwY8YM5MuXL9l3PnToUCxduhSrV6/G7du38d133+Hz58/o1q0bAKBLly4YPXq0Zv/vvvsO79+/x6BBg3Dv3j3s3r0bU6dORb9+/ZIdQ1Zz+LC8XL1a2TiISAdhYXKqpI8fZUvZlStA06ZKR0VECtG5TlloaCisrKwAAEZGRjA3N0eeFJaJ9/X1xdu3bzF+/Hj4+/ujXLly2Ldvn6bz/9OnTzWFagHA1dUV+/fvx5AhQ1CmTBm4uLhg0KBBGDlyZIriyCpiT6ukR2USIlKKhYUsc7F9OzBpEqvzExk4nUtiGBsb48cff4SNjQ0AYOTIkRg+fDgc1UO2/2/gwIGpH2UqyspDatWTjwOyw3/sdSLKIP74Q5a46NFD6UiIMpWs/P2tpnNS5u7uDqMvfMsbGRlpRmVmVFn1SQ0KktX7AWDAAO0O/0SUAYSEAIMGAcuWyerOV64AevbFJTJkWfX7Ozad28ofP36chmFQSl28GLM8d65iYRBRQm7fBtq2BW7ckE3Yo0dz3koiiocdGLKI589jlo1TrSQwEaXY6tVyAvGQEMDZWZ6+rFdP6aiIKANiUpYF3Lsni38DQLNmysZCRP8nBNCzZ0wVZ29vYN06mZgRESWAbSpZQMOGMcsdOyoXBxHFYmQkJw83NgamTAH27WNCRkRJYktZJnf3LvDkiVxu1Ajw9VU2HiKDJoT2qJtRo+Qbs0IFRcMiosyBLWWZ3KlTMcvr1ikXB5HB+/hRNlV7ecn+Y4BsJWNCRkQ6SlZS9uDBA/zwww9o37493rx5AwDYu3cvbt68marB0Zd9+CAva9aUM7QQkQKuXAE8PYE//5QjLY8dUzoiIsqE9E7K/v33X5QuXRpnz57Ftm3b8OnTJwDA1atXMWHChFQPkJL2/ffy8v81fYkoPQkB/PYbULUqcP8+4OoqE7JGjZSOjIgyIb2TslGjRuHHH3/EgQMHtCYBr1evHs6cOZOqwVHS5syJWU7hjFdEpK+gINmJs29fIDxcDn2+fBmoXl3pyIgok9I7Kbt+/Tq++eabeNudnJwQEBCQKkGRboYOjVlmBX+idNa/P7B5s5yvctYsYMcO9iEgohTROymzt7fHq1ev4m2/fPkyXFxcUiUo+rL//otZXrGCpy+J0t20abIf2YkT8hcSJ5slohTSOylr164dRo4cCX9/fxgZGUGlUuHkyZMYNmwYunTpkhYxUgK2bo1Z7tZNuTiIDMaHD7I6v1q+fMD580CVKsrFRERZit5J2dSpU1GsWDG4urri06dPKFGiBGrVqoXq1avjhx9+SIsYKY6oKFn+CODZEqJ0cfYsUL480LWrPE2pxtYxIkpFehePNTMzw9KlSzFu3DjcuHEDnz59Qvny5VG4cOG0iI8S8PRpzPKmTcrFQZTlCQHMni1/BUVFAR4esoWMiCgN6J2UnThxAjVr1kT+/PmRP3/+tIiJvmDSpJhlzmtMlEbevZMtY7t2yfW2bYGlSwFbW0XDIqKsS+/Tl/Xq1UOBAgUwZswY3Lp1Ky1ioiQIAaxZI5c9PJSNhSjLOnkSKFdOJmTm5rIW2YYNTMiIKE3pnZS9fPkS33//Pf7991+UKlUK5cqVw4wZM/D8+fO0iI9iCQrSbhnbvVu5WIiytJcvgefPgcKFgTNngD592H+MiNKckRBCJPfGjx49wh9//IE///wTd+7cQa1atXD48OHUjC/VBQcHw87ODkFBQbDNZL96Bw2KqUfm4AC8f69sPERZihDaidfq1UDLlkD27MrFREQamfn7W1cpSsoAIDo6Gnv37sW4ceNw7do1REdHp1ZsaSIzP6nW1jHzHD94ABQsqGw8RFnGv/8CQ4bI5mdOj0GUIWXm729dJWtCcgA4efIk+vbtizx58qBDhw4oVaoUdvN8Wpp58CAmIdu6lQkZUaqIjgamTJH9Ai5fBsaPVzoiIjJgeo++HD16NDZs2ICXL1+iQYMGmDdvHr7++mtYWVmlRXz0fw8fxiw3aaJcHERZhr8/0KkTcOiQXO/aFZg7V8mIiMjA6Z2UHTt2DMOHD0fbtm3h6OiYFjFRAqZPl5dVqgAWFsrGQpTpHToEdOwIvH4NWFnJ0ZWckYSIFKZ3Unby5Mm0iIOSIETMj3lW8CdKoe3bgVat5BurVClZgbl4caWjIiLSLSnbuXMnGjduDFNTU+zcuTPJfZs3b54qgVGM2BX858xRLg6iLKFBA6BoUcDLC5g3D7C0VDoiIiIAOo6+NDY2hr+/P5ycnGBsnPjYACMjI46+TAOLFgH9+snllI2VJTJQ588Dnp6A+vMrKAiws1M2JiLSS2b8/taXTqMvVSoVnJycNMuJ/WX0hCyzWrlS6QiIMqmoKGD0aKByZTmHpRoTMiLKgPQuibFmzRqEh4fH2x4REYE16vl/KFX5+8vLDh2UjYMoU3n2DKhTB/j5Z7nOWUeIKIPTOynr1q0bgoKC4m3/+PEjunXrlipBkTaVSl5y8nEiHe3eLeeuPHlSzle5eTPLXRBRhqd3UiaEgFECc8A9f/4cdjwlkOoiI+U0fABQpoyysRBleBERwLBhwFdfyXnIKlaURWFbt1Y6MiKiL9K5JEb58uVhZGQEIyMj1K9fH9myxdw0Ojoajx49QqNGjdIkSEM2cmTMctGiysVBlCncvh0zQeygQbLAn7m5sjEREelI56SsRYsWAIArV67Ax8cHNjY2muvMzMzg7u6OVq1apXqAhs7EJGY5iw42IUo9ZcsCCxYATk7A/z+ziIgyC52TsgkTJgAA3N3d4evrCwuWlU8X16/LS07JR5SA8HBgzBigc2fZhwwAevVSNCQiouTSu6K/n59fWsRBidi/X17GbjEjIgAPHgC+vsDFi8CuXcCNG4CpqdJRERElm05JWY4cOXDv3j04OjrCwcEhwY7+au/fv0+14AxdSEjMcsWKysVBlOFs3gz06AEEBwM5csgaZEzIiCiT0ykpmzNnDrJnz65ZTiopo9QzeXLMcuPGysVBlGGEhQFDh8oJxAGgRg3gzz8BV1dl4yIiSgU6JWWxT1l27do1rWKhOGKXg2MeTAbv7VugYUPgyhW5Pnq0/OWSTe9eGEREGZLedcouXbqE6+re5wB27NiBFi1aYMyYMYiIiEjV4Azd0qXycsAAZeMgyhBy5AAcHYFcuYB9+4CpU5mQEVGWondS1rt3b9y7dw8A8PDhQ/j6+sLKygqbN2/GiBEjUj1AQxUVBainEi1RQtlYiBQTEgKEhsplExNg/XrZUubjo2hYRERpQe+k7N69eyj3/6HnmzdvRu3atfHHH39g1apV2Lp1a2rHZ7DevYtZ5hljMki3bwNVqgCDB8dsc3IC8uZVLCQiorSUrGmWVP+fjPHgwYNo0qQJAMDV1RUBAQGpG50By507ZpkFycngrF4thxzfuAHs2CH7kxERZXF6J2UVK1bEjz/+iLVr1+Lff/9F06ZNAQCPHj2Cs7NzqgdoiFQqwPj/z0yePOzkTwbk82fZNNy1qzx1Wb++PF2ZK5fCgRERpT29k7K5c+fi0qVL6N+/P8aOHYtChQoBALZs2YLq1auneoCGyN9fJmYAcP++srEQpZsbN4BKlWQrmbExMGWKrJ4cu9mYiCgLMxJCiNQ4UFhYGExMTGCawQs4BgcHw87ODkFBQbDNoJNJduok+zMDQOo8O0QZXEQE4OEBPH8u+4z98QdQu7bSURFRBpIZvr9TKtnjyS9evIjbt28DAEqUKIEKFSqkWlCG7OPHmISsalVlYyFKN2ZmwOLFwMKFsqWMpyuJyADpnZS9efMGvr6++Pfff2Fvbw8ACAwMRN26dbFhwwbk4odpisQ+Xblzp3JxEKW5q1eBN2+ABg3ketOmQJMm7ERJRAZL7z5lAwYMwKdPn3Dz5k28f/8e79+/x40bNxAcHIyBAwemRYwGRf0QuriwsYCyKCFkq1iVKnJC8adPY65jQkZEBkzvlrJ9+/bh4MGDKF68uGZbiRIlsHDhQjRs2DBVgzM0oaHAyZNyuXBhZWMhShNBQUCvXsCmTXK9QQPA2lrZmIiIMgi9W8pUKlWCnflNTU019csoeWbNillevVq5OIjSxMWLQIUKMiHLlk2+4HfuBHLmVDoyIqIMQe+krF69ehg0aBBevnyp2fbixQsMGTIE9evXT9XgDM2jRzHL+fMrFwdRqps/H6heHXj4EHBzA06cAIYO5elKIqJY9E7KFixYgODgYLi7u8PDwwMeHh4oUKAAgoODMX/+/LSI0WCsWCEvx45VNg6iVHfzpix70aIFcPmy7E9GRERa9O5T5urqikuXLuHQoUOakhjFixeHt7d3qgdnSN6/j1kuUkS5OIhSjRAxLWFz5siWss6d2TpGRJQIvZKyjRs3YufOnYiIiED9+vUxYMCAtIrL4Pz3X8xyx47KxUGUYkLIJOzAAWDXLsDEBLC0BLp0UToyIqIMTeek7LfffkO/fv1QuHBhWFpaYtu2bXjw4AFmzJiRlvEZjG3b5GWpUvI7jChTevdOzlu5a5dc37YNaNNG0ZCIiDILnfuULViwABMmTMDdu3dx5coVrF69GosWLUrL2AyK+jvs40dl4yBKtlOngPLl5YvZ3Bz47TegdWuloyIiyjR0TsoePnwIPz8/zXqHDh0QFRWFV69epUlghmT/ftkPGuCpS8qEVCpg+nSgVi3g2TNZZO/MGaBPH/YfIyLSg85JWXh4OKxjFXk0NjaGmZkZQkND0yQwQyEE0KhRzPq33yoXC1GyDBwIjBoFREcDHTrIemTlyikdFRFRpqNXR/9x48bByspKsx4REYGffvoJdnZ2mm2zZ89OvegMwLVrMcuzZgEeHsrFQpQsvXoBf/4J/PKL/FXB1jEiomTROSmrVasW7t69q7WtevXqePjwoWbdiB/Genv3LmZ56FDl4iDSWXQ0cOFCTK2xMmWAx4+B7NkVDYuIKLPTOSk7evRoGoZhuJ49k5elSikbB5FOXr8GOnUCjh6VVfnViRkTMiKiFNO7oj+lrj//lJcvXigbB9EXHT4MlC0LHDwImJkBz58rHRERUZbCpExB16/LkZcA0LixsrEQJSo6GpgwAfD2li1lpUrJ05etWikdGRFRlqL3NEuUepYti1meOlW5OIgS9fKlrNOi7r7Qowcwbx4Qa8APERGljgzRUrZw4UK4u7vDwsICVapUwblz53S63YYNG2BkZIQWLVqkbYBp5Ndf5WXr1oCbm7KxECVo2zaZkNnYAOvXA0uXMiEjIkojiidlGzduxNChQzFhwgRcunQJZcuWhY+PD968eZPk7R4/foxhw4bBy8srnSJNXeHhMcsVKyoXB1GS+vUDhg2Ttcc6dFA6GiKiLC1ZSdnx48fRqVMnVKtWDS/+30N97dq1OHHihN7Hmj17Nnr27Ilu3bqhRIkSWLx4MaysrLBixYpEbxMdHY2OHTti0qRJKFiwYHL+BcWpK/gDsvYmUYbw/Lmcu1I935eRETBjBlCkiKJhEREZAr2Tsq1bt8LHxweWlpa4fPkywv/f5BMUFISpenaMioiIwMWLF+Ht7R0TkLExvL29cfr06URvN3nyZDg5OaF79+76hp9hNG0as2xpqVwcRBq7d8tK/KtXA99/r3Q0REQGR++k7Mcff8TixYuxdOlSmJqaarbXqFEDly5d0utYAQEBiI6OhrOzs9Z2Z2dn+Pv7J3ibEydOYPny5Vi6dKlO9xEeHo7g4GCtv4xA/e+xvBMpLjISGD4c+OorWc3Y0xMYOVLpqIiIDI7eSdndu3dRq1ateNvt7OwQGBiYGjEl6uPHj+jcuTOWLl0KR0dHnW4zbdo02NnZaf5cXV3TNEZdxG4EPHZMuTiI8OSJnEh85ky5PnAgcPIk5/siIlKA3iUxcufOjf/++w/u7u5a20+cOKF3/y5HR0eYmJjg9evXWttfv36N3Llzx9v/wYMHePz4MZo1a6bZplKpAADZsmXD3bt34RHny2T06NEYGmv+ouDgYMUTs9g1ycqWVS4OMnDHjwPNmwOBgYC9PbByJZBJRzITEWUFereU9ezZE4MGDcLZs2dhZGSEly9fYv369Rg2bBi+++47vY5lZmYGT09PHDp0SLNNpVLh0KFDqFatWrz9ixUrhuvXr+PKlSuav+bNm6Nu3bq4cuVKgsmWubk5bG1ttf6UFhQkL0uW5NzNpKDChQFzczlV0uXLTMiIiBSmd0vZqFGjoFKpUL9+fYSEhKBWrVowNzfHsGHDMGDAAL0DGDp0KPz8/FCxYkVUrlwZc+fOxefPn9GtWzcAQJcuXeDi4oJp06bBwsICpeJMEmlvbw8A8bZnVI8exSwvX65cHGSg3r0DcuaUy7lzyxpkBQvKaZOIiEhReidlRkZGGDt2LIYPH47//vsPnz59QokSJWBjY5OsAHx9ffH27VuMHz8e/v7+KFeuHPbt26fp/P/06VMYGyteTi3VnD0bs8z6ZJSutmwBuncHliwBfH3ltmLFlI2JiIg0jIQQQukg0lNwcDDs7OwQFBSkyKnMlSuBb78FGjUC9u5N97snQxQWJktcLFok1xs3luUveO6ciDIRpb+/04PeLWV169aFURIf5ocPH05RQFndggXykjPVULq4fx9o2xa4ckWujxoFTJ7MhIyIKAPSOykrV66c1npkZCSuXLmCGzduwM/PL7XiyrLUpdxYn4zS3J9/Ar16AZ8+AY6OwNq1somWiIgyJL2Tsjlz5iS4feLEifj06VOKA8rKnjyJWZ47V7EwyBBcuxYzV2WtWsAffwAuLsrGRERESUq1HvSdOnVKcr5KAu7ciVn+/6BRorRRpoycSHzcOODQISZkRESZgN4tZYk5ffo0LCwsUutwWdKaNUpHQFna+vWAlxeQP79c/+UX9h0jIspE9E7KWrZsqbUuhMCrV69w4cIFjBs3LtUCy4rUkxQUKaJsHJTFfP4MDBggh/ZWry5rj5maMiEjIspk9E7K7OzstNaNjY1RtGhRTJ48GQ0bNky1wLKaqChg9my5rO7qQ5RiN2/K0ZW3bgHGxoCPj7wkIqJMR6+kLDo6Gt26dUPp0qXh4OCQVjFlSZcvxyxzrmdKMSFky1j//kBoKJAnj+zMX6eO0pEREVEy6fWT2sTEBA0bNkRgYGAahZN13b4ds8yWMkqRz5+BLl1kdf7QUNk6duUKEzIiokxO7/McpUqVwsOHD9Milixt5kx5WaAAzy5RChkby5IXJibAtGnAnj2Ak5PSURERUQrp3afsxx9/xLBhwzBlyhR4enrC2tpa6/qsOvVBSl2/Li8LFVI2DsqkhJB/xsaApSWwaRPw9i1Qs6bSkRERUSrRee7LyZMn4/vvv0f2WKXoY0+3JISAkZERoqOjUz/KVKTE3Fnq71JADoyrXTtd7payiqAgWZm/dGnghx+UjoaISBGGMPelzkmZiYkJXr16hduxO0cloHYGzziUeFJVKnmmCZCNG46O6XK3lBVcvAj4+gIPHgAWFsDDh7JTPxGRgTGEpEzn05fq3C2jJ10Z0ePHMcuc85J0IoScvX7YMCAiAnBzAzZsYEJGRJSF6dWnzIjFKJOlfPmYZXNz5eKgTCIwUI6s3LZNrrdoAaxYAbAMDRFRlqZXUlakSJEvJmbv379PUUBZzdWrQHCwXHZ3VzQUygyiomRV/tu3ZVX+mTNltX7+ICIiyvL0SsomTZoUr6I/Ja1cuZhl9QhMokRlywYMGiTnrdy4EahYUemIiIgonejc0d/Y2Bj+/v5wyuT1kNKzo+C7dzGd+r/+GvjrrzS9O8qs3r8HXr0CSpaU60IAISFAnHIzRESGzBA6+utcxpT9yfSnPm0JxHQPItJy6pRsTv3qK9mXDJCnKpmQEREZHJ2TMh0b1CiWS5fkZY4crOJPcahUwPTpQK1awLNnsv/YmzdKR0VERArSuU+ZSqVKyziypOHD5WVUlLJxUAbz9i3g5wfs3SvX27cHfv+d9VKIiAwc22/SUI4c8rJrV0XDoIzk2DF5unLvXlkMdulSYP16JmRERKT/3Jeku7Awefn118rGQRnI7NnAy5dAsWJy/srSpZWOiIiIMggmZWno5k15aWGhbByUgSxfDhQsCEyeDNjYKB0NERFlIDx9mUbOn49ZzptXuThIYYcPA99/L8tcAEDOnLK1jAkZERHFwZayNLJ+fcwyK/kboOho2Ro2ZYpMyKpUAdq2VToqIiLKwJiUpZF37+QluwwZoJcvgY4dgaNH5Xr37rIOGRERURKYlKWRdevkZZ06ioZB6e2ff4BOnWTZC2trWeqiY0eloyIiokyAfcrSwLJlMcvFiysXB6WzGTOARo1kQla2rKwezISMiIh0xKQsDcyZE7PcubNycVA6K19eXn73HXDmDFCkiLLxEBFRpsLTl2kgKEhezpzJQXZZ3ps3gJOTXPb2Bq5fj5lYnIiISA9sKUtlKhXw4oVcbtZM2VgoDUVGynm0ihQBHjyI2c6EjIiIkolJWSqLPae0m5tycVAaevIE8PKSTaFBQcDffysdERERZQE8fZnKrl2Tl9bWgLm5srFQGvjrL6BbNyAwELCzA1asAFq2VDoqIiLKAthSlsqePZOXJibKxkGpLCICGDwY+OYbmZBVrgxcvsyEjIiIUg2TslTWo4e8bNJE2TgolS1YAMybJ5eHDgWOHwcKFFA2JiIiylJ4+jIVXboUs2xtrVwclAb69wcOHAD69uUIDiIiShNGQqhnSjYMwcHBsLOzQ1BQEGxtbVPtuEIAxrHaHaOjtdcpkwkLAxYtAgYMAExNlY6GiMjgpdX3d0bClrJUEhwcszxuHBOyTO3+fcDXV/YZe/sWmDZN6YiIiMgAMHVIJVu2xCyPG6dcHJRCGzYAFSrIhMzREahVS+mIiIjIQDApSyX378cs82xXJhQaCvTuDbRvD3z6JOuQXbkCNG6sdGRERGQgmJSlkunT5eWwYcrGQclw7x5QpQqwZAlgZAT88ANw+DDg4qJ0ZEREZEDYpyyVmJsD4eFA0aJKR0J6U6mAhw/lHJbr18s5LImIiNIZk7JU8OyZTMgAWVuUMgGVKmY0RrFiwLZtQOnSQJ48ysZFREQGi6cvU8HEiTHLdnaKhUG6unkTKFcOOHYsZlvDhkzIiIhIUUzKUsGKFfLS3R3IxrbHjEsIYPlyoFIl4Pp14Pvv5TYiIqIMgElZKrC0lJe9eikbByXh40egc2c5D1ZoqGwZ271bduwnIiLKAJiUpZAQ8jseYH+yDOvqVaBiRdmJ38QEmDoV2LtXduwnIiLKIHiyLYWeP49ZzpVLuTgoEbdvy3IX4eGyxMWGDUDNmkpHRUREFA+TshRasCBmOWdO5eKgRBQrBjRvDnz+DKxeLav0ExERZUCckDyFYndJMqxHMgO7fBkoUACwt5froaGykBwnJCUiyrQMYUJyfkulwKtXMcvLlysXB/2fELLpsmpV2aFfnSVbWjIhIyKiDI+nL1Pg7t2Y5S5dlIuDAAQGAt27yyKwABAVBYSFxQyNJSIiyuDYfJACffvKy8qVWZ9MUefOAeXLy4TM1BSYOxfYvp0JGRERZSpMylLg9m15GRGhbBwGSwhgzhw5mvLxY9mP7ORJYNAg1h8jIqJMh0lZMqnnugSAVasUC8OwBQUBs2cDkZFAq1bApUuyWj8REVEmxJNuyXTpUsxyqVLKxWHQ7O2BP/+UxWH79mXrGBERZWpMypKpTZuYZRMT5eIwKCoVMHMmkDt3zMiKmjVZDJaIiLIEJmXJ9OKFvMyipVIynrdvAT8/OT2SlRVQty7g6qp0VERERKmGSVkyREbGLJ84oVwcBuP4caBdO+DlS8DCQo6uzJdP6aiIiIhSFTv6J0PsTv4eHsrFkeWpVMBPPwF16siErGhR4OxZoGdP9h8jIqIshy1lyRA7KTM3Vy6OLC06GmjaFNi/X6537gwsWgTY2CgbFxERURphS1ky7N4tL01M2Mk/zZiYABUryv5jK1cCa9YwISMioiwtQyRlCxcuhLu7OywsLFClShWcO3cu0X2XLl0KLy8vODg4wMHBAd7e3knunxaOHpWX0dHperdZX3S07NCvNnEicOUK0LWrQgERERGlH8WTso0bN2Lo0KGYMGECLl26hLJly8LHxwdv3rxJcP+jR4+iffv2OHLkCE6fPg1XV1c0bNgQL9TDIdPBypXycvr0dLvLrO/VK6BBA6Bx45jzw9myAYULKxsXERFROjESQgglA6hSpQoqVaqEBQsWAABUKhVcXV0xYMAAjBo16ou3j46OhoODAxYsWIAuOswKHhwcDDs7OwQFBcE2GfUs1q6NKZG1Z4/MISiF/vkH6NRJtpJZWwOHD8sJRYmIiP4vpd/fmYGiLWURERG4ePEivL29NduMjY3h7e2N06dP63SMkJAQREZGIkeOHGkVppZx42KWmZClUFQUMHYs0KiRTMjKlAEuXmRCRkREBknR0ZcBAQGIjo6Gs7Oz1nZnZ2fcuXNHp2OMHDkSefPm1UrsYgsPD0d4rOGSwcHByQ8YwJMn8nLixBQdhp4/Bzp0kDXIAKB3bzm5uKWlsnEREREpRPE+ZSnx888/Y8OGDdi+fTssLCwS3GfatGmws7PT/LmmUhX4Jk1S5TCGq2dPmZBlzw5s2AAsXsyEjIiIDJqiSZmjoyNMTEzw+vVrre2vX79G7ty5k7ztzJkz8fPPP+Off/5BmTJlEt1v9OjRCAoK0vw9e/Ys2fGePBmzzKKxKbRwoZwq6dIlwNdX6WiIiIgUp2hSZmZmBk9PTxw6dEizTaVS4dChQ6hWrVqit/vll18wZcoU7Nu3DxUrVkzyPszNzWFra6v1l1zr1sUsp1MXtqzj6VNg2bKY9YIFZYf+QoWUi4mIiCgDUbyi/9ChQ+Hn54eKFSuicuXKmDt3Lj5//oxu3boBALp06QIXFxdMmzYNADB9+nSMHz8ef/zxB9zd3eHv7w8AsLGxgU0aFxdVd38aODBN7ybr2blT1hoLDATy5wcaNlQ6IiIiogxH8aTM19cXb9++xfjx4+Hv749y5cph3759ms7/T58+hbFxTIPeb7/9hoiICLRu3VrrOBMmTMDENO59f/OmvCxaNE3vJuuIiABGjpQTiANApUqsO0ZERJQIxeuUpbfk1jl5+DCmH9mDB/LsGyXh0SPZV+z8ebk+ZAjw88+AmZmycRERUaZkCHXKFG8pyyzUrWQAE7Iv+usveboyKAhwcABWrQKaN1c4KCIiooyNSZmO1LVs3d0VDSNzCA6WCVm1arLcRf78SkdERESU4TEp09HHj/KSgwUTER0NmJjI5S5dAAsL4JtvAFNTZeMiIiLKJDJ18dj08u4d8P+pOTkDUEI2bABKlwYCAmK2tW3LhIyIiEgPTMp0sH59zHKLFoqFkfGEhsrpkdq3B27fBmbPVjoiIiKiTIunL3Wgnu/S1lZWdSAAd+7I1rDr1wEjI2DMGE4ISkRElAJMynTw77/ysl49ZePIMNauBb77Dvj8GXByklMdNGigdFRERESZGpMyHVy8KC+/MB2nYfj9d6BPH7lct648t5snj7IxERERZQHsU6aHli2VjiADaNdODkGdOBE4cIAJGRERUSphS9kXBAfHLJcqpVwcihFCThxer57sO2ZnB1y7BlhaKh0ZERFRlsKWsi84cyZm2eAahT59Avz8AG9vYPHimO1MyIiIiFIdW8q+4Kuv5KXBldy6dk2Orrx7FzA2lp36iYiIKM0wKfuCyEh52b+/snGkGyGAJUuAQYOA8HDAxQX480/Ay0vpyIiIiLI0JmVJCAqKWR4/Xrk40k1wMNCrF7Bxo1xv3BhYswZwdFQ2LiIiIgPAPmVJUBeNBWT/9izvxg1g82Y5h+UvvwC7djEhIyIiSidsKUtCSIi8dHOTAw+zvOrV5SSf5coB1aopHQ0REZFBYUtZIoSIyUvMzZWNJc0EBgKdO8t5K9W++44JGRERkQLYUpaIy5djlsuVUyyMtHP+PODrCzx6BNy6BVy4YCDNgURERBkTW8oSsWdPzPKGDcrFkeqEAObOBWrUkAmZu7usQcaEjIiISFFsKUuEupN/oUJZKF95/x7o1g3YuVOut2wJLF8O2NsrGhYRERExKUuQEMCyZXK5QAFlY0k1jx4BdeoAT58CZmbA7NlA375ZKOMkIiLK3JiUJWDBgpjlGjWUiyNVuboC+fPLqQk2bQIqVFA6IiIiIoqFSVkCnj2LWR47Vrk4UuzdOyB7dtkyli2brEFmZQXY2iodGREREcXBjv4JEEJefv+9zGUypePHgbJlgZEjY7blzs2EjIiIKINiUpaAo0flpTo5y1RUKmDqVKBuXeDFC2DfPk4mTkRElAkwKUtAwYLy8uNHZePQ25s3QKNG8pxrdDTQqZOsR2ZtrXRkRERE9AWZ9eRcmgoPl5eensrGoZcjR4AOHQB/f8DSEli4EOjalaMriYiIMgkmZQnYsUNeZprplYKDgVatgA8fgBIl5OjKkiWVjoqIiIj0wKQsjoiImGUHB+Xi0IutLfD778DevcD8+TxdSURElAkxKYsjMDBmuXZtxcL4soMHAWNjoF49ud6mjfwjIiKiTIkd/eOYNClmOUM2OEVFAT/8ADRsCLRvD7x6pXRERERElArYUhaHhYW8dHKSxe8zlBcvZCJ2/Lhcb9GC81YSERFlEUzK4lCPvOzdW9k44tm7F+jSBQgIAGxsgKVLgXbtlI6KiIiIUglPX8axerW8VLeYKU6lklX5mzSRCVn58sClS0zIiIiIshgmZbFERQGfPsnlDJOUGRvL2mMA0K8fcOoUULiwsjERERFRquPpy1hCQ2OW/fyUiwOAzBDVE28uXChHVn71lbIxERGlMSEEoqKiEB0drXQopABTU1OYmJgoHYZimJTFou5PBijYfz4iAhg1CvjvP1nF1shI9iFjQkZEWVxERARevXqFkJAQpUMhhRgZGSFfvnywsbFROhRFMCmL5eZNeWliIv/S3aNHgK+vnK8SkDOj162rQCBEROlLpVLh0aNHMDExQd68eWFmZgYjThNnUIQQePv2LZ4/f47ChQsbZIsZk7L/EwKoU0cuK9Jqvm0b8O23QFCQbKZbtYoJGREZjIiICKhUKri6usLKykrpcEghuXLlwuPHjxEZGWmQSRk7+v/f27cxy999l453HB4ODBgg564MCgKqVgWuXAG+/jodgyAiyhiMjfm1ZMgMvXWUr/7/Gz8+ZnnGjHS8444dgQUL5PLw4cCxY4CbWzoGQERERBkBkzIAly/L+bwBWck/XadXGjkSyJMH2LUL+OWXDDiNABEREaUHg0/KhAAqVIhZnzs3je8wNBT499+Y9UqVgIcPgaZN0/iOiYgorZw+fRomJiZomsBn+dGjR2FkZITAwMB417m7u2NunC+eI0eOoEmTJsiZMyesrKxQokQJfP/993jx4kUaRQ+EhYWhX79+yJkzJ2xsbNCqVSu8fv06ydt8+vQJ/fv3R758+WBpaYkSJUpg8eLFCe4rhEDjxo1hZGSEv/76Kw3+g6zB4JOy2Dp2TONC+Xfvyj5jPj6y35hahqlUS0REybF8+XIMGDAAx44dw8uXL5N9nN9//x3e3t7InTs3tm7dilu3bmHx4sUICgrCrFmzUjFibUOGDMHff/+NzZs3499//8XLly/RsmXLJG8zdOhQ7Nu3D+vWrcPt27cxePBg9O/fHzt37oy379y5cw2+v5guOPoyljlzZFmwNLF+vZxQ8/NnIFcuIIFfTERElPl8+vQJGzduxIULF+Dv749Vq1ZhzJgxeh/n+fPnGDhwIAYOHIg5c+Zotru7u6NWrVoJtrSlhqCgICxfvhx//PEH6tWrBwBYuXIlihcvjjNnzqBq1aoJ3u7UqVPw8/NDnf+XLujVqxd+//13nDt3Ds2bN9fsd+XKFcyaNQsXLlxAnjx50uR/yCrYUpbWQkKAHj2ATp1kQlanjmwlU9ffICKieISQH5lK/AmhX6ybNm1CsWLFULRoUXTq1AkrVqyA0PcgADZv3oyIiAiMGDEiwevtk6hq3rhxY9jY2CT6V7JkyURve/HiRURGRsLb21uzrVixYsifPz9Onz6d6O2qV6+OnTt34sWLFxBC4MiRI7h37x4aNmyo2SckJAQdOnTAwoULkTt37iT+ewLYUpa2bt0C2raVVWmNjOQQz3HjFKpMS0SUeYSEyMlMlPDpk34DvpYvX45OnToBABo1aoSgoCD8+++/mhYkXd2/fx+2trbJak1atmwZQmPPFRiHaRKDyPz9/WFmZhYv6XN2doa/eu7lBMyfPx+9evVCvnz5kC1bNhgbG2Pp0qWoVauWZp8hQ4agevXq+JplnnTCpCwt7dghE7LcueXpy/83CxMRUdZw9+5dnDt3Dtu3bwcAZMuWDb6+vli+fLneSZkQItn9rlxcXJJ1u5SYP38+zpw5g507d8LNzQ3Hjh1Dv379kDdvXnh7e2Pnzp04fPgwLl++nO6xZVZMytLSiBGyLXzAAMDZWeloiIgyDSsr2WKl1H3ravny5YiKikLevHk124QQMDc3x4IFC2BnZwdbW1sAsu9W3NaowMBA2NnZAQCKFCmCoKAgvHr1Su/WssaNG+P48eOJXu/m5oab6rkE48idOzciIiIQGBioFd/r168TPeUYGhqKMWPGYPv27ZoRp2XKlMGVK1cwc+ZMeHt74/Dhw3jw4EG8/7lVq1bw8vLC0aNH9fofDYHBJ2WpOsL4+nVg8mRgzRrA0lKepvzxx1S8AyIiw2BklM41I5MhKioKa9aswaxZs7T6UQFAixYt8Oeff6JPnz4oXLgwjI2NcfHiRbjFKg7+8OFDBAUFoUiRIgCA1q1bY9SoUfjll1+0OvqrxU2aYkvJ6UtPT0+Ympri0KFDaNWqFQDZAvj06VNUq1YtwdtERkYiMjIy3gwMJiYmUKlUAIBRo0ahR48eWteXLl0ac+bMQbNmzRKNx5AZfFI2bFjM8v9/zOhPCGDZMmDgQCAsDChYEJg+PVXiIyKijGnXrl348OEDunfvrmntUmvVqhWWL1+OPn36IHv27OjRowe+//57ZMuWDaVLl8azZ88wcuRIVK1aFdWrVwcAuLq6Ys6cOejfvz+Cg4PRpUsXuLu74/nz51izZg1sbGwSLYuRktOXdnZ26N69O4YOHYocOXLA1tYWAwYMQLVq1bRGXhYrVgzTpk3DN998A1tbW9SuXRvDhw+HpaUl3Nzc8O+//2LNmjWYPXs2ANkCl1BLW/78+VGgQIFkx5ulCQMTFBQkAIigoCAhhBAFCwoBCFG6dLIPKES7dvIggBCNGgnx5k3qBUxEZABCQ0PFrVu3RGhoqNKh6Oyrr74STZo0SfC6s2fPCgDi6tWrQgj5/02YMEEUK1ZMWFpaigIFCohevXqJt2/fxrvtgQMHhI+Pj3BwcBAWFhaiWLFiYtiwYeLly5dp9r+EhoaKvn37CgcHB2FlZSW++eYb8erVK619AIiVK1dq1l+9eiW6du0q8ubNKywsLETRokXFrFmzhEqlSvR+AIjt27cnGUdir4O4399ZkZEQyRi3m4kFBwfDzs4OQUFByJ7dFuqW1xEjktG4dfmyHF3533/yVOXUqbLpjRPqEhHpJSwsDI8ePUKBAgVgwYLaBiup10Hs72/bZJ/aytgM+vRl7PIr7dvreePt22X5/4gIwNUV2LAB+H8TNBEREZG+DDopiz0TRrlyet64YkVZRKdGDWDlSiBnztQMjYiIiAyMQSdlFy/KyziDZhL34gWg7kzp6gqcOyc79XM+LyIiIkohg+789OqVvHz//gs7CgHMmycTsNgTrXp4MCEjIiKiVGHQSZl6iEOSLWXv3wPffAMMHiz7j8VOyoiIiIhSiUEnZXv2yMtECyefOQOULy+nSzIzA+bPB5YuTbf4iIgMjYEVBKA4DP35N+ikLFEqFTBzJuDlBTx9Kk9TnjoF9O/P05VERGlAXXE+JCRE4UhISREREQDkzACGyKA7+gcEyMvKleNccewYMHy4XG7bVraOZdGaKEREGYGJiQns7e3x5s0bAICVlVWyJ+emzEmlUuHt27ewsrJCtmyGmZ4Y5n8N4OzZmOV4k8/WqQMMGgQUKwb07s3WMSKidKCekkedmJHhMTY2Rv78+Q02ITfYiv4FCwbh4UPZ+qWKUsHo13mygmwC83QREVH6iY6ORmRkpNJhkALMzMziTXKuxor+6WThwoWYMWMG/P39UbZsWcyfPx+V451TjLF582aMGzcOjx8/RuHChTF9+nQ0adJEr/sMD5eXzaq8gVGTzsA//wC7dgEHDnCaJCIiBZmYmBhsnyIybIpnHxs3bsTQoUMxYcIEXLp0CWXLloWPj0+izdenTp1C+/bt0b17d1y+fBktWrRAixYtcOPGDb3u98ULoDaOYtP9cjIhs7QEOnbkqUoiIiJShOKnL6tUqYJKlSphwYIFAGRHP1dXVwwYMACjRo2Kt7+vry8+f/6MXbt2abZVrVoV5cqVw+LFi794f+rmzxEYjamYDhOogOLFgU2bgFKlUu8fIyIiolRjCKcvFW0pi4iIwMWLF+Ht7a3ZZmxsDG9vb5yOPVt4LKdPn9baHwB8fHwS3T8xYzFNJmTdugHnzzMhIyIiIkUp2qcsICAA0dHRcHZ21tru7OyMO3fuJHgbf3//BPf39/dPcP/w8HCEqzuQAQgKCpLHgQUCfpoHx/7tgOhoIDg4Jf8KERERpaHg/39PZ+XxiRmio39amjZtGiZNmhRve1GEAWN7yz8iIiLKFN69ewc7Ozulw0gTiiZljo6OMDExwevXr7W2v379WlOvJq7cuXPrtf/o0aMxdOhQzXpgYCDc3Nzw9OnTLPukZhbBwcFwdXXFs2fPsmz/gMyEz0fGweci4+BzkXEEBQUhf/78yJEjh9KhpBlFkzIzMzN4enri0KFDaNGiBQDZ0f/QoUPo379/grepVq0aDh06hMGDB2u2HThwANWqVUtwf3Nzc5ibm8fbbmdnxzdYBmFra8vnIgPh85Fx8LnIOPhcZByJ1THLChQ/fTl06FD4+fmhYsWKqFy5MubOnYvPnz+jW7duAIAuXbrAxcUF06ZNAwAMGjQItWvXxqxZs9C0aVNs2LABFy5cwJIlS5T8N4iIiIhSRPGkzNfXF2/fvsX48ePh7++PcuXKYd++fZrO/E+fPtXKiqtXr44//vgDP/zwA8aMGYPChQvjr7/+QimOniQiIqJMTPGkDAD69++f6OnKo0ePxtvWpk0btGnTJln3ZW5ujgkTJiR4SpPSF5+LjIXPR8bB5yLj4HORcRjCc6F48VgiIiIiygDTLBERERERkzIiIiKiDIFJGREREVEGkCWTsoULF8Ld3R0WFhaoUqUKzp07l+T+mzdvRrFixWBhYYHSpUtjz5496RRp1qfPc7F06VJ4eXnBwcEBDg4O8Pb2/uJzR/rR972htmHDBhgZGWnqCVLK6ftcBAYGol+/fsiTJw/Mzc1RpEgRflalEn2fi7lz56Jo0aKwtLSEq6srhgwZgrCwsHSKNus6duwYmjVrhrx588LIyAh//fXXF29z9OhRVKhQAebm5ihUqBBWrVqV5nGmKZHFbNiwQZiZmYkVK1aImzdvip49ewp7e3vx+vXrBPc/efKkMDExEb/88ou4deuW+OGHH4Spqam4fv16Okee9ej7XHTo0EEsXLhQXL58Wdy+fVt07dpV2NnZiefPn6dz5FmTvs+H2qNHj4SLi4vw8vISX3/9dfoEm8Xp+1yEh4eLihUriiZNmogTJ06IR48eiaNHj4orV66kc+RZj77Pxfr164W5ublYv369ePTokdi/f7/IkyePGDJkSDpHnvXs2bNHjB07Vmzbtk0AENu3b09y/4cPHworKysxdOhQcevWLTF//nxhYmIi9u3blz4Bp4Esl5RVrlxZ9OvXT7MeHR0t8ubNK6ZNm5bg/m3bthVNmzbV2lalShXRu3fvNI3TEOj7XMQVFRUlsmfPLlavXp1WIRqU5DwfUVFRonr16mLZsmXCz8+PSVkq0fe5+O2330TBggVFREREeoVoMPR9Lvr16yfq1auntW3o0KGiRo0aaRqnodElKRsxYoQoWbKk1jZfX1/h4+OThpGlrSx1+jIiIgIXL16Et7e3ZpuxsTG8vb1x+vTpBG9z+vRprf0BwMfHJ9H9STfJeS7iCgkJQWRkZJae5yy9JPf5mDx5MpycnNC9e/f0CNMgJOe52LlzJ6pVq4Z+/frB2dkZpUqVwtSpUxEdHZ1eYWdJyXkuqlevjosXL2pOcT58+BB79uxBkyZN0iVmipEVv78zRPHY1BIQEIDo6GjNbABqzs7OuHPnToK38ff3T3B/f3//NIvTECTnuYhr5MiRyJs3b7w3HekvOc/HiRMnsHz5cly5ciUdIjQcyXkuHj58iMOHD6Njx47Ys2cP/vvvP/Tt2xeRkZGYMGFCeoSdJSXnuejQoQMCAgJQs2ZNCCEQFRWFPn36YMyYMekRMsWS2Pd3cHAwQkNDYWlpqVBkyZelWsoo6/j555+xYcMGbN++HRYWFkqHY3A+fvyIzp07Y+nSpXB0dFQ6HIOnUqng5OSEJUuWwNPTE76+vhg7diwWL16sdGgG5+jRo5g6dSoWLVqES5cuYdu2bdi9ezemTJmidGiUBWSpljJHR0eYmJjg9evXWttfv36N3LlzJ3ib3Llz67U/6eZ/7d17UFRVHAfwLwsuu+IiQ8nAxkNB2RiDcAENySHIYpnUTVQoGURBcSTE0bSYUh4ZigY44FjROLJGjDycCkYSFJOCdSo0FhrBRZBVG7EmaEAU4rGnPxrutPLIRYVt/X1m7h/33HPO/Z17Zmd/c+7duxOZi2Hp6elIS0tDZWUlPDw8HmeYTwx956O1tRUajQbLly/nyrRaLQDAzMwMarUaLi4ujzdoIzWRz4adnR2mTZsGU1NTrszNzQ23b99Gf38/+Hz+Y43ZWE1kLvbs2YOIiAhs3LgRAODu7o67d+8iJiYG77//vs5/NZPHa6zvb0tLy//lKhlgZCtlfD4fXl5eOHfuHFem1Wpx7tw5+Pr6jtrG19dXpz4AnD17dsz65MFMZC4A4ODBg9i7dy/Ky8vh7e09GaE+EfSdj2effRa//PILVCoVt61YsQIBAQFQqVRwcHCYzPCNykQ+G35+fmhpaeESYwBobm6GnZ0dJWQPYSJzce/evRGJ13CyzOhfCyeVUX5/T/UvDR61goICZm5uzhQKBWtsbGQxMTHMysqK3b59mzHGWEREBEtISODqK5VKZmZmxtLT01lTUxNLSkqiV2I8IvrORVpaGuPz+ezkyZOsvb2d2+7cuTNVQzAq+s7H/ejXl4+OvnNx48YNJhKJWFxcHFOr1ezUqVPMxsaGffjhh1M1BKOh71wkJSUxkUjETpw4wa5du8bOnDnDXFxcWGho6FQNwWjcuXOH1dXVsbq6OgaAZWZmsrq6Onb9+nXGGGMJCQksIiKCqz/8Soxdu3axpqYmduTIEXolhiE6fPgwc3R0ZHw+ny1cuJD98MMP3DF/f38WGRmpU7+oqIi5uroyPp/P5s+fz8rKyiY5YuOlz1w4OTkxACO2pKSkyQ/cSOn72fg3SsoeLX3n4sKFC2zRokXM3NycOTs7s9TUVDY4ODjJURsnfeZiYGCAJScnMxcXFyYQCJiDgwOLjY1lf/755+QHbmTOnz8/6nfA8PWPjIxk/v7+I9p4enoyPp/PnJ2dWW5u7qTH/SiZMEbrrYQQQgghU82onikjhBBCCPm/oqSMEEIIIcQAUFJGCCGEEGIAKCkjhBBCCDEAlJQRQgghhBgASsoIIYQQQgwAJWWEEEIIIQaAkjJCCCGEEANASRkhRIdCoYCVldVUhzFhJiYm+Prrr8ets379erz++uuTEg8hhDwoSsoIMULr16+HiYnJiK2lpWWqQ4NCoeDi4fF4sLe3x4YNG/D7778/kv7b29sRHBwMANBoNDAxMYFKpdKpk5WVBYVC8UjON5bk5GRunKampnBwcEBMTAw6Ozv16ocSSEKeHGZTHQAh5PGQyWTIzc3VKZs1a9YURaPL0tISarUaWq0W9fX12LBhA27duoWKioqH7tvW1vY/68ycOfOhz/Mg5s+fj8rKSgwNDaGpqQlRUVHo6upCYWHhpJyfEPL/QitlhBgpc3Nz2Nra6mympqbIzMyEu7s7LCws4ODggNjYWPT09IzZT319PQICAiASiWBpaQkvLy9cvHiRO15TU4MlS5ZAKBTCwcEB8fHxuHv37rixmZiYwNbWFmKxGMHBwYiPj0dlZSV6e3uh1WrxwQcfwN7eHubm5vD09ER5eTnXtr+/H3FxcbCzs4NAIICTkxP279+v0/fw7cs5c+YAABYsWAATExO89NJLAHRXnz777DOIxWJotVqdGOVyOaKiorj9kpISSKVSCAQCODs7IyUlBYODg+OO08zMDLa2tnjmmWewdOlSrFmzBmfPnuWODw0NITo6GnPmzIFQKIREIkFWVhZ3PDk5GcePH0dJSQm36lZVVQUAuHnzJkJDQ2FlZQVra2vI5XJoNJpx4yGEGDZKygh5wvB4PGRnZ+Py5cs4fvw4vv32W7zzzjtj1g8PD4e9vT1qa2tx6dIlJCQkYNq0aQCA1tZWyGQyrFq1Cg0NDSgsLERNTQ3i4uL0ikkoFEKr1WJwcBBZWVnIyMhAeno6GhoaEBQUhBUrVuDq1asAgOzsbJSWlqKoqAhqtRr5+fmYPXv2qP3+9NNPAIDKykq0t7fjyy+/HFFnzZo16OjowPnz57myzs5OlJeXIzw8HABQXV2NdevWYdu2bWhsbEROTg4UCgVSU1MfeIwajQYVFRXg8/lcmVarhb29PYqLi9HY2IjExES89957KCoqAgDs3LkToaGhkMlkaG9vR3t7OxYvXoyBgQEEBQVBJBKhuroaSqUSM2bMgEwmQ39//wPHRAgxMIwQYnQiIyOZqakps7Cw4LbVq1ePWre4uJg99dRT3H5ubi6bOXMmty8SiZhCoRi1bXR0NIuJidEpq66uZjwej/X29o7a5v7+m5ubmaurK/P29maMMSYWi1lqaqpOGx8fHxYbG8sYY2zr1q0sMDCQabXaUfsHwL766ivGGGNtbW0MAKurq9OpExkZyeRyObcvl8tZVFQUt5+Tk8PEYjEbGhpijDH28ssvs3379un0kZeXx+zs7EaNgTHGkpKSGI/HYxYWFkwgEDAADADLzMwcsw1jjL311lts1apVY8Y6fG6JRKJzDf766y8mFApZRUXFuP0TQgwXPVNGiJEKCAjAJ598wu1bWFgA+GfVaP/+/bhy5Qq6u7sxODiIvr4+3Lt3D9OnTx/Rz44dO7Bx40bk5eVxt+BcXFwA/HNrs6GhAfn5+Vx9xhi0Wi3a2trg5uY2amxdXV2YMWMGtFot+vr68OKLL+Lo0aPo7u7GrVu34Ofnp1Pfz88P9fX1AP659fjKK69AIpFAJpNh2bJlePXVVx/qWoWHh2PTpk34+OOPYW5ujvz8fLzxxhvg8XjcOJVKpc7K2NDQ0LjXDQAkEglKS0vR19eHL774AiqVClu3btWpc+TIERw7dgw3btxAb28v+vv74enpOW689fX1aGlpgUgk0inv6+tDa2vrBK4AIcQQUFJGiJGysLDA3Llzdco0Gg2WLVuGLVu2IDU1FdbW1qipqUF0dDT6+/tHTS6Sk5Oxdu1alJWV4fTp00hKSkJBQQFWrlyJnp4ebN68GfHx8SPaOTo6jhmbSCTCzz//DB6PBzs7OwiFQgBAd3f3f45LKpWira0Np0+fRmVlJUJDQ7F06VKcPHnyP9uOZfny5WCMoaysDD4+PqiursahQ4e44z09PUhJSUFISMiItgKBYMx++Xw+NwdpaWl47bXXkJKSgr179wIACgoKsHPnTmRkZMDX1xcikQgfffQRfvzxx3Hj7enpgZeXl04yPMxQfsxBCNEfJWWEPEEuXboErVaLjIwMbhVo+Pml8bi6usLV1RXbt2/Hm2++idzcXKxcuRJSqRSNjY0jkr//wuPxRm1jaWkJsVgMpVIJf39/rlypVGLhwoU69cLCwhAWFobVq1dDJpOhs7MT1tbWOv0NP781NDQ0bjwCgQAhISHIz89HS0sLJBIJpFIpd1wqlUKtVus9zvvt3r0bgYGB2LJlCzfOxYsXIzY2lqtz/0oXn88fEb9UKkVhYSFsbGxgaWn5UDERQgwHPehPyBNk7ty5GBgYwOHDh3Ht2jXk5eXh008/HbN+b28v4uLiUFVVhevXr0OpVKK2tpa7Lfnuu+/iwoULiIuLg0qlwtWrV1FSUqL3g/7/tmvXLhw4cACFhYVQq9VISEiASqXCtm3bAACZmZk4ceIErly5gubmZhQXF8PW1nbUF97a2NhAKBSivLwcv/32G7q6usY8b3h4OMrKynDs2DHuAf9hiYmJ+Pzzz5GSkoLLly+jqakJBQUF2L17t15j8/X1hYeHB/bt2wcAmDdvHi5evIiKigo0Nzdjz549qK2t1Wkze/ZsNDQ0QK1W448//sDAwADCw8Px9NNPQy6Xo7q6Gm1tbaiqqkJ8fDx+/fVXvWIihBgOSsoIeYI8//zzyMzMxIEDB/Dcc88hPz9f53US9zM1NUVHRwfWrVsHV1dXhIaGIjg4GCkpKQAADw8PfPfdd2hubsaSJUuwYMECJCYmQiwWTzjG+Ph47NixA2+//Tbc3d1RXl6O0tJSzJs3D8A/tz4PHjwIb29v+Pj4QKPR4JtvvuFW/v7NzMwM2dnZyMnJgVgshlwuH/O8gYGBsLa2hlqtxtq1a3WOBQUF4dSpUzhz5gx8fHzwwgsv4NChQ3ByctJ7fNu3b8fRo0dx8+ZNbN68GSEhIQgLC8OiRYvQ0dGhs2oGAJs2bYJEIoG3tzdmzZoFpVKJ6dOn4/vvv4ejoyNCQkLg5uaG6Oho9PX10coZIf9jJowxNtVBEEIIIYQ86WiljBBCCCHEAFBSRgghhBBiACgpI4QQQggxAJSUEUIIIYQYAErKCCGEEEIMACVlhBBCCCEGgJIyQgghhBADQEkZIYQQQogBoKSMEEIIIcQAUFJGCCGEEGIAKCkjhBBCCDEAlJQRQgghhBiAvwEwTGE75yPrdQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1665,14 +1911,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.3807559013366699\n", - "lead_lag: True inv_rest: False thres_distance: 32000 auc: 0.7777777777777778\n", - "fit_time: 1.74491286277771\n" + "compute_auc_time: 259.4003691673279\n", + "lead_lag: True inv_rest: False thres_distance: 32000 auc: 0.8419117000000002\n", + "Threshold distance: 4000\n", + "lead_lag: False\n", + "inv_reset: True\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 12.511054992675781\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1684,14 +1936,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.2918431758880615\n", - "lead_lag: False inv_rest: True thres_distance: 4000 auc: 0.8155555555555556\n", - "fit_time: 1.770664930343628\n" + "compute_auc_time: 38.976033210754395\n", + "lead_lag: False inv_rest: True thres_distance: 4000 auc: 0.57581702\n", + "Threshold distance: 8000\n", + "lead_lag: False\n", + "inv_reset: True\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 12.427032232284546\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1703,14 +1961,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.3539090156555176\n", - "lead_lag: False inv_rest: True thres_distance: 8000 auc: 0.7488888888888889\n", - "fit_time: 1.9913699626922607\n" + "compute_auc_time: 39.384063959121704\n", + "lead_lag: False inv_rest: True thres_distance: 8000 auc: 0.48937509999999995\n", + "Threshold distance: 16000\n", + "lead_lag: False\n", + "inv_reset: True\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 12.668967962265015\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1722,14 +1986,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.35626983642578125\n", - "lead_lag: False inv_rest: True thres_distance: 16000 auc: 0.7622222222222222\n", - "fit_time: 1.7985730171203613\n" + "compute_auc_time: 32.15404915809631\n", + "lead_lag: False inv_rest: True thres_distance: 16000 auc: 0.78722396\n", + "Threshold distance: 32000\n", + "lead_lag: False\n", + "inv_reset: True\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 12.898165941238403\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1741,32 +2011,110 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 0.2609882354736328\n", - "lead_lag: False inv_rest: True thres_distance: 32000 auc: 0.7511111111111111\n" + "compute_auc_time: 32.97649002075195\n", + "lead_lag: False inv_rest: True thres_distance: 32000 auc: 0.78283068\n", + "Threshold distance: 4000\n", + "lead_lag: False\n", + "inv_reset: False\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 8.701767206192017\n" ] }, { - "ename": "IndexError", - "evalue": "list index out of range", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m:25\u001b[0m\n", - "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:135\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature_transform \u001b[39m=\u001b[39m SignatureTransformer(\n\u001b[1;32m 131\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39msignature_kwargs,\n\u001b[1;32m 132\u001b[0m )\n\u001b[1;32m 134\u001b[0m \u001b[39m# compute signatures\u001b[39;00m\n\u001b[0;32m--> 135\u001b[0m sigs \u001b[39m=\u001b[39m Parallel(n_jobs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_jobs)(\n\u001b[1;32m 136\u001b[0m delayed(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_transform\u001b[39m.\u001b[39;49mfit_transform)(X_train[i])\n\u001b[1;32m 137\u001b[0m \u001b[39mfor\u001b[39;49;00m i \u001b[39min\u001b[39;49;00m \u001b[39mrange\u001b[39;49m(\u001b[39mlen\u001b[39;49m(X_train))\n\u001b[1;32m 138\u001b[0m )\n\u001b[1;32m 139\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignatures_train \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(pd\u001b[39m.\u001b[39mconcat(sigs))\n\u001b[1;32m 140\u001b[0m \u001b[39melse\u001b[39;00m:\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1863\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1861\u001b[0m output \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m 1862\u001b[0m \u001b[39mnext\u001b[39m(output)\n\u001b[0;32m-> 1863\u001b[0m \u001b[39mreturn\u001b[39;00m output \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mreturn_generator \u001b[39melse\u001b[39;00m \u001b[39mlist\u001b[39;49m(output)\n\u001b[1;32m 1865\u001b[0m \u001b[39m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m 1866\u001b[0m \u001b[39m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m 1867\u001b[0m \u001b[39m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m 1868\u001b[0m \u001b[39m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m 1869\u001b[0m \u001b[39m# callback.\u001b[39;00m\n\u001b[1;32m 1870\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1792\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1790\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_batches \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 1791\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m-> 1792\u001b[0m res \u001b[39m=\u001b[39m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1793\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_completed_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 1794\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprint_progress()\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:669\u001b[0m, in \u001b[0;36mBaseTransformer.fit_transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 604\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Fit to data, then transform it.\u001b[39;00m\n\u001b[1;32m 605\u001b[0m \n\u001b[1;32m 606\u001b[0m \u001b[39mFits the transformer to X and y and returns a transformed version of X.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 665\u001b[0m \u001b[39m Example: i-th instance of the output is the i-th window running over `X`\u001b[39;00m\n\u001b[1;32m 666\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 667\u001b[0m \u001b[39m# Non-optimized default implementation; override when a better\u001b[39;00m\n\u001b[1;32m 668\u001b[0m \u001b[39m# method is possible for a given algorithm.\u001b[39;00m\n\u001b[0;32m--> 669\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfit(X, y)\u001b[39m.\u001b[39mtransform(X, y)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:486\u001b[0m, in \u001b[0;36mBaseTransformer.fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 484\u001b[0m \u001b[39m# we call the ordinary _fit if no looping/vectorization needed\u001b[39;00m\n\u001b[1;32m 485\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m vectorization_needed:\n\u001b[0;32m--> 486\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fit(X\u001b[39m=\u001b[39;49mX_inner, y\u001b[39m=\u001b[39;49my_inner)\n\u001b[1;32m 487\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 488\u001b[0m \u001b[39m# otherwise we call the vectorized version of fit\u001b[39;00m\n\u001b[1;32m 489\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_vectorize(\u001b[39m\"\u001b[39m\u001b[39mfit\u001b[39m\u001b[39m\"\u001b[39m, X\u001b[39m=\u001b[39mX_inner, y\u001b[39m=\u001b[39my_inner)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_signature_method.py:100\u001b[0m, in \u001b[0;36mSignatureTransformer._fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_fit\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[0;32m--> 100\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_method\u001b[39m.\u001b[39;49mfit(X)\n\u001b[1;32m 101\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/base.py:1152\u001b[0m, in \u001b[0;36m_fit_context..decorator..wrapper\u001b[0;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1145\u001b[0m estimator\u001b[39m.\u001b[39m_validate_params()\n\u001b[1;32m 1147\u001b[0m \u001b[39mwith\u001b[39;00m config_context(\n\u001b[1;32m 1148\u001b[0m skip_parameter_validation\u001b[39m=\u001b[39m(\n\u001b[1;32m 1149\u001b[0m prefer_skip_nested_validation \u001b[39mor\u001b[39;00m global_skip_validation\n\u001b[1;32m 1150\u001b[0m )\n\u001b[1;32m 1151\u001b[0m ):\n\u001b[0;32m-> 1152\u001b[0m \u001b[39mreturn\u001b[39;00m fit_method(estimator, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:423\u001b[0m, in \u001b[0;36mPipeline.fit\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Fit the model.\u001b[39;00m\n\u001b[1;32m 398\u001b[0m \n\u001b[1;32m 399\u001b[0m \u001b[39mFit all the transformers one after the other and transform the\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[39m Pipeline with fitted steps.\u001b[39;00m\n\u001b[1;32m 421\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 422\u001b[0m fit_params_steps \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_fit_params(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mfit_params)\n\u001b[0;32m--> 423\u001b[0m Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fit(X, y, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mfit_params_steps)\n\u001b[1;32m 424\u001b[0m \u001b[39mwith\u001b[39;00m _print_elapsed_time(\u001b[39m\"\u001b[39m\u001b[39mPipeline\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_log_message(\u001b[39mlen\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msteps) \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m)):\n\u001b[1;32m 425\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_final_estimator \u001b[39m!=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m\"\u001b[39m:\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:357\u001b[0m, in \u001b[0;36mPipeline._fit\u001b[0;34m(self, X, y, **fit_params_steps)\u001b[0m\n\u001b[1;32m 354\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_fit\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mfit_params_steps):\n\u001b[1;32m 355\u001b[0m \u001b[39m# shallow copy of steps - this should really be steps_\u001b[39;00m\n\u001b[1;32m 356\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msteps \u001b[39m=\u001b[39m \u001b[39mlist\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msteps)\n\u001b[0;32m--> 357\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_validate_steps()\n\u001b[1;32m 358\u001b[0m \u001b[39m# Setup the memory\u001b[39;00m\n\u001b[1;32m 359\u001b[0m memory \u001b[39m=\u001b[39m check_memory(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmemory)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:238\u001b[0m, in \u001b[0;36mPipeline._validate_steps\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[39mif\u001b[39;00m t \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mor\u001b[39;00m t \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m 237\u001b[0m \u001b[39mcontinue\u001b[39;00m\n\u001b[0;32m--> 238\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mhasattr\u001b[39m(t, \u001b[39m\"\u001b[39m\u001b[39mfit\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39mor\u001b[39;00m \u001b[39mhasattr\u001b[39m(t, \u001b[39m\"\u001b[39m\u001b[39mfit_transform\u001b[39m\u001b[39m\"\u001b[39m)) \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mhasattr\u001b[39;49m(\n\u001b[1;32m 239\u001b[0m t, \u001b[39m\"\u001b[39;49m\u001b[39mtransform\u001b[39;49m\u001b[39m\"\u001b[39;49m\n\u001b[1;32m 240\u001b[0m ):\n\u001b[1;32m 241\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\n\u001b[1;32m 242\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mAll intermediate steps should be \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 243\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mtransformers and implement fit and transform \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 244\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mor be the string \u001b[39m\u001b[39m'\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m'\u001b[39m\u001b[39m \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 245\u001b[0m \u001b[39m\"\u001b[39m\u001b[39m'\u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m (type \u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m%\u001b[39m (t, \u001b[39mtype\u001b[39m(t))\n\u001b[1;32m 246\u001b[0m )\n\u001b[1;32m 248\u001b[0m \u001b[39m# We allow last estimator to be None as an identity transformation\u001b[39;00m\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/utils/_available_if.py:31\u001b[0m, in \u001b[0;36m_AvailableIfDescriptor.__get__\u001b[0;34m(self, obj, owner)\u001b[0m\n\u001b[1;32m 25\u001b[0m attr_err \u001b[39m=\u001b[39m \u001b[39mAttributeError\u001b[39;00m(\n\u001b[1;32m 26\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mThis \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mrepr\u001b[39m(owner\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m)\u001b[39m}\u001b[39;00m\u001b[39m has no attribute \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mrepr\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mattribute_name)\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[1;32m 27\u001b[0m )\n\u001b[1;32m 28\u001b[0m \u001b[39mif\u001b[39;00m obj \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 29\u001b[0m \u001b[39m# delegate only on instances, not the classes.\u001b[39;00m\n\u001b[1;32m 30\u001b[0m \u001b[39m# this is to allow access to the docstrings.\u001b[39;00m\n\u001b[0;32m---> 31\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcheck(obj):\n\u001b[1;32m 32\u001b[0m \u001b[39mraise\u001b[39;00m attr_err\n\u001b[1;32m 33\u001b[0m out \u001b[39m=\u001b[39m MethodType(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfn, obj)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:667\u001b[0m, in \u001b[0;36mPipeline._can_transform\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 666\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_can_transform\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m--> 667\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_final_estimator \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mor\u001b[39;00m \u001b[39mhasattr\u001b[39m(\n\u001b[1;32m 668\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_final_estimator, \u001b[39m\"\u001b[39m\u001b[39mtransform\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 669\u001b[0m )\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:321\u001b[0m, in \u001b[0;36mPipeline._final_estimator\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[39m@property\u001b[39m\n\u001b[1;32m 319\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_final_estimator\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 320\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 321\u001b[0m estimator \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msteps[\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m][\u001b[39m1\u001b[39m]\n\u001b[1;32m 322\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mif\u001b[39;00m estimator \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m estimator\n\u001b[1;32m 323\u001b[0m \u001b[39mexcept\u001b[39;00m (\u001b[39mValueError\u001b[39;00m, \u001b[39mAttributeError\u001b[39;00m, \u001b[39mTypeError\u001b[39;00m):\n\u001b[1;32m 324\u001b[0m \u001b[39m# This condition happens when a call to a method is first calling\u001b[39;00m\n\u001b[1;32m 325\u001b[0m \u001b[39m# `_available_if` and `fit` did not validate `steps` yet. We\u001b[39;00m\n\u001b[1;32m 326\u001b[0m \u001b[39m# return `None` and an `InvalidParameterError` will be raised\u001b[39;00m\n\u001b[1;32m 327\u001b[0m \u001b[39m# right after.\u001b[39;00m\n", - "\u001b[0;31mIndexError\u001b[0m: list index out of range" + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 17.6672580242157\n", + "lead_lag: False inv_rest: False thres_distance: 4000 auc: 0.80501948\n", + "Threshold distance: 8000\n", + "lead_lag: False\n", + "inv_reset: False\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 8.961244106292725\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 18.04946804046631\n", + "lead_lag: False inv_rest: False thres_distance: 8000 auc: 0.80946924\n", + "Threshold distance: 16000\n", + "lead_lag: False\n", + "inv_reset: False\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 9.036370038986206\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmgAAAHcCAYAAABiXFa3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACcmElEQVR4nOzdd1hTZxsG8BuQKTIUAUUU917FUfesuOvGjVvr1rr3qlatq866q7V1+7n3qHvvvfcCFVBk5/3+eEtCJGCCwAnk/l1XrpxzcnLykJNwnrzTTAghQERERERGw1zpAIiIiIhIGxM0IiIiIiPDBI2IiIjIyDBBIyIiIjIyTNCIiIiIjAwTNCIiIiIjwwSNiIiIyMgwQSMiIiIyMkzQiIiIiIwMEzSib+Dl5YUOHTooHYbJqVq1KqpWrap0GF81btw4mJmZISAgQOlQjI6ZmRnGjRuXJMd6/PgxzMzMsHLlyiQ5HpExYIJGRmvlypUwMzNT39KlSwcPDw906NABL168UDo8oxYSEoKJEyeiWLFisLOzg6OjIypVqoRVq1YhtczudvPmTYwbNw6PHz9WOpQ4oqOjsWLFClStWhUZM2aEtbU1vLy80LFjR5w/f17p8JLE33//jdmzZysdhhZjjIkouaRTOgCir5kwYQJy5syJsLAwnD59GitXrsTx48dx/fp12NjYKBrbnTt3YG5uXL9z3rx5gxo1auDWrVto2bIlevfujbCwMGzatAl+fn7YtWsX1qxZAwsLC6VDTdDNmzcxfvx4VK1aFV5eXlqP7du3T5mgAISGhqJJkybYs2cPKleujBEjRiBjxox4/Pgx1q9fjz///BNPnz5FtmzZFIsxKfz999+4fv06+vfvnyzHDw0NRbp0hl2C4ospR44cCA0NhaWlZRJGSKQsJmhk9OrUqYNSpUoBALp06QIXFxdMnToV27ZtQ4sWLRSNzdraOsVfMywsDFZWVvEmhn5+frh16xa2bNmChg0bqrf37dsXgwcPxm+//YaSJUti6NChKRUyAFmqlz59+iQ5lpWVVZIcJzEGDx6MPXv2YNasWXEShbFjx2LWrFkpGo8QAmFhYbC1tU3R100MlUqFiIgI2NjYJOmPKzMzM8V/rBElOUFkpFasWCEAiHPnzmlt37FjhwAgJk+erLX91q1bomnTpsLZ2VlYW1sLb29vsXXr1jjH/fDhg+jfv7/IkSOHsLKyEh4eHqJdu3bC399fvU9YWJgYM2aMyJ07t7CyshLZsmUTgwcPFmFhYVrHypEjh/Dz8xNCCHHu3DkBQKxcuTLOa+7Zs0cAENu3b1dve/78uejYsaNwdXUVVlZWolChQmLZsmVazzt8+LAAIP755x8xcuRIkTVrVmFmZiY+fPig8z07deqUACA6deqk8/HIyEiRN29e4ezsLD5//iyEEOLRo0cCgJg+fbqYOXOmyJ49u7CxsRGVK1cW165di3MMfd7nmHN35MgR8dNPP4nMmTMLJycnIYQQjx8/Fj/99JPIly+fsLGxERkzZhTNmjUTjx49ivP8L2+HDx8WQghRpUoVUaVKlTjv07p168SkSZOEh4eHsLa2FtWrVxf37t2L8zfMmzdP5MyZU9jY2IjSpUuLo0ePxjmmLs+ePRPp0qUTP/zwQ4L7xRg7dqwAIO7duyf8/PyEo6OjcHBwEB06dBAhISFa+y5fvlxUq1ZNZM6cWVhZWYmCBQuKBQsWxDlmjhw5RL169cSePXuEt7e3sLa2FrNmzTLoGEIIsWvXLlG5cmVhb28vMmTIIEqVKiXWrFkjhJDv75fvfY4cOdTP1ff7AUD06tVL/PXXX6JQoUIiXbp0YsuWLerHxo4dq943ODhY9OvXT/29zJw5s6hZs6a4cOHCV2OK+QyvWLFC6/Vv3bolmjdvLlxcXISNjY3Ily+fGDFiREKnjMhosASNUp2YNknOzs7qbTdu3ECFChXg4eGBYcOGIX369Fi/fj0aNWqETZs2oXHjxgCAT58+oVKlSrh16xY6deqE7777DgEBAdi2bRueP38OFxcXqFQqNGzYEMePH0e3bt1QsGBBXLt2DbNmzcLdu3fxv//9T2dcpUqVQq5cubB+/Xr4+flpPbZu3To4OzvDx8cHgKyG/P7772FmZobevXsjc+bM2L17Nzp37ozg4OA4JTMTJ06ElZUVBg0ahPDw8HhLkLZv3w4AaN++vc7H06VLh9atW2P8+PE4ceIEatasqX5s1apV+PjxI3r16oWwsDDMmTMH1atXx7Vr1+Dm5mbQ+xyjZ8+eyJw5M8aMGYOQkBAAwLlz53Dy5Em0bNkS2bJlw+PHj7Fw4UJUrVoVN2/ehJ2dHSpXroy+ffvi999/x4gRI1CwYEEAUN/H59dff4W5uTkGDRqEoKAgTJs2DW3atMGZM2fU+yxcuBC9e/dGpUqVMGDAADx+/BiNGjWCs7PzV6sld+/ejaioKLRr1y7B/b7UokUL5MyZE1OmTMHFixexdOlSuLq6YurUqVpxFS5cGA0bNkS6dOmwfft29OzZEyqVCr169dI63p07d9CqVSt0794dXbt2Rf78+Q06xsqVK9GpUycULlwYw4cPh5OTEy5duoQ9e/agdevWGDlyJIKCgvD8+XN1iaC9vT0AGPz9OHToENavX4/evXvDxcUlTnV1jB49emDjxo3o3bs3ChUqhHfv3uH48eO4desWvvvuuwRj0uXq1auoVKkSLC0t0a1bN3h5eeHBgwfYvn07fvnlF/1OHJGSlM4QieITU4py4MAB4e/vL549eyY2btwoMmfOLKytrcWzZ8/U+9aoUUMULVpU6xe8SqUS5cuXF3nz5lVvGzNmjAAgNm/eHOf1VCqVEEKI1atXC3Nzc3Hs2DGtxxctWiQAiBMnTqi3xS5BE0KI4cOHC0tLS/H+/Xv1tvDwcOHk5KRVqtW5c2eRJUsWERAQoPUaLVu2FI6OjurSrZiSoVy5cqm3JaRRo0YCQLwlbEIIsXnzZgFA/P7770IITemDra2teP78uXq/M2fOCABiwIAB6m36vs8x565ixYoiKipK6/V1/R0xJX+rVq1Sb9uwYYNWqVls8ZWgFSxYUISHh6u3z5kzRwBQlwSGh4eLTJkyidKlS4vIyEj1fitXrhQAvlqCNmDAAAFAXLp0KcH9YsSUoH1Zotm4cWORKVMmrW263hcfHx+RK1curW05cuQQAMSePXvi7K/PMQIDA0WGDBlE2bJlRWhoqNa+Md8BIYSoV6+eVqlZDEO+HwCEubm5uHHjRpzj4IsSNEdHR9GrV684+8UWX0y6StAqV64sMmTIIJ48eRLv30hkzIyrdTORDjVr1kTmzJnh6emJZs2aIX369Ni2bZu6tOP9+/c4dOgQWrRogY8fPyIgIAABAQF49+4dfHx8cO/ePXWvz02bNqF48eJxSnoA2Y4FADZs2ICCBQuiQIEC6mMFBASgevXqAIDDhw/HG6uvry8iIyOxefNm9bZ9+/YhMDAQvr6+AGSboU2bNqFBgwYQQmi9ho+PD4KCgnDx4kWt4/r5+enVxujjx48AgAwZMsS7T8xjwcHBWtsbNWoEDw8P9XqZMmVQtmxZ7Nq1C4Bh73OMrl27xumMEPvviIyMxLt375AnTx44OTnF+bsN1bFjR63SxUqVKgEAHj58CAA4f/483r17h65du2o1UG/Tpo1WiWx8Yt6zhN5fXXr06KG1XqlSJbx7907rHMR+X4KCghAQEIAqVarg4cOHCAoK0np+zpw51aWxselzjP379+Pjx48YNmxYnHZbMd+BhBj6/ahSpQoKFSr01eM6OTnhzJkzePny5Vf3/Rp/f38cPXoUnTp1Qvbs2bUe0+dvJDIGrOIkozd//nzky5cPQUFBWL58OY4eParVOP/+/fsQQmD06NEYPXq0zmO8ffsWHh4eePDgAZo2bZrg6927dw+3bt1C5syZ4z1WfIoXL44CBQpg3bp16Ny5MwBZveni4qK+gPn7+yMwMBCLFy/G4sWL9XqNnDlzJhhzjJjE4ePHj3ByctK5T3xJXN68eePsmy9fPqxfvx6AYe9zQnGHhoZiypQpWLFiBV68eKE17MeXiYihvrwYxyRdHz58AAA8efIEAJAnTx6t/dKlSxdv1VtsDg4OADTvYVLEFXPMEydOYOzYsTh16hQ+f/6stX9QUBAcHR3V6/F9HvQ5xoMHDwAARYoUMehviGHo90Pfz+60adPg5+cHT09PeHt7o27dumjfvj1y5cplcIwxCXli/0YiY8AEjYxemTJl1L04GzVqhIoVK6J169a4c+cO7O3toVKpAACDBg3SWaoAxL0gJ0SlUqFo0aKYOXOmzsc9PT0TfL6vry9++eUXBAQEIEOGDNi2bRtatWqlLrGJibdt27Zx2qrFKFasmNa6vj30ChYsiP/973+4evUqKleurHOfq1evAoBepRqxJeZ91hV3nz59sGLFCvTv3x/lypWDo6MjzMzM0LJlS/VrJFZ8Q4eIJBr7rUCBAgCAa9euoUSJEno/72txPXjwADVq1ECBAgUwc+ZMeHp6wsrKCrt27cKsWbPivC+63ldDj5FYhn4/9P3stmjRApUqVcKWLVuwb98+TJ8+HVOnTsXmzZtRp06db46bKLVhgkapioWFBaZMmYJq1aph3rx5GDZsmPoXtqWlpVajd11y586N69evf3WfK1euoEaNGomqDvH19cX48eOxadMmuLm5ITg4GC1btlQ/njlzZmTIkAHR0dFfjddQ9evXx5QpU7Bq1SqdCVp0dDT+/vtvODs7o0KFClqP3bt3L87+d+/eVZcsGfI+J2Tjxo3w8/PDjBkz1NvCwsIQGBiotV9yVEXlyJEDgCwNrFatmnp7VFQUHj9+HCcx/lKdOnVgYWGBv/76y+COAgnZvn07wsPDsW3bNq3StoSq0xN7jNy5cwMArl+/nuAPl/je/2/9fiQkS5Ys6NmzJ3r27Im3b9/iu+++wy+//KJO0PR9vZjP6te+60TGjG3QKNWpWrUqypQpg9mzZyMsLAyurq6oWrUq/vjjD7x69SrO/v7+/urlpk2b4sqVK9iyZUuc/WJKM1q0aIEXL15gyZIlcfYJDQ1V90aMT8GCBVG0aFGsW7cO69atQ5YsWbSSJQsLCzRt2hSbNm3SeQGJHa+hypcvj5o1a2LFihXYsWNHnMdHjhyJu3fvYsiQIXFKNv73v/9ptSE7e/Yszpw5o744GvI+J8TCwiJOidbcuXMRHR2ttS1mzLQvE7dvUapUKWTKlAlLlixBVFSUevuaNWvU1aAJ8fT0RNeuXbFv3z7MnTs3zuMqlQozZszA8+fPDYorpoTty+reFStWJPkxatWqhQwZMmDKlCkICwvTeiz2c9OnT6+zyvlbvx+6REdHx3ktV1dXZM2aFeHh4V+N6UuZM2dG5cqVsXz5cjx9+lTrsaQqTSVKbixBo1Rp8ODBaN68OVauXIkePXpg/vz5qFixIooWLYquXbsiV65cePPmDU6dOoXnz5/jypUr6udt3LgRzZs3R6dOneDt7Y33799j27ZtWLRoEYoXL4527dph/fr16NGjBw4fPowKFSogOjoat2/fxvr167F37151lWt8fH19MWbMGNjY2KBz585xBpX99ddfcfjwYZQtWxZdu3ZFoUKF8P79e1y8eBEHDhzA+/fvE/3erFq1CjVq1MCPP/6I1q1bo1KlSggPD8fmzZtx5MgR+Pr6YvDgwXGelydPHlSsWBE//fQTwsPDMXv2bGTKlAlDhgxR76Pv+5yQ+vXrY/Xq1XB0dEShQoVw6tQpHDhwAJkyZdLar0SJErCwsMDUqVMRFBQEa2trVK9eHa6urol+b6ysrDBu3Dj06dMH1atXR4sWLfD48WOsXLkSuXPn1quEZsaMGXjw4AH69u2LzZs3o379+nB2dsbTp0+xYcMG3L59W6vEVB+1atWClZUVGjRogO7du+PTp09YsmQJXF1ddSbD33IMBwcHzJo1C126dEHp0qXRunVrODs748qVK/j8+TP+/PNPAIC3tzfWrVuHgQMHonTp0rC3t0eDBg2S5PvxpY8fPyJbtmxo1qwZihcvDnt7exw4cADnzp3TKmmNLyZdfv/9d1SsWBHfffcdunXrhpw5c+Lx48fYuXMnLl++bFB8RIpQpO8okR7iG6hWCCGio6NF7ty5Re7cudXDODx48EC0b99euLu7C0tLS+Hh4SHq168vNm7cqPXcd+/eid69ewsPDw/1IJt+fn5aQ15ERESIqVOnisKFCwtra2vh7OwsvL29xfjx40VQUJB6vy+H2Yhx79499WCax48f1/n3vXnzRvTq1Ut4enoKS0tL4e7uLmrUqCEWL16s3idm+IgNGzYY9N59/PhRjBs3ThQuXFjY2tqKDBkyiAoVKoiVK1fGGWYg9kC1M2bMEJ6ensLa2lpUqlRJXLlyJc6x9XmfEzp3Hz58EB07dhQuLi7C3t5e+Pj4iNu3b+t8L5csWSJy5colLCws9Bqo9sv3Kb4BTH///XeRI0cOYW1tLcqUKSNOnDghvL29Re3atfV4d4WIiooSS5cuFZUqVRKOjo7C0tJS5MiRQ3Ts2FFrCI6YYTZiD4Ic+/2JPTjvtm3bRLFixYSNjY3w8vISU6dOFcuXL4+zX8xAtbroe4yYfcuXLy9sbW2Fg4ODKFOmjPjnn3/Uj3/69Em0bt1aODk5xRmoVt/vB/4bqFYXxBpmIzw8XAwePFgUL15cZMiQQaRPn14UL148ziC78cUU33m+fv26aNy4sXBychI2NjYif/78YvTo0TrjITI2ZkKwvJfIlD1+/Bg5c+bE9OnTMWjQIKXDUYRKpULmzJnRpEkTnVV3REQpjW3QiMikhIWFxWmHtGrVKrx//x5Vq1ZVJigioi+wDRoRmZTTp09jwIABaN68OTJlyoSLFy9i2bJlKFKkCJo3b650eEREAJigEZGJ8fLygqenJ37//Xe8f/8eGTNmRPv27fHrr7/GO8cpEVFKYxs0IiIiIiPDNmhERERERoYJGhEREZGRSdYE7ciRIzAzM8PGjRuT82X0lhzxjBs3Tu/pR8zMzDBu3LhEvU5M7EeOHFFv69Chg14TPFPatXLlyhT5/H2Lx48fw8zMDCtXrkzW56QWVatWTfHeoqnhc0L60XUtSCnTpk1DgQIFvjqvq9Lf35jP+/nz5xV5/dj27NkDe3v7RM0QY3CCZmZmptdNiQ8Pfd3Nmzcxbtw4PH78WOlQktXZs2fRs2dPeHt7w9LS8qsXpzdv3qB79+7w8PCAjY0NvLy80Llz5zj7vXjxAi1atICTkxMcHBzw448/4uHDhzqPuWzZMhQsWBA2NjbImzevzqmBDD0mKcfLyyve/3dfTplEacvkyZPxv//975uOEZM06LoNGzYsaQJNRsHBwZg6dSqGDh0aZ2YUpSxYsECxJHDy5Mn4/vvvkTlzZvX/+P79+8dJxGrXro08efJgypQpBr+Gwb04V69erbW+atUq7N+/P872ggUL4tatWwYHRPpbsmTJV3/JfOnmzZsYP348qlatmqZL33bt2oWlS5eiWLFiyJUrF+7evRvvvs+ePVNPHN6jRw94eHjg5cuXOHv2rNZ+nz59QrVq1RAUFIQRI0bA0tISs2bNQpUqVXD58mWtqYr++OMP9OjRA02bNsXAgQNx7Ngx9O3bF58/f8bQoUMTdUxSXokSJfDzzz/H2Z6Wen+GhoYiXTp28I9t8uTJaNasGRo1avTNx5owYQJy5sypta1IkSLffNzktnz5ckRFRaFVq1ZKh6K2YMECuLi4oEOHDin+2hcuXECJEiXQsmVLZMiQAbdu3cKSJUvUU4nFzCUMAN27d8egQYMwfvx4ZMiQQe/XMPhb2LZtW63106dPY//+/XG2A/jmBO3z58+ws7P7pmOkZZaWlkqHYLR++uknDB06FLa2tujdu3eCCVr37t2RLl06nDt3LsGEaMGCBbh37x7Onj2L0qVLAwDq1KmDIkWKYMaMGZg8eTIAeYEbOXIk6tWrp65O79q1K1QqFSZOnIhu3brB2dnZoGOScfDw8ND5vy4tsbGxUToEndLK9aBOnToGz1VqDFasWIGGDRsa7ecjpW3atCnOtnLlyqFZs2bYvn271ny8TZs2RZ8+fbBhwwZ06tRJ79dIkXJKlUqFX375BdmyZYONjQ1q1KiB+/fva+1TtWpVFClSBBcuXEDlypVhZ2eHESNGAADCw8MxduxY5MmTB9bW1vD09MSQIUMQHh6udYz9+/ejYsWKcHJygr29PfLnz68+hqHxAMCGDRvg7e0NW1tbuLi4oG3btnjx4sVX/97w8HAMGDAAmTNnRoYMGdCwYUM8f/5c7/fr+fPnaNSoEdKnTw9XV1cMGDAgzt8K6G6DtnbtWnh7eyNDhgxwcHBA0aJFMWfOHACyiD1mIM5q1arFqY7eunUr6tWrh6xZs8La2hq5c+fGxIkTER0drfUaMefq5s2bqFatGuzs7ODh4YFp06bFiTEsLAzjxo1Dvnz5YGNjgyxZsqBJkyZ48OCBeh+VSoXZs2ejcOHCsLGxgZubG7p3744PHz5oHSsoKAi3b99GUFDQV99DNzc32NrafnW/27dvY/fu3Rg8eDAyZcqEsLAwREZG6tx348aNKF26tDqRAoACBQqgRo0aWL9+vXrb4cOH8e7dO/Ts2VPr+b169UJISAh27txp8DGTy4sXL9CpUye4ubnB2toahQsXxvLly7X2iYiIwJgxY+Dt7Q1HR0ekT58elSpVwuHDh+McLzAwEB06dICjoyOcnJzg5+eHwMDAJIn16tWr6NChA3LlygUbGxu4u7ujU6dOePfuXZx9jxw5glKlSsHGxga5c+fGH3/8obO9aEBAAG7fvo3Pnz9/c3wrVqxQT+ZubW2NQoUKYeHChXo9d+7cuShcuDDs7Ozg7OyMUqVK4e+//9baR59zlRS+bIMW877dv38fHTp0gJOTExwdHdGxY0et961IkSKoVq1anOOpVCp4eHigWbNmeseQUtcDfY5lZmaGkJAQ/Pnnn+r/mbFLbG7fvo2nT5/q/bfF58mTJ+jZsyfy588PW1tbZMqUCc2bN9erOcq9e/fQtGlTuLu7w8bGBtmyZUPLli3j/K/866+/1Ne0jBkzomXLlnj27NlXj//o0SNcvXoVNWvWjPOYId/527dvo1mzZsiYMSNsbGxQqlQpbNu2TWufmKrgo0ePonv37siUKRMcHBzQvn17rWuCl5cXbty4gX///Vd9Xr5s2xkeHo6BAwcic+bMSJ8+PRo3bpyotmD6irkef/n3u7q6olixYti6datBx0uRcuxff/0V5ubmGDRoEIKCgjBt2jS0adMGZ86c0drv3bt3qFOnDlq2bIm2bdvCzc0NKpUKDRs2xPHjx9GtWzcULFgQ165dw6xZs3D37l11u4AbN26gfv36KFasGCZMmABra2vcv38fJ06cSFQ8K1euRMeOHVG6dGlMmTIFb968wZw5c3DixAlcunQJTk5O8f69Xbp0wV9//YXWrVujfPnyOHToEOrVq6fXexUaGooaNWrg6dOn6Nu3L7JmzYrVq1fj0KFDX33u/v370apVK9SoUQNTp04FIEsxT5w4gX79+qFy5cro27cvfv/9d4wYMQIFCxYEAPX9ypUrYW9vj4EDB8Le3h6HDh3CmDFjEBwcjOnTp2u91ocPH1C7dm00adIELVq0wMaNGzF06FAULVoUderUAQBER0ejfv36OHjwIFq2bIl+/frh48eP2L9/P65fv47cuXMDkCVYMe9337598ejRI8ybNw+XLl3CiRMn1CWFW7ZsQceOHbFixYokK9I+cOAAAJnQ1ahRA4cOHYKFhQV++OEHLFy4UP2FU6lUuHr1qs5fP2XKlMG+ffvw8eNHZMiQAZcuXQKAOL+Svb29YW5ujkuXLqFt27YGHTM5vHnzBt9//z3MzMzQu3dvZM6cGbt370bnzp0RHByM/v37A5BtT5YuXYpWrVqha9eu+PjxI5YtWwYfHx+cPXsWJUqUAAAIIfDjjz/i+PHj6NGjBwoWLIgtW7bAz88vSeLdv38/Hj58iI4dO8Ld3R03btzA4sWLcePGDZw+fVqdfF26dAm1a9dGlixZMH78eERHR2PChAnInDlznGPOmzcP48ePx+HDh/VquB8ZGYmAgACtbXZ2drCzs8PChQtRuHBhNGzYEOnSpcP27dvRs2dPqFQq9OrVK95jLlmyBH379kWzZs3Qr18/hIWF4erVqzhz5gxat24NQP9zlZxatGiBnDlzYsqUKbh48SKWLl0KV1dX9f8aX19fjBs3Dq9fv4a7u7v6ecePH8fLly+1ShT0kdzXA32PtXr1anTp0gVlypRBt27dAED9vwuQ/z+rVKmid7vroKCgOJ8hFxcXnDt3DidPnkTLli2RLVs2PH78GAsXLkTVqlVx8+bNeEsPIyIi4OPjg/DwcPTp0wfu7u548eIFduzYgcDAQDg6OgIAfvnlF4wePRotWrRAly5d4O/vj7lz56Jy5cpfvaadPHkSAPDdd99pbTfkO3/jxg1UqFABHh4eGDZsGNKnT4/169ejUaNG2LRpExo3bqy1f+/eveHk5IRx48bhzp07WLhwIZ48eaLuJDF79mz06dMH9vb2GDlyJAD5fzy2Pn36wNnZGWPHjsXjx48xe/Zs9O7dG+vWrVPv8+nTJ73akFpaWqrfy9h//7t37xAVFYV79+5h2LBhsLCw0Pm/xNvb2/B2jN8623qvXr1EfIc5fPiwACAKFiwowsPD1dvnzJkjAIhr166pt1WpUkUAEIsWLdI6xurVq4W5ubk4duyY1vZFixYJAOLEiRNCCCFmzZolAAh/f/94Y9U3noiICOHq6iqKFCkiQkND1fvt2LFDABBjxoxRbxs7dqzW33/58mUBQPTs2VPrtVu3bi0AiLFjx8YbnxBCzJ49WwAQ69evV28LCQkRefLkEQDE4cOH1dv9/PxEjhw51Ov9+vUTDg4OIioqKt7jb9iwIc5xYnz+/DnOtu7duws7OzsRFham3hZzrlatWqXeFh4eLtzd3UXTpk3V25YvXy4AiJkzZ8Y5rkqlEkIIcezYMQFArFmzRuvxPXv2xNm+YsUKAUCsWLEi3r9Pl4Q+o3379hUARKZMmUTt2rXFunXrxPTp04W9vb3InTu3CAkJEUII4e/vLwCICRMmxDnG/PnzBQBx+/Zt9etZWFjofL3MmTOLli1bGnzM+MS8J/r48vPXuXNnkSVLFhEQEKC1X8uWLYWjo6P68xAVFaX1fRFCiA8fPgg3NzfRqVMn9bb//e9/AoCYNm2aeltUVJSoVKmSweft0aNHcZ6j6/P5zz//CADi6NGj6m0NGjQQdnZ24sWLF+pt9+7dE+nSpYvzXsV8f3V9H76UI0cOASDOLeY91RWfj4+PyJUrl9a2KlWqiCpVqqjXf/zxR1G4cOEEX1vfcxWfb/mcxLxHsc+1EEI0btxYZMqUSb1+584dAUDMnTtXa7+ePXsKe3v7r8YYW0pcD/Q9lhBCpE+fXvj5+ek8DgCt8xmfmHOg6yaE7s/PqVOn4vyvjbmOxXxmL126JACIDRs2xPvajx8/FhYWFuKXX37R2n7t2jWRLl26ONu/NGrUKAFAfPz4UWu7Id/5GjVqiKJFi2pdS1QqlShfvrzImzevelvM++Tt7S0iIiLU26dNmyYAiK1bt6q3FS5cWOd7H3OMmjVrqq81QggxYMAAYWFhIQIDA9Xb/Pz84j0vsW+6XufVq1da+2TLlk2sW7dO53s4efJkAUC8efNG5+O6pEgVZ8eOHbUa0VaqVAkA4vRUs7a2RseOHbW2bdiwAQULFkSBAgUQEBCgvlWvXh0A1NUsMdn/1q1bv9pw/mvxnD9/Hm/fvkXPnj216tvr1auHAgUKaFVRfWnXrl0AgL59+2pt1/cX7q5du5AlSxat6gA7Ozv1L7eEODk5ISQkBPv379frtb4Uu0rw48ePCAgIQKVKlfD582fcvn1ba197e3uttjhWVlYoU6aM1jndtGkTXFxc0KdPnzivFVPasWHDBjg6OuKHH37QOr/e3t6wt7fXqkbr0KEDhBBJ2iD006dPAAB3d3fs3LkTLVq0wKBBg7BkyRI8ePBAXc0UGhoKQH5GvxTzGYnZJzQ0NN5G4zY2Nlr76XvMpCaEwKZNm9CgQQMIIbTeex8fHwQFBeHixYsAAAsLC/Xfo1Kp8P79e0RFRaFUqVLqfQD52U2XLh1++ukn9TYLCwud5z8xYn8+w8LCEBAQgO+//x4A1HFER0fjwIEDaNSoEbJmzareP0+ePOqS3djGjRsHIYTew16ULVsW+/fv17q1b98+TnwxpSRVqlTBw4cPE6yWd3JywvPnz3Hu3DmdjxtyrpJTjx49tNYrVaqEd+/eITg4GACQL18+lChRQqt0Ijo6Ghs3bkSDBg30anIQW3JfD/Q91tcIIQwatWD+/PlxPkOA9ucnMjIS7969Q548eeDk5JTg+Y0p1dm7d2+8VfWbN2+GSqVCixYttP5Wd3d35M2b96t/67t375AuXTrY29trbdf3O//+/XscOnQILVq0UF9bAgIC8O7dO/j4+ODevXtxmg9169ZNq531Tz/9hHTp0qmvsfro1q2bVrOGSpUqITo6Gk+ePFFvGzJkSJzzoes2Y8aMOMfPmDEj9u/fj+3bt2PChAlwcXFRX1O+FNPu+MvS04SkSBVn9uzZtdZjAv2yjZGHh0ecC9u9e/dw69YtndUTAPD27VsAsnh96dKl6NKlC4YNG4YaNWqgSZMmaNasWZwuwV+LJ+bk5c+fP87rFShQAMePH4/3b33y5AnMzc21isDjO1Z8z8+TJ0+ctjL6PL9nz55Yv3496tSpAw8PD9SqVQstWrRA7dq19XrtGzduYNSoUTh06JD6n26MLy8w2bJlixOjs7Mzrl69ql5/8OAB8ufPn2CPsHv37iEoKAiurq46H485v8kl5p9iixYttD4nzZs3R7t27XDy5El06dJFvZ+utoAxxeMx+9ja2iIiIkLn64WFhWntp+8xk5q/vz8CAwOxePFiLF68WOc+sd/7P//8EzNmzMDt27e12ujF7o325MkTZMmSJc4/cX0/+1/z/v17jB8/HmvXro3zuYj5fL59+xahoaHIkydPnOfr2mYoFxcXne1wAODEiRMYO3YsTp06FedCGRQUFKd6JMbQoUNx4MABlClTBnny5EGtWrXQunVrdc9iQ89Vckno/6aDgwMA+X94xIgRePHiBTw8PHDkyBG8ffsWvr6+Br9ecl8P9D1WUitTpozOTgKhoaGYMmUKVqxYgRcvXkDEmoUxoQQ/Z86cGDhwIGbOnIk1a9agUqVKaNiwIdq2bav+zN27dw9CCOTNm1fnMRLb4Uzf7/z9+/chhMDo0aMxevRoncd6+/YtPDw81Otfxmpvb48sWbIYNESUPrlHoUKFUKhQIb2PGZuVlZX6/0H9+vVRo0YNVKhQAa6urqhfv77WvjHnU9/xCIEUStAsLCx0bo/9AQR0X4xUKhWKFi2KmTNn6jyGp6en+rlHjx7F4cOHsXPnTuzZswfr1q1D9erVsW/fPq0Y9I0ntXF1dcXly5exd+9e7N69G7t378aKFSvQvn17/Pnnnwk+NzAwEFWqVIGDgwMmTJiA3Llzw8bGBhcvXsTQoUPj/ApNqvdQpVLB1dUVa9as0fl4fP88k0pMKcuXbRcsLCyQKVMm9Rc5Y8aMsLa2xqtXr+IcI2ZbzLGyZMmC6OhovH37VivxjIiIwLt379T7GXLMpBZzPtu2bRtvG7FixYoBkA2LO3TogEaNGmHw4MFwdXWFhYUFpkyZotXZI7m1aNECJ0+exODBg1GiRAnY29tDpVKhdu3aBg83k9QePHiAGjVqoECBApg5cyY8PT1hZWWFXbt2YdasWQnGV7BgQdy5cwc7duzAnj17sGnTJixYsABjxozB+PHjDTpXyUmf77yvry+GDx+ODRs2oH///li/fj0cHR31/pEYW3JfD/Q9Vkrp06cPVqxYgf79+6NcuXJwdHSEmZkZWrZs+dXP94wZM9ChQwds3boV+/btQ9++fTFlyhScPn0a2bJlg0qlgpmZGXbv3q3zPH6ZYH0pU6ZMiIqKSnSb2Jj4Bw0aBB8fH537JMUPqC/p85kNCgrSq6bCysoKGTNmTHCf8uXLI0uWLFizZk2cBC3mWuLi4vLV14ph9IPd5M6dG1euXEGNGjW+mnmam5ujRo0aqFGjBmbOnInJkydj5MiROHz4cLy/enXJkSMHAODOnTvq4u4Yd+7cUT8e33NVKpW69Cj28/R97evXr0MIofX36vt8KysrNGjQAA0aNIBKpULPnj3xxx9/YPTo0TpL5mIcOXIE7969w+bNm1G5cmX19kePHun1urrkzp0bZ86cQWRkZLy/0HLnzo0DBw6gQoUKyVZalBBvb28AiFO8HhERgYCAAHWCaG5ujqJFi+ocmfrMmTPIlSuX+h9XTKP58+fPo27duur9zp8/D5VKpX7ckGMmtZgextHR0V/9bmzcuBG5cuXC5s2btT4/Y8eO1dovR44cOHjwID59+qT1D1/fz25CPnz4gIMHD2L8+PEYM2aMevu9e/e09nN1dYWNjY3OXtm6tiWV7du3Izw8HNu2bdP61a5vNVn69Onh6+sLX19fREREoEmTJvjll18wfPhwg86V0nLmzIkyZcpg3bp16N27NzZv3oxGjRrprMZPjKS8HhhyLENKPRJr48aN8PPz06pKCwsL07sXdNGiRVG0aFGMGjUKJ0+eRIUKFbBo0SJMmjQJuXPnhhACOXPmRL58+QyOrUCBAgDk9SD2jwF9v/O5cuUCIEvq9P0M37t3T6tX8KdPn/Dq1Sut/6lJcV769ev31QIMAHp3BAkLC9NZ4vno0SO4uLgYVOhgHMMBJ6BFixZ48eIFlixZEuex0NBQhISEAJDVH1+KuRDqqkJKSKlSpeDq6opFixZpPXf37t24detWgj0yY9q5/P7771rbZ8+erddr161bFy9fvtSajurz58/xVm3E9uVwA+bm5uovU8zfETN43pdf+phfGrF/WURERGDBggV6xa1L06ZNERAQgHnz5sV5LOZ1WrRogejoaEycODHOPlFRUVpxGjLMhr6qVq2qLsGL3ZNn5cqViI6Oxg8//KDe1qxZM5w7d04robpz5w4OHTqkHr4EAKpXr46MGTPGGWJh4cKFsLOz0/r86HvMpGZhYYGmTZti06ZNuH79epzHY3dF1/XZOHPmDE6dOqX1nLp16yIqKkrr746Ojo53BgVD4/0yBiDu98rCwgI1a9bE//73P7x8+VK9/f79+9i9e3ec4ybVMBu64gsKCsKKFSu++twvv7dWVlYoVKgQhBCIjIw06FwZA19fX5w+fRrLly9HQEBAoqo345OU1wN9jwXI/5sJDR2RFMNsWFhYxPl8z507N84wR18KDg5GVFSU1raiRYvC3Nxc/bc2adIEFhYWGD9+fJzXEP/1RExIuXLlACDOj0l9v/Ourq6oWrUq/vjjD501Bro+w4sXL9ZqTrFw4UJERUVptSVN6LzoKzFt0EJCQnT+z9i0aRM+fPigswr7woUL6vdRX0ZfgtauXTusX78ePXr0wOHDh1GhQgVER0fj9u3bWL9+Pfbu3YtSpUphwoQJOHr0KOrVq4ccOXLg7du3WLBgAbJly4aKFSsa9JqWlpaYOnUqOnbsiCpVqqBVq1bqYTa8vLwwYMCAeJ9bokQJtGrVCgsWLEBQUBDKly+PgwcP6v3rvWvXrpg3bx7at2+PCxcuIEuWLFi9erVeAzR26dIF79+/R/Xq1ZEtWzY8efIEc+fORYkSJdRDaZQoUQIWFhaYOnUqgoKCYG1tjerVq6N8+fJwdnaGn58f+vbtCzMzM6xevfqbqn3bt2+PVatWYeDAgTh79iwqVaqEkJAQHDhwAD179sSPP/6IKlWqoHv37pgyZQouX76MWrVqwdLSEvfu3cOGDRswZ84cdYcJQ4bZePLkiXp2i5h/KpMmTQIgf/W1a9cOgGyIPH36dPj5+aFy5cpo164dnj59ijlz5qBSpUpo0qSJ+pg9e/bEkiVLUK9ePQwaNAiWlpaYOXMm3NzctEaXt7W1xcSJE9GrVy80b94cPj4+OHbsGP766y/88ssvWsXk+h4zOfz66684fPgwypYti65du6JQoUJ4//49Ll68iAMHDqgvcvXr18fmzZvRuHFj1KtXD48ePcKiRYtQqFAhrQaxDRo0QIUKFTBs2DA8fvwYhQoVwubNm5MkoXZwcEDlypUxbdo0REZGwsPDA/v27dNZwjtu3Djs27cPFSpUwE8//YTo6GjMmzcPRYoUweXLl7X2NXSYjfjUqlVLXXrdvXt3fPr0CUuWLIGrq6vOC9KXz3V3d0eFChXg5uaGW7duYd68eahXr566BFXfc2UMYjraDBo0CBkzZkzSUr+kvB7oeyxAlrQfOHAAM2fORNasWZEzZ06ULVsWgOHDbMSnfv36WL16NRwdHVGoUCGcOnUKBw4c+OpsIocOHULv3r3RvHlz5MuXD1FRUVi9erU6sQdkyeOkSZMwfPhwPH78GI0aNUKGDBnw6NEjbNmyBd26dcOgQYPifY1cuXKhSJEiOHDggNawQIZ85+fPn4+KFSuiaNGi6Nq1K3LlyoU3b97g1KlTeP78Oa5cuaK1f0REBGrUqIEWLVrgzp07WLBgASpWrIiGDRuq9/H29sbChQsxadIk5MmTB66urnFqvb4mMW3Q7t27h5o1a8LX1xcFChSAubk5zp8/j7/++gteXl7o16+f1v5v377F1atXExxuRye9+3vGQ59hNr7s/qurC32VKlXi7WoeEREhpk6dKgoXLiysra2Fs7Oz8Pb2FuPHjxdBQUFCCCEOHjwofvzxR5E1a1ZhZWUlsmbNKlq1aiXu3r2bqHiEEGLdunWiZMmSwtraWmTMmFG0adNGPH/+XGufL4fZEEKI0NBQ0bdvX5EpUyaRPn160aBBA/Hs2TO9htkQQognT56Ihg0bCjs7O+Hi4iL69eunHnYioWE2Nm7cKGrVqiVcXV2FlZWVyJ49u+jevbt49eqV1vGXLFkicuXKJSwsLLSOeeLECfH9998LW1tbkTVrVjFkyBCxd+/eOK8b37n6Mh4hZNfxkSNHipw5cwpLS0vh7u4umjVrJh48eKC13+LFi4W3t7ewtbUVGTJkEEWLFhVDhgwRL1++VO9jyDAbMeda101Xd+l//vlHFC9eXFhbWws3NzfRu3dvERwcHGe/Z8+eiWbNmgkHBwdhb28v6tevL+7du6czhsWLF4v8+fMLKysrkTt3bjFr1iytLt+JOeaXvmX4BCGEePPmjejVq5fw9PRUn58aNWqIxYsXq/dRqVRi8uTJIkeOHMLa2lqULFlS7NixQ+f5fvfunWjXrp1wcHAQjo6Ool27duphAL51mI3nz5+Lxo0bCycnJ+Ho6CiaN28uXr58qfPvOnjwoChZsqT6vV+6dKn4+eefhY2NjdZ+hg6zUa9evXgf37ZtmyhWrJiwsbERXl5eYurUqeqhZh49eqTe78thNv744w9RuXJlkSlTJmFtbS1y584tBg8erP7fFkOfcxWfpBhm48shK2KOGftvi1GhQgUBQHTp0kWv1/xSSlwP9D2WEELcvn1bVK5cWdja2goAWkNuxPc/5Usx79e5c+d0Pv7hwwfRsWNH4eLiIuzt7YWPj4+4ffu2yJEjh9brfTnMxsOHD0WnTp1E7ty5hY2NjciYMaOoVq2aOHDgQJzX2LRpk6hYsaJInz69SJ8+vShQoIDo1auXuHPnzlfjnzlzps7hUgz5zj948EC0b99euLu7C0tLS+Hh4SHq168vNm7cGOd9+vfff0W3bt2Es7OzsLe3F23atBHv3r3TOt7r169FvXr1RIYMGbTOQ3zv9ZfvXWL5+/uLbt26iQIFCoj06dMLKysrkTdvXtG/f3+dQ7ssXLhQ2NnZ6bymJMRMiFTeMp7IhMUM8Muv8dc1atQIN27ciNNuzRTwc0LfKigoCLly5cK0adPQuXPnZHudmM/quXPnUuWUWLqULFkSVatWxaxZswx6ntG3QSMiMtSXvbLu3buHXbt2fVM1JpEpc3R0xJAhQzB9+nTFe02nJnv27MG9e/cwfPhwg59r9G3QiCjtiIiI+Gp7KUdHx2/u0ZsrVy71vJ1PnjzBwoULYWVlhSFDhnzTcenbvH//Pt4xAgHZUD65h9ahxBs6dCiGDh2qdBipSu3ateMdvPZrmKARUYo5efKkzgm1Y0uKuVZr166Nf/75B69fv4a1tTXKlSuHyZMnxztQJ6WMJk2a4N9//4338Rw5chg0EClRWqZoG7SjR49i+vTpuHDhAl69eoUtW7agUaNGCT7nyJEjGDhwIG7cuAFPT0+MGjUqSaf+IaLk8+HDB1y4cCHBfQoXLowsWbKkUESUki5cuBBnBpnYbG1t1TMoEJk6RUvQQkJCULx4cXTq1ElrOIP4PHr0CPXq1UOPHj2wZs0aHDx4EF26dEGWLFniHZ2YiIyHs7Oz0Q+2SsknZmBoIvo6o+nFaWZm9tUStKFDh2Lnzp1agzW2bNkSgYGB2LNnTwpESURERJT8UlUbtFOnTsX59e3j44P+/fvH+5zw8HCt2QBUKhXev3+PTJkypcj0HURERPTthBD4+PEjsmbNqp70Pi1LVQna69ev40xq7ebmhuDgYISGhurs+TVlyhSMHz8+pUIkIiKiZPTs2TNky5ZN6TCSXapK0BJj+PDhGDhwoHo9KCgI2bNnx7Nnz+Dg4KBgZERERCkvPBx4/hx49AiIjARu3JD3v/6atK9jawuYm8ubhQVgZqZZ9/cHXF2BqlVlPJaWQM6cmv0sLOTN48JW2Db8AVaOdnB0DEbt2p7qKdDSulSVoLm7u+PNmzda2968eQMHB4d4x02ytraGtbV1nO0ODg5M0IiIyKiFhgKXLgEPHsgkSqUCoqLk7dEj4NQpIGNGmXC9eAG4ucnHoqPl7dEjwMpKJjuAPMYXc6vHq0ABIF06+dx06eSxypUD3r0DihUDihQB7Ow0+0REAJ6eQIkSwDcPZxcSAvTqBez4E3DvAixZguBg+ZCpNE9KVQlauXLlsGvXLq1t+/fvN3iGeCIiImMgBBAUBAQHA0uXAlu2ANevA15eMjn7okziqwIC4m6Lb2xgW1uZrHl7A+/fy8QqVy5gwgRZoqWY69eBFi2AW7dkcVv27PKNMjGKJmifPn3C/fv31euPHj3C5cuXkTFjRmTPnh3Dhw/HixcvsGrVKgBAjx49MG/ePAwZMgSdOnXCoUOHsH79euzcuVOpP4GIiCheKpUs5bp+HfjwQZZgnTghS8TSpweuXNH9vC/H67WxkVV/lSvL58WUaj1/DtjbAzEjVbm5AQ4O2iVf1tZyW2weHvIxoyIEsHw50KePzE6zZAH+/lvWg5ogRU/P+fPntUYVj2kr5ufnh5UrV+LVq1d4+vSp+vGcOXNi586dGDBgAObMmYNs2bJh6dKlHAONiIgUExwsq/8WLpQlUXv2yOrFz58NP5abG9C3r6w+9PSUpVx58hhhMpXUPn0CevQA1qyR67VqAatXy4ZqJspoxkFLKcHBwXB0dERQUBDboBERkV6EkKVh9+8Dc+bIdl1z5hh2DGdnoH59wNFRJnWFC8tbiRJA1qyyhMxkPX8u34jAQGDSJGDIEFm9GYupXb/Tek5OREQUr8+fZZVjWJisfrx+XfYw/PwZ+Pdf2RYsLEzuo4/vvgN++kmWoOXLJ2vpsmeXjekpAdmyAf/8I4sMK1ZUOhqjwASNiIjSHJUKOH9e1pxFRckmTQcPAh8/ArdvA6dPywTq7t2Ej/Pgge7tFhbA8OHy2D17yupIMkBwMNCtG9CyJRAzg9APPygakrFhgkZERKlWeLjs6fjihaxyXLdONqgPC/v6c2MnZ5kyaYaVePVKtgHLl0+WfBUsKHs15skjC3ocHZPv7zEJFy4Avr4y+z18WLY3YxFjHEzQiIjI6F2/LkddCAoC7twBrl4F9u3Tve+XyVmJEppG9m/eAHXrynG6PD2BkiVlFeQXk9RQchACmDcPGDRIjv2RIwewdi2Ts3gwQSMiIqNx7Jgc2f7aNdlGfM0aOTyFIdatAypVkkNLpE+fPHGSgQIDgc6dgc2b5XqjRnJIDWdnJaMyakzQiIhIEWFhwKFDsj3YvHn6JWI//KAZszRHDlk61r27wgOrUsICA2VR5ePH8kT99psc68yku61+HRM0IiJKdkIA48cDBw7IHpHW1rL9WHzq15e9KkuWlFMZ1asHFCqUcvFSEnJyAurUAfbulcWbpUopHVGqwASNiIiSRFSUrJrcu1e2/c6YEdi2TfeArV8mZ8WLA40by059+fKxcCXVe/dOfiBiGvfNnClPOntY6I0JGhERGezdOzlyvo0NcPGiHMJKH1ZWwO+/y4b5uXPLnpFfjEdKqd3JkzLTzpMH2L9fjkliYyNvpDcmaEREpJcnT4C5c2V7sYSqJzNnliPk58oFlC4tmx2VKgXkz89rdJqmUgHTpwMjR8qReq2t5Zgl2bIpHVmqxASNiIh02rpVthc7eTLhkfS7dpUlY02ayEHgraxSLkYyEv7+gJ8fsHu3XG/VCvjjDyBDBmXjSsWYoBERmSAhgKdP5bSHUVHAzp3yGuvoKBvnJzTRd+7cwIwZcjwx9p4kHDsmqzRfvpRFpL//DnTpwoaE34gJGhFRGvfuHbBli2aEg0ePgJAQ3fsGBcXdNny4HNKicGGgfHm2GaNYoqPlXFcvX8qpGNavB4oWVTqqNIEJGhFRGhIeLifrfvcOOH4ceP/+689Jn14mYW5ummEtLC1lVWXmzCwIoQRYWMgeInPmALNmAfb2SkeUZjBBIyJK5d6+lQ33jx+Xw1skxMcHuHxZ7l+likzAiAxy6BBw754cIRiQE5cuWaJsTGkQEzQiolRCpZKFFYcPy85xu3YlvP/EiXKkgypVgCxZUiZGSsOio4EJE+QHy8IC8PbmoLPJiAkaEZGRu3sXaNBA3n+Nry/Qtq0ciZ8oybx8CbRpAxw5Itc7dODUDsmMCRoRkZFQqeR0hbt2AQ8eyLkp//xT97516gDffScb77dsydEMKBnt3Qu0aye7+drby+EzWrdWOqo0jwkaEZHCbt8GypYFgoMT3q9lS9kO2909ZeIiwrhxchJVQM7HtX69nIuLkh0TNCIiBQgh25O1aRP/Pg0byqEtcuaUNUocc4xSnJOTvO/RQ/464FQQKYYJGhFRCvj4EXj2DNi+HRg2TPc+Y8cCAwcCDg4pGxuRlpAQOfYKAPTrJ8deqVJF2ZhMEBM0IqJk8vGjbLpz/bpsUxafjh2BpUs5ACwpLDISGDEC2LYNOH9eNmw0M2NyphAmaERESUgIYPRomZRt3Rr3cRcXICAA6NsX6N9fVl8SKe7JE9nI8fRpuf6//8lfF6QYJmhERN8oMlIWOLx/r3t4i/TpgYUL5dyVmTKlfHxECdq6VTZyDAyUk7EuXy5nvidFMUEjIkokf3+ga1fdJWWAbE/WsaMcaJ3I6EREAEOGyGmaAKBMGWDtWhbrGgkmaEREerp5U1ZNHjyo+3FnZzkEhrMzsG+fpp01kVEaOlSTnP38MzB5spyAlYwCEzQiIj2sWyeb6OhiZQVcuMCSMkplhg0D9u8HpkyRU1WQUWGCRkSkQ1AQcOmSLFi4eFH7sQEDgNq15TyXOXPKjm5ERi8sDNiyBWjVSq67uQFXr7L7sJFigkZE9B9/f3ntiq8KE5AlZd99l3IxESWJe/eAFi2Ay5flekySxuTMaPHMEJFJEwLYvVuWgrm6xk3OnJ2BvHllYiYEkzNKhf75R35wL1+W47xkzKh0RKQHlqARkUkSQk44vndv3MecnORYnRUrsvqSUrHQUDkTwJIlcr1yZeDvvwEPD2XjIr2wBI2ITEJkpGbuSzMzWbMTOzkzMwPatpVtzz58ACpVYnJGqdjt20DZsjI5MzMDRo2SxcNMzlINlqARUZokhBwcfdEiYOrUhPe9eFFON0iUZjx4AFy7Juvt16wBatZUOiIyEBM0IkoToqPluJsREbIWp2fP+PetVAkYOVLe29mlXIxEKaZePVl6Vq8ekCWL0tFQIrCKk4hStTVrZA1OunQy2XJyipucubgAK1bIJE4I4OhRwMeHyRmlITduyF8cT55otnXpwuQsFWOCRkSp0pQpmnZjX4ppO/bnnzIh8/eXUw1yRAFKc4SQc2eWLg0cPw707690RJREWMVJRKmCEMCBA7Kt89mzcR+fNQvo1EmO6m9pCVhYpHyMRCnq0yegRw9ZjAwAtWoBf/yhbEyUZJigEZFRu3MHKFAg/se3bwfq10+5eIiMwpUrcuDZu3flr5GJE+XcmiwmTjOYoBGR0Xn1CmjSBHj+XN6+1KABMG1awokbUZp17Bjwww9AeLgcNmPtWjloH6UpTNCISHGHD8trzqRJsuF+UFDcfZo3B37/HXB3T/n4iIxK6dLy14mHh2xo6eKidESUDJigEZFiVqyQ7cZii52cdewIDBokO6I5O6dsbERG5dYtIF8+WZ1pYyMbZGbMyCrNNIxnlohSjBDAunWyl6WZWdzkrGJFOTPNxYtylprly4FChZickQkTApg3DyhRAvjlF812FxcmZ2kcS9CIKNmoVHKIi7t3AT8/4NEj3fvt3Ss7oBFRLIGBQOfOwObNcv3KFfmlYmJmEniWiShZrF8va2Pc3eUczbGTM3Nz2Yzm6lU58j+TM6IvnD0r5x/bvFmOGzN7NrBxI5MzE8ISNCJKUipV/GOQ5csnrzFFi6ZsTESphhAyGRs6FIiMBHLmlO0CSpdWOjJKYUzFiShJ3LgBlCoVNzlbsUJec4SQY5oxOSNKwKNHwIgRMjlr2lQ2yGRyZpJYgkZE3yQoSM5/+SVPT+Dp0xQPhyh1y5ULmD9f9pLp2VMzbxmZHJagEVGiLVgQNzlr1ky2LWNyRqQHlQqYPh04fVqzrVMnoFcvJmcmjiVoRGSQsDDg11+B8eO1t2fLBjx7pkxMRKmSv7/s3rx7N5AjB3D9OmBvr3RUZCSYoBGRXqKjgfbtgb//jvvYtm1y+iUi0tPRo0CrVsDLl3Lg2ZEjgfTplY6KjAgTNCL6qk+fgAwZ4m6fPVsOLEtEelKpgClTgDFj5HL+/HJMmmLFlI6MjAwTNCKK49YtORzGP//I5djs7IBz5+QI/0RkgE+fgCZNgP375Xq7drIhJ6s1SQcmaESk9uQJ8NtvcmYZXdq1A1atStmYiNKM9OkBW1t5W7AA6NBB6YjIiDFBIyJcuSKn+vtS7dpAtWpAuXLA99/LAc2JyADR0XK6DFtb2StzxQrg9WsWQdNXMUEjMnEPHsRNzsqWBaZNk1M0EVEivXoFtG4NeHgAq1fLBC1jRnkj+gomaEQm7OlTIE8ezXqLFrIK09pauZiI0oR9+4C2beVQGunTAw8fArlzKx0VpSIcqJbIBM2dK6src+TQbOvTR075x+SM6BtERckhM2rXlslZsWLA+fNMzshgLEEjMiH+/kDhwvI+hqUlMHx43IFnichAz5/LKs1jx+R69+7ArFmy/RmRgZigEaVxJ08CM2cCmzbFfWz/fqBmzZSPiSjNUamAOnXkbAAZMgBLlgC+vkpHRakYqziJ0qiLFwF3d6BChbjJWfPmci5mJmdEScTcXI7cXKqU/PIxOaNvxBI0ojQkMhI4fBjo0QN49Ej7sYoV5XRMXbsCzs7KxEeUpjx9Cty+DdSqJddr1ADOnJHJGtE3YoJGlEYsWgT89FPc7b/9BgwcKHv4E1ES2bZNDjQbFSVLzGK6QzM5oyTCBI0olTt3DihTJu52V1fg/n3dc2gSUSJFRABDh8rqTAAoXRpIx0spJT3FU/358+fDy8sLNjY2KFu2LM6ePZvg/rNnz0b+/Plha2sLT09PDBgwAGFhYSkULZFx6do1bnK2ezcgBPDmDZMzoiT16JFsKxCTnA0YABw/Dnh5KRkVpVGKJmjr1q3DwIEDMXbsWFy8eBHFixeHj48P3r59q3P/v//+G8OGDcPYsWNx69YtLFu2DOvWrcOIESNSOHIiZV26JMctW7pUs23YMNmRrHZt5eIiSrM2bQJKlpRF1s7OwNatsnu0lZXSkVEapWi57MyZM9G1a1d07NgRALBo0SLs3LkTy5cvx7Bhw+Lsf/LkSVSoUAGtW7cGAHh5eaFVq1Y4c+ZMisZNpJR582Ri9qULF4Dvvkv5eIhMxsmTQFCQnJh27Voge3alI6I0TrEStIiICFy4cAE1Y/XzNzc3R82aNXHq1CmdzylfvjwuXLigrgZ9+PAhdu3ahbp168b7OuHh4QgODta6EaU2Hz7IRv5fJmeVKjE5I0o2QmiWp0wB5swB/v2XyRmlCMUStICAAERHR8PNzU1ru5ubG16/fq3zOa1bt8aECRNQsWJFWFpaInfu3KhatWqCVZxTpkyBo6Oj+ubp6ZmkfwdRcjt5Mu7cysuXy2vH0aNMzoiSxdq1QN26cuwaQFZl9u0rp94gSgGKdxIwxJEjRzB58mQsWLAAFy9exObNm7Fz505MnDgx3ucMHz4cQUFB6tuzZ89SMGKixHv6VHYCqFBBsy1rViA6GvivVQARJbXQUDlFU6tWwJ49ckYAIgUo1gbNxcUFFhYWePPmjdb2N2/ewN3dXedzRo8ejXbt2qFLly4AgKJFiyIkJATdunXDyJEjYa5j/Blra2tYc/ZnSkX27JEzxnxp0CBg+vSUj4fIZNy5A7RoAVy9KtsUjBgBdOumdFRkohQrQbOysoK3tzcOHjyo3qZSqXDw4EGUK1dO53M+f/4cJwmzsLAAAIjYbQWIUqH37+W4l18mZ40bA3v3MjkjSlZ//QV4e8vkzNVVfukmTeIYZ6QYRT95AwcOhJ+fH0qVKoUyZcpg9uzZCAkJUffqbN++PTw8PDBlyhQAQIMGDTBz5kyULFkSZcuWxf379zF69Gg0aNBAnagRpUb79gE+PtrbVq8GWrfmwOREye6XX4BRo+RytWrAmjVAlizKxkQmT9EEzdfXF/7+/hgzZgxev36NEiVKYM+ePeqOA0+fPtUqMRs1ahTMzMwwatQovHjxApkzZ0aDBg3wyy+/KPUnECWaEECRIsDNm9rbixQBduwAcuRQJi4ik9OsGTBtmpwTbdQogD/4yQiYCROrGwwODoajoyOCgoLg4OCgdDhkYoKDgfHjgbt3ZRL2pUmTgJEjUz4uIpMihKzKLF5cs+3dOyBTJuVioq8ytes3K9eJUsCnT7JZS2io7sfv3wdy507ZmIhM0qdPwE8/AX//DRw6BFSpIrczOSMjw9YtRMlICGDuXDknZuzkzNwc+PNP2Q5ZCCZnRCni6lWgVCnZIQAArl9XNh6iBLAEjSgZCCHnUx44UHu7jw+wbRun7yNKUULI8cz69gXCwwEPD+Cff+RUHERGigkaURJTqWSJ2OPHmm1eXrLErHJlpaIiMlHBwXLg2bVr5XqdOsCqVYCLi7JxEX0FqziJklB4OODpqZ2c7dwJPHrE5IxIEVu3yuTMwkL21Nyxg8kZpQosQSNKQvb2QFSUXHZwAAID5YDkRKSQtm2BS5eA5s2BeAZBJzJGLEEjSiJ372qSM0DOpcnkjCiFBQYCvXsDHz7IdTMzYOZMJmeU6rAEjSgJfP4M5M+vWY+O5gwARCnu3DnA11e2KQgI0LQ7I0qFeAkh+gbPnwM1awLp02u2bdzI5IwoRcV0m65QQSZnOXMCP/+sdFRE34SXEaJEmjdPdgg4eFCzrVIloGlT5WIiMjnv3wONGgEDBgCRkfILePEiULq00pERfRMmaESJsH070KePZr1cOeDVK+DoUeViIjI5164BJUtqBhecNw/YsAFwclI6MqJvxjZoRAY6fBho2FCz/vSpLEkjohSWNatmKo7164HvvlM6IqIkwwSNSE/h4YCNjfa2PXuYnBGlqI8f5Xg2ZmZy/szdu+WX0AQmzybTwipOIj2oVHGTswMH5NRNRJRCjh0DChYEVq7UbCtcmMkZpUlM0Ij04OysWU6XTo53VqOGcvEQmRSVCpg8GahWDXjxApg7V45lQ5SGMUEjisfbt0ChQrImJThYsz0yUs4aQ0Qp4O1boHZtYORImZS1bSt74/BLSGkc26ARfeHZMyB7dt2PPX2asrEQmbTDh4HWrYHXrwFbW9lLs2NHTtFBJoElaESxzJoVNznLkEE2fVGp2CGAKMU8eQLUqiWTs0KF5CwBnToxOSOTwQSN6D8fPgADB2rWx4yRSVlwMFCxIq8LRCkqRw5g+HBZYnb2rOwMQGRCWMVJ9J/NmzXLDx4AuXIpFwuRSTpwAPDyAvLkkevjx/OXEZkslqARQc4M06WLXHZwYHJGlKKiooBRo2SVpq+vHHQQYHJGJo0JGpm8/v0Bb2/N+oYNioVCZHpevACqVwd++UXOClC6tLwnMnGs4iSTtnUrMGeOZv2XX+SPeCJKAbt3A+3bAwEBsjfO4sVAy5ZKR0VkFJigkUn6/FleG5o102x7/Fi2SyaiZBYZKas0p02T6yVLAuvWAXnzKhsXkRFhgkYm59w5oEwZ7W0TJjA5I0oxQsgxzgCgVy/gt9/izqVGZOKYoJFJ2bIFaNJEe9vkycCwYcrEQ2RShJAN/62sZInZxYtA06ZKR0VklJigkcno0gVYtkyzvmgR0L27cvEQmYyICPkryMZG/iICgJw55Y2IdGKCRiahZEng8mXN+pEjQJUqSkVDZEIePZIN/8+elaVn7dsDBQooHRWR0WOCRmlexYraydmnT0D69IqFQ2Q6Nm+W0zMFBQFOTsDKlUzOiPTEcdAoTfv4EThxQrMeGcnkjCjZhYcDffrI9mVBQcD338tfST/+qHRkRKkGEzRKs65ckbMCxPjwAUjHMmOi5CWEHExw3jy5PmQIcPQou0kTGYgJGqU5ERHA+vVAiRKabS4usoaFiJKZmZnskZMpE7BzJzB1KmBpqXRURKkOEzRKU0JCAGtrOZ1fjK5dgbdvlYuJKM0LDQVu3dKst2sH3L0L1K2rXExEqRwTNEpTRo3SLNvaAv/8I2eP4ZzLRMnkzh3ZxqxmTcDfX7M9Y0blYiJKA5igUZoye7a8r1lTTufEaf2IktFffwHe3sDVq7IHzqNHSkdElGYwQaM0Y/FizfKIEcrFQZTmff4MdO4sqzJDQoCqVWUvzS/nUCOiRGOCRmlCSIj2rABVqyoWClHadvOmTMSWL5dtB8aOBQ4cALJmVToyojSFgw5QmmBvr1n+5x+2OSNKNlOnAjduAO7uwJo1QPXqSkdElCYxQaNUr2FD7fUWLZSJg8gk/P67HFBw8mTAzU3paIjSLFZxUqp18KAsKdu+XbNNCMCcn2qipHPtGjB4sPxyAYCjI7BsGZMzomTGEjRKdZ48Aby8tLe5usrtRJREhACWLgX69gXCwoD8+eUAtESUIljWQKnK589xk7MNG4A3bwAbG0VCIkp7goOB1q2Bbt1kclanDufRJEphLEGjVCM8XHui8yJFgHPnmJgRJalLl2RDzvv3AQsL2dZs0CC2HSBKYd+UoIWFhcGGV0dKIbE/apkzy6YxRJSEVq+W1ZgREYCnJ7B2LVC+vNJREZkkg38SqVQqTJw4ER4eHrC3t8fDhw8BAKNHj8ayZcuSPECia9fiDpvx+rUysRClaTlzAtHRQIMGcuBZJmdEijE4QZs0aRJWrlyJadOmwcrKSr29SJEiWLp0aZIGRxQUBBQrpllPl07Oy8zaFqIkEhSkWa5YETh1Cti6lXNpEinM4MvcqlWrsHjxYrRp0wYWFhbq7cWLF8ft27eTNDgybU+eAE5OmnUfH+DjR7Y5I0oSQgBz5sheNzdvaraXLs2RnomMgMEJ2osXL5AnT54421UqFSIjI5MkKKJDh7R7a1avDuzZw+SMKEm8fw80bgz07w8EBgIrVyocEBF9yeAErVChQjh27Fic7Rs3bkTJkiWTJCgyXULIZi81ami2jRsnB6UloiRw+jRQsqSsxrSyAubOldM3EZFRMbgX55gxY+Dn54cXL15ApVJh8+bNuHPnDlatWoUdO3YkR4xkQkqWBK5c0ax37y7nYiaib6RSATNnAsOHA1FRQO7cwLp1gLe30pERkQ4Gl6D9+OOP2L59Ow4cOID06dNjzJgxuHXrFrZv344ffvghOWIkEyAEUK+ednL24gWwaJFyMRGlKX/9JadsioqS45xduMDkjMiImQkRM8GaaQgODoajoyOCgoLg4OCgdDgE4N49IF8+7W0BAUCmTMrEQ5QmRUXJX0GNG8uiaXYEoFTG1K7fBpeg5cqVC+/evYuzPTAwELly5UqSoMh0nD0bNzl79ozJGdE3U6nkXJrh4XI9XTrZ06ZHDyZnRKmAwQna48ePER0dHWd7eHg4Xrx4kSRBkWlYuRIoW1az/sMPsqozWzbFQiJKG96+lfNndu0KDB2q2c7EjCjV0LuTwLZt29TLe/fuhaOjo3o9OjoaBw8ehNeXs1gTxePOHaBjR816kybA+vXKxUOUZhw5Iic6f/UKsLXVHumZiFINvRO0Ro0aAQDMzMzg5+en9ZilpSW8vLwwY8aMJA2O0qa3b4ECBTTrBw5oD6tBRIkQHQ388gswfrys3ixYENiwAShcWOnIiCgR9E7QVCoVACBnzpw4d+4cXFxcki0oStuaNtUsd+rE5Izom71+DbRpI0d4BmTx9Ny5QPr0ysZFRInGXpyU4mI3gzGtTx9RMnn4UA4iGBUlx6Zp107piIiSnKldvw0eqBYAQkJC8O+//+Lp06eIiIjQeqxv375JEhilPYGBgLOzZj1Ws0YiMpQQml87uXLJRpw5cmi3HyCiVMvgErRLly6hbt26+Pz5M0JCQpAxY0YEBATAzs4Orq6uePjwYXLFmiRMLQM3FkIA5l/0GVap2KmMKFFevADatpWzAtSqpXQ0RCnC1K7fBg+zMWDAADRo0AAfPnyAra0tTp8+jSdPnsDb2xu//fZbcsRIaYCdnWa5WjXtH/9EZIA9e4ASJWRvzZ49ZbUmEaU5Bidoly9fxs8//wxzc3NYWFggPDwcnp6emDZtGkaMGJEcMVIq17AhEBamWefE50SJEBkJDBsmxzcLCJBJ2q5dcgBaIkpzDE7QLC0tYf5fXZWrqyuePn0KAHB0dMSzZ88MDmD+/Pnw8vKCjY0NypYti7Nnzya4f2BgIHr16oUsWbLA2toa+fLlw65duwx+XUoZoaHA9u2a9Y8fWXJGZLBnz4CqVYGpU+V6z57AqVNxp+EgojTD4J9eJUuWxLlz55A3b15UqVIFY8aMQUBAAFavXo0iRYoYdKx169Zh4MCBWLRoEcqWLYvZs2fDx8cHd+7cgaura5z9IyIi8MMPP8DV1RUbN26Eh4cHnjx5AicnJ0P/DEoBwcFArPGMcfkyYG+vWDhEqdOLF7K07P17wMEBWLYMaNZM6aiIKJkZ3Eng/Pnz+PjxI6pVq4a3b9+iffv2OHnyJPLmzYtly5ahRIkSeh+rbNmyKF26NObNmwdAjrXm6emJPn36YNiwYXH2X7RoEaZPn47bt2/D0tLSkLDVTK2RoVL8/YHYObaDAxAUpFw8RKlahw7AjRvAunWyxyaRCTK167di46BFRETAzs4OGzduVM9SAAB+fn4IDAzE1q1b4zynbt26yJgxI+zs7LB161ZkzpwZrVu3xtChQ2FhYaHX65raCVZK7GpMR0fgwwdWbRLp7fFjWdwcMyD458+AhQVgba1oWERKMrXrt8Ft0OJz8eJF1K9fX+/9AwICEB0dDTc3N63tbm5ueP36tc7nPHz4EBs3bkR0dDR27dqF0aNHY8aMGZg0aVK8rxMeHo7g4GCtGyWfjRu1E7Hvv5fjnzE5I9LTli2yStPPT45FA8hu0EzOiEyKQQna3r17MWjQIIwYMUI93tnt27fRqFEjlC5dWj0dVHJRqVRwdXXF4sWL4e3tDV9fX4wcORKLFi2K9zlTpkyBo6Oj+ubp6ZmsMZoyMzOgeXPtbcePKxMLUaoTHg707Qs0aSLbA7x7x3YBRCZM7wRt2bJlqFOnDlauXImpU6fi+++/x19//YVy5crB3d0d169fN6g3pYuLCywsLPDmzRut7W/evIG7u7vO52TJkgX58uXTqs4sWLAgXr9+HWdGgxjDhw9HUFCQ+paYnqb0dePGaa83ayarNfWseSYybQ8eABUqyPkzAWDQIODYMe2pN4jIpOidoM2ZMwdTp05FQEAA1q9fj4CAACxYsADXrl3DokWLULBgQYNe2MrKCt7e3jgYa1AslUqFgwcPoly5cjqfU6FCBdy/f1+rpO7u3bvIkiULrKysdD7H2toaDg4OWjdKWlu3AuPHa9aFADZsANi5lkgP69fLeTQvXAAyZQJ27ACmTwcS2RGKiNIGvRO0Bw8eoPl/9VdNmjRBunTpMH36dGTLli3RLz5w4EAsWbIEf/75J27duoWffvoJISEh6NixIwCgffv2GD58uHr/n376Ce/fv0e/fv1w9+5d7Ny5E5MnT0avXr0SHQN9u1h9PHDtmmJhEKU+YWFyuqaPH2UJ2uXLQL16SkdFREZA73HQQkNDYffffD1mZmawtrZGlixZvunFfX194e/vjzFjxuD169coUaIE9uzZo+448PTpU/WguADg6emJvXv3YsCAAShWrBg8PDzQr18/DB069JvioMT78EGz3KULYOBQeESmzcZGDp2xZYsshuasAET0H72H2TA3N8ekSZNg/99Io0OHDsXgwYPhEtMN/D99+/ZN+iiTkKl1001upUsD58/L5dBQeb0hogT8/bccNqNLF6UjIUpVTO36rXeC5uXlBbOvjJVgZmam7t1prEztBCeniAhNz38bG5mgEVE8Pn8G+vUDli4FrKxkdaaBbXeJTJmpXb/1Lk9//PhxMoZBqVHsvhwcToMoAbduAS1aANevy/Fohg/nPJpElCA2eKBEadQIuHhRs+7trVgoRMbtzz/l5OafPwNubrKKs3p1paMiIiPHBI0MtnSpHFojxr17ysVCZLSEALp2lZObA0DNmsBff8kkjYjoK5JsqicyDXv3ymtOjGfPgDx5lIuHyGiZmcmJzc3NgYkTgT17mJwRkd5YgkZ6mzcP6NNHs372LPANw+ARpT1CyOmZYkZpHjYMqF0b+O47RcMiotSHCRp91e3bcTub/fabHGKDiP7z8SPQvbscrfnMGTnBubk5kzMiSpREVXE+ePAAo0aNQqtWrfD27VsAwO7du3Hjxo0kDY6UFxERNzmbPx8YMECZeIiM0uXLsqfMP//IHptHjyodERGlcgYnaP/++y+KFi2KM2fOYPPmzfj06RMA4MqVKxg7dmySB0jKiY4GMmbUrA8YIGtwevaUBQNEJk8IYOFC4PvvZW8ZT0+ZnNWurXRkRJTKGXyZHTZsGCZNmoT9+/drTVBevXp1nD59OkmDI+VERspZZ0JC5HqmTMDMmcrGRGRUgoIAX1/5iyU8HGjQALh0CShfXunIiCgNMDhBu3btGho3bhxnu6urKwICApIkKFJekyba6y9fKhMHkdHq3RvYsEH+kpkxQ449kymT0lERURphcILm5OSEV69exdl+6dIleHh4JElQpKwFC4AdOzTrYWFyZhoiimXKFNnu7PhxYOBAOawGEVESMThBa9myJYYOHYrXr1/DzMwMKpUKJ06cwKBBg9C+ffvkiJFS0KhRQK9emvWAAM18m0Qm7cMHOStAjGzZgHPngLJllYuJiNIsgxO0yZMno0CBAvD09MSnT59QqFAhVK5cGeXLl8eoUaOSI0ZKIU+fAr/8olk/d441NkQA5LAZJUsCHTpoT6PBUjMiSiZmQgiRmCc+ffoU169fx6dPn1CyZEnkzZs3qWNLFsHBwXB0dERQUBAcHByUDsdoCCFLyiIj5fqTJ0D27MrGRKQ4IWTvmGHDgKgoIHduYN06Tj5LpABTu34bPFDt8ePHUbFiRWTPnh3ZeQVPM6pV0yRn/fszOSPCu3eyxCymQWaLFsCSJYAJXBiISHkGV3FWr14dOXPmxIgRI3Dz5s3kiIlS2Lx5wL//atanTFEuFiKjcOIEUKKETM6sreVYZ2vXMjkjohRjcIL28uVL/Pzzz/j3339RpEgRlChRAtOnT8fz58+TIz5KZiqV9vyaHz8CNjbKxUNkFF6+BJ4/B/LmBU6fBnr0YHszIkpRBidoLi4u6N27N06cOIEHDx6gefPm+PPPP+Hl5YXq1asnR4yUjGKfsoULAXt75WIhUlTs5rjNmwMrVwIXLsiSNCKiFJboTgIxoqOjsXv3bowePRpXr15FdHR0UsWWLEytkWFCHjwA8uSRy25ustCAUziRSfr3XzmX2c6dQJYsSkdDRDqY2vU70ZfjEydOoGfPnsiSJQtat26NIkWKYOfOnUkZGyWzKlU0y0+fMjkjExQdDUycKIuSL10CxoxROiIiIgCJ6MU5fPhwrF27Fi9fvsQPP/yAOXPm4Mcff4SdnV1yxEfJZPx44MULudyjB2cKIBP0+jXQti1w8KBc79ABmD1byYiIiNQMruKsUKEC2rRpgxYtWsDFxSW54ko2plZEqktIiHZbM5WK7Z/JxBw8CLRpA7x5A9jZyQaYnAmFyKiZ2vXb4BK0EydOJEcclIIqVtQsX7nC5IxMzJYtQNOmslNAkSLA+vVAwYJKR0VEpEWvBG3btm2oU6cOLC0tsW3btgT3bdiwYZIERsljzhzg8mXNerFiioVCpIwffgDy5wcqVZJfCFtbpSMiIopDrypOc3NzvH79Gq6urjBPoCW5mZkZe3EasQ8fgIwZNeu3bgEFCigXD1GKOXdOTs8U8/8rKAhwdFQ2JiIyiKldv/Xqt6dSqeDq6qpeju9m7MmZqZs1S7N8/DiTMzIBUVHA8OFAmTJyTs0YTM6IyMgZPLDCqlWrEB4eHmd7REQEVq1alSRBUfKYPl3eFy4MVKigbCxEye7ZM6BqVeDXX+U6ZzsholTE4AStY8eOCAoKirP948eP6NixY5IERUmvTBkgLEwuL1umbCxEyW7nTjkDwIkTcv7MDRs4hAYRpSoGJ2hCCJjp6Pb3/PlzOLLawCj5+8smOIBsD12mjLLxECWbiAhg0CCgfn3g/XugVCk5AG2zZkpHRkRkEL2H2ShZsiTMzMxgZmaGGjVqIF06zVOjo6Px6NEj1K5dO1mCpG8zY4ZmOSiIw2pQGnbrFvD773K5Xz9g6lTA2lrZmIiIEkHvBK1Ro0YAgMuXL8PHxwf2sUY6tbKygpeXF5o2bZrkAdK3iYyU1ygA+P57wNJS2XiIklXx4sC8eYCrK/Df/ywiotRI7wRt7NixAAAvLy/4+vrCxsYm2YKipBO7J/Lw4crFQZQswsOBESOAdu1kmzMA6NZN0ZCIiJKCwVM9pXamNI5KUBDg5CSXPT2BJ09YvUlpyIMHgK8vcOECkC8fcP06i4iJ0jBTun4DepagZcyYEXfv3oWLiwucnZ11dhKI8f79+yQLjr5NpUqaZSZnlKZs2AB06QIEB8vRl2fOZHJGRGmKXgnarFmzkCFDBvVyQgkaGYdbt4Br1+SyhQWTM0ojwsKAgQPl5OaAHNDvn39kETERURrCKs406O1bwM1Nsx4YyIHTKQ3w9wdq1dJMJjt8ODBhApBO76a0RJSKmcL1OzaDx0G7ePEirsUUzQDYunUrGjVqhBEjRiAiIiJJg6PEadxYs9ylC5MzSiMyZgRcXIDMmYE9e4DJk5mcEVGaZXCC1r17d9y9excA8PDhQ/j6+sLOzg4bNmzAkCFDkjxAMsyaNcDJk3K5WDFg8WJl4yH6Jp8/A6GhctnCQn7AL18GfHwUDYuIKLkZnKDdvXsXJf7rzr5hwwZUqVIFf//9N1auXIlNmzYldXxkgI8fgbZtNesHD7LtGaVit24BZcsC/ftrtrm6AlmzKhYSEVFKSdRUTyqVCgBw4MAB1K1bFwDg6emJgICApI2ODDJpkmb5xg1ZG0SUKv35p5ym6fp1YOtW2f6MiMiEGJyglSpVCpMmTcLq1avx77//ol69egCAR48ewS12y3RKURERwLRpctnTEyhUSNl4iBIlJATo0EHePn8GatSQVZqZMyscGBFRyjI4QZs9ezYuXryI3r17Y+TIkciTJw8AYOPGjShfvnySB0j6iT3d4MyZysVBlGjXrwOlS8vSM3NzYOJEYO9ewN1d6ciIiFJckg2zERYWBgsLC1ga+WCRabGb7sWLgLe3XG7aFNi4Udl4iAwWEQHkzg08fy7bmP39N1ClitJREZERSYvX74Qkuo/6hQsXcOvWLQBAoUKF8N133yVZUGSYFi00yxs2KBcHUaJZWQGLFgHz58sSNFZpEpGJMzhBe/v2LXx9ffHvv//C6b+JHgMDA1GtWjWsXbsWmfmPNUW9eSOnJASAIUPYa5NSkStX5KjKP/wg1+vVA+rW5YeYiAiJaIPWp08ffPr0CTdu3MD79+/x/v17XL9+HcHBwejbt29yxEgJaN9eszx6tHJxEOlNCFlaVrasnOz86VPNY0zOiIgAJKIEbc+ePThw4AAKFiyo3laoUCHMnz8ftWrVStLgKGH16gH79snlOnUAe3tl4yH6qqAgoFs3YP16uf7DD0D69MrGRERkhAwuQVOpVDo7AlhaWqrHR6Pk9+4dsGuXZn3JEuViIdLLhQvAd9/J5CxdOmDGDGDbNiBTJqUjIyIyOgYnaNWrV0e/fv3w8uVL9bYXL15gwIABqFGjRpIGR/EbNkyzHBUFeHgoFwvRV82dC5QvDzx8COTIARw/DgwcyCpNIqJ4GJygzZs3D8HBwfDy8kLu3LmRO3du5MyZE8HBwZg7d25yxEhfqF8fWLpULru4yCkKiYzajRtyKI1GjYBLl2T7MyIiipfBbdA8PT1x8eJFHDx4UD3MRsGCBVGzZs0kD47imjkT2LlTsx4zMTqR0RFCU0I2a5YsQWvXjqVmRER6MGig2nXr1mHbtm2IiIhAjRo10KNHj+SMLVmk5oHubt8GYvXNQGgoYGOjXDxEOgkhE7L9+4EdO1jES0RJIjVfvxND7xK0hQsXolevXsibNy9sbW2xefNmPHjwANOnT0/O+CiWSpU0yxcvMjkjI/TunZxHc8cOub55M9C8uaIhERGlRnq3QZs3bx7Gjh2LO3fu4PLly/jzzz+xYMGC5IyNYpk8GQgIkMsdOwIlSyobD1EcJ0/KD+aOHXJy2IULgWbNlI6KiChV0ruK09bWFrdu3YKXlxcAOdyGra0tHj9+jCxZsiRnjEkqtRaRZsgAfPokl8PD5cw4REZBpQKmTwdGjgSio4G8eeVQGiVKKB0ZEaUhqfX6nVh6l6CFh4cjfawBJc3NzWFlZYXQ0NBkCYw0oqM1ydmmTUzOyMj07SvHfYmOBlq3luOdMTkjIvomBvXiHD16NOzs7NTrERER+OWXX+Do6KjeNnPmzKSLjgAATZtqljk6ARmdbt2Af/4Bpk0DOnViL00ioiSgd4JWuXJl3LlzR2tb+fLl8fDhQ/W6Gf8xJ4tHjzTLHJCWFBcdDZw/r/m1UKwY8PixrIcnIqIkoXeCduTIkWQMg+IjBHD1qlw+d07ZWIjw5g3Qti1w5IicDSAmSWNyRkSUpAyeSYBS1pUrmuUCBZSLgwiHDgHFiwMHDsiGkM+fKx0REVGaxQTNyMUeTsPeXrk4yIRFRwNjxwI1a8oStCJFZBVn7MaRRESUpAye6olSzuvXmuVChZSLg0zYy5dAmzayShMAunQB5swBYnUWIiKipGcUJWjz58+Hl5cXbGxsULZsWZw9e1av561duxZmZmZo1KhR8gaokNjDy124oFwcZMI2b5bJmb09sGYNsGQJkzMiohSgeIK2bt06DBw4EGPHjsXFixdRvHhx+Pj44O3btwk+7/Hjxxg0aBAqxZ7/KA3Ztk2z3LUrp3UihfTqBQwaJH8htG6tdDRERCYjUQnasWPH0LZtW5QrVw4vXrwAAKxevRrHjx83+FgzZ85E165d0bFjRxQqVAiLFi2CnZ0dli9fHu9zoqOj0aZNG4wfPx65cuVKzJ9g9H78UbP8xx/KxUEm5vlzOZfmx49y3cxMzhKQL5+iYRERmRqDE7RNmzbBx8cHtra2uHTpEsLDwwEAQUFBmDx5skHHioiIwIULF1CzZk1NQObmqFmzJk6dOhXv8yZMmABXV1d07tzZ0PBThYgIzfLChRz3k1LIzp1yBoA//wR+/lnpaIiITJrBCdqkSZOwaNEiLFmyBJaWlurtFSpUwMWLFw06VkBAAKKjo+Hm5qa13c3NDa9jt5CP5fjx41i2bBmWLFmi12uEh4cjODhY62bMPn+W80zH6NpVuVjIRERGAoMHA/XrA+/eAd7ewNChSkdFRGTSDE7Q7ty5g8qVK8fZ7ujoiMDAwKSIKV4fP35Eu3btsGTJEri4uOj1nClTpsDR0VF98/T0TNYYv9Xs2Zrlrl0BCwvFQiFT8OQJULky8Ntvcr1vX+DECSB3bmXjIiIycQYPs+Hu7o779+/Dy8tLa/vx48cNbg/m4uICCwsLvHnzRmv7mzdv4O7uHmf/Bw8e4PHjx2jQoIF6m0qlAgCkS5cOd+7cQe4vLizDhw/HwIED1evBwcFGnaSNHCnvLS2BxYuVjYXSuGPHgIYNgcBAwMkJWLECSKM9oomIUhuDS9C6du2Kfv364cyZMzAzM8PLly+xZs0aDBo0CD/99JNBx7KysoK3tzcOHjyo3qZSqXDw4EGUK1cuzv4FChTAtWvXcPnyZfWtYcOGqFatGi5fvqwz8bK2toaDg4PWzVjFrtVlEyBKdnnzyvr0smWBS5eYnBERGRGDS9CGDRsGlUqFGjVq4PPnz6hcuTKsra0xaNAg9OnTx+AABg4cCD8/P5QqVQplypTB7NmzERISgo4dOwIA2rdvDw8PD0yZMgU2NjYoUqSI1vOdnJwAIM721ChmWkNADtxOlOTevQMyZZLL7u5yjLNcueTUTUREZDQMTtDMzMwwcuRIDB48GPfv38enT59QqFAh2CdyHiJfX1/4+/tjzJgxeP36NUqUKIE9e/aoOw48ffoU5uaKD9eW7M6cAZ4+lcujRnHcM0oGGzcCnTvLunNfX7mNE7wSERklMyGEUDqIlBQcHAxHR0cEBQUZVXXnzz8DM2fK5ehowARyUkopYWHyA7ZggVyvU0cOqcHxW4goFTHW63dyMbgErVq1ajBL4B/7oUOHvikgUxWTnDVpwuSMktC9e0CLFsDly3J92DBgwgQmZ0RERs7gBK1EiRJa65GRkbh8+TKuX78OPz+/pIrLpPw31i8A4IcflIuD0ph//gG6dQM+fQJcXIDVq4HatZWOioiI9GBwgjZr1iyd28eNG4dPnz59c0Cm6NdfNctpdHIESmlXr2rmzqxcGfj7b8DDQ9mYiIhIb0nWBu3+/fsoU6YM3r9/nxSHSzbGVocdHQ2ki5Umm1aLQEpWgwcDtrbAmDHaHzIiolTI2K7fyS3J/mufOnUKNux6aLDBgzXLp08rFwelAWvWAJUqAdmzy/Vp09jWjIgolTI4QWvSpInWuhACr169wvnz5zF69OgkC8xUxK4xjj0OGpHeQkKAPn3kTADly8uxzSwtmZwREaViBidojo6OWuvm5ubInz8/JkyYgFq1aiVZYKagb1/N8rhxioVBqdmNG7KX5s2bsvuvjw+7ARMRpQEGtUGLjo7GiRMnULRoUTg7OydnXMnGmOqwra2BiAi5/PmzbC5EpBchZIlZ795AaCiQJYvsCFC1qtKRERElC2O6fqcEg35qW1hYoFatWggMDEymcEzHqVOa5GzGDCZnZICQEKB9e9nlNzRUlppdvszkjIgoDTG4LqRIkSJ4+PBhcsRiMiIjZVOhGG3aKBcLpULm5nIYDQsLYMoUYNcuwNVV6aiIiCgJGdwGbdKkSRg0aBAmTpwIb29vpE+fXutxUyh2/FalS2uWly8H/pt2lCh+Qsibubksbl2/HvD3BypWVDoyIiJKBnq3QZswYQJ+/vlnZMiQQfPkWL3EhBAwMzNDdHR00keZhJSuw378GMiZUy5nzAi8e5fiIVBqExQkZwQoWhQYNUrpaIiIFKH09Tul6Z2gWVhY4NWrV7h161aC+1WpUiVJAksuSp7gCxeAUqU06y9fyrbdRPG6cAHw9QUePABsbICHD/mhISKTZGoJmt5VnDF5nLEnYMYqOhqoUUOzXqUKr7OUACGAefOAQYNkb5IcOYC1a/mhISIyEQZ1EjDjwJeJ9uqVrKkCgOHDgd27lY2HjFhgINCsmRwoLyICaNQIuHQJ+P57pSMjIqIUYlAngXz58n01STP2uTiV8vSpZnnyZOXiICMXFSW7+N66JWcD+O03OUsAfxwREZkUgxK08ePHx5lJgPQTHi7v8+VTNg4ycunSAf36yXk0163TbrRIREQmw6AErWXLlnDleEuJEhYm7+3slI2DjND797IOvHBhud6tG9C2LfDFEDZERGQ69G6DxvZn3+byZXmfzuCR5yhNO3kSKFECqF9ftj0DZHUmkzMiIpOmd4JmwJSdpEPM6CQhIcrGQUZCpQKmTgUqVwaePZPtzd6+VToqIiIyEnqX56hUquSMI807d07eFyumbBxkBPz9AT8/TVfeVq2AP/4AYg0CTUREpo0VbikkppNA2bLKxkEKO3pUJmQvX8qBZ+fOlZOeswkBERHFwgQtBaxeDTx6JJfLlVM2FlLYzJkyOStQQM6nWbSo0hEREZERYoKWAtq31ywXL65cHGQEli0DcuUCJkwA7O2VjoaIiIyUQTMJkOGuXdMsb9wI2NoqFwsp4NAh4Oef5dRNAJApkyxFY3JGREQJYAlaMtu8WbPctKlycVAKi46WpWQTJ8rkrGxZoEULpaMiIqJUgglaMluxQt6zatOEvHwJtGkDHDki1zt3luOcERER6YkJWjI6dAh48kQud+mibCyUQvbtk7MA+PvLwWb/+EMma0RERAZgG7RkVKeOZrltW+XioBQyfTpQu7ZMzooXBy5eZHJGRESJwgQtGcUMbTVmDODkpGgolBJKlpT3P/0EnD4N5MunbDxERJRqsYozmQihGZy2QQNlY6Fk9PYt4Ooql2vWlN12YyY9JyIiSiSWoCWTY8c0y3nyKBcHJZPISGDwYFlK9uCBZjuTMyIiSgJM0JJJ376aZUdH5eKgZPDkCVCpEvDbb0BQELB9u9IRERFRGsMqzmQQGgpcuSKXmzThNItpyv/+B3TsCAQGysx7+XJ5komIiJIQS9CSga+vZnnOHOXioCQUEQH07w80biyTszJlgEuXmJwREVGyYIKWDGJqvEqUALJlUzQUSirz5mmy7YEDZSPDnDmVjYmIiNIsVnEmsQsXNMvbtikXByWx3r2B/fuBnj3ZLZeIiJIdS9CS2MuXmmVPT+XioG8UFiYnNY+MlOtWVsDu3UzOiIgoRbAELYn98ou8r1pV0TDoW9y7JxsSXrokZwWYMkXpiIiIyMSwBC2JXbsm72/eVDYOSqS1a4HvvpPJmYsLULmy0hEREZEJYoKWhM6dAz5/lssLFigbCxkoNBTo3h1o1Qr49EmOc3b5svaEqkRERCmECVoSWrRIs8ymSqnI3btA2bLA4sVy0LpRo4BDhwAPD6UjIyIiE8U2aEnoyBF537atbFNOqYRKBTx8KOfUXLNGzqlJRESkICZoSejhQ3n/3XfKxkF6UKkA8/8KkAsUADZvBooWBbJkUTYuIiIisIozycyerVlu3VqxMEgfN27IUYSPHtVsq1WLyRkRERkNJmhJ5PJlzbKbm2JhUEKEAJYtA0qXlt1tf/5ZbiMiIjIyTNCSgBDAn3/K5QEDlI2F4vHxI9CuHdCli+yxWasWsHMnZ7InIiKjxAQtCcS0PQM4bJZRunIFKFVKdgCwsAAmT5azAri6Kh0ZERGRTuwkkAQ+ftQsN2qkWBiky61bcgiN8HA5bMbatUDFikpHRURElCAmaEng7Fl5nyuXsnGQDgUKAA0bAiEhsh7axUXpiIiIiL6KCdo3EkIOQA8AtrbKxkL/uXQJyJkTcHKSbcz+/BOwttYMq0FERGTkeMX6RosXa5bbtFEuDoLMlufNA77/XnYGiOmhaWvL5IyIiFIVlqB9AyGAHj0068OGKReLyQsMBDp3lgPOAkBUFBAWxmJNIiJKlVis8A3ev9cs793LERsUc/YsULKkTM4sLeWowVu2MDkjIqJUiwnaNyhXTt5bWclhtSiFCQHMmiV7ZT5+LNudnTgB9OvHbJmIiFI1JmiJVLs2cO+eXK5QQdlYTFZQEDBzJhAZCTRtCly8KGcJICIiSuXYBi2R9u7VLG/bplwcJs3JCfjnHzkQbc+eLDUjIqI0gwlaIkRHa5bPnAHs7ZWLxaSoVMBvvwHu7kD79nJbxYoceJaIiNIcJmiJEBCgWS5eXLk4TIq/P+DnJ6dosrMDqlUDPD2VjoqIiChZMEFLhClTNMtWVsrFYTKOHQNatgRevgRsbGQvzWzZlI6KiIgo2bCTQCKcOiXvM2Vis6dkpVIBv/wCVK0qk7P8+WWdcteufOOJiChNYwlaIsTMvTlokLJxpGnR0UC9epreGO3aAQsWsMEfERGZBJagGSg0VLNcpYpycaR5FhZAqVKyvdmKFcCqVUzOiIjIZBhFgjZ//nx4eXnBxsYGZcuWxdmYIiodlixZgkqVKsHZ2RnOzs6oWbNmgvsntWPHNMtlyqTYy5qG6GjZGSDGuHHA5ctAhw4KBURERKQMxRO0devWYeDAgRg7diwuXryI4sWLw8fHB2/fvtW5/5EjR9CqVSscPnwYp06dgqenJ2rVqoUXL16kSLyrV2uWLSxS5CVNw6tXwA8/AHXqAOHhclu6dEDevMrGRUREpAAzIYRQMoCyZcuidOnSmDdvHgBApVLB09MTffr0wTA9Zh+Pjo6Gs7Mz5s2bh/YxY2MlIDg4GI6OjggKCoKDg4PB8TZtKqd8rFABOH7c4KeTLvv2AW3bytKz9OmBQ4dYPElERFq+9fqd2ihaghYREYELFy6gZs2a6m3m5uaoWbMmTsV0lfyKz58/IzIyEhkzZkyuMLXs2SPv27ZNkZdL26KigJEj5bxZ/v5AsWLAhQtMzoiIyOQp2oszICAA0dHRcHNz09ru5uaG27dv63WMoUOHImvWrFpJXmzh4eEIj6kyg8zAv8Xnz/I+hfLBtOv5c6B1a02jvu7d5cTntrbKxkVERGQEFG+D9i1+/fVXrF27Flu2bIGNjY3OfaZMmQJHR0f1zfMbRp+PnTN+912iD0OAHMvs2DEgQwZg7Vpg0SImZ0RERP9RNEFzcXGBhYUF3rx5o7X9zZs3cHd3T/C5v/32G3799Vfs27cPxYoVi3e/4cOHIygoSH179uxZouMtWFCznDt3og9DADB/vpyu6eJFwNdX6WiIiIiMiqIJmpWVFby9vXHw4EH1NpVKhYMHD6JcuXLxPm/atGmYOHEi9uzZg1KlSiX4GtbW1nBwcNC6JcanT5rln37iQPYGe/oUWLpUs54rl+wMkCePcjEREREZKcVnEhg4cCD8/PxQqlQplClTBrNnz0ZISAg6duwIAGjfvj08PDww5b8JMKdOnYoxY8bg77//hpeXF16/fg0AsLe3h30yDmQae4Da+fOT7WXSpm3b5FhmgYFA9uxArVpKR0RERGTUFE/QfH194e/vjzFjxuD169coUaIE9uzZo+448PTpU5ibawr6Fi5ciIiICDRr1kzrOGPHjsW4ceNSJGaWnukpIgIYOlRObg4ApUtzXDMiIiI9KD4OWkpL7Dgq58/L/AIATOsdS6RHj2TbsnPn5PqAAcCvvwJWVsrGRUREqZKpjYOmeAlaarF+vdIRpCL/+5+s0gwKApydgZUrgYYNFQ6KiIgo9WCCpqegIHnv5aVoGKlDcLB8w8qVk0NoZM+udERERESpChM0PUVFyfsvmr5RjOhozeSk7dsDNjZA48aApaWycREREaVCqXqg2pTk7y/vs2ZVNg6jtHYtULQoEBCg2daiBZMzIiKiRGKCpqft2+W9tbWycRiV0FA5RVOrVsCtW8DMmUpHRERElCawilMPsabyZAlajNu3ZSnZtWty3JERI4AUGuaEiIgorWOCpoefftIs16+vXBxGY/Vq+aaEhACursBffwE//KB0VERERGkGEzQ9xEzzZGkJpDP1d+yPP4AePeRytWrAmjVAlizKxkRERJTGsA2aHkJC5P3vvysbh1Fo2VLOnzluHLB/P5MzIiKiZGDq5UF6eflS3js6KhuHIoSQk5pXry7bmjk6AlevAra2SkdGRESUZrEETQ+XL8v7mGG+TManT4CfH1CzJrBokWY7kzMiIqJkxRI0Pdjby1zFw0PpSFLQ1auyl+adO4C5uaael4iIiJIdE7SveP9e00nAJJpbCQEsXgz06yfHF/HwAP75B6hUSenIiIiITAYTtK+oXl2znObn4QwOBrp1A9atk+t16gCrVgEuLsrGRUREZGLYBu0rrlyR99mzy5q+NO36dWDDBtnYbto0YMcOJmdEREQKYAlaAq5f1ywvW6ZcHCmmfHlg3jygRAmgXDmloyEiIjJZab1M6Jv89ptmuUoV5eJINoGBQLt2ch7NGD/9xOSMiIhIYSxBS8ClS/K+XDk5i0Cacu4c4OsLPHoE3LwJnD8vxzkjIiIixbEELQFXr8r71q2VjSNJCQHMng1UqCCTMy8vOcYZkzMiIiKjwRK0eBw7pllu0EC5OJLU+/dAx47Atm1yvUkT2bjOyUnRsIiIiEgbE7R4bN+uWc6RQ7k4ksyjR0DVqsDTp4CVFTBzJtCzJ0vOiIiIjBATtHgcPizva9VSNo4k4+kpxwqxtATWrwe++07piIiIiCgeTNDicfOmvE/VvTffvQMyZJAlZunSyTHO7OwABwelIyMiIqIEsJOADlFRwOfPcrldO2VjSbRjx4DixYGhQzXb3N2ZnBEREaUCTNB0GD5cs+zurlwciaJSAZMnA9WqAS9eAHv2cKJzIiKiVIYJmg7Pn2uWU9X4Z2/fArVrAyNHAtHRQNu2cryz9OmVjoyIiIgMwDZoOpw6Je+XLFE2DoMcPiwHbHv9GrC1BebPBzp0YC9NIiKiVIgJ2hcePgSePJHLVlbKxqK34GCgaVPgwwegUCHZS7NwYaWjIiIiokRigvaFv//WLKeaAWodHIA//gB27wbmzmWVJhERUSrHBO0LK1fK+5o1AWdnRUNJ2IEDgLk5UL26XG/eXN6IiIgo1WMngS+8eyfvixRRNo54RUUBo0bJEXRbtQJevVI6IiIiIkpiLEH7QmCgvG/YUNEwdHvxQiZlMROFNmrEeTSJiIjSICZosVy+rFn28lIqinjs3g20bw8EBAD29rKLacuWSkdFREREyYBVnLHEDK8BADlzKheHFpVKzgZQt65MzkqWBC5eZHJGRESUhjFBiyWmB6ePj7JxaDE3l2ObAUCvXsDJk0DevMrGRERERMmKVZyxHD8u742i92ZUlJzgHJCDzjZvDtSvr2xMRERGIDo6GpGRkUqHQcnA0tISFhYWSodhFJig/Sf2dJXduikXByIigGHDgPv3ga1b5UwA9vZMzoiIAHz69AnPnz+HEELpUCgZmJmZIVu2bLC3t1c6FMUxQfvPnj2a5YoVFQri0SPA11fOnwkAR47ISc+JiAjR0dF4/vw57OzskDlzZphxKrs0RQgBf39/PH/+HHnz5jX5kjQmaP+Jmd7JzU2hCdI3bwY6dQKCguTQGStXMjkjIoolMjISQghkzpwZtra2SodDySBz5sx4/PgxIiMjTT5BYyeB/9y6Je9LlkzhFw4PB/r0kXNpBgUB338vx/v48ccUDoSIKHVgyVnaxXOrwQTtP/7+8t7VNYVfuE0bYN48uTx4MHD0KJAjRwoHQURERMaECdp/tm+X9wUKpPALDx0KZMkC7NgBTJumUP0qERERGRMmaJAjWqhUcjlPnmR+sdBQ4N9/NeulSwMPHwL16iXzCxMRkZJOnToFCwsL1NPx//7IkSMwMzNDYMx8g7F4eXlh9uzZWtsOHz6MunXrIlOmTLCzs0OhQoXw888/48WLF8kUPRAWFoZevXohU6ZMsLe3R9OmTfHmzZsEn/Pp0yf07t0b2bJlg62tLQoVKoRFixYlW4xpCRM0AAsWaJaTdZDaO3dkGzMfH+15pWxskvFFiYjIGCxbtgx9+vTB0aNH8fLly0Qf548//kDNmjXh7u6OTZs24ebNm1i0aBGCgoIwY8aMJIxY24ABA7B9+3Zs2LAB//77L16+fIkmTZok+JyBAwdiz549+Ouvv3Dr1i30798fvXv3xrZt25ItzrSCvTgBxB5Ox8EhmV5kzRqge3c54FrmzJpZ2YmIKM379OkT1q1bh/Pnz+P169dYuXIlRowYYfBxnj9/jr59+6Jv376YNWuWeruXlxcqV66sswQuKQQFBWHZsmX4+++/Ub16dQDAihUrULBgQZw+fRrff/+9zuedPHkSfn5+qFq1KgCgW7du+OOPP3D27Fk0bNgwWWJNK1iCBk0JWpcuyXDwz5/lgdu2lclZ1aqy9Oy/DysRESWOEPLfqhI3Q8fJXb9+PQoUKID8+fOjbdu2WL58eaIG292wYQMiIiIwZMgQnY87OTnF+9w6derA3t4+3lvhwoXjfe6FCxcQGRmJmjVrqrcVKFAA2bNnx6nYE1l/oXz58ti2bRtevHgBIQQOHz6Mu3fvolatWl//Y02cyZegRUcDjx/LZTu7JD74zZtAixbAjRtyRoAxY4DRowETH9uFiCgpfP4sJ1pRwqdPQPr0+u+/bNkytG3bFgBQu3ZtBAUF4d9//1WXLOnr3r17cHBwQJYsWQx6HgAsXboUoaGh8T5umUAntdevX8PKyipOAujm5obXMfNF6zB37lx069YN2bJlQ7p06WBubo4lS5agcuXKBsdvakw+QVu4UM6uBAATJiTxwbdulcmZu7us4vyvWJiIiEzHnTt3cPbsWWzZsgUAkC5dOvj6+mLZsmUGJ2hCiESPFebh4ZGo532LuXPn4vTp09i2bRty5MiBo0ePolevXsiaNatWaRzFZfIJWp8+8t7SEnB0TOKDDxkiy8L79JFTFBARUZKxs5MlWUq9tr6WLVuGqKgoZM2aVb1NCAFra2vMmzcPjo6OcPivAXRQUFCcUqrAwEA4/neBypcvH4KCgvDq1SuDS9Hq1KmDY8eOxft4jhw5cOPGDZ2Pubu7IyIiAoGBgVrxvXnzBu7u7jqfExoaihEjRmDLli3qnqvFihXD5cuX8dtvvzFB+wqTTtBit6XctSsJDnjtmiyGW7UKsLWVVZmTJiXBgYmI6EtmZoZVMyohKioKq1atwowZM+K0u2rUqBH++ecf9OjRA3nz5oW5uTkuXLiAHLEGK3/48CGCgoKQL18+AECzZs0wbNgwTJs2TauTQIwvE6jYvqWK09vbG5aWljh48CCaNm0KQJYMPn36FOXKldP5nMjISERGRsLcXLu5u4WFBVQxY1tRvEw6QfvzT83yN9U+CgEsXQr07QuEhQG5cgFTp35zfERElLrt2LEDHz58QOfOndWlYDGaNm2KZcuWoUePHsiQIQO6dOmCn3/+GenSpUPRokXx7NkzDB06FN9//z3Kly8PAPD09MSsWbPQu3dvBAcHo3379vDy8sLz58+xatUq2NvbxzvUxrdUcTo6OqJz584YOHAgMmbMCAcHB/Tp0wflypXT6sFZoEABTJkyBY0bN4aDgwOqVKmCwYMHw9bWFjly5MC///6LVatWYebMmYmOxWQIExMUFCQA/Hcv1LdvOKAQLVtqDlS7thBv3yZZvEREJIWGhoqbN2+K0NBQpUPRW/369UXdunV1PnbmzBkBQFy5ckUIIf++sWPHigIFCghbW1uRM2dO0a1bN+Hv7x/nufv37xc+Pj7C2dlZ2NjYiAIFCohBgwaJly9fJtvfEhoaKnr27CmcnZ2FnZ2daNy4sXj16pXWPgDEihUr1OuvXr0SHTp0EFmzZhU2NjYif/78YsaMGUKlUsX7GvGd49jXb1NgJkQi+vmmYsHBwXB0dMT790HImFHW+U+cCIwalYiDXboke2nevy+rMydPBgYNAsw5egkRUVILCwvDo0ePkDNnTthwgO80KaFzHHP9DgoKUrfZS8tMtooz9rAtQ4cm4gBbtgAtW8ouoJ6ewNq1wH9F0ERERETfwmQTtNgzLSVqfvJSpeQAPBUqACtWAJkyJVVoREREZOJMNkGztpb3efMa8KQXL4CYRpaensDZs7JDQCLHpCEiIiLSxWQbS4WHy/syZfTYWQhgzhyZjMWe4DV3biZnRERElORMNkFbtkzex5Skxev9e6BxY6B/f9neLHaCRkRERJQMTDZBixmOJoEx+4DTp4GSJeWUTVZWwNy5wJIlKRIfERHpZmKDD5gUnlsNk03QYubfbNlSx4MqFfDbb0ClSsDTp7Iq8+RJoHdvVmkSESnEwsICABAR8w+c0pyYcxtzrk2ZyXYSiJluzNlZx4NHjwKDB8vlFi1kqZkJjLlCRGTM0qVLBzs7O/j7+8PS0jLOFEKUuqlUKvj7+8POzg7p0plseqJm8u+Ara2OjVWrAv36AQUKAN27s9SMiMgImJmZIUuWLHj06BGePHmidDiUDMzNzZE9e3aY8boLk51JAAgC4ICQEMDORiV7abZqBbi7Kx0iERElQKVSsZozjbKysoq3ZJQzCShg/vz5mD59Ol6/fo3ixYtj7ty5KJPA+BcbNmzA6NGj8fjxY+TNmxdTp05F3bp1E/Xadp/eAo3bAfv2ATt2APv3c6omIiIjZm5uzqmeKM1TPBNZt24dBg4ciLFjx+LixYsoXrw4fHx88PbtW537nzx5Eq1atULnzp1x6dIlNGrUCI0aNcL169cNfu1+xY8AJUrI5MzWFmjThtWZREREpDjFqzjLli2L0qVLY968eQBk0bWnpyf69OmDYcOGxdnf19cXISEh2LFjh3rb999/jxIlSmDRokVffb2YItIhGI4pZlNhLlRAwYLA+vVAkSJJ94cRERFRkjG1Kk5FS9AiIiJw4cIF1KxZU73N3NwcNWvWxKnYs5nHcurUKa39AcDHxyfe/eMzElNkctaxI3DuHJMzIiIiMhqKtkELCAhAdHQ03NzctLa7ubnh9u3bOp/z+vVrnfu/fv1a5/7h4eEIj5nXCUBQUJA8DmyAP+bIgdCio4Hg4G/5U4iIiCgZBf93nTaVvo1G0UkgOU2ZMgXjx4+Psz0/wuQQGt27KxAVERERJca7d+/+G40hbVM0QXNxcYGFhQXevHmjtf3Nmzdwj2e4C3d3d4P2Hz58OAYOHKheDwwMRI4cOfD06VOTOMHGLDg4GJ6ennj27JlJtCcwdjwfxoPnwnjwXBiPoKAgZM+eHRkzZlQ6lBShaIJmZWUFb29vHDx4EI0aNQIgOwkcPHgQvXv31vmccuXK4eDBg+jfv7962/79+1GuXDmd+1tbW8Nax4zojo6O/LIZCQcHB54LI8LzYTx4LowHz4XxMJUZJBSv4hw4cCD8/PxQqlQplClTBrNnz0ZISAg6duwIAGjfvj08PDwwZcoUAEC/fv1QpUoVzJgxA/Xq1cPatWtx/vx5LF68WMk/g4iIiCjJKJ6g+fr6wt/fH2PGjMHr169RokQJ7NmzR90R4OnTp1rZcvny5fH3339j1KhRGDFiBPLmzYv//e9/KMJemERERJRGKJ6gAUDv3r3jrdI8cuRInG3NmzdH8+bNE/Va1tbWGDt2rM5qT0pZPBfGhefDePBcGA+eC+NhaudC8YFqiYiIiEibabS0IyIiIkpFmKARERERGRkmaERERERGJk0maPPnz4eXlxdsbGxQtmxZnD17NsH9N2zYgAIFCsDGxgZFixbFrl27UijStM+Qc7FkyRJUqlQJzs7OcHZ2Rs2aNb967sgwhn43YqxduxZmZmbq8Qrp2xl6LgIDA9GrVy9kyZIF1tbWyJcvH/9XJRFDz8Xs2bORP39+2NrawtPTEwMGDEBYWFgKRZt2HT16FA0aNEDWrFlhZmaG//3vf199zpEjR/Ddd9/B2toaefLkwcqVK5M9zhQj0pi1a9cKKysrsXz5cnHjxg3RtWtX4eTkJN68eaNz/xMnTggLCwsxbdo0cfPmTTFq1ChhaWkprl27lsKRpz2GnovWrVuL+fPni0uXLolbt26JDh06CEdHR/H8+fMUjjxtMvR8xHj06JHw8PAQlSpVEj/++GPKBJvGGXouwsPDRalSpUTdunXF8ePHxaNHj8SRI0fE5cuXUzjytMfQc7FmzRphbW0t1qxZIx49eiT27t0rsmTJIgYMGJDCkac9u3btEiNHjhSbN28WAMSWLVsS3P/hw4fCzs5ODBw4UNy8eVPMnTtXWFhYiD179qRMwMkszSVoZcqUEb169VKvR0dHi6xZs4opU6bo3L9FixaiXr16WtvKli0runfvnqxxmgJDz8WXoqKiRIYMGcSff/6ZXCGalMScj6ioKFG+fHmxdOlS4efnxwQtiRh6LhYuXChy5colIiIiUipEk2HouejVq5eoXr261raBAweKChUqJGucpkafBG3IkCGicOHCWtt8fX2Fj49PMkaWctJUFWdERAQuXLiAmjVrqreZm5ujZs2aOHXqlM7nnDp1Smt/APDx8Yl3f9JPYs7Flz5//ozIyEiTmXctOSX2fEyYMAGurq7o3LlzSoRpEhJzLrZt24Zy5cqhV69ecHNzQ5EiRTB58mRER0enVNhpUmLORfny5XHhwgV1NejDhw+xa9cu1K1bN0ViJo20fv02ioFqk0pAQACio6PVsxDEcHNzw+3bt3U+5/Xr1zr3f/36dbLFaQoScy6+NHToUGTNmjXOF5AMl5jzcfz4cSxbtgyXL19OgQhNR2LOxcOHD3Ho0CG0adMGu3btwv3799GzZ09ERkZi7NixKRF2mpSYc9G6dWsEBASgYsWKEEIgKioKPXr0wIgRI1IiZIolvut3cHAwQkNDYWtrq1BkSSNNlaBR2vHrr79i7dq12LJlC2xsbJQOx+R8/PgR7dq1w5IlS+Di4qJ0OCZPpVLB1dUVixcvhre3N3x9fTFy5EgsWrRI6dBMzpEjRzB58mQsWLAAFy9exObNm7Fz505MnDhR6dAojUlTJWguLi6wsLDAmzdvtLa/efMG7u7uOp/j7u5u0P6kn8Scixi//fYbfv31Vxw4cADFihVLzjBNhqHn48GDB3j8+DEaNGjw//buPSiq8o0D+JcFl11xkaFkYOOioGyMYbiAhuQQZAGTuYkKJYMoKI6EOJoWU8olw1uCA44VjSMYMXJxKhhJUEwK1qnQuDSCiyiojVgTNCAKcdnn90fD+bVyKbzAtj6fmfPHec/7vud5zzs7+8x79pwVyrRaLQDAxMQEGo0GTk5OjzZoA3U/nw0bGxtMmjQJxsbGQpmLiwtu3bqF3t5eiMXiRxqzobqfudixYwfCwsKwdu1aAICrqyvu3LmDqKgovPfeezr/Hc0erZG+v83Nzf/zq2eAga2gicViuLu748yZM0KZVqvFmTNn4OXlNWwbLy8vnfoAcPr06RHrs3/nfuYCAPbt24edO3eipKQEHh4e4xHqY2Gs8/H000/j559/Rk1NjbAtWbIEvr6+qKmpgZ2d3XiGb1Du57Ph7e2NpqYmIUkGgMbGRtjY2HBy9gDuZy7u3r07JAkbTJyJ/zlxXBn89/dEP6XwsOXm5pKpqSllZWVRfX09RUVFkYWFBd26dYuIiMLCwiguLk6or1arycTEhPbv308NDQ2UkJDAr9l4SMY6F3v27CGxWEzHjx+n1tZWYbt9+/ZEDcGgjHU+7sVPcT48Y52L69evk0wmo5iYGNJoNHTixAmysrKiDz74YKKGYDDGOhcJCQkkk8no2LFjdPXqVTp16hQ5OTlRcHDwRA3BYNy+fZuqq6upurqaAFBqaipVV1fTtWvXiIgoLi6OwsLChPqDr9nYtm0bNTQ00KFDh/g1G/ru4MGDZG9vT2KxmObNm0fff/+9cMzHx4fCw8N16ufn55OzszOJxWKaPXs2FRcXj3PEhmssc+Hg4EAAhmwJCQnjH7iBGutn4+84QXu4xjoX586do/nz55OpqSk5OjpScnIy9ff3j3PUhmksc9HX10eJiYnk5OREEomE7OzsKDo6mv7444/xD9zAnD17dtjvgMHrHx4eTj4+PkPauLm5kVgsJkdHR8rMzBz3uB8VIyJek2WMMcYY0ycG9Rs0xhhjjDFDwAkaY4wxxpie4QSNMcYYY0zPcILGGGOMMaZnOEFjjDHGGNMznKAxxhhjjOkZTtAYY4wxxvQMJ2iMMcYYY3qGEzTGmI6srCxYWFhMdBj3zcjICF999dWodVavXo3XXnttXOJhjLH7wQkaYwZo9erVMDIyGrI1NTVNdGjIysoS4hGJRLC1tcWaNWvw22+/PZT+W1tbERgYCABoaWmBkZERampqdOqkpaUhKyvroZxvJImJicI4jY2NYWdnh6ioKLS3t4+pH04mGXs8mUx0AIyxRyMgIACZmZk6ZdOmTZugaHSZm5tDo9FAq9WitrYWa9aswc2bN1FaWvrAfVtbW/9jnalTpz7wef6N2bNno6ysDAMDA2hoaEBERAQ6OjqQl5c3LudnjP138QoaYwbK1NQU1tbWOpuxsTFSU1Ph6uoKMzMz2NnZITo6Gl1dXSP2U1tbC19fX8hkMpibm8Pd3R3nz58XjldWVmLhwoWQSqWws7NDbGws7ty5M2psRkZGsLa2hlwuR2BgIGJjY1FWVobu7m5otVq8//77sLW1hampKdzc3FBSUiK07e3tRUxMDGxsbCCRSODg4IDdu3fr9D14i3PGjBkAgLlz58LIyAgvvPACAN1VqU8//RRyuRxarVYnRpVKhYiICGG/sLAQSqUSEokEjo6OSEpKQn9//6jjNDExgbW1NZ566iksWrQIK1aswOnTp4XjAwMDiIyMxIwZMyCVSqFQKJCWliYcT0xMxNGjR1FYWCisxpWXlwMAbty4geDgYFhYWMDS0hIqlQotLS2jxsMY++/gBI2xx4xIJEJ6ejouXryIo0eP4ptvvsHbb789Yv3Q0FDY2tqiqqoKFy5cQFxcHCZNmgQAuHLlCgICArBs2TLU1dUhLy8PlZWViImJGVNMUqkUWq0W/f39SEtLQ0pKCvbv34+6ujr4+/tjyZIluHz5MgAgPT0dRUVFyM/Ph0ajQU5ODqZPnz5svz/++CMAoKysDK2trfjiiy+G1FmxYgXa2tpw9uxZoay9vR0lJSUIDQ0FAFRUVGDVqlXYtGkT6uvrkZGRgaysLCQnJ//rMba0tKC0tBRisVgo02q1sLW1RUFBAerr6xEfH493330X+fn5AICtW7ciODgYAQEBaG1tRWtrKxYsWIC+vj74+/tDJpOhoqICarUaU6ZMQUBAAHp7e/91TIwxPUaMMYMTHh5OxsbGZGZmJmzLly8ftm5BQQE98cQTwn5mZiZNnTpV2JfJZJSVlTVs28jISIqKitIpq6ioIJFIRN3d3cO2ubf/xsZGcnZ2Jg8PDyIiksvllJycrNPG09OToqOjiYho48aN5OfnR1qtdtj+AdCXX35JRETNzc0EgKqrq3XqhIeHk0qlEvZVKhVFREQI+xkZGSSXy2lgYICIiF588UXatWuXTh/Z2dlkY2MzbAxERAkJCSQSicjMzIwkEgkBIACUmpo6YhsiojfffJOWLVs2YqyD51YoFDrX4M8//ySpVEqlpaWj9s8Y+2/g36AxZqB8fX3x8ccfC/tmZmYA/lpN2r17Ny5duoTOzk709/ejp6cHd+/exeTJk4f0s2XLFqxduxbZ2dnCbTonJycAf93+rKurQ05OjlCfiKDVatHc3AwXF5dhY+vo6MCUKVOg1WrR09OD559/HocPH0ZnZydu3rwJb29vnfre3t6ora0F8NftyZdeegkKhQIBAQFYvHgxXn755Qe6VqGhoVi3bh0++ugjmJqaIicnB6+//jpEIpEwTrVarbNiNjAwMOp1AwCFQoGioiL09PTg888/R01NDTZu3KhT59ChQzhy5AiuX7+O7u5u9Pb2ws3NbdR4a2tr0dTUBJlMplPe09ODK1eu3McVYIzpG07QGDNQZmZmmDlzpk5ZS0sLFi9ejA0bNiA5ORmWlpaorKxEZGQkent7h000EhMTsXLlShQXF+PkyZNISEhAbm4uli5diq6uLqxfvx6xsbFD2tnb248Ym0wmw08//QSRSAQbGxtIpVIAQGdn5z+OS6lUorm5GSdPnkRZWRmCg4OxaNEiHD9+/B/bjuTVV18FEaG4uBienp6oqKjAgQMHhONdXV1ISkpCUFDQkLYSiWTEfsVisTAHe/bswSuvvIKkpCTs3LkTAJCbm4utW7ciJSUFXl5ekMlk+PDDD/HDDz+MGm9XVxfc3d11EuNB+vIgCGPswXCCxthj5MKFC9BqtUhJSRFWhwZ/7zQaZ2dnODs7Y/PmzXjjjTeQmZmJpUuXQqlUor6+fkgi+E9EItGwbczNzSGXy6FWq+Hj4yOUq9VqzJs3T6deSEgIQkJCsHz5cgQEBKC9vR2WlpY6/Q3+3mtgYGDUeCQSCYKCgpCTk4OmpiYoFAoolUrhuFKphEajGfM477V9+3b4+flhw4YNwjgXLFiA6Ohooc69K2BisXhI/EqlEnl5ebCysoK5ufkDxcQY00/8kABjj5GZM2eir68PBw8exNWrV5GdnY1PPvlkxPrd3d2IiYlBeXk5rl27BrVajaqqKuHW5TvvvINz584hJiYGNTU1uHz5MgoLC8f8kMDfbdu2DXv37kVeXh40Gg3i4uJQU1ODTZs2AQBSU1Nx7NgxXLp0CY2NjSgoKIC1tfWwL9e1srKCVCpFSUkJfv31V3R0dIx43tDQUBQXF+PIkSPCwwGD4uPj8dlnnyEpKQkXL15EQ0MDcnNzsX379jGNzcvLC3PmzMGuXbsAALNmzcL58+dRWlqKxsZG7NixA1VVVTptpk+fjrq6Omg0Gvz+++/o6+tDaGgonnzySahUKlRUVKC5uRnl5eWIjY3FL7/8MqaYGGP6iRM0xh4jzz77LFJTU7F3714888wzyMnJ0XlFxb2MjY3R1taGVatWwdnZGcHBwQgMDERSUhIAYM6cOfj222/R2NiIhQsXYu7cuYiPj4dcLr/vGGNjY7Flyxa89dZbcHV1RUlJCYqKijBr1iwAf90e3bdvHzw8PODp6YmWlhZ8/fXXworg35mYmCA9PR0ZGRmQy+VQqVQjntfPzw+WlpbQaDRYuXKlzjF/f3+cOHECp06dgqenJ5577jkcOHAADg4OYx7f5s2bcfjwYdy4cQPr169HUFAQQkJCMH/+fLS1temspgHAunXroFAo4OHhgWnTpkGtVmPy5Mn47rvvYG9vj6CgILi4uCAyMhI9PT28osaYgTAiIproIBhjjDHG2P/xChpjjDHGmJ7hBI0xxhhjTM9wgsYYY4wxpmc4QWOMMcYY0zOcoDHGGGOM6RlO0BhjjDHG9AwnaIwxxhhjeoYTNMYYY4wxPcMJGmOMMcaYnuEEjTHGGGNMz3CCxhhjjDGmZzhBY4wxxhjTM/8DjBZDQ6Y6KR0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 18.47234296798706\n", + "lead_lag: False inv_rest: False thres_distance: 16000 auc: 0.79710896\n", + "Threshold distance: 32000\n", + "lead_lag: False\n", + "inv_reset: False\n", + "len(data.corpus) 5000\n", + "len(data.test_inlier) 5000\n", + "len(data.test_outlier) 5000\n", + "fit_time: 9.334766149520874\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compute_auc_time: 19.540114879608154\n", + "lead_lag: False inv_rest: False thres_distance: 32000 auc: 0.78804452\n", + "CPU times: user 5h 20min 27s, sys: 8min 49s, total: 5h 29min 16s\n", + "Wall time: 50min 31s\n" ] } ], @@ -1787,17 +2135,24 @@ " augmentation_list = augmentation_list1\n", "\n", " if (not inv_reset) and (not lead_lag):\n", - " augmentation_list = ()\n", + " augmentation_list = None\n", "\n", " for thres_distance in [4000, 8000, 16000, 32000]:\n", - " signature_maha_knn = SignatureMahalanobisKNN()\n", + " signature_maha_knn = SignatureMahalanobisKNN(random_state=seed)\n", " data.load_ship_movements(\n", " thres_distance=thres_distance,\n", " )\n", + " print(\"Threshold distance: \", thres_distance)\n", + " print(\"lead_lag: \", lead_lag)\n", + " print(\"inv_reset: \", inv_reset)\n", + " print(\"len(data.corpus)\", len(data.corpus))\n", + " print(\"len(data.test_inlier)\", len(data.test_inlier))\n", + " print(\"len(data.test_outlier)\", len(data.test_outlier))\n", + "\n", " # Measure the time spent on fit\n", " start_time = time.time()\n", " signature_maha_knn.fit(\n", - " knn_library=\"sklearn\",\n", + " knn_library=\"pynndescent\",\n", " X_train=data.corpus,\n", " signature_kwargs={\n", " \"augmentation_list\": augmentation_list,\n", @@ -1849,12 +2204,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 44, "id": "303b9c84", "metadata": {}, "outputs": [], "source": [ - "data = Data.Data(if_sample=True, n_samples=[100, 10, 10])\n", + "# data = Data.Data(if_sample=True, n_samples=[100, 10, 10])\n", + "data = Data.Data(if_sample=False)\n", "data_full_names = [\n", " \"Adiac\",\n", " \"ArrowHead\",\n", @@ -1889,7 +2245,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "n_neighbours = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 46, "id": "a22e802a-c924-4ead-9c8d-0fb3c262e84d", "metadata": {}, "outputs": [ @@ -1897,23 +2262,101 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:255: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + " rho = numerator / denominator\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n" ] }, @@ -1921,15 +2364,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 17min 48s, sys: 18min 8s, total: 35min 57s\n", - "Wall time: 5min 57s\n" + "CPU times: user 1h 53min 41s, sys: 45min 25s, total: 2h 39min 7s\n", + "Wall time: 34min 37s\n" ] } ], "source": [ "%%time\n", "depth = 5\n", - "signature_maha_knn = SignatureMahalanobisKNN()\n", + "signature_maha_knn = SignatureMahalanobisKNN(random_state=seed)\n", "\n", "iter = 10\n", "data_names = data_full_names\n", @@ -1959,13 +2402,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 47, "id": "e6043a4d-1ba9-4e77-acbb-5a758d9c1693", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABCIAAAIxCAYAAACYQxlcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1xT1/sH8M9N2NsBgoqAAm5F3ANRq4IDHDhRK446q/WrVVu1Kq2tq2pba23rrts6cONeOOtElCoyFBEHguyZnN8f/JISEyCEhJuE5/165aW549zn3iT3OZx77zkcY4yBEEIIIYQQQgghpAII+A6AEEIIIYQQQgghlQc1RBBCCCGEEEIIIaTCUEMEIYQQQgghhBBCKgw1RBBCCCGEEEIIIaTCUEMEIYQQQgghhBBCKgw1RBBCCCGEEEIIIaTCUEMEIYQQQgghhBBCKgw1RBBCCCGEEEIIIaTCUEMEIYQQQgghhBBCKgw1RBC1yc7OxsKFC+Hu7g4TExPUrFkTY8eORUJCgkrlpaSk4IsvvoCTkxOMjY3h5OSEGTNm4MOHD8WuIxKJsGbNGjRt2hSmpqawtbXFkCFDEBkZqXD5pKQkbNq0CRMmTICHhwcMDAzAcRy2bt2qUsx8uHjxIjiOQ1BQkFaVRSpWly5dwHEc4uLi+A6FEFJJ8V0PCAoKAsdxxb5+//33cuxdxVi8eLHa6iHqLItULI7j4OzszHcYhGiUAd8BEP2Qk5ODbt264caNG3BwcEC/fv0QFxeHLVu24NixY7hx4wbq1q2rdHlJSUlo3749nj17hrp166J///549OgRfv75Z5w8eRLXr19H1apVZdYRi8UYPHgwDh06BBsbG/Tp0wdJSUnYv38/jh8/jgsXLqBNmzYy64SFhWH8+PFqOQYA4OzsjOfPn4MxprYyCdFnQUFB2LZtGy5cuIAuXbrwHQ4hREXaUA+Q8PHxgb29vdz0+vXrK739uLg4uLi4wNvbGxcvXlR6PUIqM6oHkzJhhKjB/PnzGQDWvn17lp6eLp2+atUqBoB5e3uXqbwRI0YwAGzgwIEsPz9fOn3atGkMABs9erTcOhs2bGAAmJubG3v9+rV0+v79+xkA5urqKlMWY4xdu3aNTZkyhW3evJk9fPiQffbZZwwA27JlS5nilXBycmIV/bPKzMxkkZGR7NWrV1pVFqlY3t7eDACLjY3lO5QyGT16NAPALly4wHcohJBy0IZ6gDrPJ7GxsSrFXV7v3r1jkZGR7MOHD1pVFqlYAJiTkxPfYZQZH/Vgorvom0LKLTc3l1lbWzMA7O7du3LzmzVrxgCw27dvK1Xeq1evmEAgYEZGRjINCowxlpOTw2xtbZlQKGRv3ryRmdewYUMGgB06dEiuTH9/fwaA7d+/v8RtT5w4UecaIghhjBoiCCH80ZZ6gD40RBDCGDVEkMqB+ogg5Xb16lWkpqaiXr16aNGihdz8QYMGAQCOHj2qVHmhoaEQi8Xw8vJCjRo1ZOYZGxvDz88PIpEIJ06ckE6PjY1FZGQkTE1N0adPn3LHUFaSvhWeP38OADLPpBZ9xq/oc/y7du1Cu3btYGlpCRsbG+kyx48fx9ixY9GwYUNYWVnB3NwczZs3xw8//IDc3Nxit/1xvw5Fnw19+PAh/P39UaVKFZibm8Pb2xvXrl3TaFkAkJ+fj+XLl6N+/fowMTFBnTp1MHPmTGRkZJS5T4MPHz5g7dq18PHxkT4vXK1aNfj6+uLMmTMK1ym6jZCQELRr1w7m5uaoWrUqhg8fjpcvXypcLysrC9999x2aNGkCU1NTWFtbo3PnztizZ4/C5Z2dncFxHABg3bp10vVcXFywYsUK6S2Kd+/ehZ+fH6pWrQoLCwv069dP+p0pKjExEStWrIC3tzdq1aoFIyMj2NvbY+DAgfjnn3+UOl6JiYkwNDSEo6MjRCKRwmV27doFjuMwevRopcqUfJ/z8vLw7bffokGDBjA2Nkb//v0BFN6avWnTJvTr1w9169aFqakpbGxsij12HMdh27ZtAICuXbvK/G4+/l6EhoaiT58+sLW1hbGxMerWrYuZM2fi/fv3SsVOCNEcbagHqNPixYvh4uICALh06ZLMualoflT3OVGybUX9OqiSz9RZFlD4uMzkyZNRs2ZNmJqaokmTJli3bh0YY2Xu0+DZs2dYvHgx2rdvD3t7exgZGaF27dr49NNP8fTpU4XrSLYhEomwfPlyuLu7w9jYGI6Ojpg7d67COhIAxMfHY+LEidK6g52dXbH5NC4uDhzHoUuXLsjMzMTMmTPh6OgIU1NTeHp6ynyH//77b7Rt2xbm5uaoUaMGpk+fjuzsbLky79+/jzlz5qBly5YyOWzKlCl49eqVUsdr//794DgOgYGBxS4zYcIEcByHLVu2lFpe0fre69evMX78eNSuXRsGBgb46aefAJStLqJsPRgACgoKsH79erRv3x5WVlYwNTWFh4cHfvrpJxQUFCh1PIie4LslhOi+NWvWMABs8ODBCucfO3aMAWADBgxQqrwvvviCAWCzZ89WOP/XX39lANj//vc/6bRDhw4xAKx169YK14mIiGAAWIsWLUrctqp3RERGRrLRo0czc3Nz6S2jktesWbOky0muWk+YMIEJBALm5eXFhg0bxjp27ChdpkaNGszKyop16NCBDRkyhPn4+LAqVaowAKxbt26soKBAZtsXLlxQeJvqokWLGAA2depUZmZmxpo2bcqGDh3KmjdvzgAwExMT9vDhQ42VJRaL2YABAxgAZm5uzvz8/NjAgQOZjY0Na926NWvfvn2ZruCfPHmSAWDOzs6sR48ebOjQoax9+/aM4zjGcRzbtGmT3DqS4z179mwmFApZly5d2KBBg5ijo6P0MZ6srCyZddLS0ljLli0ZAGZra8sGDRrEevXqxYyNjRkANn36dLntSK4AzJgxg5mamrLevXuzvn37MktLSwaALVy4kIWFhTEzMzPm6enJhgwZwlxdXRkAVq9ePbkY1q9fzwCw+vXrM19fXzZkyBDWokULBoAZGhqyU6dOFbuvRY/nwIEDGQB27Ngxhce0S5cuDAALCwtT5iNgAJijoyPr1asXMzc3Z71792aDBw9mkyZNYowV/g4AsJo1a7KuXbuyoUOHMm9vb2ZoaMgAsEWLFsmUN3r0aFavXj0GgPn4+Mj8bt69eyddbu7cuQwAMzIyYh07dmSDBg1ibm5u0uP38RVTQkjF0oZ6AGP/3RExbdo09vnnn7PJkyezFStWsMjIyDLtz6FDh1hAQAADwGrUqCFzbtqwYYN0OXWfExn7L99+XA9RJZ+ps6x3795Jz7s1a9ZkQ4YMYT169GCGhobSz6ssV/Dnzp3LOI5jTZs2ZX379mUBAQHSO1utrKzYgwcP5NaRbGPIkCHMwsKC9e3bl/Xt21d6N86IESPk1gkPD2fVq1eX5tRhw4axDh06MADMwMCA7du3T2Z5yZ0w7du3Z23btmV2dnZs0KBBrEuXLkwgEDChUMjOnDnDVq9ezQwMDNgnn3zCBgwYwKpVq8YAsMDAQLkYhg4dygwMDJinpyfr378/69+/P3N2dmYAmIODA0tISCh2XyXy8vKYvb09MzY2ZklJSXLLp6enMwsLC2ZlZcUyMzNLPf6S+l7v3r1Z7dq1mb29PRs0aBDr27cv++OPPxhjZauLKFsPzsrKYl27dmUAWNWqVVmPHj2Yn58fs7OzYwCYv78/E4lEpcZP9AM1RJBy+9///qewQiBx//59BoB5enoqVZ7kj9eff/5Z4fyQkBDpc6MSP//8c4mVnA8fPkhPeiXR9KMZkuRvYmLCLl68qHCZkJAQhX8c9+3blwFg27Ztk5lXWuOBomM5Y8YMBoCNGjVKY2Vt376dAWAuLi4sPj5eOj0pKYl5eHhIy1O2ISImJoZdv35dbvrdu3eZjY0Ns7KyknkumbH/jreZmRm7du2adHpmZqa0IvJxA8bnn3/OALCuXbuytLQ06fTIyEhpojx69KjMOpLPvWbNmuzZs2cy6xgbGzMzMzPm7OzM1q9fL52Xm5vLunXrxgCwzZs3y5QXHh7OIiIi5PY1NDSUGRkZsXr16jGxWKxwX4sez9OnTzMArF+/fnJlRUVFMQCsYcOGcvOKI/nMXF1d2cuXL+XmJyUlsTNnzsjFFhMTw5ydnZlAIJD7vEu7lXrfvn0MAGvSpAmLioqSTheLxWzhwoUMABs6dKjS+0AIUT9tqAcw9t/55OMXx3FsypQpcv1ElUSZRzM0cU4srfGgLPlMnWWNGzdO+odidna2dPqdO3ekDQFlaYi4fv06i4mJkZu+efNmaQ7+mOR4N2zYkCUmJkqnx8TEMBsbGwZAJgeLxWLWtGlTBoDNmTNH5nPYv38/EwgEzMLCQqZfLMnnLrn4k5GRIZ23ZcsW6eddpUoV9s8//0jnJSQkSOsI0dHRMnGfP39ersFcJBKx4OBgBoCNGTNG4b5+fDznzZvHALA1a9bILS/pJ23y5Mly8xSR1Pckdeein6mEKnWR0urBU6ZMkebton2XpKWlsd69ezMAMnUlot+oIYKUm6SDx/nz5yucL/mDx83NTanyevTowQDIXHUo6syZMwwA69Gjh3Ta999/X2xrOGOM5efnS1twS1JRDRFTp04tc9mS4/hxxau0xoOid1tIJCUlKUxy6iyrY8eODADbvn273DqSz7AsDRElkXSSduTIEZnpkuOt6Lsp6cS06L5mZGQwU1NTJhAIFF5B++WXXxgA1r17d5npks9948aNcutIKtSdOnWSm3f48GGFx7skkg7cwsPDZaYraogQi8XM1dWVGRgYyHVAKrnLYPXq1UpvW/KZ/f3330qvIyGpJP3yyy8y00triJDcdfPxHTeMFe6fh4cHEwqFMndQEEIqljbUAxhj7KeffmK///47e/r0KcvKymIxMTFs3bp10rsKZ8yYofQ+laUhQp3nxNIaD5TNZ+osKz09nZmYmDChUKgwZ0tysLr6NOjYsSPjOE6uk03J8T5z5ozcOpKLCEX39fz58wwAq1OnDsvLy5NbR3LX4JIlS6TTJJ+7QCBgT548kVleJBJJ765YsGCBXHmSBrmy1CFr1arFqlWrJjdd0fGMi4tjAoGANWrUSG75tm3bMkBxHy2KSOp7xsbGChvRSlNcXaSkevCbN2+YoaEhc3R0lLvgxhhjiYmJzMjIiDVr1qzM8RDdpPHhOx89eoTGjRtrejOE6BR/f/8S50dFReHEiRN49uwZMjMzIRaLpf0MREVFlWlbPXv2lJtWrVo1VK1aFYmJiRopKz8/H//88w84jpM+G1xU9+7dUbVqVSQnJ5dp+yKRCOfOncO1a9eQmJgofR5UckyKOzaK4nZ3dwcAmbjv3LmD7OxstGrVCg0aNJBbZ9SoUZg+fTquXr0KsVgMgUC2mx1F25EMV1fSPEWfQ25uLkJDQ3Hr1i28e/cOeXl5AICHDx9K97Vp06YK91eC4zhMmDABc+bMwZYtWzBv3jwAhZ/P1q1bYWxsjE8//bTEMhSV6efnV+IyYWFhuHjxIhISEpCTkwPGmHQfy/L9ffv2LR48eAA3Nzc0adJEYSwdO3bE/fv3cefOHfj4+JRpX4j6UK4n2uCLL76Qee/i4oIpU6bA29sbnp6e+PXXX6XP/KtLRZ4TAeXzmTrLunPnDnJyctCuXTuF/UAMHToU33//fZm2DQAZGRk4evQo7t+/j+TkZOTn50u3zRhDdHQ0PD09ZdYxNDRE165dlYr7ypUrAIAhQ4bA0NBQbp1Ro0bh4MGD0uWKcnZ2lpYpIRAI4OTkhKSkpDLn9Pfv3+PIkSOIiIjAhw8fpH035efn4/3790hOTi52OFoJJycn+Pr64sSJE7h27Ro6dOgAoLBecPPmTbRq1UphHy0l8fT0RK1atYqdr466iMTFixeRn58PX19fmJqays23t7eHm5sbHj58iOzsbIXLEP2ikYaIN2/eYNeuXdi+fTvCw8Op4xE9Z2FhAaCwgz9FMjMzAQCWlpYaK0/dMWhanTp1FE5njOHLL7/EmjVrih2DOT09vUzbql27tsLplpaWZW4IULas9+/fIy8vD7a2tjAxMVG4Tp06dcq0/ZcvX6Jv37548OBBscsUd2wUxS35LhTt3ErSaVRxHW7Z2NjA2toaqampSElJQbVq1WTmK0rmku9mSfM+7mBL0iFoSR15Kvs9GDNmDL755hts2rQJX3/9NTiOw9GjR/HmzRsMHz5cbh9KY2dnB2NjY4XzUlNTMXDgQJw/f77ccQOQ7n9UVJS0M9DiJCUlKV0uUQ/K9URCG+oBJWncuDH8/f2xf/9+nDt3Tq5D5vKoyHMioHw+U2dZkj+si2vAKa5OU5Lz589j2LBhePfuXbHLKDo29vb2EAqFctNVyemS6QkJCXLzivvjXJWcvnv3bkyYMAEZGRkKywQK97W0hggAmDRpEk6cOIENGzZIGyI2bNgAAPjss89KXf9jJX126qyLAP/l9A0bNkhjLk5ycnKJDSREP6itISI7OxsHDx7E9u3bce7cOekV3CpVqqhrE0RLSU5ixfWyLJnu5OSksfLUHYOmFffH+d69e7F69Wo4OjpizZo1aN++PWxtbWFoaIi8vDwYGxsX20BRnI+v2peHOssqq/Hjx+PBgwcICAjAnDlzUL9+fVhaWkIgEODPP//ExIkTiz026oy7pD+IS9qOsjEwxjBkyBDExcVh0qRJmDRpEurWrQsLCwtwHId58+Zh6dKlSn8PqlevjoCAAOzatQvnzp1D9+7dsXHjRgCqVVqK++4CwNy5c3H+/Hl4e3sjODgYTZo0gY2NDYRCIU6fPg0fH58yfX/FYjGAwopnaXc7aMtvW99RrieKaEM9oDRubm4Ayn7XQGkq8pwI6EdOz8jIwJAhQ5CcnIyFCxdi2LBhcHJygqmpqXRkiN27dys8NtqQz8sSx/Pnz6UNXz/99BP69OmDWrVqSa/2d+jQAdevX1f6e9C7d284Ojpi3759+Pnnn2FkZIQdO3bAwsICw4cPV6qMoor7/qq7LgL8l9M9PDzQvHnzEpctrnGP6JdyNUQwxnD27Fls374dISEh0hZqMzMz+Pv7Y/jw4XSrbCUgOZncvXtX4XzJ9GbNmmmsPMk6ERERyM/Pl7sFr6wx8OXQoUMAgPXr18sNQxoTE8NHSCqpVq0aDA0NkZSUhJycHIWJLj4+XunyMjMzcebMGdSoUQN79+6VuxqirmNTs2ZNAFA4pCZQeHXrw4cPMDU11dgfXv/++y/+/fdftGrVCuvXr5ebr8q+Tpo0Cbt27cKGDRvg7u6OU6dOwc3NTeHtreVx6NAhCIVCHDlyBFZWVjLzVIlbcrWuevXqcsPPkYpDuZ6URhvqAaVJSUkBAJibmyu9Tnmp+5zIFwcHBwDF5+2y5HOg8JGJ9+/fY9CgQQgODpabX1E5XXKFXpNX3k+cOIG8vDx8+eWXco8OAWXfV6FQiM8++wwLFy7Ezp07YWVlhZSUFIwfP16td/1qoi4iyemdOnXC2rVryx0j0X0qNSs+ePAAs2fPRu3ateHr64sdO3YgOztb2nr17t077Ny5E3379lX4TBbRLx07doS1tTWio6Nx//59ufn79+8HgFKfoZTw9fWFQCDAlStX8PbtW5l5ubm5OHr0KIRCIXr37i2d7uLigoYNGyI7OxvHjx8vdwyqMjIyAgCVb1GWVJQU3S65b98+1QOrYIaGhmjTpg0YYzh48KDc/PPnz+P9+/dKl5eamgqxWAwHBwe5Roj8/HxpA055tWzZEqamprhz547C53Z37NgBoPA7r6krSSV9B1JSUnDmzJkyl+nl5YXGjRsjJCQEK1asgFgsxvjx48sdq6L4rKys5CrcQPHf35J+M7Vr10aDBg3w+PHjYseVJ5pDuZ4oSxvqASXJzc2V1g0+7nOgOOXN54Bq50Rt1LJlS5iYmOD27dt48eKF3Pyy7ktJee7Zs2fFNkCVlZeXFwDg77//lvbJUJQkp0uW04SS9vXy5ct48+ZNmcscP348DAwMZB5xUOUOx5KoWhcp6XfTtWtXCIVCHDt2TNofCKnclK5Jv3r1CitXrkSzZs3g6emJVatWITExES1atMCaNWuQkJCAli1bAij5NjWif4yMjPD5558DAKZOnSq9WgYAq1evRnh4OLy9vaXfD4lff/0VDRo0wNdffy0z3cHBAcOHD0deXh6mTJkiczKbM2cO3r17h5EjR8LOzk5mvZkzZ0qXKVpxOXjwII4cOQJXV1f069dPPTtdDEnr+5MnT1RaX9Ix0p9//ilzu9uVK1ewcuXK8gdYgSZNmgQAWLhwoczzl8nJyZg9e3aZyrKzs4O1tTUiIiJw9epV6XSRSIS5c+eq7Y9Uc3NzjB07FmKxWO67/PTpUyxZsgQAMH36dLVsTxFXV1cIBAKcP39epjEkJycHkyZNKnO/HhITJ05EXl4e1q1bB0NDQ7U+Iy3h7u6OlJQU7N27V2b6mjVrcOHCBYXrlPab+eabbyAWixEQEKDwD5z379+X+qwpUR7leqIKbagH/Pvvv9i+fbvc8/nv3r3DsGHDEB8fj+bNm6Njx45K7VP16tVhaGiI6OhohX/EKkOVc6I2srCwwIgRI1BQUIAvvvhC5hg/ePCgzFe3JXWdgwcPyvQR8eHDB4wbN05tf6R26dIFTZs2RVxcHBYuXChTrzp06BAOHjwICwsLjB07Vi3bU0Syrzt27JD5XSQkJEjrSWXl4OAAf39/3Lt3D5cuXUKzZs3Qpk0btcQroWpdpKScXqtWLYwdOxZxcXEYPny4wkaYZ8+e4cCBA2raC6L1lBla45NPPmEGBgZMIBAwjuOYi4sLmz9/vtzwdp06dWICgaB843gQnZSdnS0dOsjBwYENGTJE+t7W1lZuTGXG/htWStHQhe/evWP16tVjAFi9evXY0KFDWZMmTaTDf71//15uHZFIJB0qsUqVKmzQoEGsS5cujOM4Zmpqym7cuKEw9rZt20pfkjGg69atK52m7JjMjDG2atUqBoDVqFGDDRs2jI0bN47NnTtXOl/REItFPXnyhJmbmzMArFGjRmzYsGHMy8uLcRzHvvzyS5WG3CxuGClFQyypsyyxWCz9PCwsLFi/fv3YwIEDWZUqVVirVq1Yu3btGACWkJCgsMyPSYZoFQqFrEePHmzo0KHM2dmZmZqasqlTpzIAbNGiRTLrlHS8ixuaLS0tjbVs2ZIBYHZ2dmzw4MGsd+/ezMTEhAFg06dPV2r/JUo6dsXFIBkKz9TUlPXp04cNGjSI1ahRg1WvXp0FBQWVOBxbcd+tDx8+MDMzMwaADRo0SOEypVH0/Stqx44d0uHVvLy82PDhw1mjRo2YQCCQDmv28Xfr9u3bjOM4ZmJiwvr168fGjRvHxo0bx5KSkqTLSMZOFwgEzNPTkw0ePJgNGjSItWjRggmFQmZtba3S/hBZlOtJefBdD5DkrypVqrAePXqwwMBA1qVLF2ZpackAsNq1a8sNx1gaPz8/BoA1btyYjRo1io0bN45t3rxZOl8T58TShtwsSz5TZ1nv3r1jrq6uDACrVasWGzp0KPPx8WGGhobSoTOVHZ6Vsf+GaLWxsWH9+/dn/fv3ZzY2NszV1ZX169dP4bDOJR3vLVu2KKwHhIeHs2rVqjEArGHDhmz48OHS4cUNDAzY3r17ldp/iZKOnaIYcnNzWePGjRkAZm9vzwICAlifPn2YmZkZ69ChA+vQoYPC8kr7bp0+fVr63fr111+LXa44xdX3ilKlLlJaPTgrK0v62Zubm7OOHTuy4cOHM39/f+n3q1+/fmXeH6KblLoj4vz589Lboo8fP46YmBgsWbJE4fB2pHIyMTHBhQsX8M0338DMzAwhISHSDnru3r0rHdJIWdWrV8etW7cwbdo05OXl4dChQ0hNTcX06dNx69YthT0LCwQC/P3331i1ahVq1qyJY8eO4eHDhwgICMDt27fRtm1bhdu6efOm9CW5kyImJkY67fHjx0rHPX36dCxYsAAWFhY4cOAANm3ahD179ii9vru7O27fvg0/Pz8kJSXhyJEjyMjIwB9//KFzd0RwHIe9e/di6dKlcHBwwMmTJ3Hz5k2MHDkS58+fR1JSEjiOU7qvhXnz5mHbtm1o1qwZrl69irNnz6J58+a4ceMGWrVqpba4LS0tcenSJQQHB6N69eo4cuQIrly5glatWmHXrl34+eef1bat4qxfvx6rVq2Ci4sLzp07hytXrqB79+64ffu2yp0yWltbS29JVvctnBIjRozA8ePH0a5dO9y/fx8nT55EzZo1cf78+WKHrG3ZsiV27NiBRo0a4fTp09i0aRM2bdok0xP3999/j0uXLiEgIACvX79GSEgILly4AJFIhMmTJ+PIkSMa2Z/KhnI9KQ++6wHu7u6YMWMG6tevj4cPH+Lvv//G7du34ebmhkWLFiE8PFxuOMbSbNy4EaNGjcL79++xa9cubNq0CZcuXVJ6fVXOidqqevXquHbtGiZOnAiRSISQkBC8ePECK1euxJw5cwCgTKMwHT58GPPnz4etrS1OnjyJO3fuYNiwYbhx4wZsbGzUFnfTpk1x9+5dfPbZZ8jIyMD+/fvx5MkT9O/fH1evXsWQIUPUti1FjIyMcOXKFUyePBkmJiY4duwYIiMjMW3aNJw5c0blx9q8vLxgaGgIU1NTjBgxQs1RF1KlLlJaPdjU1BQnT57Etm3b0LZtW0RGRmL//v24ffs2bG1tERwcjBUrVmhkf4j24RgrvbvTKlWqIDU1FUBh51T9+vXDyJEj4ePjI/OctJeXF65du6byLWyEkMrh5cuXcHFxgaurKyIjI/kOp1KIj4+Hi4sLHB0dERMTU+pwmKTyoVxPCFHFnj17MHz4cEyaNElhx4ZE/Xbv3o3AwECMHj2aOnMmOkupOyLevHmD/fv3w9/fH/n5+di9ezf69u0LBwcHfPHFF7h9+7am4ySE6KDw8HC5Zz3fvHmDoKAgFBQUYOTIkTxFVvksW7YMIpEIU6dOpUYIohDlekJISe7cuSM37f79+9J+nyinV4z8/HwsX74cQGGfLIToKqXuiCgqJSUFe/bswfbt23Hjxo3CQjgObm5uSElJQVJSEl0lIYQAKOz5/NatW/Dw8ECNGjWQmJiIO3fuICMjA61bt8bly5epwzsNevLkCVauXInY2FicP38etWvXRmRkJCwsLPgOjWg5yvWEkI+ZmJjA3t4eDRs2hJWVFWJjY3Hnzh2IxWJ8/vnnNCSjhh05cgQhISG4desWHj16hP79+6tt1DBC+FDmhoiioqOjsX37duzcuRPR0dGFBXIcWrdujeHDh2PIkCHSsYcJIZXPnj17sGXLFjx8+BDJyckQCoVwd3fHoEGD8L///Q9mZmZ8h6jXLl68iK5du8LU1BStW7fG2rVr0axZM77DIjqGcj0hBACCg4Nx4sQJxMTE4MOHD7CwsICHhwfGjx+vsX4KyH8WL16M4OBgVKlSBb169cLatWsV9plGiK4oV0NEUTdu3MBff/2Fv//+G+/fvwfHcRAIBOjcuTPOnTunjk0QQgghhEeU6wkhhBCiDmpriJAoKCjAiRMn8Ndff+HYsWPIz8+n2zcJIYQQPUK5nhBCCCHlofaGiKJSU1Oxb98+jQ0VRwghhBB+Ua4nhBBCSFlptCFCn4nFYrx69QqWlpbUAz0hhBDeMcaQnp6OmjVrygy3SVRHuZ4QQoi20Zd8b1CWhUUiER49eoSCggK4urrCyspKOi8qKgrr169HVFQULCws0KdPH70exufVq1dwdHTkOwxCCCFERnx8PGrXrq3y+pTr/0O5nhBCiLYqb77nm9J3ROzZswfTp0/H+/fvAQCGhoaYMmUKVq9ejdDQUPTr1w8FBQWQFMdxHPz9/VUeVubOnTs4c+YMbt26hVu3biEhIQEAoOoNHCkpKVi8eDFCQkLw+vVr2NvbY8CAAVi8eDFsbGzKXF5qaipsbGwQHx8vU0kjhBBCKkpBQQH8/Pxw7do1/O9//8OaNWvw4cMHWFtbq1Qe5XpZlOsJIYRog6VLl2LZsmVo164d9uzZA2dn53Lle22gVEPE9evX0alTJzDGYGBgAGtra2lv2WvXrkVwcDBycnIwceJEuLi4ICYmBn/++ScyMjKwefNmjB49usyB9e/fH4cPH5abrkrlJCkpCe3bt8ezZ89Qt25dtGrVCo8ePcKjR4/g7u6O69evl3n4m7S0NFhbWyM1NZUqJ4QQQnjz008/ITg4GEePHoWXl5fKeYlyvTzK9YQQQrTBtWvX0LdvXyxduhTDhw/Xi9ykVEPEoEGDcPDgQXz11VcIDg6GoaEhYmNjMXToUDx9+hSZmZm4ffs2mjdvLl3n3r17aN26Nby9vVUa0mv58uXIzMxE69at0bp1azg7OyM3N1elysnIkSOxc+dODBw4EHv37oWBQeETKdOnT8fatWsxevRobN26tUxlUuVE80RihluxyXibngM7SxO0cakKoYCe0SVEX+jqb5yvuPMKxNh+PQ7Pk7PgVNUMo9o7w8ig8NnQpKQkGBkZlSsvUa6XR7le83T1PEAIUY6u/sa1NddXr15db3KTUg0RtWrVgrm5OZ4+fSozPSwsDJ07d0aHDh0QFhYmt16nTp3w5MkTvHv3rtyBmpiYqFQ5SUxMRO3atWFgYIAXL16gRo0a0nm5ublwdHREcnIyXr16BTs7O6XL1ZcvgLYKjUhE8NHHSEzNkU5zsDbBIr9G8G3iwGNkhBB10NXfOF9xLz3xGBuuxEL8/ykwM/IyLOq3x4Qu7vi6dyMA5c9LlOvlUa7XLF09DxBClKOrv3FtyfU5z8NhVLUmJvdpLc31gP7kJqW62Xz37p3MFRCJFi1aAACcnJwUrufk5IQPHz6oHp0ahIaGQiwWw8vLS6ZiAgDGxsbw8/ODSCTCiRMneIqQfCw0IhGTd9yV+fEDwOvUHEzecRehEYk8RUYIUQdd/Y3zFffSE4/xx+X/KiZptw4h6cgKvN6/BL9ffIalJx6rZTuU60lF0tXzACFEObr6G9eWXJ/76gneHgjGq+2zse7oTbXlem2iVENEQUEBLC0t5aabm5sDKEzyihgZGUEsFpcjvPJ78OABAMDT01PhfMn08PDwCouJFE8kZgg++hiKroVJpgUffQyRWLWOzAgh/NLV3zhfcecViLHhSqzMNMPqdcAZGsOkTlNwAiE2XIlFXkH5cy3lelJRdPU8QAhRjq7+xrUp1wvNq0BoWR2G1R0htKiitlyvTXR34FElvXjxAgCKHdpEMv358+cllpObm4u0tDSZF1G/W7HJci2QRTEAiak5uBWbXHFBEULURld/43zFvf16HD6u75jWbYma436DVdsAAICYFS5XmVGu1y26eh4ghChHV3/j2pTrDaztYD9iBWz7fw1OaKiXuV7vGyIyMjIAAGZmZgrnS670pKenl1jO0qVLYW1tLX3RuOKa8Ta9+B+/KssRQrSLrv7G+Yr7eXIWACA3MQqirFTpdAPrGuA4Tm65yopyvW7R1fMAIUQ5uvob5zvXi7JSkfv6mXS60MwaAiNTueX0hdINEdu2bYNQKJR7cRxX7Ly//vpLk7FXqK+//hqpqanSV3x8PN8h6SU7SxO1LkcI0S66+hvnK26nqmbIexeHt3sX4PXOuShIf1/scupAuZ5yfUXQ1fMAIUQ5uvob5zPXi3Oz8Hb/YrzZ9RWy4+4Xu5w+UbohgjGm0otvFhYWAICsLMUtSJmZmQCg8LnYooyNjWFlZSXzIurXxqUqHKxNUNzgOBwKe61t41K2seAJIdpBV3/jfMU9qr0zBAIhOCNTCE0tITAxl1tGwBUupw6U6ynXVwRdPQ8QQpSjq79xfnM9B4GxBTgDIxhYVpNbRp25Xlso1RAhFotVfolEIk3vQ4nq1KkDAHj58qXC+ZLpxfUGTiqWUMBhkV/h8DQfnwQk7xf5NdKJ8YcJIfJ09TfOV9xGBgJMHdAZ9iNXwnbQIggM5a/CfOblIh1jvDwo15OKoqvnAUKIcnT1N85nrp/4SSPYDVoI+xHLYVhN/rFAdeV6baJfe6OAZCiyu3fvKpwvmd6sWbMKi4mUzLeJA9aP9IS9tWyF297aBOtHemr1uMOEkNLp6m+8IuNOS0vDkydPAABf926EqX3bwNDUQmYZAQdM7OwiM7Z4ZUW5Xvfo6nmAEKIcXf2NV2TcjDHcvn0bQGGun9TVHcbVZRsh9DnXc0wb7qlUgomJCXJzc8t8C2hiYiJq164NAwMDxMfHw87OTjovNzcXjo6OSE5OxqtXr2TmlSYtLQ3W1tZITU2lWzc1RCRmuBWbjLfpObCzLLwNSttaTgkhqtPV37im487JyUHv3r3x4MEDHD9+HO3atQNQOLzX9utxeJ6cBaeqZhjV3lnm6og+5CXK9ZWPrp4HCCHK0dXfeEXE/e2332Lx4sX45Zdf8PnnnwMoPdcD+pObDPgOQF1+/fVX/PrrrxgwYACWLl0qne7g4IDhw4dj586dmDJlCvbs2QMDg8LdnjNnDt69e4fRo0eXqWJCKoZQwKF9PflnpAgh+kFXf+Oajjs7OxvZ2dnIy8uDoaGhdLqRgQDjvOpqbLu6gHK9/tHV8wAhRDm6+hvXdNyMMSQlJYExBoHgv4aGypTrtbYh4vjx4/juu++k7/Py8gBAemUIAL755hv06dMHAJCUlIQnT54gMTFRrqyffvoJN27cwIEDB9CgQQO0atUKjx49QkREBNzc3LB69WoN7w0hhBCinCpVquDs2bOIjIxEy5Yt+Q5HoyjXE0IIqYw4jsPPP/+MgIAAeHt78x0OL7S2IeLdu3e4efOm3PSi0969e6dUWdWrV8etW7ewePFihISE4NChQ6hRowamT5+O4OBg2NjYqCtsQgghRCVRUVFwc3MDAJibm6NVq1Y8R6R5lOsJIYRUJlFRUXB1dQXHceA4rtI2QgA61EeEttGXZ3MIIYTw75dffsGsWbOwefNmjBo1SqUyKC+pHx1TQggh6vLPP/+ga9euCAwMxPr16yEUClUqR19yk96PmkEIIYRoM8YY7ty5g4KCAsTFxfEdDiGEEEI04PHjx8jOzkZsbCwKCgr4Dod3WvtoBiGEEFIZcByHLVu2oH///ujfvz/f4RBCCCFEA0aPHg0HBwe0b98exsbGfIfDO7ojghBCCOHB69evpf8XCAQYMGAAOE77hzQjhBBCiHJSUlKQk5Mjfd+zZ09YWlryGJH2KNcdERcvXsTly5eRmJiI3NxchctwHIdNmzaVZzOEEEKIXnn8+DG8vLzw2WefYenSpVrdAEG5nhBCCCm7zMxM9OnTB0ZGRjh8+DCsra35DkmrqNQQkZqain79+uHKlSsora9LqpwQQgghsi5evIjk5GRcvHgROTk5MDU15TskOZTrCSGEENU9efIEERERMDAwwKtXr6gh4iMqNUTMnTsXly9fhqurKyZNmgR3d3e6xYQQQghR0pQpU1CtWjV0795dKxshAMr1hBBCSHl4enri0qVLyMnJQcOGDfkOR+uoNHyng4MDAODRo0eoWrWq2oPSBfoybAohhJCKkZmZCWNjYxgYaKafaHXnJcr1lOsJIYSUDWMM6enpGs0Z+pKbVOqsMjU1FR07dqy0FRNCCCGkLPLy8jBgwAAEBAQgOzub73CUQrmeEEIIKZtly5ahRYsWiI6O5jsUradSQ4SbmxsyMzPVHQshhBCil+7fv48rV67g3LlziIqK4jscpVCuJ4QQQpSXkZGBTZs2ISYmBmfOnOE7HK2nUkPEtGnTcPHiRTx79kzd8RBCCCF6p02bNjh16hQOHTqEZs2a8R2OUijXE0IIIcqzsLBAWFgYfv31V0yaNInvcLSeSg+qjh8/HlFRUfD29saSJUvQo0cP1K5dW92xEUIIITotNzcXxsbGAIDOnTvzHE3ZUK4nhBBCSlc019vb22Pq1Kk8R6QbVGqIEAqFAAo74xg/fnyJy3Ich4KCAlU2QwghhOis9evX4/fff0doaKi040ddQrmeEEIIKdm9e/fQr18//PXXX+jSpQvf4egUlRoiHB0dwXGcumMhhBBC9EJGRga+//57JCQkYPfu3Zg5cybfIZUZ5XpCCCGkZMuWLUN8fDyWLVsGb29vyptloFJDRFxcnJrDIIQQQvSHhYUFrly5gu3bt+N///sf3+GohHI9IYQQUrJt27bB2dkZ8+bNo0aIMuIYY4zvIHSRvozfSgghRH3EYjEEApX6gS43ykvqR8eUEELIx/jM9YD+5Cb+jiAhhBCiR548eYKmTZvizp07fIdCCCGEEA3Izs5Gt27d8Oeff/Idis5T6dGMoh49eoSoqCikp6ejuJsrPv300/JuhhBCSCWn6JZHAwMD2Nraon379pg1axY6dOjAQ2SFvv76azx+/BizZ8/GuXPn5OJ1dnbG8+fPi82VyoqLi4OLi0ux862trTF69Ghs3bpVZnlvb29cvHhRpW1SrieEEFIRtD3Xb9u2DZcuXcL9+/cxYMAA2NraysyvqFwPAJMnT8bOnTtlli9Prq9oKjdEnD17FlOmTEF0dHSxyzDGwHEcVU4IIYSozejRo6X/T09Px4MHD3Dw4EEcOnQIO3bsQGBgYIXHFBcXh0OHDsHe3h579+6tkOdEzc3NMWjQIOn7/Px87Nq1C4GBgejUqZNatkG5nhBCCB+0NddPnjwZTk5O2L59u1wjhCZ8nOuB//J9u3btNL59TVKpIeL27dvo06cPOI5DYGAgHj58iIcPH+Krr75CdHQ0zp49i5SUFIwZMwZ16tRRd8yEEEIqMcmVfgmxWIx58+Zh+fLlmD59OgYPHgxDQ8MKiUXyR7hE/fr1K6RiAgDVq1eXORZpaWnYtWsX1q9fr5ZnRinXE0II4Ys25XoAMnc4ODs7w8vLq0K2+3GuB/7L90Uba3SRSn1ELF26FAUFBTh69Ci2b9+OFi1aAAC+//577NmzB8+ePcOgQYNw7NgxjB07Vq0BE0IIIUUJBAJ8++23MDAwwPv37/Ho0aMK2W5+fj4GDhyIv//+u0K2V9Eo1xNCCNEWfOV6APjxxx8xffp0iMXiCttmZaBSQ8S1a9fQokUL9OjRQ+F8Gxsb/PXXXxAIBFiwYEG5AiSEEEJKY2RkBGtrawBAQUGB3PysrCwsXboULVq0gIWFBSwsLNCuXTts27at2DKTk5Px9ddfo1GjRjA1NYW1tTW6deuGY8eOAQA2bNiAkJAQjBgxQvoc56VLl8BxnPQVFBSkVPzx8fH4/PPPUa9ePZiYmKBq1aro27cvrl27VsYjoZwff/wRHMdh3rx5xS5z7NgxiMViGBgovnmScj0hhJCKxEeuf/LkCebOnYtff/0V9erVA6Bfub5nz57gOA4XLlzQSAwlUenRjOTkZHTp0kX63sjICACQmZkJc3NzAICxsTG8vLxw5syZ8kdJCCGElCA2Nhbv37+HoaEhXF1dZea9ffsWPXr0QHh4OOzt7eHt7Q3GGK5du4agoCDcvn0ba9eulVnn6dOn6N69O+Lj4+Hs7AwfHx+kp6fjxo0b8PPzw8qVK/G///0P//77L6ytrREZGYkDBw6gRo0a8PX1lZajTF8N169fR58+fZCSkoL69eujT58+ePfuHU6dOoXQ0FDs3LkTQ4cOVc+B+n9BQUFYsGABtmzZIr3CVFRsbCzy8vJgYWGBrl27AqBcTwghhF985Povv/wSO3bswP79+8FxnN7l+rNnz8LNzU2a6ysUU0GtWrVY7969pe/nz5/PBAIBCw8Pl1mub9++zMzMTJVNaL3U1FQGgKWmpvIdCiGEVAoA2MdpKz09nV25coW1atWKAWDTp0+XW693794MAPviiy9YTk6OdPrr16+l6508eVI6vaCggDVt2pQBYCtWrGAikUg6Lyoqirm4uDChUMgePnwonR4bG8sAMG9v72Ljd3Jykos/NTWVOTg4MKFQyHbs2CEz759//mFVqlRhFhYW7O3bt3LbcnJykitLUV4qLrbAwEAGgB06dEgu1vnz5zMArEGDBjLTKNcTQgjRJMr1stv6ONdLyvs4N5Un1y9fvrzY/dEklRoivL29WcOGDaXvDx8+zDiOY1OnTpVOi4qKYmZmZqxJkyblj1ILUeWEEEIqlqRyouhlaWnJ1q5dy8Riscw69+7dYwBY69atZSoZEnfv3mUAmL+/v3TaoUOHGAAWEBAgt/zGjRvZkCFD5CpCqlZO1qxZwwCwWbNmKVxn9erVDABbvXq13LZKehVVXGyXL19mAGQuLDBWWDmrVasW4ziOubu7S6dTrieEEKJp2pDrHzx4wDp06KD1uV6ZhojScr2hoSF78+ZNsfujSSo9mtG7d298/fXXiIyMRMOGDeHr6wsnJyesX78e//zzD2rXro3z588jJycH48aNU2UThBBCiEJFe4nOzc3F8+fPcfPmTXz77beoV68eevXqJZ1/+vRpAED//v0hEMh3iyR5jvTWrVty6wwcOFBm2SdPnmDChAnSzqqKrqOq4rYlIemVW9G2Shq+UxleXl5o3LgxQkNDER8fD0dHRwDAiRMnkJCQgKZNm+LRo0eU6wkhhFQ4vnJ9QUEBAgIC8OzZMwDal+uB//K9MkrL9YMGDYKdnZ3S+6JWqrReJCYmst9//51FRERIp4WHh7MGDRowjuMYx3FMKBSyCRMmyLVY6Qu6SkIIIRULCq72S9y9e5dZWloyAwMD9u+//0qnT548udQrCgCYgYGBdJ1evXoptY6rq6t0HVWvkjRs2FCpbXXv3l1uW+V9NIMxxn755RcGgC1evFg6zc/PjwFgu3fvplxPuZ4QQioU5XrZbZX30QzGSs71p06dKnZfNE2lOyLs7e0xceJEmWlNmzZFZGQk/v33X6SkpMDV1bXCxlInhOgmkZjhVmwy3qbnwM7SBG1cqkIo4PgOi1QQdX7+LVq0wMSJE/Hjjz9i/fr1+OmnnwBAevdCp06dpL1dl0ayjq+vL2rUqFHsctWrV1cpVkXbGjRoEMzMzJGUkYvsfBFMDYWobmEM7v8PR4MGDaTH6+GT1+XersSnn36Kr776Cps3b8Y333yD169f48SJE3B2dsbQoUPBcbKfB+V6QkhZUa6v3CjXa3euL24UzIqgUkNESRo0aKDuIgkheig0IhHBRx8jMTVHOs3B2gSL/BrBt4kDj5GRiqCJz18yhGZUVJR0Wu3atQEU3q45a9YspcqRrDN+/Hh4eHhg5cqV+Pnnn2FsbKxSXKVt68mTJ+g8aDx2xRgUezxCIxLRafl5JKbmoCD1DQAgMTUHoRGJ5fq9WFtbY9iwYdi8eTNOnTqFu3fvQiQSYfz48XKNEEVRrieEKINyfeWmK7m+T58++Pzzz/HNN9/AyclJpbhK25Yu5npNk3+IhhBCNCw0IhGTd9yVOREDwOvUHEzecRehEYk8RUYqgqY+/5iYGACAhYWFdJqkpf/QoUNKlyNZ58CBA/Dz88Mff/yBL7/8ssR1JENbKhrXXJltffPzlmKPx9ITjxUeL5GYqeX3MmnSJADAH3/8gU2bNkEoFGLMmDHlKpMQQijXV266kusPHTqEWbNmYdOmTejVqxdEIlGx61CuVy+l7oj49ttvwXEcpk6diqpVq+Lbb79VegMcx+Gbb75ROUBCiH4RiRmCjz4GUzCPAeAABB99jB6N7OnWTT2kqc//3r17+PPPPwEUdqgs0bZtW/To0QNnzpzB1KlTsXTpUlhZWcms++DBAyQmJkrHBA8ICECjRo2we/dujB49GoaGhliwYMF/cf7/uOQA0LFjRwCFt24aGhoiOjoaIpEIQqFQqbjHfzYB33y3DKk3D0BoZQuL5j3BcQLp8WBiEX7eth8Ci2owsnVWWIbkeKmqdevW8PT0xOHDhwEU3qZas2ZNyvWEEJVRrq/cdCnX79y5E7NmzYKHhwdWr14tzd/amutV/b18nOv9/f1Rs2ZNlcpSF6UaIhYvXgyO4zB06FBUrVpV+p4xRV8vWVQ5IYQUdSs2Wa61tyiGwtvQbsUmo329ahUXGKkQ6vj8g4KCpP/Py8vD8+fPcePGDYjFYvj5+WHUqFEyy+/YsQO+vr747bffsGvXLnh4eKBmzZpITU1FeHg44uPj8cUXX0grJwYGBggJCYGPjw+2bdsGOzs7jBw5EnZ2dkhKSsL9+/fx9u1brFmzRlo5MTIygq+vL44ePYrmzZvD09MTRkZG6NixY4lXHJ6miFFtwAK8PfAtkk/9itRre2FoWwcCEwuIM1OQ9zoa4txM2A6Yr7ByUvR4NbY1LHY7pZk0aRImTJgAABgwYAAAUK4nhKiMcn3lpmu5ftWqVbCzs8MPP/yAjRs3anWuL8/vpWiul/zLJ6UaIrZs2QIAcHBwkHlPCCFl9Ta9+MSkynJEt6jj89+2bZv0/wKBADY2NujcuTNGjRqFoKAguaG77OzscO3aNWzYsAF79uzBvXv3cO3aNdSoUQN169bF9OnTMWzYMACFt1vOnz8fs2bNwr179/Drr7/i4MGDuHHjBgoKCmBvb48WLVrA398fQ4YMkdnOxo0b8eWXX+LMmTPYtWsXRCIRCgoKSqycvE3PgXGtBqg5dh3SbocgO/of5MZHAACE5lVhXKcpzNzaw8TZo9TjVZ6GiG7dugEAqlSpIt0vyvWEEFVRrq/ctD3XA8Dvv/+Opk2b6lyuLw9Jrq9du7a0QYZPSjVEFB3HVdF7QghRlp2liVqXI7qlPJ+/Mlfmi2NiYoJp06Zh2rRpJS43e/Zs/PTTTzh58iTu3buH+fPnY/78+Uptw87ODn/99Vex8+Pi4uTX+f/9FFpUQZUuY1ClS+nPaxpY14DT3GMKy1HE2dm51GO3b98+AMD06dNhY2MDgHI9IUR1lOsrN23P9SdOnMDkyZNhamqKBw8eVLpcP27cOKUfK9Ek6qySEFKh2rhUhYO1CYp7wo1DYQ/CbVyqVmRYpIJo++c/efJk1KtXD0uWLKmQJF3a8QAAAQeNHq+0tDSsXbsWRkZGWnGrJiFE92n7uZ5olrZ//l26dEHv3r0xYcIEuLq6anx7lOsVo4YIQkiFEgo4LPJrBED+hCt5v8ivEXVepae0/fN3d3fH48eP4e/vXyHbK+14cAA+83Ipdj6g+vHasmULgoKC4OHhgcTEREyZMoX3jqsIIfpB28/1RLO0/fM3MzNDSEgIVq9eXSHDV1KuV4xjStz/InmeRKUNcBzOnTun8vraKi0tDdbW1khNTZXrlZUQUjoaW7xy06bPf8+ePWjUqBGaNWtWodstqrTjoczxKmteCgoKwrZt22Bra4shQ4YgIiJC7plbZVGuJ4Qook3nelLxtOnzf/ToEe7fv48RI0ZU6HaLUkeuB8qWmz7O9atWrYKxsbH6d04FSjVEFFcxKak3bck8juNKHI9VV1HlhJDyE4kZbsUm4216DuwsC285o6sjlYc2fP5nz56Fr68vLCwscOfOHdSrV69Ct19UacejtPnlzUuU6+VRriek/LThXE/4ow2f/9u3b+Hp6YmEhATs3LkTgYGBFbr9osqb6wH9yU1KdVYZGxsrN23VqlVYv349Bg0ahOHDh8PZ2RkA8Pz5c+zevRv79+/HpEmTMGvWLLUGTAjRH0IBR8N2VWLa8Pm3atUK7du3R7169eDi4sJrLKUdD00fL8r1hBBN0IZzPeGPNnz+1atXx7Bhw3Dy5EneR4vgO9drE6XuiPjYzp07MXr0aBw+fBh9+vRRuMyJEyfg7++PrVu3YuTIkeUOVNvoS0sUIYRUdtnZ2TAwMIChoerDX2oDdeclyvWU6wkhRJ+kp6fD0tKS7zDKTV9yk0oNEa1atYKFhQUuXrxY4nJdunRBeno67ty5o2p8WktfvgCEEFLZxMbG4vHjx8X+ca2r1J2XKNdTrieEEF2Vm5uLv/76C+PHj6+QDikrkr7kJpV6pYqMjEStWrVKXa5mzZr4999/VdkEIYQQonZJSUno2bMn+vXrhwMHDvAdjlajXE8IIUQXMcYwevRoTJgwAdOmTeM7HFIMlRoizM3NcevWLYjF4mKXEYvF+Oeff2Bubq5ycIQQQog62djYoFOnTnB0dET79u35DkerUa4nhBCiiziOg4+PD0xNTdGvXz++wyHFUKkhwsfHBzExMZg0aRLS09Pl5mdkZGDy5MmIiYmBj49PuYMkhBBC1MHAwACbN2/GzZs3tWYcbW1FuZ4QQoiuGjNmDGJjY9GjRw++QyHFUKmPiJcvX6J169Z4+/YtrKys4OvrCycnJwCFPWmHhoYiLS0NNWrUwM2bN+Ho6Kj2wPmmL8/mEEKIvhOJRDh8+DAGDBigd8+JFqXuvES5nnI9IYTokmPHjqFbt24wMzPjOxSN0pfcpFJDBADExcVh8uTJOHXqlML5PXv2xPr163kfDk1T9OULQAgh+owxhokTJ2LDhg2YO3culi1bxndIGqOJvES5nnI9IYTogn379mHYsGHo0KEDTp8+rdeNEfqSmwxUXdHZ2RknT55EbGwswsLC8OrVKwCAg4MDOnXqhLp166otSEIIIUQVHMehQYMGEAqFaNOmDd/h6BzK9YQQQnRBzZo1YW1tjebNm8PU1JTvcIgSVL4jorLTl5YoQgipDJ49ewZXV1e+w9AoykvqR8eUEEJ0R0xMDJycnCAUCvkORaP0JTep1Fnlx6KionD9+nU8ffpUHcURQggh5RIWFob8/Hzpe31vhKgIlOsJIYRok6dPnyIhIUH6vm7dunrfCKFPVG6IyM3Nxbx581C9enU0aNAAnTp1knn2dseOHfD09MT9+/fVESchhBCilJMnT6Jr167o168fsrOz+Q5Hp1GuJ4QQoo1evnyJ7t27o2PHjnj27Bnf4RAVqNQQkZ2djS5dumD58uUwMjJC79698fETHt26dcODBw+wb98+tQRKCCGEKMvQ0BBVqlSBsbEx36HoLMr1hBBCtJVIJIKJiQlMTExgY2PDdzhEBSo1RKxYsQI3b97E2LFjERMTg6NHj8otU7NmTTRq1Ahnz54td5CEEEKIsnr16oWbN29iy5YtEAjU8gRipUS5nhBCiLZycnJCWFgYzpw5g+rVq/MdDlGBSjW0vXv3ok6dOli/fj1MTEyKXa5+/fqIj49XOThCCCFEGfHx8Xj//r30fdOmTWFkZMRjRLqPcj0hhBBtkp+fj8ePH0vf29nZwdHRkceISHmo1BARGxuLVq1awcCg5NE/jYyMkJKSolJghBBCiDLevXuHHj16wMvLi/4gViPK9YQQQrSFWCxGUFAQ2rZtS3fh6YmSaxfFMDU1VarSERsbiypVqqiyCUIIIUQpycnJyMzMBMdxfIeiVyjXE0II0RY5OTl4+/YtcnJyUFBQwHc4RA1Uaojw8PDA7du38e7dO9ja2ipcJjY2Fvfu3UPPnj3LFSAhhBBSkvr16+Pq1avIzs6mWzTViHI9IYQQbWFmZoZjx47h5s2b6Ny5M9/hEDVQ6dGMzz77DOnp6Rg+fDiSkpLk5n/48AFjx45Ffn4+JkyYUO4gCSGEkKJEIhGeP38ufV+nTh3Ur1+fx4j0D+V6QgghfIuNjZX+39jYmBoh9IhKDRHDhw/HsGHDcP78edStWxe+vr4AgKtXr6Jfv35wdnbGpUuXMGrUKPTt21etARNCCKncGGOYPn06PD09cfPmTb7D0VuU6wkhhPDpwIEDcHd3x7p16/gOhWiAyuOa7dy5E8uXL4eJiQlOnz4NAIiKisLRo0fBcRy+//57bNmyRW2Bksrt3r174DgOtWrVUjhfLBbDxsYGHMcVe2Xu8uXL4DgOjRs3VjmOX375BY0bN4axsTE4jkOXLl1ULosQopqsrCzcvn0bKSkpiIuL4zscvUa5nlQkyvWEkKKuXr2KgoIChIeHgzHGdzhEzVTqIwIAOI7D7NmzMXPmTNy9exdxcXEQi8WoXbs2WrduTcOmEbVq3rw5rKys8OrVK8TExKBu3boy8x8+fIjU1FQAQFhYmMIyrly5AgDw8vJSKYaDBw/iiy++QJUqVeDv7w9zc3M0aNBApbIIIaozNzfHuXPncP78efj7+/Mdjl6jXE8qEuV6QkhRq1atQrt27RAQEEAdUushlRsiJIRCIVq3bo3WrVurIx5CFBIIBOjQoQNCQ0MRFhYmVzmRVDyaN2+O8PBwvH//HtWqVVO4jKqVk5CQEADA/v370a1bN5XKIISorminiRYWFtQIUYEo15OKQLmeEJKUlIRq1aqB4zhwHIchQ4bwHRLREJUfzSCkokkqFYqugoSFhcHQ0BAzZswAYwxXr16VmS8Wi3H9+nWZcsrq5cuXACBXMSKEaN7Zs2fh4uKCXbt28R0KIUSDKNcTUnm9evUKrVu3xuTJkyESifgOh2iYyg0Rubm52LZtG8aOHYtevXqhW7duCl+ffPKJOuMllZikUiG52lHUlStX4OnpiR49eihc5sGDB0hLS0OdOnVQp04d3L9/H3PmzEHLli1ha2sLY2Nj1K1bF1OmTMGrV69k1l28eDE4jsOFCxcAAC4uLtJW2osXL0qXKygowPr169G+fXtYWVnB1NQUHh4e+OmnnxSOd+zs7AyO48AYw9q1a9G8eXOYmZnBw8OjPIeJEL20b98+ZGZm4ujRo/ScaAWiXE8qGuV6QiqvK1eu4Pnz5zh37hw+fPjAdzhEw1R6NOPFixfo3r07oqOjS60Q0vM8RF3atGkDY2NjPHnyBElJSahevToAICYmBq9evcLw4cNRq1YtODk5yV1J+fhWzWXLluHAgQNo1qwZOnXqBAC4f/8+1q9fj5CQENy+fRs1a9YEAHh4eGD06NEIDQ3FmzdvEBAQAAsLCwCAvb09ACA7Oxt9+vTBhQsXULVqVbRr1w4mJia4efMm/ve//+HChQs4dOgQBAL5tr9JkyZhy5Yt8Pb2RsOGDZGXl6eBo0eIbvv999/h4eGBcePGUV6pIJTrCR8o1xNSeQ0dOhRGRkbw8PCQe+yK6CGmgn79+jGO49gnn3zCjhw5wiIiIlhcXFyxL32UmprKALDU1FS+Q6lUOnXqxACwkJAQ6bRt27YxAOzQoUOMMcYCAwOZkZERy8rKki4zePBgBoD9/vvvjDHGzp8/z16/fi1TtkgkYsHBwQwAGzNmjNy2vb29GQAWGxsrN2/KlCkMABs6dCj78OGDdHpaWhrr3bs3A8DWr18vs46TkxMDwKpXr84iIiLKfCwI0XcZGRl8h6BT1J2XKNdTrucL5XpCKo/8/HyWnZ3Ndxg6RV9yk0oNERYWFszd3Z3l5+erOx6doS9fAF3z9ddfMwBs1qxZ0mnjx49nANjbt28ZY4ytW7eOAWAXLlyQLuPg4MAAsEePHpW6jVq1arFq1arJTS+ucvLmzRtmaGjIHB0dZSpEEomJiczIyIg1a9ZMZrqkcrJy5cpSYyKksklKSmKNGjVi8+bNY2KxmO9wdIK68xLlesr1fKFcT0jlIBKJ2OjRo1nXrl3pPFsG+pKbVOojwsjICJ6enjAwKPegGyXKzs7GwoUL4e7uDhMTE9SsWRNjx45FQkJCmcu6ceMG+vXrh+rVq8PExATu7u6YP38+MjMzNRA50RRFnViFhYXB3d1d2pt+x44dZZaJjo5GYmIiqlWrhoYNG0rXe//+PbZs2YJZs2Zh3LhxCAoKQlBQEPLz8/H+/XskJycrFdPFixeRn58PX19fmJqays23t7eHm5sbHj58iOzsbLn51PM/IfKOHz+Ox48fY9u2bUhKSuI7nEqJcj3hC+V6QiqH6OhoHDx4EJcvX8Y///zDdzikoqnSetG3b1/WqlUrdTeKyMjOzmbt2rVjAJiDgwMbMmQIa9OmDQPAbG1tWXR0tNJl7dixgwmFQgaAeXp6sgEDBrA6deowAKxZs2YqtSbpS0uUrvnw4QMTCATM0NCQZWVlsbdv3zIAbOzYsdJlRCIRs7KyYj4+PowxxrZs2cIAsH79+kmX2bVrF7OwsGAAin19fKtxcVdJli9fXmI5RV8vX76Urie5SkK3oxGi2ObNm+lW5jJQd16iXE+5ni+U6wmpPO7cucN27tzJdxg6RV9yk0qXOYKDg9G5c2ds2LABn332mSpFlGrJkiW4ceMG2rdvj9OnT0s7DFq9ejVmzZqFsWPHyvRiXJyXL19i/PjxEIlE2LRpE8aOHQsAyMvLQ1BQEHbv3o3Zs2fjjz/+0Mh+kJKJxAy3YpPxNj0HdpYmaONSFUJB8Z2eWVtbo1mzZrh//z5u3Lgh7VFX0gkVUDgOebt27XD9+nWIRCK5zqueP3+OoKAgAMBPP/2EPn36oFatWtIrHB06dMD169eV7plfLBYDKOzoqnnz5iUua2xsLDfNxMREqe0Qoqqy/s74IhaLIRaLpVfgx4wZw3NElRvleqIulOsp15OKoSv5Pj8/H4aGhgAAT09PeHp68hwR4YNKDRGenp44ffo0Ro4ciR07dqBnz56oVauWwl6CAeDTTz8tU/l5eXn49ddfAQDr1q2TVkwAYObMmdi2bRsuXbqEO3fuoGXLliWWtXXrVuTk5KBHjx7SiglQeMvpr7/+imPHjmHz5s344YcfqHfWChYakYjgo4+RmJojneZgbYJFfo3g28Sh2PW8vLxw//59hIWFKaycAIW3bJ4+fRrh4eHS2zYllZMTJ04gLy8PX375Jb744gu58mNiYsq0H7Vr15bGsHbt2jKtS4imqfo7q2iMMcycORPPnz/H7t27qdKuBSjXE3WgXE9IxdCVfH/kyBHMmTMHJ06cQN26dfkOh/BI5Qc/z5w5g7dv3yIuLk5u+CQJxhg4jitz5eTq1atITU1FvXr10KJFC7n5gwYNQnh4OI4ePVpq5eTOnTsAgC5dusjNq1q1Kpo1a4arV6/i+PHjZY6TqC40IhGTd9zFx9chXqfmYPKOu1g/0rPYk6aXlxfWrl2LsLAwpKSkoEaNGnBzc5NZRvLs6MGDB/H06VOYm5tLW1tTUlIA/FepKOry5ct48+ZNmfala9euEAqFOHbsGFavXi1t4SWEb+X5nVW0qKgo/P7778jNzcXFixfh6+vLd0gElOtJ+VCuJ6Ri6Eq+LygowLx58/DkyROsW7cOq1at4jskwiOVGiJWrlyJ4OBgGBsbY8CAAahbt67MlYzyevDgAQAUe5uOZHp4eHipZUk6qKpSpYrC+ZIrI5JtEs0TiRmCjz6WO1kChQ9XcgCCjz5Gj0b2Cm8nk1ztuHbtGnJychR2ANW2bVsIhUKsW7cOANCuXTvp7d7u7u4AgB07dmD8+PEwNzcHACQkJGDSpEll3p9atWph7Nix2LBhA4YPH45169ahRo0aMss8e/YMDx48QEBAQJnLJ0QV5f2dVTR3d3ecOnUKjx49okYILUG5npQH5XpCKoYu5XsDAwOcOXMGq1atwrJly3iNhfBPpYaI9evXw8rKCjdv3kT9+vXVHRNevHgBQHErdtHpz58/L7UsSe/KxS0bGxurVFm5ubnIzc2Vvk9LSyt120SxW7HJMreNfYwBSEzNwa3YZLSvJ38Lrb29PVxdXfHs2TMA8rdqAoCFhQWaN2+Ou3fvAvivQgMU9lzduHFj3L59G66urujYsSNycnJw4cIFeHh4oEOHDrh27VqZ9unnn39GXFwcDhw4gNDQUHh4eKBOnTrIzMzE48eP8ezZM/Tr148qJ6TClPd3VlEkV9MBwNvbG97e3rzFQmRRrqdcXx6U6wmpGLqQ74vmegcHB/z444+8xEG0i0rDd75+/Rre3t4aqZgAQEZGBgDAzMxM4XxJq3Z6enqpZXXu3BkAsHv3buTl5cnMu337Nh4+fKhUWUuXLoW1tbX05ejoWOq2iWJv04s/WSq7XNHKhqLKCfDfLZsfL29kZIQrV65g8uTJMDExwbFjxxAZGYlp06bhzJkzKt1uaWpqipMnT2Lbtm1o27YtIiMjsX//fty+fRu2trYIDg7GihUrylwuIapSx+9M0y5cuIB27dohMTGRtxhI8SjXU64vD8r1hFQMbc/3b968QevWrXHp0iVetk+0l0p3RNSrV0/ae7C2GzFiBJYsWYIXL17A398fP/74I5ycnHD9+nV89tlnMDAwQEFBQbGdb0l8/fXXmDlzpvR9WloaVVBUZGepXCd0JS23efNmbN68ucT1f/nlF/zyyy8K51WpUgW//fabwnnF9dBeWs/tQqEQn376qdLPH8fFxSm1HCGqUMfvTJMKCgowadIkPH36FEuXLi32t0r4Q7mecn15UK4vRLmeaJq25/vg4GDcuXMHU6ZMQXh4OIRCIS9xEO2j0h0RkyZNwoULFzR2cpU8g5qVlaVwvuRZUEtLS6XKOnbsGGrXro1Tp06hadOmsLKygo+PD4yMjDBr1iwAxT9XKmFsbAwrKyuZF1FNG5eqcLA2QXFPqXEo7OW3jUvVigyLEL2i7b8zAwMDnDx5EkFBQXQFUUtRrqdcXx7afg4iRF9o+29t1apVGDduHA4fPkyNEESGSg0RU6dOxYQJE+Dl5YWtW7ciISFBrUHVqVMHQOG44IpIpjs5OSlVXvPmzfHkyRNs2bIF06ZNw5QpU7Bx40bcv39f2qlR48aN1RA5UYZQwGGRXyMAkDtpSt4v8mvEe4c6hOgyXfid1a1bF1u2bKGhOrUU5XpSHrpwDiJEH2j7b83U1BQbN26Eq6srL9sn2kulRzMkrVmMMYwbN67EZTmOQ0FBQZnKb968OQBIOx/6mGR6s2bNlC7TzMwMQUFBCAoKkpku6ahI0ZBfRHN8mzhg/UhPufGO7bVwvGNCdJW2/c4+fPiAwYMHY/ny5cWOlEC0B+V6Ul7adg4iRF9p02+NMYbJkyejVatWGD9+fIVtl+gejjGmaLSXEjk7O0t7PlWGpLdqZeXl5cHOzg6pqam4d+8ePDw8ZOY3b94c4eHhuH37dqlji5ckPDwcLVq0QMOGDREREVGmddPS0mBtbY3U1FS6dbMcRGKGW7HJeJueAzvLwtvG6OoIIeqlLb+zyZMn4/fff0f9+vXx6NEjukVTzdSdlyjXU65XF205BxGi77Tht3bw4EEEBARAKBQiMjISbm5uFbr9ykBvchPTUvPnz2cAWIcOHVhGRoZ0+qpVqxgA5u3tLbP82rVrWf369dlXX30lV9a9e/dYfn6+zLTHjx8zV1dXxnEcO3/+fJnjS01NZQBYampqmdclhBA+oXA0L5mXgYEBc3BwYAMHDmRXr15VuJ63tzcDwGJjY1XabmpqKhswYAB78OCBdFpsbKzCc3pRjx49Yp9//jlr3Lgxs7KyYkZGRqxmzZrMz8+Pbdu2jeXm5srtn5OTU5liK+++McbYokWLGAC2ZcsWlcsoD13MS5TrCSFEc/jI92KxmH399ddsw4YNMtMp36uPvuQmlR7NqAgLFizA2bNnce3aNbi5ucHLywvPnz/HzZs3YWtrK9eLclJSEp48eaJwGLgZM2bg8ePHaN68OWxtbREfH4/r16+D4zj88ccf6Nq1a0XtFiGEaI3Ro0dL/5+eno4HDx7g4MGDOHToEHbs2IHAwEC1bs/KygoHDx5UennGGBYuXIilS5dCJBKhTp066Nq1K0xNTREfH4/Q0FAcPXoUwcHBiI6OVmuspGJQrieEEM2ryHzPcRx++OGHMq1D+b6S4rslpCRZWVnsm2++YfXq1WNGRkbM3t6eBQUFsfj4eLllJS1To0ePlpu3YcMG5u3tzWxtbZmhoSGrWbMmCwwMZPfu3VM5Nn1piSKEVD74/6siHxOJRGzu3LkMAKtWrRrLy8uTmf/8+XMWGRkpN70k8+bNY3///Xex80u6QvLVV18xAKxGjRrs+PHjcvOTk5PZvHnzmKGhocx0qHCFRJV9+xhdIVEN5XpCCNGMisr3x48fZzNnzmQikajYZSjfq4++5CatbojQZvryBSCEVD7FVUwYYyw3N5cZGBgwAOX6A44xxg4dOsQAMKFQyJ4+fapwmeIqJjdv3mQcxzFTU1P2+PHjErcTFhYm816Viok6UMVE/9AxJYTosorI969fv2bm5uYMAPv999+LXY7yvfroS25SafhOQggh+snIyAjW1tYAIDcKQpcuXcBxHOLi4mSmcxwHZ2dn5OXl4dtvv0WDBg1gbGyMLVu2YOLEiVi2bBlMTEwwatQo2NrawszMDC1btsSOHTuKjWPVqlVgjGH69Olo2LBhiTF37NhR4XSRSITly5fD3d0dxsbGcHR0xNy5c5Gbmyu3bHH7BgDv37/H/Pnz0bRpU5ibm8PKygpNmzbFnDlzFD4i8DHGGGbMmAGO49CpUyd8+PBBOi8yMhJBQUFwdHSEsbExatSogWHDhuHRo0dy5WzduhUcx2Hx4sV48eIFAgMDYWtrC1NTU7Rq1QonT54sNRZCCCEEUF++r1OnDho0aIB+/fph7NixiI+Pp3xP+V4pWttHBCGEkIoXGxuL9+/fw9DQsExjfovFYvTv3x+XL1+Gt7c3mjVrhmrVquG3335DXFwc2rRpg9evX6Nu3bro3r07EhIS8Omnn2Lq1KkKywoNDQWAcj23GhgYiBMnTqBLly6oX78+rly5ghUrViAhIaHESlFRkZGR6NmzJ16+fAl7e3v4+PgAAJ4+fYqVK1eiQ4cO6N+/f7HrFxQUYOzYsdi+fTt69eqF/fv3w8zMDAAQEhKCYcOGITc3Fx4eHmjXrh3i4+Oxb98+HD16FCdPnkTnzp3lyoyLi0Pr1q1haWmJTz75BC9evMD169fV3qcHIYQQ/aWpfN+hQwfK95TvlcPvDRm6S19uiSGEVD5QcKtmeno6u3LlCmvVqhUDwKZPny63XnE9TUvKc3V1ZQcOHGBLlixhYrFYOt/X15cBYGPHjpUZ1eDIkSNMKBTK3aoZFRXFADBjY2NWUFCg8v41bNiQJSYmSqfHxMQwGxsbBoA9e/as1H3Lz89n9evXZwDYjBkz5HrrjoiIkCnn41s1s7KyWN++fRkANnz4cJnnUWNjY5m5uTmzsLBgZ86ckSn35MmTzNDQkDk6Ospsc8uWLdJ9mzVrlsyzuGvWrJHOo7ykPpTrCSG6TFP53sXFhY0cOZKlp6fLzKd8T/m+LKghQkVUOSGE6CpJAlP0srS0ZGvXrpVpSJAorWKyceNGZm1tzQCwP//8kzHGWHR0NAPArKys2IcPH+TKHDp0qFzF5MaNGwwAs7e3L9f+fZzwGWPs888/V/hcp6J927t3LwPAGjdurFQFqWjF5MOHD8zLy4sBYFOmTJE7nl988QUDwNauXauwrOnTpzMA7ODBg9JpkoqJi4uLXCUpPz9fWul69+5dqbES5VCuJ4ToMk3l+0aNGjEAbNCgQdJ5lO8p35cV9RFBCCGV1OjRo6WvYcOGoX379sjMzMS3334rvVVSWRzHYeTIkViyZAk6d+6MkSNHAgDCwsIAAL6+vtJnUYsaPnx4+XdEAUNDQ4XDNbq7uwOAUs96nj17FgAwfvx4CIVCpbf99u1bdOnSBVeuXMGCBQuwbt06cBwns8zp06cBAAMHDlRYhpeXFwDg1q1bcvO6dOkCIyMjmWkGBgZwcnICACQnJysdKyGEEP2n7nz/+++/o379+liyZIl0OuV7yvdlVe4+Ih48eIBbt24hKSkJjRs3hr+/PwAgNzcXubm5sLKyKneQhBBC1G/r1q1y0+7duwdvb2/4+/sjIiIC9evXV6osOzs7GBsb4/PPP8fkyZOlifzVq1cAIE2aH3N2dpabVq1aNQBASkoKRCJRmSoFEvb29grXs7S0BACFHVh9LD4+HgBQr169Mm17/vz5KCgowOTJk/Hdd98pXEbSSVatWrVKLCspKUluWu3atRUuW5Z9KyvK9YQQorvUne+9vLzw6NEjmTxL+V4/8n1FUrkh4smTJxgzZgxu3rwpnTZ69Ghp5WTXrl0YP348jh8/Dl9f3/JHSgghRONatGiBiRMn4scff8T69evx008/lbh8amoqAMDY2Fg6TZWKRFF169aFlZUV0tLS8OjRIzRr1qzMZQgE/N3wN3DgQISEhGD79u0IDAxEp06d5JYRi8UACvNmSdq2bSs3rSL3jXI9IYTop7Lke8YYfvjhBwCAiYkJgPLneoDyfVF853s+qNQQER8fj86dO+Pdu3fw9/eHl5cXZs+eLbPMkCFDMGXKFBw4cIAqJ4QQokNcXFwAAFFRUSUuxxjDkCFDABQOeaWIg4MDAOD58+cK5yuaLhAI4Ovri3379mHXrl0qVUzUwdHREQAQHR1dpvV69eqFESNGYNCgQejVqxdOnTqFDh06yCxTu3ZtREdHY9WqVdIrQtqGcj0hhOg3ZfP96tWrsWDBAgCFuV8Ryve6m+/5olIzy7fffoukpCRs3LgRISEhmDVrltwy5ubm8PDwkLmKQgghRPvFxMQAACwsLEpcjuM46fm/uFvzJVcHQkNDkZaWJjd/z549CtebOXMmOI7DL7/8gsjIyBLjuHbtWonzS8NxHC5dugSgsFLGcRw4jsOGDRsAFN56KbmioSx/f3/s27cPubm58PX1xY0bN2Tm9+jRAwBw6NChcsUuGQ+d4zjp87nNmjWTTvv4WdWyoFxPCCH6Tdl8P2TIEDRs2BAAis0rlO91N9/zRaWGiNDQUDRr1gxjx44tcTlnZ2ckJCSoFBghhJCKd+/ePfz5558AgN69e5e6fM+ePQFArjMliXr16qFnz55IS0vDrFmzIBKJpPNOnDiBv//+W+F6bdu2xZw5c5CdnY1u3brhxIkTcsukpqZi0aJFCjupUlVAQIC0Q69Ro0bBysoKWVlZmDNnDvLz82WWffTokbQSp0j//v2xZ88eZGdnw9fXV6YjqlmzZsHU1BRffvklDh48KLdubm4u9u/fj5cvXyoVt4+PD+zs7AAUVoqKdkymKsr1hBCiv8qS7x0dHXH37t0Sl6F8r7v5ni8qPZrx9u1bdOzYsdTl8vPzkZWVpcomCCGEaFhQUJD0/3l5eXj+/Dlu3LgBsVgMPz8/jBo1SuF6O3bswMSJE2Fra6vUdtavX48OHTpg48aNuHDhAlq3bo1Xr17hypUrmDJlCtatW6dwvaVLl8LAwABLly5Fnz594OTkhBYtWsDU1BQvX77EzZs3kZeXBzc3tzLve3F+/PFHmQ61IiIi0KNHD6xatQq7du1C+/btwRhDVFQUIiIicOjQIdStW7fY8gYOHIjdu3dj+PDh8PHxwZkzZ9CqVSu4urpi9+7dCAwMREBAAFxdXdGwYUOYm5sjISEBd+/eRWZmJu7du1dsZ1VFffXVV/jmm2/w9u1bLFmyBE2bNi33saBcTwgh+kHVfH/37l1pTpT0DVESyve6me/5otIdEdWqVcOLFy9KXe7p06fS54UIIYRol23btklfe/fuxb///ovOnTtj06ZNCAkJKbaTpG+++QadOnVCZmamUtupW7cubt68icDAQHz48AEhISFIS0vDli1b8OWXXxa7HsdxWLJkCcLDwzF16lSYmZnh3Llz2L9/P6Kjo+Hj44MdO3bg0aNHKu2/Mpo0aYIHDx7gyy+/hKWlJU6cOIHz58+D4zjMnTsX7dq1K7WMQYMGYefOnUhPT0fPnj2lV5X69euH8PBwTJkyBRzH4cyZMzh+/Djevn0LPz8/7Nu3D40aNdLYvpWGcj0hhOiHsub7jIwMAEBgYCBu376t9HYo3+tmvucNU8GgQYOYgYEBu3fvnnQax3FszJgx0vcXL16Um6ZPUlNTGQCWmprKdyiEEFJh/v33X+bk5MS+//57vkNRGwBMmXR4+fJlNnXqVNa0aVNmY2PDTExMWP369dncuXNZSkpKses9fvyYjR07ljk5OTEjIyNma2vLOnTowFauXMny8/Nlls3Pz2e//fYba9euHbO0tGQmJiasefPmbM2aNXLLMsaYt7c3A8AuXLigVF7KzMxk3377LWvcuDEzMTFhVlZWzMvLi+3evVtu2UGDBjEAzMHBQTqtaF7fsmWL9NgVzfWSmGJjY9nOnTtZ27ZtmYWFBbO2ti42Lm1FuZ4QUhllZGSwXr16sR49erDc3Fy+w1EbyveK873k2Dg5OSmcJ8n3ixYtUhiTqvlepYaIGzduMKFQyOrUqcNOnDjBCgoKZCon586dY46OjszQ0JA9ePBAlU1oPaqcEEIqq5SUFCYWi/kOQ22UrZi0bduWmZiYsDZt2rCAgADWp08f5uDgwACwxo0bs/T0dLl19u3bx4yNjRkA1rBhQzZ06FDm6+vLHB0dGQCZCk1WVhbr2rUrA8CqVq3KevTowfz8/JidnR0DwPz9/ZlIJJIpvywVk7S0NNayZUsGgNna2rJBgwaxXr16SeObPn26zPI3btxgAJhQKFSY62fPns0AMIFAIJPrJTFNmDCBCQQC5uXlxYYNG8Y6duxY6jHWNpTrCSGVVV5eHsvIyOA7DLWifK8430uOjaoNEarme5UaIhhjbN26dczAwIAJBAJmYWHBBAIBs7KyYjY2NkwgEDChUMj++OMPVYvXelQ5IYRUFtevX2fh4eF8h6ExylZMTpw4wT58+CAzLScnh02YMIEBYMHBwTLznj59ykxMTJiBgQHbuXOnzDyxWMxOnTrFcnJypNOmTJnCALChQ4fKbCctLY317t2bAWDr16+XKacsFZPPP/+cAWBdu3ZlaWlp0umRkZHSys/Ro0cVHhtFuZ7jOAaA9e3bV2FMJiYm7OLFi8UdTp1AuZ4QUlkkJSWxAwcO8B2GRlG+Lznfq9oQoWq+V7khgrHCymm/fv2YpaUl4ziOcRzHTE1NWa9evVhYWFh5itZ6VDkhhFQGjx8/ZlWqVGE2Njbs/v37fIejEZKKSXGv2NjYEtfPyspiBgYGzNPTU2b65MmTGQA2adKkUmN48+YNMzQ0ZI6OjiwrK0tufmJiIjMyMmLNmjWTmS6pBBT32rJlC2Os8DZbU1NTJhAIWGRkpFz5v/zyCwPAunfvLnds7O3tFeb6pk2bllgxmTp1aqn7re0o1xNCKoOsrCzWtm1bBoD9+eeffIejMZTvS873qjZEqJrvVRo1Q6Jdu3YICQkBYwxJSUkQi8WoXr06hEJheYolhBCiJezt7dGoUSOIRCK4urryHY5GFTf0VdHx1RMSEnD06FH8+++/SEtLk443bmRkhKioKJn1zp49CwCYOHFiqdu+ePEi8vPz4evrC1NTU7n59vb2cHNzw8OHD5GdnS23jI+PD6pVq4Zdu3YhMDAQhoaGACD9zO7cuYPs7Gy0atUKDRo0kCt/1KhRmD59Oq5evQqxWCzTcZmxsbHCXL99+3aMGTOm2H3y9/cvdb8JIYTwz9jYGB06dMDTp0+VGi1J11G+V5zvVaVqvi9XQ4QEx3FKD+NGCCFEd1SpUgWnT59Gbm4uzM3N+Q5Ho7Zu3Vri/NWrV+Orr76SG1+8OPHx8QAKx1YvTVxcHABgw4YN2LBhQ4nLJicno1atWjLTvvrqK3h6emLXrl1Yv349rKysZOa/evUKAGSGKivKxsYG1tbWSE1NRUpKCqpVqya3TFlzfZ06dZRelhBCCH8EAgFWrVqFWbNmyeUXfUT5vuR8X1aq5nu1NEQQQgjRH+np6fjnn3/QrVs3AICZmRnMzMx4jopfN27cwKxZs2BtbY2ff/4ZXbp0gb29PYyNjQEANWvWRGJiosrlS660eHh4oHnz5iUuK9mmunEcV6blJTEXR5kx5wkhhPCDMYajR4/Cz88PHMeB47hK0QhRGsr38jSV75VqiJBURlXBcRzOnTun8vqEEEIqTm5uLgYOHIgLFy5g27ZtGDFiBN8haYVDhw4BAL7//nu5Wzqzs7Px+vVruXUcHR0RFRWF6OhoeHh4lFh+7dq1AQCdOnXC2rVr1RN0ETVr1gQAPH/+XOH81NRUfPjwAQKBAIMHD5ZO5zgOCQkJCusBsbGxAArHp79y5QrlekII0SE//PADFixYgPHjx+PPP/8s8x+n+qqy5HtTU1NUqVJFOt3Q0BAZGRkK15Hc8aFuSjVEXLx4UeUN0JeaEEJ0h0AgQK1atWBiYgJ3d3e+w9EaKSkpAP6rQBT1999/o7CfJ1ndu3dHVFQU/vzzT/z2228llt+1a1cIhUIcO3YMq1evlj7zqS4tW7aEqakp7ty5g6ioKLi5ucnM37FjB4DCqx5Fcz5jDAUFBQrrAZJ9jouLw4sXL9QaLyGEEM1ycHCAQCBA06ZN6e+1IipLvu/YsaNM/xAODg548eIF3r9/L/e4hqQPDHVTqneK2NhYlV8xMTEaCZwQQoj6GRoaYsuWLbhz5w5at27NdzhaQ9Ios2nTJplnRh8/foy5c+cqXGfGjBkwMTHBhg0bsHfvXpl5jDGcOXMGubm5AIBatWph7NixiIuLw/Dhw/HmzRu58p49e4YDBw6oFL+5uTnGjh0LsViMqVOnIjMzUzrv6dOnWLJkCQBg48aNMjl8wIABAIAxY8bITC+6z1988QXlekII0TFjx45FREQEpk+fzncoWqWy5PuPP3dvb28AkM6XWLFiBcLCwlSKpVQqjbVBaEgvQohe0fchl0sCJcYVT0pKYvb29gwAc3FxYUOGDGHdu3dnhoaGbPDgwczJyUlhGbt372aGhoYMAGvUqBEbNmwY69WrF3N0dGQAWEpKinTZrKws1qNHDwaAmZubs44dO7Lhw4czf39/5urqygCwfv36yZRflnHF09LSWMuWLRkAZmdnxwYPHsx69+7NTExMGAA2ffp0uXUiIiKYqakpA8A8PDxYQEAAc3d3Z6amptJx0Isbzqu0YdB0AeV6Qog+uXPnjsIhIysLyvfale/LP14HIYQQnfbrr7+iU6dO+PLLLxXeckiAatWq4Z9//kFgYCDy8vJw5MgRJCQk4LvvvsPu3buLXW/YsGG4ffs2Ro4cidTUVBw4cAB37txBnTp1sGrVKpmhwkxNTXHy5Els27YNbdu2RWRkJPbv34/bt2/D1tYWwcHBWLFihcr7YGlpiUuXLiE4OBjVq1fHkSNHcOXKFbRq1Qq7du3Czz//LLdO48aNcf78eXTp0gVPnz7FmTNnUK9ePVy/fp3umCGEEB1y584deHt7o2fPnkhNTeU7HK1F+b7i8j3HylHrzM3NxYEDB3DlyhXpUCE1a9ZEp06dEBAQoNc9ZqelpUmHPvl42BRCCNElq1evxqxZs7B48WIsWrSI73CIijSVlyjXU64nhOi+sLAw9O3bFy1btsSJEyc0NiID0Tx9yU0qN0ScPXsWQUFBSExMlLuCxnEc7O3tsXXrVvTo0UMtgWobffkCEEIIUDhcVdu2banDKh2mibxEuZ5yPSFEfzx69AiOjo50PtNx+pKbVGqIuHnzJry9vZGXl4e2bdti+PDhcHZ2BlA4VMju3btx48YNGBkZ4dKlS2jbtq264+advnwBCCGV09OnT+Hi4qL23poJf9SdlyjXU64nhOi2lJQUZGdnS4d0JPpBX3KTSg0RPXv2xLlz5/Dbb79h4sSJCpf5888/MWnSJPTo0QOnTp0qd6DaRl++AES9RGKGW7HJeJueAztLE7RxqQqhgK4wq0KTx1JXy1aXf//9F506dUK7du2wb98+mJmZ8R1ShdKFz0gV6s5LlOsp15Pi6et5hA+aOpaVPddnZWWhZ8+eSEhIwOnTp+WGcawMdOFzUoW+5CYDVVa6efMmWrVqVWzFBAAmTJiATZs24caNGyoHR4guCY1IRPDRx0hMzZFOc7A2wSK/RvBt4sBjZLpHk8dSV8tWp+fPnyMrKwtv376FSCTiO5wKpSufkTagXE+IYnQeUR9NHUvK9UBycjLevHmDDx8+ICcnp/QV9IyufE6VmUqjZggEAri6upa6nKurKz1vTCqF0IhETN5xV+ZkBwCvU3MwecddhEYk8hSZ7tHksdTVstXNx8cHFy5cwIkTJ2Bpacl3OBVGlz4jbUC5nhB5dB5RH00dS8r1hWrXro2rV6/i9OnTaNq0Kd/hVChd+pwqM5UaItq0aYPw8PBSlwsPD0ebNm1U2QQhOkMkZgg++hiKnnGSTAs++hgiMQ2LWBpNHktdLVtdMjMzkZycLH3ftm1bVK9enbd4KpoufEbahnI9IbLoPKI+mjqWlT3XM8YQHx8vfW9nZ1fphlrWhc+JFFKpIeK7775DVFQUFi1aBLFYLDefMYZFixYhKioK3333XbmDJESb3YpNlmtxLYoBSEzNwa3Y5GKXIYU0eSx1tWx1yMvLQ0BAALy8vPDy5UteYuCbtn9G2ohyPSGy6DyiPpo6lpU51wPAypUr0ahRI5w7d463GPimC58TKaRUHxF//fWX3LTRo0djyZIl2L59OwICAuDk5ASg8NnjgwcPIi4uDp999hmePHmilz1pEyLxNl255+6UXa4y0+Sx1NWy1eHVq1d4+PAhPnz4gISEBNSuXZuXOPik7Z+RNqBcT0jJ6DyiPpo6lpU514tEIpw+fRoZGRkIDw/HJ598wkscfNP2z4n8R6mGiKCgIIXPfzLGEBcXh1WrVknnFx2E488//8SGDRvw6aefqilcQrSPnaWJWperzDR5LHW1bHVwdnbGtWvXEB0dXWn/WNT2z0gbUK4npGR0HlEfTR3LypzrhUIhjh8/jgMHDiAwMJCXGLSBtn9O5D9KNUQsXLiQOqIipBhtXKrCwdoEr1NzFD6PxgGwty4cMoiUTJPHUlfLLo/k5GRUrVq4TScnJ+nV7MpIWz8jbUK5npCS0XlEfTR1LCt7rjc2Nq7UjRCA9n5ORJ5SDRGLFy/WcBiE6C6hgMMiv0aYvOMuOEDmpCep0i/ya6QX4xZrmiaPpa6Wrao///wT8+fPx/Hjx6kjQWjnZ6RtKNcTUjI6j6iPpo5lZcv1Dx48QNeuXbFkyRJMmTKlwrarzbTxcyKKqdRZJSFElm8TB6wf6Ql7a9nbvOytTbB+pCeNV1wGmjyWulp2WYlEImzZsgVJSUkIDQ2tsO1qO236jAghuonOI+qjqWNZWXI9APz9999ISUnB3r17UVBQUKHb1mba9jkRxThW9EFPorS0tDRYW1sjNTUVVlZWfIdDtIRIzHArNhlv03NgZ1l42xe1uKpGk8dSV8sui/T0dGzduhWff/453W7/EW35jNSN8pL60TElxdHX8wgfNHUsK0OuZ4xh/fr1CAwMhI2NTYVvX9tpy+ekbvqSm8rVEBEWFobDhw8jKioK6enpUFQUx3F6OYSMvnwBCCH6Izs7G6ampnyHQXiiqbxEuZ5yPSFEe2RnZ8PExIQuMlRi+pKblOoj4mOMMYwbNw7btm2TVkg4jpOpnEje04+EEEI0LyoqCl27dsWPP/6IYcOG8R0O0QOU6wkhRLvk5OTA19cXjRs3xtq1ayEUCvkOiRCVqdRHxO+//46tW7eiZcuWOHPmDAYOHAgAePLkCU6ePImgoCAIBALMnj0bMTExag2YEEKIvD/++AMJCQlYtWoVPSdK1IJyPSGEaJcLFy7gypUr2LlzJ2JjY/kOh5ByUemOiK1bt8Lc3BwnT55EtWrVsGPHDgCAm5sb3Nzc4OPjg969e2Po0KHo0KFDpR4yjhBCKsKKFStgY2ODCRMmwMBApVM7ITIo1xNCiHbp1asX9u7dCzs7O7i6uvIdDiHlotIdEZGRkejQoQOqVasGANJbMkUikXSZQYMGoWXLlvjxxx/VECYhhJCPFb3zQSAQYMGCBbCzs+MxIqJPKNcTQoh2KJrvBw8eDG9vbx6jIUQ9VGqIEIvF0ooJAJiZmQEAUlJSZJZzc3PDw4cPyxEeIYQQRfLz8zFgwAB88803CjsPJKS8KNcTQgj/1qxZAx8fH6Snp/MdCiFqpVJDRK1atfDq1Svpe8ntmPfu3ZNZ7unTp3SLMCGEaEBoaCiOHTuGH3/8EVFRUXyHQ/QQ5XpCCOHX27dvsXjxYpw/fx5///033+EQolYqNUR4enri8ePH0tsze/bsCcYY5syZg3///Rfp6elYuXIl7ty5gxYtWqg1YEIIIYCfnx/++OMP7Nu3D+7u7nyHQ/QQ5XpCCOGXnZ0dzp8/j8WLF2PMmDF8h0OIWnFMhXt6d+/ejREjRiAkJAT+/v4AgMDAQOzZs0dmCC+hUIiwsDC0adNGfRFrCX0Zv5UQoltoqERSHHXnJcr1lOsJIfygXE9Koi+5SaWGCADIzc2FgYGBdPza/Px8rFq1CiEhIUhJSYG7uzvmzJkDLy8vtQasLfTlC0AI0R2bN2/G8ePHsXPnTpiYmPAdDtEymshLlOsp1xNCKtbDhw8xfvx47NmzBy4uLnyHQ7SQvuQmlRsiKjt9+QIQQnTD27dv4eLigqysLPzxxx+YMGEC3yERLUN5Sf3omBJCKhJjDF5eXrh69SoCAgKwf/9+vkMiWkhfcpNKfUR83GM2IYQQzbKzs8OxY8cwbdo0fPbZZ3yHQyoByvWEEFKxOI7Dvn37MHToUGzYsIHvcAjRKJUaIhwcHDBgwADs378fubm56o6JEEKIAl27dsUvv/xCz42SCkG5nhBCKl7NmjWxZ88eVKlShe9QCNEolRoirK2tcfjwYQwdOhQ1atTAuHHjcO7cORrLnhBC1CgmJga9evXC69ev+Q6FVEKU6wkhRPNycnIQEBCAK1eu8B0KIRVKpYaIxMREnDx5EoGBgRCLxdiyZQt69uwJR0dHzJ49W26McUIIIWXDGMOnn36K0NBQTJ48me9wSCVEuZ4QQjRv+fLlOHjwIAICApCZmcl3OIRUmHJ3VpmdnY2QkBDs3LkTp0+fRkFBATiOQ4MGDTBy5EgMHz4czs7OagpXe+hLJyGEEO0VHR2NyZMnY9u2bXBwcOA7HKLlNJmXKNdTrieEaEZ2djZGjx6NiRMn4pNPPuE7HKID9CU3qXXUjPfv32Pv3r3YuXMnrl+/Do7jwHEcCgoK1LUJraEvXwBCCCH6oaLyEuV6QgghhD/6kptUejSjONWqVcOUKVOwZ88eTJo0CYwxepaUEEKUVFBQgAkTJuD+/ft8h0JIsSjXE0JI+axbtw6bN2/mOwxCeGWgroI+fPiAv//+Gzt37kRYWJi0UtK+fXt1bYIQQvTasmXLsGHDBhw+fBgxMTEwNzfnOyRCZFCuJ4SQ8rlx4wY+//xzAED9+vXRsWNHniMihB/laojIycnBkSNHsGvXLoSGhiI/Px+MMTRo0AAjRoxAYGAgXFxc1BUrIYTotWnTpuHChQuYNm0aNUIQrUG5nhBC1Kdt27aYO3cuMjMz0aFDB77DIYQ3KjVEnDp1Crt27UJISAgyMjLAGIODgwOGDRuGESNGwNPTU91xEkKI3rO2tsbZs2fBcRzfoRBCuZ4QQjSA4zgsW7YMjDHK96RSU6kholevXgAAS0tLfPrppxgxYgS6desGgUCtXU4QQoje27FjB8zMzDBw4EAAoEoJ0RqU6wkhRD0iIyOxa9cuBAcHS8+hlO9JZadSQ4Sfnx9GjBgBf39/mJiYqDsmQgipFG7duoWgoCAwxhAWFkbP2ROtQrmeEELKLysrC76+vnjx4gWMjY2xYMECvkMiRCuo1BBx+PBhdcdBCCGVjqenJ8aMGYOcnBy0bduW73AIkUG5nhBCys/MzAxLlizBypUrMWnSJL7DIURrcKycY24lJyfjzp07SEpKgpOTU6XpdEVfxm8lhPCLMQaRSAQDA7UNYkQqKU3mJcr1lOsJIeWTn58PQ0NDvsMgekBfcpPKD3q+e/cOgYGBsLe3h6+vL0aOHImNGzdK52/cuBFVq1ZFWFiYWgIlhBB9EBcXhzVr1kiHPeQ4jhohiNaiXE8IIWWXl5eHxYsXIzMzUzqNGiEIkaVSQ0RycjI6dOiAPXv2oEmTJpgyZQo+vrFi4MCBSE9Px/79+9USKCGE6LqsrCz4+Phg5syZWLlyJd/hEFIiyvWEEKKayZMnIzg4GP369ZM7bxJCCqnUEPH9998jOjoaCxcuxN27d7F27Vq5ZapWrYpmzZrh0qVL5Q6SEEL0gZmZGaZOnQpnZ2eMGDGC73AIKRHlekIIUc348eNRo0YNzJ49m0bHIKQYKjVEhISEwN3dHYsXLy5xuXr16iEhIUGVTQAAsrOzsXDhQri7u8PExAQ1a9bE2LFjVSrzzJkz6NOnD2xtbWFoaIhq1aqhZ8+eOHTokMrxEUJIWU2fPh0RERGoVasW36EQUiLK9YQQopr27dsjOjoaPj4+fIdCiNZSqSEiISEBzZs3L3U5juOQlpamyiaQk5ODbt264bvvvkNGRgb69esHR0dHbNmyBS1atEBMTIzSZf3000/o2bMnTp48CXd3dwQEBKBBgwY4e/YsBg4ciPnz56sUIyGElEYkEmHt2rXIy8uTTjM3N+cxIkKUQ7meEEKUt2fPHsTHx0vfU64npGQqNURYWVkhMTGx1OWio6Nha2uryiawZMkS3LhxA+3bt8fTp0+xd+9e3Lx5E6tWrcK7d+8wduxYpcp59+4dvvrqKxgaGuLChQu4evUq9uzZg6tXr+LixYswNjbG0qVLy1TZIYQQZc2YMQPTp09HQEBApXxOVCRmuB79HofvJ+B69HuIxPwfA22MSRtRrieEEOWEhIQgMDAQHTp0wJs3b/gOp8Jpa17V1rhIIZW6am/dujXOnz+P2NhYuLi4KFzmwYMHuH//PgYNGlTm8vPy8vDrr78CANatWwcLCwvpvJkzZ2Lbtm24dOkS7ty5g5YtW5ZY1s2bN5GbmwsfHx94e3vLzOvcuTN8fHxw5MgR3L59G3Xr1i1zrIQQUhI/Pz9s27YNn376aaV7TjQ0IhHBRx8jMTVHOs3B2gSL/BrBt4kDxaTlKNcTQohyPD09Ub9+fXh7e8POzo7vcCqUtuZVbY2L/EelOyKmTZuG3NxcDBgwAJGRkXLznz17hlGjRoExhs8//7zM5V+9ehWpqamoV68eWrRoITdfUuE5evRoqWUZGxsrtc1q1aqVLUhCCFFCz549ERsbi8GDB/MdSoUKjUjE5B13ZSoAAPA6NQeTd9xFaETpV9orQ0zajHI9IYQop06dOrh27RrWrVtXqS46aGte1da4iCyVGiJ8fX0xZ84chIeHo0mTJmjQoAE4jsOpU6fQvHlzNGzYEBEREZg3bx46depU5vIfPHgAoLB1URHJ9PDw8FLLatOmDWxsbHD+/Hm5Xr0vX76MU6dOwc3NDV5eXmWOkxBCFDl58iTevXsnfV/Z/vgRiRmCjz6GohsgJdOCjz6u0FsktTEmbUe5nhBCivf06VPcuHFD+r5KlSoQCoU8RlSxtDWvamtcRJ5KDREAsGzZMuzduxdNmzbF06dPwRhDYmIiHj58CDc3N+zcuRPfffedSmW/ePECAFC7dm2F8yXTnz9/XmpZ1tbW2LRpEwQCAbp27YpOnTph2LBh6NSpE7p06YLWrVvj1KlTMDIyKrGc3NxcpKWlybwIIeRjZ86cQb9+/eDl5SXTGFGZ3IpNlrsKURQDkJiag1uxyZU6Jl1AuZ5yPSFE3qtXr9CzZ0988sknuHz5Mt/h8EJb86q2xkXkqdRHhMTgwYMxePBgvHv3DnFxcRCLxahdu3a5h6XLyMgAAJiZmSmcL+mFNj09XanyBg4ciJMnT2LIkCG4evWqdLqVlRV69uypVLxLly5FcHCwUtsjhFRejo6OsLe3h4eHR6W7E0LibXrxFQBVllMHbYxJV1CuJ4QQWVZWVqhfvz6MjY3RoEEDvsPhhbbmVW2Ni8hT+Y6IomxtbdG6dWu0bdu23BUTTVi1ahW6d++Ozp07Izw8HBkZGQgPD0e3bt2wcOFCDBw4sNQyvv76a6SmpkpfRYfnIYQQiQYNGuDmzZv466+/IBCo5RSrc+wsTdS6nDpoY0y6hnI9IYQUsrCwwNGjR3Hx4sVK1zmlhLbmVW2Ni8jTylqypOfsrKwshfMzMzMBAJaWlqWWdfHiRXz55Zfw8PDA33//jaZNm8Lc3BxNmzbF/v374eHhgePHj+PkyZMllmNsbAwrKyuZFyGEAEB8fDwePXokfe/g4FDqLeD6rI1LVThYm6C47ro4FPZc3calaqWOqbKjXE8I0SX5+fk4e/as9L2RkREcHCrv6Avamle1NS4iT6lHM8aOHQuO4/DDDz+gRo0aSo/rDQAcx2HTpk1lCqpOnToAgJcvXyqcL5nu5ORUalnbt28HAAwYMEDu6qRQKMTAgQNx//59XL58Gb169SpTnIQQ8v79e/Ts2RNv3rxBaGgo2rRpw3dIvBMKOCzya4TJO+6CA2Q6jJJUDBb5NYJQUHE9i2tjTNqGcj0hhCgmFosxduxY7NixA2vXrlVppCB9o615VVvjIvKUaojYunUrOI7D3LlzUaNGDWzdulXpDahSOWnevDkA4O7duwrnS6Y3a9as1LIkFRlra2uF8yXTU1JSyhQjIYQAhee4KlWqICMjA/b29nyHozV8mzhg/UhPuTG87Xkcw1sbY9ImlOsJIaR41apVg1AoRN26dfkORWtoa17V1riILKUaIi5cuADgv6sXkvea0rFjR1hbWyM6Ohr379+Hh4eHzPz9+/cDAPz8/EotS/KHwe3btxXO/+effwAAzs7OqgdMCKm0qlatijNnzuD169fScyQp5NvEAT0a2eNWbDLepufAzrLwVkg+r0JoY0zagnI9IYQoJhAIsGbNGowbNw5NmzblOxytoq15VVvjIkUwLTV//nwGgHXo0IFlZGRIp69atYoBYN7e3jLLr127ltWvX5999dVXMtMPHjzIADChUMiOHj0qMy8kJIQJBAImEAjYv//+W6b4UlNTGQCWmppath0jhOg8kUjE/vnnH77DIESGLuYlyvWEEG1269YtJhaL+Q6DEBn6kpu0srNKAFiwYAHatm2La9euwc3NDUOHDkW7du0wa9Ys2NraYvPmzTLLJyUl4cmTJ0hMTJSZ3r9/fwwePBgikQh+fn5o3bo1hgwZgtatW6N///4Qi8X47rvvUL9+/YrcPUKIjmKM4YsvvkC7du2kz6UTQlRDuZ4Qoq1CQkLQrl07fPbZZxCJRHyHQ4je0dqGCBMTE1y4cAHffPMNzMzMEBISgufPnyMoKAh3795V+vksjuOwd+9ebNq0CZ07d8azZ89w6NAhxMXFoXfv3jh58iTmzZun4b0hhOgLsViMtLQ0iEQiCIVCvsMhRKdRrieEaKuifcpU1uG4CdEkjjHGSl9M3uPHj7FixQpcvnwZiYmJyMvLU7wBjkNBQUG5gtRGaWlpsLa2RmpqKg3vRUglIxaLce3aNXTq1InvUAiR0kReolxPuZ6QyuzatWto06YNDAyU6laPkAqhL7lJpV/V9evX0b17d2RnZwMo7KyNeosnhOizqKgouLm5ASi8MkKNEETfUa4nhFQ28fHxqF69OkxNTQEAHTp04DkiQvSXSg0RX3/9NbKzszFjxgwsWLAAVatWVXdchBCiNc6fP49evXphxowZWLZsGTiOelwm+o9yPSGkMklMTESXLl1Qu3ZtHDlypNjhgAkh6qFSQ8Tt27fh4eGB1atXqzseQgjROg8fPkReXh5iYmIgFoupbwhSKVCuJ4RUJs+fP0dSUhI4jkN2djY1RBCiYSo1RBgZGaFBgwbqjoUQQrTSF198AVdXV3Tv3p0aIUilQbmeEFKZtGvXDpcuXYKVlRU9hkZIBVCpIaJTp054/PixumMhhBCt8e7dO9jY2MDQ0BAA0KdPH54jIqRiUa4nhOi7goICJCcnw87ODgDg4eHBb0CEVCIqjUXzww8/4NmzZ1i3bp264yGEEN4lJyeja9euGDhwILKysvgOhxBeUK4nhOgzxhgmTJiAtm3b4tmzZ3yHQ0ilo9QdEX/99ZfctDFjxmD69OnYt28fevTogdq1axc7xu6nn35avigJIaQCPXz4ENHR0UhJScH79+9hZmbGd0iEaBzlekJIZfL+/XtcvnwZL168wL///gtXV1e+QyKkUuEYY6y0hQQCgcJe4ouuWtx8juMgEonKGab20ZfxWwkhioWFhcHGxgZNmjThOxRClFLevES5Xh7lekL025s3b3Dt2jUMGDCA71AIUZq+5Cal7ohYuHAhDVdHCNFrYrEYmZmZsLS0BFD4fDwhlQnlekJIZZCamiodEaNGjRrUCEEIT5S6I4LI05eWKEJI4RXdL7/8EqdPn0ZoaChq1arFd0iElBnlJfWjY0qIfjl+/DhGjRqFAwcOoGvXrnyHQ4hK9CU3qdRZJSGE6JOkpCTs3r0bERERuHr1Kt/hEEIIIUTNGGNYv349UlJSsGvXLr7DIaTSU6kh4s2bNzhy5AhiY2OLXSY2NhZHjhzB27dvVQ6OEEIqgq2tLa5du4ZNmzZhyJAhfIdDiFagXE8I0Sccx2H//v1Yvnw5fvvtN77DIaTSU6khYvXq1RgwYABycnKKXSY7OxsDBgzAzz//rHJwhBCiSbm5udL/Ozs7Y+zYsTxGQ4h2oVxPCNEHRXO9iYkJ5syZA0NDQx4jIoQAKjZEnDx5Eo0bN0bDhg2LXaZRo0Zo3Lgxjh8/rnJwhBCiKZcuXYKbmxtu377NdyiEaCXK9YQQXff27Vs0b94cv//+O9+hEEI+olJDxPPnz+Hu7l7qcm5ubnjx4oUqmyCEEI1hjOG7775DfHw8fvrpJ77DIUQrUa4nhOi6rVu34smTJ1i+fDkyMzP5DocQUoRSw3d+TNmxwjmOk7kdihBCtAHHcTh06BC+//57LFq0iO9wCNFKlOsJIbpu9uzZEIvFGDhwIMzNzfkOhxBShErDdzZr1gzv37/H8+fPYWCguC2joKAATk5OsLKyQmRkZLkD1Tb6MmwKIZWJSCSCUCjkOwxCNELdeYlyPeV6QnSRWCwGx3HgOI7vUAjRCH3JTSo9muHn54fXr1/jq6++QnHtGF9//TVev34Nf3//cgVICCHqkJqaivbt22Pv3r18h0KITqBcTwjRNYwxTJo0CdOmTYNYLOY7HEJICVS6IyI5ORnNmzfHq1ev0KRJE4wbNw716tUDAERHR2PTpk2IiIiAvb09Hjx4gOrVq6s9cL7pS0sUIZXF999/jwULFsDBwQFRUVF0iybRO+rOS5TrKdcTomtu3ryJ9u3bAwCuXr0q/T8h+kRfcpNKDREAEBkZiQEDBuDp06dytz4xxuDu7o4DBw6gcePGaglU2+jLF4CQykIkEuGrr77CiBEj4OHhwXc4hKidJvIS5XrK9YTomr179yI1NRUTJkzgOxRCNEJfcpPKDRFAYcX+4MGDOHv2LOLj4wEAjo6O6N69OwYOHKjXz2LryxeAEH3GGKNnRLVEWT8HJycnxMXFaSYYAFlZWTh9+jSOHj2KsLAwPH/+HEKhEK6urggICMDMmTNhYWGhse1rgqbyEuV6yvWEaDvK99qBcn3F0JfcVK6GiMpMX74AhOizr7/+GoaGhggODqYKCs+CgoLkpoWFhSE6OhrNmzeXu0ulevXq+PHHHzUWz8aNG/HZZ58BABo2bIgmTZogLS0N165dQ3p6Oho0aIBLly7Bzs5OYzGoG+Ul9aNjSoj2Cw0NxS+//IK9e/fC0tKS73AqNcr1FUNfcpNKw3cSQoi2u3nzJpYtWwYA8PHxQceOHXmOqHLbunWr3LSgoCBER0ejf//+WLx4cYXGY2hoiAkTJmDGjBlo2LChdHpiYiL69OmDe/fuYcaMGdi1a1eFxkUIIUR5WVlZCAoKwps3b7Bq1aoKzyVEFuV6UhblbohIT09HdHQ00tPTi+1Vu3PnzuXdDCGElEnbtm2xfv16pKWlUSMEkTN69GiMHj1abrqDgwPWrVuHDh064ODBg8jLy4ORkREPEWoXyvWEEG1kZmaGo0eP4ueff8a8efP4DodoGcr12k3lhoiIiAjMmDEDFy9eLLZSIiESiVTdDCGEqGzSpEl8h0BU9P79eyxbtgwhISGIj4+HmZkZ2rRpg5kzZ6Jnz54K10lOTsbKlStx+PBhxMbGwsjICC1btsTMmTPRt29fpbfdvHlzAEBubi7ev38PBwcHteyTLqJcTwjRdq1bt8aOHTv4DoOogHJ95SZQZaWoqCh06tQJ58+fR/v27eHi4gIAGDZsGNq0aQMDg8L2DX9/f3z66afqi5YQQkpw9epVjBo1Cjk5OXyHQsohISEBbdq0wY8//oi8vDz0798fLVq0wNmzZ+Hj44M1a9bIrfP06VN4eHhg2bJlyM7Oho+PD1q1aoWbN2/Cz8+vTM+gxsTEACi8pbNq1apq2y9dQ7meEKKNkpKS4O/vr9FODonmUa4nYCr49NNPmUAgYFu3bmWMMRYUFMQEAoF0flRUFOvcuTNzd3dnycnJqmxC66WmpjIALDU1le9QiB4pEInZtWdJLOTeS3btWRIrEIn5DklrfXys0tIzWI0aNRgA9s033/AdXqVRnu/s6NGjGQC2aNEimel9+/ZlAFhgYCDLzc2VTr9y5QozMzNjQqGQ3bt3778YCgpY06ZNGQC2YsUKJhKJpPOioqKYi4sLEwqF7OHDh0rFNX78eAaA+fn5Kb0v2kDdeen/2Lvz8JjOvw3g95nJnkhEhIQQEmLf90jEFmKJEPtSW2lLW4pSrVpaVa0WbVFVtdZS5YcWrX0PsRPEGmKNRiwjIQnJPO8f3pmaZjEzmcmZTO7PdeW6zFm/8+RM7uOZc57DrGfWk3kw6/WXXVt169ZNABCNGzcWajXbLj8w6y2LtWSTUbdm7N69G1WqVMn2nhsAqFChAv744w/4+flh4sSJmDt3rjG7ISpUtp5LwGebYpGg+vfbfG83B0wOr4qw6rxc7FU5tdUH0+Zg37rFGD9+vIzVFR7mOGavXbuGzZs3w8XFBXPmzNG5ZzMoKAjvvPMOZs2ahXnz5mHhwoUAgE2bNuHs2bPo2rUrxo4dq7O9ChUqYObMmYiMjMTChQvx/fff57r/v/76C4sWLYKtrS2mTp1q1HuwFsx6ItNj1usvp7Z6952PkZSUhPnz5/OJWPmAWU/mYtStGYmJiahatar2ta2tLQDoXA5dtGhRNG/eHJs3b85jiUTWb+u5BAxbcVLnjzwA3FOlYdiKk9h6LkGmyixPbm214IoTRn6zGE5OTjJVV3iY65g9ePAgACAsLCzbSyXfeOMNAMCBAwe007Zv3w4AiIyMzHabwcHBAICjR4/muu+LFy+iX79+EELgm2++0d4/Wlgx64lMi1mvv9zaauKOBHw0ZxUqV64sU3WFB7OezMmojohixYohPT1d5zUA3LhxI8uyiYmJRpZGVDhkqgU+2xSL7IaB00z7bFMsMtW5DxRXGPy3rdTpz5C05TtkPn3EtspH5jxm7969CwAoV65ctvM10+/cuaOdprlPuG/fvpAkKcuPp6cngJf3Fefkzp07CAsLw6NHjzB69GiMHDnS4NqtDbOeyHSY9fr7b1sJIfBo31Kk3T7PtspHzHoyN6NuzShfvrzOiUjt2rUhhMCaNWswadIkAC8Pgr1796Js2bKmqZTISh29/jBLT/OrBIAEVRqOXn+IJv4e+VeYBfpvWz3YOgfPLh5AxqM7KNl3BiBJbKt8IOcxm91luGq1GsDLb1ZKliyZ47rFixfPdvrDhw/Rpk0b3LhxA4MGDTJosCtrxqwnMh1mvf7+21ZPz+7Ak+h1SD6xGaXfWgilizvbKh8w68ncjOqIaNOmDb744gvcuHEDvr6+CA8PR/HixfH5558jNjYWpUuXxvr166FSqfDee++ZumYiq5KYrN8THvRdzpr9tw2KNnsDLx7cgnvrt3VCi21lXuY8ZkuVKgUg+2/dgX+/ESldurR2mo+PDwBgyJAh6Nq1q0H7S0lJQbt27RAbG6u9t5T3HL/ErCcyHWa9/v7bBk5VmuHZ5cNwKF8XShf3HJcj02LWk7kZdWvGG2+8gbFjx+Kff/4BADg7O+O3335D0aJF8fvvv2P27Nm4ceMGWrdujQkTJpi0YCJrU6KIg0mXs2b/bQNb91LwHvQD7L0q5LocmZY5j9mgoCAAwNatW/H48eMs8zXPitfcCwoAoaGhAIANGzYYtK/09HRERETg6NGjaNu2LVavXg2lUmlwzdaKWU9kOsx6/f23DRS2DvDsOhGu9cJzXY5Mi1lP5mZUR4S/vz+mT5+Ohg0baqe1bNkSN27cwF9//YWVK1fi2LFj2LZtG+zt7U1WLJE1ali+GLzdHJBTv6yEl6MTNyzPZxw3LF8M4swfeP7PNe00Sfr3zxjbKn+Y85j18/NDhw4dkJycjJEjR+LFixfaeYcPH8b8+fOhVCrx7rvvaqd37doVVatWxcqVKzF16lSdcQ2Al/cXR0VFISoqSjstMzMTvXv3xu7duxEcHIz169frjNpNzHoiU2LW669h+WJwun8eKWd3aqcx6/Mfs57MzahbM3Li7OyMsLAwU26SyOopFRImh1fFsBUnIQE6gwJp/vhPDq8KpYKXkK1etRI3ty6EZO+M0kN+0rlEk22Vf8x9zC5YsADBwcFYvnw59u3bhyZNmuD+/fvYu3cvMjMzMXPmTNSuXVu7vI2NDTZu3Ii2bdti0qRJmDt3LmrWrIkSJUogKSkJp0+fRmJiImbPno2mTZsCAObOnav9VqV48eIYPnx4trV8++23Od5vWlgx64kMx6zXX/z1a7i++jOkpT6D0sEFjhUba+exrfIPs57MzaQdEURknLDq3pjfr26W5zR78dniOjp27Ijg4GCUr9UEl0t5s61kZM5jtnTp0jh27BimT5+OjRs3Yv369XByckKrVq0wZswYtGnTJss6FStWxKlTpzB37lysX78e0dHRyMjIgJeXF+rUqYNOnTqhR48e2uUfPXqk/Xdul3lOmTKFJydEZBLMev34+fnh/ffexY79h2FXOxD/PFVr57Gt8heznsxJEkLw2TdGePLkCdzc3KBSqeDq6ip3OWQlMtUCR68/RGJyGkoUeXm5G3v8dT1//hy2trZQC7CtLACPWcvBXDI9timZA/9u6uf58+dQ2tiyrSwAj1nLYi3ZxI4II1nLAUBk6aKjo3Hv3j107txZ7lKILBpzyfTYpkT54+HDh1i8eDFGjx4NhcKoIeyICg1rySbemkFEFuv69evo0KEDHj9+jE2bNqF9+/Zyl0REREQmlJmZifDwcBw6dAj37t3Dt99+K3dJRJQP2OVIRBarTJky6Ny5M+rXr49mzZrJXQ4RERGZmFKpxFtvvQVPT08MHDhQ7nKIKJ/w1gwjWcslMUSWTgiBlJQUFClSRO5SiCwac8n02KZE+Sc5OZlZT6QHa8kmo66I2L9/Py5fvvza5a5cuYL9+/cbswsiKqRSUlKwZMkSaPpIJUniiQmRDJj1RGQuQggsWrQIz549005j1hMVLkZ1RDRv3hxff/31a5ebMWMGWrRoYcwuiKgQyszMRGRkJAYPHozJkyfLXQ5RocasJyJz+eabbzBkyBC0adMGGRkZcpdDRDIweowIfe7o4F0fRGQIpVKJ9u3bw8XFBR06dJC7HKJCj1lPROYQFBQEd3d3dOvWDTY2HDufqDAy6yf/7t27cHFxMecuiMjKfPDBB+jduzdKliwpdylEpAdmPREZKjAwEBcvXkSJEiXkLoWIZKJ3R8Ty5ct1Xl+9ejXLNI2MjAxcunQJO3fuROPGjfNWIRFZvQ0bNqBDhw6ws7MDAHZCEMmEWU9E5hIVFQVfX1/4+PgAADshiAo5vZ+aoVAoIEmS3hsWQsDBwQF//vknWrdubXSBlspaRislkttPP/2EYcOGoW3btti8eTMv0SQykilyiVmvi1lPZBqnT59Gs2bN4O7ujn379qFcuXJyl0RUYFlLNul9xj9p0iRIkgQhBD7//HPUrl0bERER2S5rZ2eHUqVKoU2bNvD29jZZsURkfcqVKwcnJyc0bNiQnRBEMmPWE5E5uLu7w9vbG97e3vDy8pK7HCKyAHpfEfGqcuXKoUePHpgxY4Y5aioQrKUnisgSxMXFwc/Pz6BvYolIl6lziVnPrCcypfv378POzg5ubm5yl0JUoFlLNhn19WN8fLyJyyCiwiQmJgalSpVC8eLFAQD+/v4yV0RE/8WsJ6K8ePz4Ma5du4a6desCADw9PWWuiIgsiUmvg87IyMAvv/yCc+fOoUyZMnjrrbfg7u5uyl0QUQF3+fJltGrVCh4eHti5c6d20CoiKhiY9UT0OqmpqejUqRNOnjyJjRs3WuUYMkSUNwpjVvr888+hVCqxf/9+7TS1Wo3mzZvj3XffxY8//ohPPvkEDRo0wOPHj01VKxFZgczMTDg4OMDFxYWXZxJZMGY9ERlLk/U2NjZ8OgYRZcuojogdO3bAx8cHzZo1005bt24dDh06hBo1amDBggWIiIjAtWvXMG/ePJMVS0QFX5UqVXDo0CH89ddfKFKkiNzlEFEOmPVEZCwXFxds3rwZBw4cQM2aNeUuh4gskFEdEdeuXUOVKlV0pq1fvx6SJGH16tUYOnQo/ve//6FMmTJYt26dSQolooLr2bNnuHz5svZ1mTJl+A0JkYVj1hORoU6fPq39t52dHWrUqCFfMURk0YzqiHjw4IF2kDmNffv2oWLFitqTFkmS0KBBA9y8eTPvVRJRgfXixQt069YNjRs3RnR0tNzlEJGemPVEZIhvv/0WderUwZw5c+QuhYgKAKM6IooXL447d+5oX8fGxuKff/5B8+bNdZazs7PD8+fP81QgERVsT58+xaNHj5CWlga1Wi13OUSkJ2Y9EelLCIHbt28DANLS0mSuhogKAqM6IqpUqYKoqCicOnUKADBr1ixIkoT27dvrLBcfHw9vb++8V0lEBVbRokWxc+dO7Nq1C4GBgXKXQ0R6YtYTkb4kScLs2bOxY8cOjB07Vu5yiKgAMKojYtSoUcjIyECDBg1QvHhxLFmyBOXLl0dYWJh2GZVKhRMnTqBWrVomK5aICo7r169r/+3s7IwmTZrIWA0RGYpZT0Svc/36dQghALzsjOBjOolIX0Z1RLRv3x5z5sxB6dKlkZqaiqZNm2LDhg2ws7PTLrN8+XK8ePECrVq1MlmxRFQw/PLLLwgICMDKlSvlLoWIjMSsJ6LcxMTEoE6dOnjnnXeQmZkpdzlEVMBIQtONaWKpqal4/vw5XFxcoFQqzbELWT158gRubm5QqVRwdXWVuxwiiyGEwODBg7F06VJ8/PHH+PLLL+UuiahQkCOXmPVEhdevv/6KgQMHIjAwENu3b4ejo6PcJREVCtaSTTbm2rCjoyP/IBEVQpIkYdGiRWjXrh26d+8udzlEZEbMeqLC64033oCnpycaNWrEvwNEZLA8dURkZGRgy5YtOHr0KJKSktCoUSMMHjwYAHD37l0kJSWhatWqsLExW38HEVmI+/fvw9PTEwCgUCjQo0cPmSsiMi9Jkgxa3tfXF/Hx8eYp5hWzZs1CTEwMjh49qn3qRV4ufmTWE5FGcnIybG1t4eDgAAA6Y8YQWSNLzHrNINJ9+/bFqVOnTJL1cjD6rOHgwYPo168fbt26BSEEJEnCixcvtCcnhw8fRo8ePbB27VpERkaarGAisjxXr15F06ZNMWjQIEyfPt3gP9pEBdGAAQOyTDt48CDi4uJQq1Yt1K5dW2de8eLF86Wuzz77zGTbYtYTkUZaWhoiIiKgVqvxxx9/wM3NTe6SiMzOErP+m2++AQBs3rzZ7PsyJ6M6ImJjYxEWFoYXL17g/fffR1BQUJZvP8PDw+Hk5IT//e9/PDkhsnK7du1CYmIitm3bhokTJ8LZ2VnukojMbunSpVmmDRw4EHFxcejcuTOmTJmS7zUBwLhx4xAUFIQGDRqgXLlySE9PN2o7zHoietWlS5dw/PhxAMCNGzdQs2ZNmSsiMj9LzPoGDRpgy5Yt+O233xASEpKnrJeTUR0RU6dORVpaGv766y+0adMm22Xs7OxQt25d7aUjRGS93n77bbi6uqJFixbshCCS2YQJE0wyeBWznoheVatWLezbtw8qlYqdEEQyGjVqFKZMmYJ27doV6MEqjXp85549e9CwYcMcT0w0Spcujbt37xpVGPByNO5JkyYhICAADg4OKFWqFAYPHqy9D0YfS5cuhSRJr/1Zvny50XUSFUZpaWnIyMjQvu7duze8vLxkrIjIsj148ABjx45FxYoV4eDggGLFiiEsLAzbt2/PcZ2HDx/i448/RtWqVeHo6Ag3Nze0bNkyXy7HZNYTEQCkpKRo/12nTh00b95cvmKILFxBy3o5GXVFxOPHj1GmTJnXLvf06VO8ePHCmF0gLS0NLVu2RHR0NLy9vREREYH4+HgsWbIEmzdvRnR0NPz8/F67nQoVKmR7bw8AqFQqbNy4EQAQFBRkVJ1EhVFGRgZ69uwJAPjtt984WjbRa9y5cwfNmjXDtWvXULZsWXTu3Bn379/Hzp07sW3bNsyaNQujRo3SWefy5cto3bo1bt26hXLlyqFt27ZITk5GdHQ0wsPD8c033+DDDz80W83MeiL6/vvv8cMPP2D79u3w9/eXuxwii1YQs15WwghlypQRdevW1ZkmSZIYNGiQzrSKFSuKSpUqGbMLMWHCBAFANGnSRCQnJ2unz5w5UwAQISEhRm33VT/++KMAIJo2bWrwuiqVSgAQKpUqz3WYQkamWhy6miQ2nrotDl1NEhmZarlLIit2/PhxYW9vLxwcHMSxY8fkLocE/waYUl7acsCAAQKAmDx5ss70jh07CgCiT58+Ij09XTv9wIEDwsnJSSiVSnHq1Kl/a8jIEDVq1BAAxIwZM0RmZqZ23pUrV0T58uWFUqkUZ8+e1U7PLpfs7e2FkVHPrBeWl/VC8LNO+efZs2eiQoUKAoCYNWuW3OWQ4OfflApq1guRNZvykvVyMuqKiJYtW+LXX3/Fnj170KJFi2yX2bBhA65evYp3333X4O0/f/4cc+fOBQDMmzcPLi4u2nmjR4/GsmXLsG/fPpw4cQL16tUz5i0AAFasWAHg5XOQC7Kt5xLw2aZYJKjStNO83RwwObwqwqp7y1gZWat69eph+/btUKlUqF+/vtzlFHr8G2A65mjLa9euYfPmzXBxccGcOXNgZ2ennRcUFIR33nkHs2bNwrx587Bw4UIAwKZNm3D27Fl07doVY8eO1dlehQoVMHPmTERGRmLhwoX4/vvvjarrdZj1loefdcpPjo6OOHDgAFauXIkPPvhA7nIKPX7+TYdZbxmMGiNi/PjxsLOzQ+fOnTF//nzcu3dPO+/Ro0dYvHgx3nzzTTg7O2P06NEGbz8qKgoqlQr+/v6oU6dOlvndunUD8PKXZ6zr16/j0KFDsLOzyzIKeEGy9VwChq04qfNBAoB7qjQMW3ESW88lyFQZWaNXL79u1qwZwsPDZayGAP4NMCVzteXBgwcBAGFhYShWrFiW+Zr/IB84cEA7TXMvaU5PoggODgYAHD161Kia9MGstyz8rFN+eTXrvby8MGbMGD6WW2b8/JsOs95yGNURUblyZaxevRpqtRrvvfceSpcuDUmSsGzZMhQvXhxDhw5Feno6Vq5cifLlyxu8/TNnzgAA6tatm+18zfSYmBhjygfw7zckHTp0gLu7u9HbkVOmWuCzTbEQ2czTTPtsUywy1dktQWSYZcuWoX79+nkalI5Mi38DTMecban5zJQrVy7b+Zrprw7OGB8fDwDo27dvtoMuenp6AgCSkpIMrkdfzHrLwc865Zfz588jICAAe/fulbsU+n/8/JsOs96yGHVrBgB07twZ586dw+zZs7Fjxw7Ex8dDrVbDx8cHoaGhGDNmjNGD2ty8eRMA4OPjk+18zfQbN24YVzwMv1QzPT1d5/msT548MXrfpnL0+sMsvXmvEgASVGk4ev0hmvh75F9hZHVSU1MxceJE3Lp1C8uWLcPHH38sd0kE/g0wJTnbMrtvGtVqNYCX36yULFkyx3WLFy9u0lr+i1kvf9YD/KxT/vnyyy8RHx+Pzz77DCEhIbwSwgLw8286zHrLYnRHBAD4+vriu+++M1Ep/9I8JsjJySnb+c7OzgCA5ORko7Z/9OhRXL58GcWKFUOHDh30Wmf69On47LPPjNqfuSQm5/xBMmY5opw4Ojpi3759+OWXX/DRRx/JXQ79P/4NMB1ztmWpUqUA5Pwfas03IqVLl9ZO0/wnfMiQIejatavB+zQlZr38+Fmn/LJo0SJ4eXlhwoQJ7ISwEPz8mw6z3rIYdWtGQaf5hqRHjx46A4nk5uOPP4ZKpdL+3Lp1y5wl6qVEEQeTLkf0X5qeWgAoX748pk2bBoWiUP7ZsEj8G2A65mxLzSMjt27disePH2eZr8kkzb2gABAaGgrg5WCQZBxryXqAn3Uyr1ez3sHBATNnzsz2HneSBz//psOstyx5+h9Feno6Vq1ahWHDhiEiIgIREREYNmwYVq5cibQ043vlNCNnP3v2LNv5T58+BQAUKVLE4G1nZGRgzZo1AAwbQdve3h6urq46P3JrWL4YvN0ckFN/tYSXI8A2LM8wIcNdv34ddevWxfHjx+UuhXLAvwGmY8629PPzQ4cOHZCcnIyRI0fqDAR3+PBhzJ8/H0qlUufJE127dkXVqlWxcuVKTJ06Ved2AQAQQiAqKgpRUVEG12MoZr38+Fknc0lPT0f79u3x888/y10K5YCff9Nh1lsWozsidu7cCX9/f7zxxhtYsGABNm3ahE2bNmHBggXo378//P39sWPHDqO2XbZsWQDA7du3s52vme7r62vwtrdv347ExET4+fkhMDDQqPoshVIhYXJ4VQDI8oHSvJ4cXhVKBS+tI8ONHz8eZ86cwciRIyEEB0CyRPwbYDrmbssFCxagfPnyWL58OSpWrIjevXujdevWCA4OxtOnTzFjxgzUrl1bu7yNjQ02btyI8uXLY9KkSShbtixCQ0PRt29ftG3bFl5eXggKCsKxY8ey7KtVq1Zo3LgxGjdujOfPnwOA9nXjxo2xZcsWvetm1lsGftbJXH799Vds27YNY8aM0XkyDlkOfv5Nx1qyftu2bQD+zfu8Zr1cjBoj4siRI+jYsSOeP3+ORo0aoXfv3tqRQG/cuIHVq1cjOjoa4eHh2LdvHxo1amTQ9mvVqgUAOHnyZLbzNdNr1qxpcO2ay2L69etn8LqWKKy6N+b3q5vlWbhefK4w5dHChQvh6OiIL7/8kveJWjD+DTAdc7Zl6dKlcezYMUyfPh0bN27E+vXr4eTkhFatWmHMmDFo06ZNlnUqVqyIU6dOYe7cuVi/fj2io6ORkZEBLy8v1KlTB506dcr2kZTZXcV05MgR7b/v37+vV83MesvCzzqZw5tvvombN28iODgYXl5ecpdDOeDn33SsIes1T9H4b94bk/VykoQRX3W2adMGu3btwo8//oi3334722V+/vlnvPPOOwgNDdX22ujr+fPnKFGiBFQqFU6dOqXTcwS8PHmJiYnB8ePHUa9ePb23m5KSgpIlS+LZs2e4fPkyKlasaFBdr3ry5Anc3NygUqks4tLNTLXA0esPkZichhJFXl5SxJ5RosKDfwNMp6C2palziVlveVkPFNzjk4jyjp9/0ynIbWmJ2WQUYQRXV1fRsGHD1y7XsGFD4erqaswuxIQJEwQAERgYKFJSUrTTZ86cKQCIkJAQneXnzJkjKlWqJMaPH5/jNpctWyYAiMaNGxtV06tUKpUAIFQqVZ63ZQ54+QSaXH8GDBiQ7brPnz8XP//8swgLCxPe3t7Czs5OuLq6ijp16ojRo0eL2NjYHPd78eJF8cEHH4iaNWuKokWLChsbG+Hh4SGaNm0qJkyYIM6fP59lnXv37olffvlFdO7cWZQuXVrY2toKNzc30axZM7F06VKhVqtz3N+zZ8/ExIkTRcWKFYW9vb3w9vYWgwYNErdv3861fZYsWSIaNGggnJ2dhbu7u2jXrp2IiorKdR1rl5GRIXr37i3WrFkjdylEZART5xKz3vKzXgjmPfPecHPnzhXvv/++yMzMlLsUIjJCQcgmfRjVEVG0aFHRp0+f1y7Xp08f4ebmZswuRGpqqmjUqJEAILy9vUWPHj20rz09PUVcXJzO8pMnT841bIUQIjQ0VAAQ8+bNM6qmV1n6AfDqyUdOPwsXLsyy3oULF0RAQIAAIOzs7ERQUJDo1auXCA8PF2XKlBEAhEKhEEuXLtVZT61Wi08//VQolUrt76xDhw6iT58+IiwsTHh6egoAQpIk8dVXX+ms27dvXwFA2NjYiMaNG4uePXuKoKAgoVAoBADRrVs3kZGRkaXW1NRU0bhxY51jpGHDhjkeIxojR44UAISjo6OIiIgQbdu2FTY2NkKpVIoNGzYY3+gF3MKFC7XtkpCQIHc5RGQgU+cSs97ys14I5j3z3jBXr17V/u7Wrl0rdzlEZISCkE36MKojok2bNqJ69eqvXa569eoiNDTUmF0IIf7t/fb39xd2dnbCy8tLDBw4UNy6dSvLsq87Obl7965QKpXC1tZWJCUlGV2ThqUfAJoTE0PcunVLFC9eXAAQAwcOzLaddu3aJerUqSMmT56sM33s2LECgChZsqT4448/sqynVqvFzp07RVBQkHjzzTd15o0YMUJMmzZNJCYm6kw/evSocHV1FQDEggULsmxT801akyZNRHJysnZ6Tt+kCSHEjh07BADh4eEhLl++rJ1+6NAhYWdnJ4oWLSoePXqUXfNYvYyMDPHuu++KdevWyV0KERnB1LnErLf8rBeCec+8N9yqVavEyJEjc70ChYgsV0HIJn0Y1RFx5MgRYW9vLyZNmpTtZV1qtVpMmjRJ2Nvbi+jo6DwXaYks/QAw5sSkffv22pOS3KSlpYljx45pXx86dEhIkiScnZ3FxYsXc11XrVaLkydP6l3Tl19+KQCI5s2b60xPT08Xbm5uAkC226tZs6YAII4fP64zvV27dgKAmD17dpZ1RowYIQCIb7/9Vu/6iIgshalziVlv+VkvBPOeeU9EhU1ByCZ96PXUjOXLl2eZNmDAAHzxxRf49ddf0bVrV+3jtW7cuIH169cjPj4eQ4cOxaVLlwweSZvyX2xsLP766y84Ojpi1qxZuS5rb2+P+vXra1/PnDkTQgiMHDkSlSpVynVdSZJQp04dvevSjKp+9+5dnelRUVFQqVTw9/fPdnvdunVDTEwMNm3apB3kLDU1Fbt379bOz26dH374AZs2bcKYMWP0rrEgW7lyJa5cuYLJkyfzyRhEhRyzvnBg3he+vL948SI+++wzLFy4EC4uLnKXQ0QEQM/Hdw4cODDb/6QIIRAfH4+ZM2dq54tXHsLx888/Y+HChejfv7+JyiVz+euvvwAAYWFhcHd313u9zMxM7TPke/fubfK6rl27BgBZHil15swZAEDdunWzXU8zPSYmRjvt0qVLSE9Ph6enJ3x8fPRax5rFxcVh4MCByMjIQPXq1bM9WSOiwoNZXzgw7wtX3mdmZqJr166IjY1FkSJF8PPPP8tdEhERAD07IiZNmsRvS63c6dOnAeQc9Dm5fv06njx5Ant7e1StWtWkNb148QI//vgjACAiIkJn3s2bNwEg2xOMV6ffuHFD73WcnZ1RtGhRPHr0CMnJyShSpEje3oCF8/f3x/fff4/Dhw8jMjJS7nKISGbM+sKBeV+48l6pVGLJkiUYPXo0pk2bJnc5RERaenVETJkyxcxlkLnkdlK5YcMGdO7cGQDw4MEDAICnp6dB29es5+7uDoVCkWX+4cOHsWDBgizTly5d+tptT5w4ERcuXED58uXxzjvv6MxLSUkBADg5OWW7rrOzMwAgOTlZ73U06z1+/NjqT0w0hg8fjmHDhvE/H0TErC/gmPfM+5w0bNgQBw4cYNYTkUXRqyOCCq4BAwbkOK9s2bJm339cXByWLVuWZfrrTkx+++03zJgxAw4ODli1alWuJxOkv5s3b2LGjBmYOXMm7O3tAeR+8kpERAUD8540Xrx4gQ8++ADjxo3TjuvCrCciS8OOCCunzzcRAODh4QEAuH//vkHb16z36NEjqNXqLN+S9OvXD/369dO+dnBwQHp6eq7b3L17NwYOHAiFQoHVq1ejcePGWZbRDLb07NmzbLfx9OlTAND5luN16+S0nrXIzMxEeHg4YmJikJGRgZ9++knukoiIyESY98x7jfHjx+PHH3/Ejh07EBsbCxsbnu4TkeXJem0dFUq1a9cGAJw8edKg9cqXL48iRYogPT0dsbGxea7j2LFjiIiIwPPnz7Fw4ULtpaT/pfl25/bt29nO10zXfBOgzzpPnz7F48eP4e7ubpUnJkqlEjNnzkTVqlUxYcIEucshIiIZMO+tP+9HjRqFWrVq4fvvv2cnBBFZLHZEEACgffv2AICtW7fi0aNHeq+nVCrRpk0bAC8vr8yL2NhYtGvXDikpKZg1axYGDRqU47Kax3zldCKlmV6zZk3ttEqVKsHe3h7379/HnTt39FrH2rRu3RoxMTEoU6aM3KUQEZEMmPfWn/c+Pj44ceIE2rVrJ3cpREQ5YkcEAQCqVq2K9u3bIzU19bXP1H7+/DmOHz+ufa1Z/rvvvsOlS5eM2n98fDzatGmDBw8eYMqUKfjggw9yXb5p06Zwc3NDXFycdgTwV61btw4AEB4erp3m6OiIli1bAgDWrl2r1zoFXWZmJiZNmoTExETtNKVSKWNFREQkJ+a9deb90qVLERUVpX3NrCciiyfIKCqVSgAQKpVK7lKyBUAY+uu9deuWKF68uAAgBg0aJJKSkrIss2/fPlGvXj0xefJknekffvihACBKliwpNm7cmO32jxw5ImxsbLLU9c8//4iKFSsKAGLMmDF61zthwgQBQAQGBoqUlBTt9JkzZwoAIiQkJMs6O3bsEACEh4eHuHz5snb6oUOHhL29vShatKh49OiR3jVYuo8//lgAEFWrVhUvXryQuxwiMiNLz6WCqCC0KfOeeb9jxw6hUCiEo6OjiI2NlbscIjKzgpBN+pCEECIf+z2sxpMnT+Dm5gaVSgVXV1e5y8lCMzry60bR/vzzz3WmXbx4EZ06dcKVK1dgZ2eHRo0awcfHB0+fPsWZM2dw48YNKJVKLF68GP3799euJ4TAxIkTMX36dKjVanh5eaF+/fpwdXVFUlIS4uLiEBcXB0mS0Lt3b6xcuVK7bpcuXbBx40Y4OTmhe/fu2dZavHhxfPvttzrT0tLS0Lx5cxw5cgTe3t4IDg7GjRs3cOTIEXh6eiI6Ohp+fn5ZtvXBBx/g+++/h5OTE0JDQ/H8+XPs2LEDQgisW7cux/tUC6LLly8jLCwM06dPR8+ePeUuh4jMyNJzqSAqCG3KvGfeP3v2DN27d0epUqXw888/8wkZRFauIGSTXuTsBSnILL0nCv//DUluP7Vq1cp23fT0dLFgwQLRtm1bUbJkSWFrayuKFCki6tSpIz788ENx6dKlHPd74cIFMXLkSFGjRg3h5uYmbGxshIeHh2jSpIkYN26cOH/+fJZ1QkJCXlurr69vtvt79uyZmDhxovD39xd2dnbCy8tLDBw4UNy6dSvX9lmyZImoV6+ecHJyEkWLFhVhYWEiKioq13UKqtTUVLlLIKJ8YOm5VBAVhDZl3jPvhRDi+fPnvPKRqJAoCNmkD14RYSSr6Ykiq7Nhwwb4+/tb7SBcRJQ95pLpsU3JUl25cgXHjh1Dnz595C6FiPKZtWST0c/0GTx4MADA29sb06ZNyzJ/woQJSEhIgCRJWLRokfEVEpHe9u/fj549e8LJyQlHjhxBpUqV5C6JiAowZj2R5Xnw4AHatGmD+Ph4ZGRk6Nw6Q0RUUBh9RYRC8fKBG5UrV872edJVqlTBpUuXIEkSMjMz81alBbKWniiyLo8ePUKnTp3g7e2N1atXc9RsokLEHLnErGfWk+VRq9UYN24cNm7ciKioKJQsWVLukogoH1lLNhl9RcTkyZMBvBxUKDvvvfcekpKSjN08ERnB3d0d27dvh0KhYCcEEeUZs57I8igUCnz77bf49NNPUbRoUbnLISIyCseIMJK19ERRwXf79m3ExMSgffv2cpdCRDJiLpke25QsRUZGBlasWIEBAwbwqRhEhZy1ZJNC7gKIyHiPHz9G27ZtER4ejt9//13ucoiIiMgM3nrrLQwaNAjvvvuu3KUQEZkEOyKICjAXFxc0atQIXl5eaNSokdzlEBERkRk0a9YM9vb2aNeundylEBGZRJ46ImJjYzFq1Cg0bdoUlSpVwrhx47TzDh06hB9++AEPHz7Mc5FElD0bGxssWrQIx48fh6+vr9zlEJEVYtYTyW/gwIG4du0awsPD5S6FiMgkjB6sctasWRg/fjwyMjIAAJIkZRmwatSoUbC3t8fbb7+dtyqJSEutVmPz5s0IDw+HJEmQJAne3t5yl0VEVohZTySf7du3IygoCE5OTgCAUqVKyVwREZHpGHVFxJYtW/Dhhx+iTJkyWL9+PRITE/HfMS8DAwPh6emJP/74wySFEtFLY8aMQUREBD766CO5SyEiK8asJ5LPpk2b0L59e4SGhiIlJUXucoiITM6oKyJmzZoFZ2dn7NixA35+fjkuV7t2bVy6dMno4ogoqzJlykChUKBmzZpyl0JEVoxZTyQfd3d3FClSBJUqVYKzs7Pc5RARmZxRHREnTpxA48aNcz0xAV4+d/zAgQNGFUZE2Rs9ejTat2+PypUry10KEVkxZj2RfIKCgnDs2DGUK1eOj+skIqtk1K0Zz58/R5EiRV67XGJiImxsjB6Ggoj+35EjR/DixQvta3ZCEJG5MeuJ8tf169dx584d7esKFSrws0VEVsuojojy5cvjzJkzuS7z/PlzxMTEICAgwKjCiOilPXv2oFmzZoiIiEBqaqrc5RBRIcGsJ8o///zzD0JDQxEYGIgrV67IXQ4RkdkZ1RHRqVMnxMfHY9asWTkuM2PGDNy/fx+RkZFGF0dEQFpaGpRKJRwdHWFnZyd3OURUSDDrifJPWloaFAoFlEolXFxc5C6HiMjsJPHfIbD18OjRI9SqVQt37txBt27d0KVLF/Tp0wft2rXDkCFDsGHDBqxcuRLly5fHqVOn9Lq0s6B58uQJ3NzcoFKp4OrqKnc5ZOVOnz6NypUrw8HBQe5SiMhCmTqXmPXMespfiYmJSE5Ohr+/v9ylEJEFs5ZsMqojAgAuX76Mbt264dy5c5AkCUII7WA6QghUrVoVGzduRIUKFUxasKWwlgOALFNCQgLs7Ozg4eEhdylEVECYI5eY9cx6Mp+MjAxcvXqV4z4RkUGsJZuMHgEnICAAp0+fxqZNm7B9+3bEx8dDrVbDx8cHoaGh6Nq1K5RKpSlrJSoUHj9+jLZt2yIjIwPbtm1DmTJl5C6JiAopZj2ReQghMGzYMKxevRobNmxAaGio3CUREeWrPA3Fq1AoEBERgYiICFPVQ1ToJSYm4tGjR8jIyNB5UgYRkRyY9USml56ejvj4eKSmpiIlJUXucoiI8h2fCURkYQICAhAVFYUnT57Az89P7nKIiIjIxBwcHLB582YcOHAArVu3lrscIqJ8Z9RTM9avX4+6deti165dOS6zc+dO1K1bF3/88YfRxREVFkII3L59W/u6bNmyqF69uowVEVFhx6wnMr1bt25p/21vb89OCCIqtIzqiFiyZAlu3LiBoKCgHJcJDg5GfHw8Fi9ebHRxRIXFRx99hFq1auHIkSNyl0JEBIBZT2Rqf//9NypUqIB58+bJXQoRkeyM6og4c+YMatWqBXt7+xyXsbe3R+3atXH69GljayMqFFJTU7Fv3z48fPgQFy9elLscIiIAzHoiU9u9ezeeP3+O6OhoGPnQOiIiq2FUR0RiYiJKlSr12uW8vb2RmJhozC6ICg1HR0fs2rULa9euxYABA+Quh4gIALOeyNRmzJiBFStWYPHixdrH4BIRFVZGdUQULVoUN2/efO1yt27dgouLizG7ILJ6Dx8+1P7bxcUF3bp1k7EaIiJdzHqivHv48KH26gdJktC3b1/Y2trKXBURkfyM6oho2LAhDh8+jLNnz+a4zNmzZ3H48GE0aNDA6OKIrNWBAwdQrlw5rFy5Uu5SiIiyxawnypv79++jSZMmGDZsGDIzM+Uuh4jIohjVETF8+HBkZmaiQ4cOWLduXZb569atQ4cOHaBWqzF8+PA8F0lkbVatWoXk5GSsXbuW94kSkUVi1hPlzb59+3DlyhX8/fffePDggdzlEBFZFEkY+b+gMWPGYPbs2ZAkCUWLFoWfnx8A4Nq1a3j8+DGEEBgxYgS+++47U9ZrMZ48eQI3NzeoVCq4urrKXQ4VMGq1GnPnzsXQoUPh6OgodzlEZAXMkUvMemY95c369etRrVo1VKpUSe5SiMhKWEs2Gd0RAQArVqzAl19+mWWk/ypVqmD8+PF444038lygpbKWA4DyT2pqKjsdiMhszJVLzHpmPekvMzMTGRkZuT5thogoL6wlm/LUEaGRkJCAW7duAQDKlCkDb2/vPBdm6azlAKD8oVKp0KJFC4SFhWHatGkcLZuITM7cucSsZ9ZT7oQQGD58OC5duoSNGzfymCEis7CWbLIxxUa8vb0LxQkJkbG2bNmCU6dO4c6dOxgxYgS8vLzkLomIyCDMeqLcXb9+HStXrkRKSgqioqLQrl07uUsiIrJYJumIIKLc9enTB2lpaahduzY7IYiIiKyQn58f9u7di9OnT7MTgojoNYzuiEhMTMSPP/6I/fv3IyEhAenp6dkuJ0kS4uLijC6QqKASQkCtVkOpVAIABg8eLHNFRESGYdYTvV5GRgZsbF6eUtetWxd169aVuSIiIstnVEfEhQsXEBISggcPHvDRg0Q5+PTTT3H+/HmsXr2ag1QSUYHDrCd6ve3bt+ODDz7A5s2btU+VISKi11MYs9LYsWORlJSEyMhIHD9+HE+ePIFarc7xh6iwuXbtGmbOnIk//vgD27dvl7scIiKDMeuJcpeZmYkPP/wQFy5cwMyZM+Uuh4ioQDHqqRlubm4oVaoUYmNjC+3o/9YyWimZz759+3DixAmMHj1a7lKIqBAwdS4x65n19HoJCQmYPn06vv32W9jZ2cldDhEVAtaSTUbdmiGEQO3atQvtiQlRToQQ2s9FSEgIQkJCZK6IiMg4zHqi7L2a9d7e3vjhhx9kroiIqOAx6taM+vXr48aNG6auhahAO3z4MAIDA5GQkCB3KUREecasJ8rqwYMHCAwMxL59++QuhYioQDOqI2LKlCk4duwYNm3aZOp6iAoktVqNIUOGIDo6GpMnT5a7HCKiPGPWE2X1+eefIzo6GkOGDMGLFy/kLoeIqMAy+vGdI0eORGRkJPr06YPQ0FD4+PhAoci+X6NZs2ZGF0hUECgUCmzatAkTJ07E7Nmz5S6HiMgkmPVEur766iuoVCqMGzcOtra2cpdDRFRgGTVYpUKhgCRJ2sd5ve7+0czMTOOqs2DWMkgIERFZB1PnErOeWU9ERJbHWrLJqCsi+vfvz8GrqNBLTk5G79698fnnn6Nu3bpyl0NEZFLMeqKXA1OOGTMGVatWxZAhQ+Quh4jIahjVEbF06VITl0FU8EyYMAFbtmzBhQsXcPHiRV6iSURWhVlPBGzZsgWzZ8+GJEkIDAxE1apV5S6JiMgqGD1GBFFhN3XqVFy/fh2TJk1iJwQREZEV6tChAz7++GN4eXmxE4KIyITYEUFkJDc3N44mT0REZMUkScKXX34pdxlERFYnTx0RN2/exKZNm3DlyhUkJycju3EvJUnCokWL8rIbIovxxRdfoEqVKujatavcpRAR5QtmPRU2u3fvxl9//YUZM2bk+JQYIiLKI2Gkzz77TNjY2AiFQqH9kSRJSJKk81qhUBi7C4umUqkEAKFSqeQuJU9SUlLEzJkzRfPmzUWJEiWEra2tKFq0qGjcuLGYOHGiuHHjhnbZAQMGCABiz5492W7r5MmTAoAoVaqUdtqSJUsEADF58mSRmZkp3NzcBAAxdOjQbLexb98+AUBUrVpVCCGEr6+v0PcwvX79ugAgQkJC9HvzBtqyZYsAIBQKhTh//nyuy964cUOMGzdO1KlTR7i7uwtbW1tRokQJERoaKubNmyeSk5PNUiOZTkhIiAAgrl+/LncpRHoxRy4x65n1/2XtWZ+UlCRcXV0FAPHDDz/kuiyzvuBj1lNBZC3ZZFQ375o1azBlyhSUKVMGP//8M0JDQwEA27Ztw/z58xESEgIhBEaPHo3du3cb2UVC5nbo0CFUqFABY8aMwdGjR1G9enV069YNgYGBiIuLw9SpUxEQEICdO3fqtb1atWrB1dUVd+/exbVr17LMP3v2LFQqFQDg4MGD2W7jwIEDAIDg4GAj35X5tG3bFm+//TYmTZqU632i8+fPR0BAAGbMmIE7d+4gMDAQ3bp1Q7Vq1XDw4EG8++67qFChApKSkvKxess1ZcoUSJKU7wPjSZKEcuXK5es+iQoSZr11YNYbxsPDAz/++CPatm2LoUOH5rgcs94wzHoi+i+jbs348ccfYWdnhz179sDX11cbNJqTlLfffhuzZ8/GuHHj0LlzZ5MVS6Zz+vRptGrVCmlpafjoo48wceJEODs7a+er1Wps3LgR48aNw+3bt/XapkKhQGBgILZu3YqDBw/Cz89PZ77mxKNWrVqIiYnBgwcP4OHhke0ympOTXbt24cWLF3rtv3Tp0rhw4QKcnJz0Wt5QSqUS8+fPz3WZBQsWYPjw4XBxccHPP/+MN954Q+fxd8+ePcO8efMwdepUpKSkoHjx4maplfJu+fLlePbsGUqXLi13KUSyYNYXfMx64/Tt2xd9+vTJ8fG1zHrrwawnko9RV0TExMQgMDAQvr6+AKD94yteuW901KhRqFSpEr744gsTlEmmJITAG2+8gbS0NEyZMgVfffWVzokJ8PJEIzIyEidOnED9+vX13rbmpCK7b0EOHjwIW1tbfPDBBxBCICoqSme+Wq3G4cOHdbbj7++PypUr67VvW1tbVK5cGWXLltW73tc5evQopk+frj22JUnK8cTk1q1b+OCDDyBJEv7880/0798/y7JOTk4YO3Ysjhw5Ajc3N5PVSaZXtmxZVK5cmU9EoUKLWV+wMev19+jRI4wYMQJPnz7VTmPWFw7MeiL5GNURkZ6eDi8vL+1rBwcHAMDjx491lqtVqxaOHTtmfHVkFlu3bsW5c+fg4+ODCRMm5Lqsm5sbqlevnmX6/v370bJlSxQpUgSurq7o0KEDYmNjtScVmm87XnXgwAHUrVtX+23a7t27MXXqVFSvXh2Ojo5wdXXFkydPULx4ce0JRrly5bQBr/n39evXIUkSXFxc4OjoiBIlSsDX1xf29vaQJAl+fn46J8pLly6FJEmYMmUKYmJiULVqVdjY2ECSJCiVStSsWRObN2/OUu+DBw/Qpk0bfPLJJyhWrBjs7e1RsmRJ9OrVC+fPn8+y/Ny5c5GWloYePXqgRYsWubZrlSpV4O7urjPt1q1bePvtt7XvpUSJEoiMjMz2MxQfHw9JktC8eXOkpqZi/Pjx2vUqVKiAr7/+OtsB5TTva8KECahRowacnZ3h6uqKGjVqYNy4cUhISMiy/NatW9GhQwd4enrC3t4efn5+GD16NB48eJBl2YEDB0KSJOzduzfHY+RV5cqVw2effQYAGDRokLajR7MNQPf3d/nyZfTq1QslS5aEQqHAxo0bAQBXr17FlClT0KRJE3h5ecHOzg4+Pj7o378/Ll++rLNPzfYA4MaNGzr7bN68uXa55s2bQ5IkxMfHZ3mfsbGx6Nu3L7y9vWFnZ4fSpUujf//+uHTpUpZl9+7dC0mSMHDgQDx8+BDDhg2Dt7c37O3tUb16dSxevDjb3xOR3Jj1BRuzXr+sB4COHTtizpw52pxj1jPrAWY9kdkZM7CEn5+faNWqlfb1F198IRQKhThw4IDOcs2aNRNubm7G7MLiFeRBQt59910BQIwaNcqg9TQDWI0ePVoolUrRqFEj0aNHDxEQECAACA8PDxEfHy/s7e2FJEni/v372gGsRowYIQCIMWPGCCGEKFu2rHB2dhYAhKenp+jWrZuoUqWKAKBdXgjdAaw0/+7du7cAINzc3ETx4sWFra2tiIyMFM2aNdOuP2HCBG3dmho6d+4sFAqFACCcnZ2Fu7u7dnkA4ptvvtF5vxs2bBA2NjYCgKhZs6bo1q2baNSokZAkSTg5OYl9+/bpLF+tWjUBQPzxxx8G/05iYmJE8eLFBQBRqVIl0atXLxEYGCgACBsbG/H777/rLK8ZrKtJkyYiKChIFCtWTERGRoq2bdsKBweHLG2gERsbK3x8fAQA4eXlJbp06SK6dOmirX3Dhg06y3/00UcCgLCzsxNNmzYV3bp1ExUrVhQAhL+/v7h3757O8vocIwkJCdrlx4wZI2rVqiUAiKZNm4oBAwZofy5cuKDz++vVq5dwdXUV5cuXFz179hRt2rQRmzdv1tYpSZKoUaOG6Nixo+jatav2eHJ1dRVnzpzR7vPAgQPaOp2dnXX2OX36dO1yOQ1gtXPnTuHo6CgAiDp16ohevXqJ2rVrCwDCxcVF7N+/X2f5PXv2CAAiIiJCBAQEiFKlSonu3buLFi1aCKVSKQCIhQsXvuYIIXo9U+cSs55ZX1iy3s7OTgAQlStXZtYz64UQzHqybAU5m15lVEdERESE8PHx0b4+ePCgkCRJtGzZUqSkpAghhFizZo2QJEkEBgaaplILU5APgKZNmwoA4tdffzVoPc0fdIVCoRNiGRkZomvXrgKAmDhxoggKChIAxMaNG3VODF4NP01YNWvWTDx58kQIIUT37t0FAFGkSBEBQGzatCnbk5NXTypCQkK0vwNNYAMQTk5O2tGqNTVofr7++muRmZkphBBi9uzZAoBwcHAQSqVSnD17VrstZ2dn4eLiIrZu3arTDn///bewtbUVZcqUEenp6UIIIdLT04UkSQKAuHXrlkHtqlarRY0aNQQAMW7cOKFWq7Xz1q1bJxQKhXBxcRF3797VTn/1vb7aBkIIcezYMaFUKnXaQAghXrx4ISpVqiQAiA8++EBbu8a5c+fE1atXta9///13AUBUr15dXLlyRafeSZMmCQCiZ8+eOtvQ9xh51eTJkwUAsWTJkmzb59Xf33vvvScyMjKyLHP48GFx7dq1LNMXL14sAIgWLVpkmQdA+Pr6ZrtPIbI/OUlJSRElS5YUAMTcuXN1lp81a5YAIHx8fERqaqp2uubkRHOClZaWpp23YcMGAUCULVs2xzqI9GXqXGLWM+uZ9cx6Zj2znixPQc6mVxnVEfHLL78ISZLErl27tNNatmwpJEkStra2wsPDQ/tYr7///ttkxVqSgnwAVK5cWQDIErqvowmevn37Zpl3/PhxbVB+/PHH2m9ENMFSp04dAUAkJiaKlJQUYWtrKwCIZcuWabfh7e0tAGjXb926dbYnJ5r5CoVCXLx4Ubu+JrCLFSsmgH8fPfZquHXp0kWn7hcvXgh3d3dtb/WwYcPE5MmTxXvvvScAiDlz5mTbFppvfdavXy+EEOLevXvafbwaPvrYvXu3NqCeP3+eZX5kZKQAIL744oss7/W/baDRsWNHnTYQ4uV/GACIatWqZRvw/6X59kJzwvYqtVotateuLZRKpbh//752ur7HyKv0PTnx9PQUT58+fW3d/9W0aVMhSZJ4/PixznRjTk40JztNmjTJdp169eoJAGLFihXaaZqTE1dXV5GUlJRlnerVq2f7bQyRoUydS8x6Zv1/WUvWv//+++Kbb74RgwcPZtYz65n1VOAU5Gx6lVFjRPTr1w8XLlxA7dq1tdM2bNiAt956C8WKFUNycjKqVq2KX3/9FWFhYcbsAgCQmpqKSZMmISAgAA4ODihVqhQGDx6MO3fuGLW9+Ph4vPPOOyhfvjzs7e1RvHhxNGnSBN98843RNRZGbdq0yTItICAAAJCQkJDtIFa3bt1CQEAAPD09ceLECe3o2Ddv3gQAxMXFISEhAR4eHhg7diwAZBngSqN169YAAF9fX1SqVCnLfM1I2tndA9mtWzed1zY2NihfvjwyMzMBAL/99hs+++wzLF++HAAQGRmZbQ2a93j06NFs5xtCc49tjx49sh0s6Y033tBZ7lU5tcGrvw8NzaPZhgwZAqVSmWtNiYmJOHPmDCpWrJjtfcOSJKFp06bIzMzEiRMnssx/3TFijNatW+c6SnpKSgpWr16Njz76CEOHDsXAgQMxcOBAJCQkQAiBuLg4o/b7Ks3voG/fvtnO79evn85yr6pXr16WkeOBvLcLkbkw6ws3a876TZs2YezYscx6Zn22mPVE+cOox3fa29tn+YPo6uqKn376CT/99JNJCktLS0PLli0RHR0Nb29vREREID4+HkuWLMHmzZsRHR2d5ZFRufn777/RrVs3pKamom7dumjcuDEePHiAs2fPYsGCBdpALAw0fyDv379v1Po+Pj5ZphUpUgTAy8HNAgMDoVAocPLkSTx//hwAkJSUhE6dOgEA7t69C+DliYHmBEbzxzwoKAju7u5wc3ODSqWCWq3Osi/NI5ayqwOANnjT09OzzOvbt2+OwQIAjo6OsLW11T4D/XWPc9I8H9zd3R2SJEEIgfv37+dYW3Y07ZHTc64107M7Kc9pP6/+PjRu3boF4OXo5K+jGbTpypUrOY4crpHdM9Jfd4wYI7cR0nfv3o1evXrlekwnJycbtd9X5dfvisgSMOsLNmZ9zlkPvBxI8urVqzr7ygmznln/KmY9kWkY1RGRH7744gtER0ejSZMm2L59O1xcXAAAs2bNwpgxYzB48GDtSLuvc/HiRURGRqJIkSLYsWMHAgMDtfPUajVOnjxpjreQrzLVAkevP0RichpKFHFAw/LFoFRkHyq1a9dGVFQUTp48qe3V1WfbNx8+AwAI5B5Wbm5uqFmzJk6fPq3TMx0UFKSznIeHBw4fPozMzMwszxTPLRDt7e0BvHzsmKHCwsJQsmRJnWlbt27FP//8g65du6JcuXL4/PPPUaxYMQDAgAEDct1eo0aNAAB2dnaoWrUqzp8/j5MnTxp0cvI6ubWFMW2gD81JoZeXF9q2bZvrsppH+5m7Ls2I/f+VkpKCHj164OHDh5g0aRJ69eoFX19fODo6QpIk9OnTB6tXr85xZHFTkuN3RVSQMesNp2/eM+uZ9a/DrDcOs57INCyyI+L58+eYO3cuAGDevHnaExMAGD16NJYtW4Z9+/bhxIkTqFev3mu3N3r0aKSlpeF///ufzokJ8PIPhiHPzrZEW88l4LNNsUhQpWmnebs5YHJ4VYRV986yfIcOHTBv3jysXbsWM2bMgI1NzofBq9tOuv4QAPD+6pOYVaJyttvWCA4OxunTp3HlyhXtNM3JSalSpQC8/DbjyZMniImJ0X5bEhwcDJVKhcePH8PR0dHkf9CHDBmCrl276kyrXLky/vnnH3z77bfaXm4fHx/ExcVh5syZ2V5il50OHTrg/PnzWLVqlfYbIX1o2uPGjRvZztd8Y/G6b2xep0yZMgCg12WLmpOr4sWLY+nSpXnar7kdOHAADx48QLdu3bSPB3vVtWvXTLav/PpdERUGzHrDGZL3zHrdrK9Tpw6z/j+Y9dlj1hPlD73+8rds2RKtWrXC7du3ta/1/WnVqpXBRUVFRUGlUsHf3x916tTJMl9z79+mTZteu61bt25h27Zt8PPzQ/v27Q2uxdJtPZeAYStO6pyUAMA9VRqGrTiJreey3osWFhaGatWq4fbt25g2bVqu23570UHcuKr7vOSHT5/nuG0Nzbcdmuc6Ozs7o2LFigBe3j/n6OiovU9u/fr1uHz5MpydnVG3bl2sWLECANC0adPXvX2DbdiwQef1kiVLtM+DTklJ0U7XPP/8v8vn5r333oO9vT1+//137NmzJ9dlL168iEePHgH4t63Wrl2rvX/1VZr20CxnLM39tosWLcr2MthX+fj4oHLlyoiNjc3ybG5Ts7OzAwBkZGQYtb6mHbP7Zurq1as5fgtqa2tr8D41v4PVq1dnO99UvysiOTDrLZuhec+s/1dsbCzOnj0LADh9+rR2OrOeWZ8dZj1R/tCrI2Lv3r3Yu3cvnj17pvNa3x9DnTlzBgBQt27dbOdrpsfExOhVu1qtRmBgIDIyMvD7779j5MiReO+99/DTTz9p/7AVRJlqgc82xSK7i9A00z7bFItMte4SkiRhxYoVcHBwwJQpU/Dxxx/j6dOnOstkZKoxcsYvuLvsAzy/dwXZyW7bGpo/zpoe+Vfv+XN2dsbgwYMhhIAkSZg3bx4AoHHjxrh27Rq++OILAMCIESNyff+G8vT0xMqVKzF16lTtPXpNmzbVXv558eJF7aBZY8aMgaOjIz788EOsX78+y7bS09Oxbt067Qk78PJbiO+++w5CCHTq1Am//vprlksEU1NT8d1336FRo0bacSiaN2+OGjVqID4+HpMmTdJZZ8OGDVi/fj1cXFwwePDgPL3/yMhIBAQE4Ny5cxg3bpx2EDGN8+fP63yjMHHiRKjVanTt2lXnxE3jwYMHWLhwYZ5qAv795kHTIWQozQBQ69ev17lv9PHjx3jzzTezvM9X9/vPP//g8ePHeu+rR48eKFmyJA4ePIiff/5ZZ94PP/yA48ePo3Tp0lm+iSMqCJj1lsuYvGfW/5v1vr6+cHV1BQA8e/aMWc+szxWznih/6HVrxvXr1wH8ewmS5rW5aEZXzuneO830nC6ZelVsbCwAwMXFBcHBwYiOjtaZP2HCBKxbtw4tWrTIdTvp6ek6A8w8efLktfs2t6PXH2b5ZuRVAkCCKg1Hrz9EE3/dSw5r166NnTt3omvXrvjqq6/www8/oEmTJihZsiRUKhUOHzmGh0mJkGzsoCxS3KBtAy/vN6xQoYJ2ICjNpYIa06dPR3R0NE6cOKE9Qbx58yZq1aqFtLQ0jBgxAuHh4Xj//fcNbJWc9ezZE1u2bMGkSZMwd+5c1KxZEyVKlICjoyPS09PRvXt3zJ49G02bNkWFChWwevVq9OnTB127dkWFChVQpUoVODs7486dOzh58iSePn2KU6dO6Ryn77zzDtRqNUaPHo3+/ftj7NixaNCgAVxdXXHv3j1ER0fj2bNnKFWqlPYyZEmSsHLlSrRo0QJffvklNmzYgNq1a+PmzZuIioqCjY0NFi1aBG/vnC+P1YeNjQ3+97//ITQ0FDNnzsSqVavQpEkTCCFw5coVnDt3Dhs2bNAODNenTx+cP38eX375JerVq4fatWvD399fOyp1TEwMXFxcMHTo0DzV1aZNGzg4OGD27Nk4d+4cSpUqBUmSMHbs2GxHCf+v+vXrIzQ0FDt27EBAQACaN28O4OV/TIoXL46IiAj88ccfWdbr1KkT5syZg7p16yIwMBAODg6oVKlSroPZOTs7Y+XKlQgPD8fbb7+Nn3/+GQEBAbh48SJOnToFFxcXrF69Osd7XIksGbPeMrMeMD7vmfX/Zr1G3759mfXMemY9kQXQ64oIX19f+Pr6au8v1LzW98dQmkvkc3p8j7OzMwD9RsbVBN8vv/yCixcvYtWqVXj48CEuXbqEfv364eHDh+jSpctrHxM2ffp0uLm5aX/+G7ZySEzO+aREn+WaNm2Kq1ev4ttvv0WDBg0QExOD33//HVFRUSjuXRpuTXuj1NCf4ViutlE1vHrJ2n9HQS5SpAj27dunHQAKAG7fvo369etj1apV+P777/V6b4bw8PDAqVOnMHz4cHh4eCA6Ohrr169HWtrL9/D555/rDOgVERGBmJgYDB8+HJIkYceOHdiyZQsSExMRHh6O33//HVWrVs2yn+HDh+Py5csYO3YsvLy8cODAAfz+++84d+4cgoKCMH/+fFy+fBnFi/970lejRg2cPHkSQ4cORUpKCtatW4dLly6hc+fOiIqKQo8ePUzSBtWrV8eZM2fw4YcfokiRIvjrr7+we/duSJKEjz76CI0bN9ZZftq0adi3bx+6du2Ke/fuYePGjdizZw8yMzMxbNgw/Pnnn3muqVSpUvjjjz/QuHFjHDx4EIsXL8aiRYsMesTVH3/8gQkTJsDT0xN///03Tpw4gV69eiE6OhpFixbNdp3p06fjvffeQ0ZGBtasWYNFixZhy5Ytr91Xq1atcOzYMfTu3Ru3b9/GunXrcO/ePfTr1w/Hjx/npZpUYDHrLTPrgbzlfWHN+k8//RQuLi7arE9NTQXArGfWM+uJLIUkjBhetm7duvD398fatWvNURPeeustLFy4EBMmTNBeuveqq1evomLFiqhYseJr72nTbAsA1qxZk+WPfMOGDXHs2DF88sknud5Dmd23JGXKlIFKpdJe7pffDsc9QO+F0a9dbvXQxtl+kyHXtuV09epVBAYG4sWLF9i1a1eOlwQTERU0T5480T4O0RS5xKy3jKwHzJfJ1pr16enpaNOmDfbv34+ffvoJb7/9ttwlERGZjKnzXi5GDVN86dIl2NramroWLc1lbJr7VP9Lc4+j5pm8+mzLxcUF3bt3zzJ/0KBBAIB9+/bluh17e3u4urrq/MitYfli8HZzyPEBWxJejqbdsHwxi9q2nDw8PBAQEIDy5cujQoUKcpdDRGSxmPWWkfWA+TLZWrPe1tYW9erVg6urq87VGEREZDmM6oioWLEiHjx4YOpatDSX9r06ONCrNNP1uRRUs0zZsmWzfe6v5hFOiYmJxpQqK6VCwuTwl5cL/vedaV5PDq+a7fPF5dy2nNzd3bF9+3Zs27bNYk4wiYgsEbPecpgrk6016xUKBWbOnImzZ8+idu3acpdDRETZMKoj4s0338S+fftw8eJFU9cDAKhVqxYA5PgoHs30mjVrvnZbmkeC5TRi9sOHL5+X/erzywuSsOremN+vLrzcdAfM8XJzwPx+dXN9/rec285Pz5490xnR3cnJCZ6envIVRERUADDrLYu5Mtlash4Atm7dqn0ahSRJWcasICIiy6HXUzP+6/3338f58+cREhKC8ePHIzw8HGXLltU+IzivmjZtCjc3N8TFxeH06dNZerPXrVsHAAgPD3/ttgIDA+Hh4YF79+7h0qVLWUbm1Vymmd0zzAuKsOreCK3qhaPXHyIxOQ0liry8jNIU32CYc9v54cWLF+jRowe2bt2KpUuX6gxQRUREOWPWWx5zZXJBz3oAmDVrFsaMGYPBgwfjl19+yfbKGCIishxGXRGhVCqxcOFC3L9/Hx9++CEqVaoER0dHKJXKLD+a0bcNYWdnh/feew8A8O677+o893rWrFmIiYlBSEgI6tWrp50+d+5cVK5cGR9//LHOtmxsbDB69GgIIfDuu+/qPIpr586dWLp0KSRJKvADGSkVEpr4eyCidmk08fcw6cmDObdtbpIkoXjx4rC1tUX58uXlLoeIqMBg1lsmc2VyQc564OWtlwqFAgEBAeyEICIqAIy6IqJMmTJm/yP/6aefYufOnTh06BAqVqyI4OBg3LhxA0eOHIGnpycWL16ss3xSUhIuXbqU7WOAxo4diz179mDnzp0ICAhA48aNkZSUhOjoaGRmZmLatGlo2LChWd8PycPGxgZLlizB2LFjUa1aNbnLISIqMJj1VJAMGjQIDRo0YNYTERUQRnVExMfHm7iMrBwcHLBnzx5Mnz4dq1atwsaNG1GsWDEMHDgQU6dOhY+Pj97bsrW1xV9//YXZs2dj+fLl2LZtG+zs7BASEoJRo0ahY8eOZnwnJIejR49qTzglSeKJCRGRgZj1ZOnOnj2LChUqwNHREQBQvXp1mSsiIiJ9SUIzqg8ZxFqe32qNlixZgsGDB2PMmDH45ptveIkmERUKzCXTY5tarnPnziE4OBjVq1fHpk2bULRoUblLIiLKF9aSTUaNEUFkyTSjpiuVSnZCEBERWSGVSgUhBNRqtckGUCUiovxj1K0Zrzp//jyuXLmC5ORk5HRxRf/+/fO6GyK9jR49Gg0aNEBQUJDcpRARWQVmPVmapk2b4uDBgyhVqhScnJzkLoeIiAxk9K0ZO3fuxPDhwxEXF5fjMkIISJKEzMxMowu0VNZySYy1uHbtGsqUKQNbW1u5SyEikoU5colZz6y3JMnJyUhJSYG3t7fcpRARycZassmoKyKOHz+ODh06QJIk9OnTB2fPnsXZs2cxfvx4xMXFYefOnXj06BEGDRqEsmXLmrpmIh3Xrl1D06ZNUa9ePfz+++/8ZoSIyASY9WRJ0tPT0blzZ1y7dg3bt29HxYoV5S6JiIjywKiOiOnTpyMjIwNbt25FaGgoBg0ahLNnz2LatGkAgMePH+Ptt9/G5s2bcfz4cZMWTPRfcXFxUKlUuH37Np4/f86OCCIiE2DWkyV58OABbt68iaSkJKhUKrnLISKiPDJqsMpDhw6hTp06CA0NzXZ+0aJFsXz5cigUCnz66ad5KpDodUJDQ7F79278/fffHDWbiMhEmPVkSUqVKoWoqChs3boV9evXl7scIiLKI6M6Ih4+fKhzSZxmtOKnT59qp9nb2yM4OBg7duzIY4lEWaWlpWmfjgEAjRs35j2jREQmxKwnS5CQkKD9d4kSJdC0aVMZqyEiIlMxqiPC09MTT5480XkNvLxX/1Wpqam8fI5MLiMjA71790ZwcDDu3LkjdzlERFaJWU9ymzt3LgICArBr1y65SyEiIhMzqiOiQoUKuH79uvZ1w4YNIYTAggULtNOuXr2K3bt3w8/PL+9VEr3i7t27OHbsGK5evZrrSO5ERGQ8Zj3JSa1W488//0RKSgqio6PlLoeIiEzMqI6I9u3b49KlS7hw4QIAICwsDL6+vpg/fz4aNWqErl27okGDBkhLS8Obb75p0oKJypYti6ioKGzYsAHNmjWTuxwiIqvErCc5KRQKbNq0CUuWLMEnn3widzlERGRiRj01o3///nBzc4NarQbw8r7RP//8Ez169MCxY8dw7NgxKBQKDBkyBCNHjjRpwVR4qVQquLm5AQB8fX3h6+src0VERNaLWU9yeDXr7e3tMXDgQHkLIiIis5CEEMKUG7x48SIePXqEChUqaO8ntUZPnjyBm5sbVCoVXF1d5S7H6q1YsQKjRo3Cli1b0LBhQ7nLISKyOPmZS8x6MocLFy4gJCQEU6ZMwfDhw+Uuh4jIIllLNhl1RURuKleubOpNUiGnVqsxf/58JCUlYcOGDeyIICKSGbOezOG3337D/fv3sWzZMgwdOhS2trZyl0RERGZi1BgR3bp1wx9//IEXL16Yuh6iLBQKBbZt24Zvv/0W06ZNk7scIqJCgVlP+W3KlCn44YcfsGXLFnZCEBFZOaNuzVAoFJAkCW5ubujevTv69u1b6AYNtJZLYixZeno67O3t5S6DiKhAMHUuMeuZ9fkhPT0ddnZ2kCRJ7lKIiAoEa8kmo66I+OOPP9C9e3ekp6dj4cKFaNGiBXx9ffHxxx/j3Llzpq6RCqEbN26gcuXKWL16tdylEBEVSsx6Mrfnz5+jU6dOePfdd5GZmSl3OURElI/yNFhlSkoK1q9fj5UrV2L37t3IzMyEJEmoUaMG+vbti969e8PHx8eU9VoMa+mJslTjx4/H119/jRo1auDEiRO8RJOI6DXMlUvMema9uWzfvh1hYWFwdHTEiRMnOPYIEZEerCWbTPbUjMTERKxevRorV67E8ePHAby8rLNZs2bYvXu3KXZhUazlALBUarUan3/+OYYOHYrSpUvLXQ4RkcXLj1xi1pOp/f7773B1dUVYWJjcpRARFQjWkk0mf3wnAFy9ehXffvstfv75Z0iSZJWX21nLAWBJMjMzoVQq5S6DiKhAyu9cYtaTsZj3RETGs5ZsMmqMiJwkJydj6dKlGD58OBYtWmTKTZOVy8zMRO/evfHpp5/CDH1jRERkIsx6youffvoJbdu2RXJystylEBGRjGzyuoEXL15gy5YtWLlyJbZs2YL09HQIIeDv74++ffuib9++pqiTrNyOHTuwdu1a2Nraok+fPqhatarcJRER0f9j1pMpPHjwAOPHj4dKpcKKFSswbNgwuUsiIiKZGN0RsWfPHqxatQr/+9//oFKpIISAp6cnhgwZgr59+6JRo0amrJOsXFhYGBYsWAB3d3d2QhARWQhmPZmSh4cHdu3ahbVr1+Kdd96RuxwiIpKRUR0RPj4+SEhIgBACzs7O6N27N/r27Ys2bdrwnj8yiBBC++zwt956S+ZqiIhIg1lPpvJq1terVw/16tWTuSIiIpKbUWNE3Lt3D23btsWvv/6Kf/75BytWrEC7du14YkIGWb16Nbp37460tDS5SyEiov9g1pMpXL58GUFBQbh+/brcpRARkQUx6oqIhIQEeHp6mroWKkQePHiAt956CykpKQgJCcH7778vd0lERPQKZj2Zwttvv41Dhw5hxIgR2LRpk9zlEBGRhTDqigiemFBeeXh44M8//8TQoUPx7rvvyl0OERH9B7OeTGHlypWIjIzkE1aIiEiHJPisRKNY2vNbM9UCR68/RGJyGkoUcUDD8sWgVEhmX5eIiCyDpeWSNbDENmXeExEVbpaYTcbI8+M7SX5bzyXgs02xSFD9O9aCt5sDJodXRVh1b7Ota6hbt25h+PDhWLhwIby8vEy6bSIiImtXEPL+xYsXGDhwIN555x0EBwebbLtERGRdjLo1gyzH1nMJGLbipM6JBQDcU6Vh2IqT2HouwSzrGqN///7YvHkzhgwZYtLtEhERWbuCkvfffvstVq1ahc6dO+PJkycm2y4REVkXdkQUYJlqgc82xSK7e2s00z7bFItMddYl8rKusRYuXIiQkBD8+OOPJtsmERGRtStIef/BBx8gMjISy5cvL9CXDBMRkXmxI6IAO3r9YZZvN14lACSo0nD0+kOTrmusChUqYO/evShbtqzJtklERGTtClLeOzo64n//+x86dOhgku0REZF1YkdEAZaYnPOJxeuWy8u6+lKr1RgxYgROnTpl9DaIiIgKO0vP+8WLF2Px4sVGr09ERIVPngerfPjwIU6cOIGkpCT4+voiMDDQFHWRHkoUcTB6ubysq6+ZM2dizpw5WLVqFa5du8ZLNImICihmvbwsOe9PnDiBoUOHQq1Ww8/PD82bNzdqO0REVLgYfUXE/fv30adPH3h5eSEsLAz9+vXDL7/8op3/yy+/oFixYjh48KBJCqWsGpYvBm83B+T04C0JL0fEbli+mEnX1ddbb72FFi1aYM6cOeyEICIqgJj1lsGS875u3boYN24c3nzzTYSEhBi1DSIiKnyM6oh4+PAhAgMD8dtvv6F69eoYPnw4hNAd5CgyMhLJyclYt26dSQqlrJQKCZPDqwJAlhMMzevJ4VWzfUZ4XtbVl5ubG3bu3InevXsbvQ0iIpIHs95yWHLeS5KE6dOn4+eff4YkGX/OQEREhYtRHRHTpk1DXFwcJk2ahJMnT2LOnDlZlilWrBhq1qyJffv25blIyllYdW/M71cXXm66l1R6uTlgfr+6uT4bPC/r5uR///sf1q9fr32tUHAYEiKigohZb1ksKe/j4uIwZcoUqNVq7TTmPRERGcKoMSI2btyIgIAATJkyJdfl/P39sXfvXmN2QQYIq+6N0KpeOHr9IRKT01CiyMtLLPX5diMv6/7XqVOn0KdPH2RkZGDPnj1o1qyZMW+HiIgsALPe8lhC3qelpaFt27aIi4sDgNceH0RERNkxqiPizp07iIiIeO1ykiThyZMnxuyCDKRUSGji75Hv676qZs2aGDBgAB4+fIimTZvmeXtERCQfZr1lkjvvHRwcMGXKFHzxxRd455138rQtIiIqvIzqiHB1dUVCQsJrl4uLi4Onp6cxu6ACSKlUYsGCBcjIyIBSqZS7HCIiygNmPeWkX79+6NGjB+zs7OQuhYiICiijbuhr0KABjh07huvXr+e4zJkzZ3D69Gl+M27l7t69ix9++EE7gJkkSbC1tZW5KiIiyitmPWlkZGTgyy+/xNOnT7XT2AlBRER5YVRHxPvvv4/09HR06dIFFy5cyDL/6tWreOONNyCEwHvvvZfnIskyae4THTlyJKZPny53OUREZELMetL44IMPMGHCBHTs2DHLk1OIiIiMYVRHRFhYGMaNG4eYmBhUr14dlStXhiRJ2LZtG2rVqoUqVarg3Llz+OSTTxAUFGTqmslCODg4YOjQoShdujQf0UlEZGWY9aTRt29feHp64oMPPuAjOomIyCQkkYeu7bVr12LatGmIiYnRmV65cmVMnDjRqv9z+uTJE7i5uUGlUsHV1VXucmSVnJyMIkWKyF0GEVGhZq5cYtYz6wFmPRGRpbCWbDKqI+LJkyeQJEkbSPfv30d8fDzUajV8fHxQunRpkxdqaazlADCUWq3GwoULMWjQIN4fSkRkQUydS8z6wpv1ALBhwwbUr18fZcqUkbsUIiJ6hbVkk1FPzShatCgaNWqEw4cPAwA8PT05YnYh8fHHH2PGjBn4888/sXnzZl6iSURkpZj1hdfWrVvRvXt3eHt74+jRo/D29pa7JCIisjJGjRHh5uYGPz8/U9dCBUCrVq3g4uKCnj17shOCiMiKMesLr6pVq6JixYpo2bIlSpYsKXc5RERkhYy6IqJOnTqIi4szdS1UALRp0wZxcXEoUaKE3KUQEZEZMesLr7JlyyIqKgpFihSBQmHUd1ZERES5MipdPvroIxw7dgzr1q0zdT1kgXbt2oWkpCTta3ZCEBFZP2Z94RIfH48jR45oXxcrVgy2trYyVkRERNbMqCsiHB0dMWTIEPTs2RMdO3ZEeHg4ypYtCwcHh2yXb9asWZ6KJPns378fHTp0QLly5bBv3z5eoklEVEgw6wuPxMREtGnTBnfu3MGWLVvQvHlzuUsiIiIrZ1RHRPPmzSFJEoQQ2LRpEzZv3pzr8pmZmUYVR/IrUaIESpQogcqVK8PDw0PucoiIKJ8w6wsPZ2dn+Pn54fnz5wgICJC7HCIiKgSM6ojo378/ByosJCpXrozo6Gi4u7vDxsaow4WIiAogZn3h4ezsjD///BP//PMPSpUqJXc5RERUCEhCCCF3EQWRtTy/NTv37t3DgwcPUK1aNblLISIiPVlzLsnFmts0MzMTBw4c4G0YREQFjLVkE4dCJh0qlQphYWEIDg7WGbSKiIiIrIMQAu+++y5atGiBOXPmyF0OEREVQuyIIB2ZmZlwcnKCnZ0dihcvLnc5REREZGJCCDg4OECSJN6KQUREsjDqpv/BgwfrvawkSVi0aJExuyEZFCtWDDt27MDt27fh7+8vdzlERCQTZr31UigUmD17Nvr374+6devKXQ4RERVCRo0RoVC8/kIKzUjbkiRZ5Uja1nJvDvDym5EzZ86gdu3acpdCRERGMnUuMeutK+sB4PTp06hVqxYHISUiKsCsJZuMuiJiz5492U5Xq9W4desWtm/fjt9++w2jRo1CeHh4ngok8/vkk0/wzTffYPHixejfv7/c5RARkQVg1luXrVu3Ijw8HP3798eCBQv4JCwiIpKVUSkUEhKS6/z+/fujQ4cOGDBgADp16mRUYZQ/1Go17ty5g8zMTGRkZMhdDhERWQhmvXVJSEiAWq1GamqqXle7EBERmZNZH99Zp04duLu7Y/fu3ebahWys5ZIY4GVnxN69e9GyZUu5SyEiIiPJlUvM+oJj//79aNy4Mezs7OQuhYiIjGQt2WTWLvGKFSvi+PHj5twFGenatWvafysUCnZCEBGRUZj1lishIQGpqana182aNWMnBBERWQSzdUSo1WrExMTw8j8LFBUVherVq2PcuHEw4wUxRERk5Zj1lispKQktW7ZEWFgYVCqV3OUQERHpMPmZw7Nnz3D69Gn07t0bV65cee09ppT/Tp48idTUVMTGxlrlKOdERGRezHrLd+3aNdy9exfXr19HcnKy3OUQERHpMGqwSqVS+dplhBDw9PTEN998Y8wuyIzef/99+Pr6onXr1hw1m4iIssWsL9gaNmyI/fv3w87ODj4+PnKXQ0REpMOo/4WWKVMmx2dQ29nZwdvbGyEhIXj33XdRokSJPBVIpvHo0SO4uLjA1tYWADjCORER5YpZX/Co1Wo8fPgQxYsXBwDUqlVL5oqIiIiyZ1RHRHx8vInLIHNKTk5GaGgovL29sWbNGjg5OcldEhERWThmfcEihMDIkSOxZcsWbN++HRUqVJC7JCIiohxZ9OhSqampmDRpEgICAuDg4IBSpUph8ODBuHPnjkHbKVeuHCRJyvHn4sWLZnoHluHMmTM4f/48jhw5goSEBLnLISIi0mLWm8bjx4/x999/Iz4+HqdOnZK7HCIiolwZdUWEn58funfvjq+//jrX5T7++GP8/vvviIuLM3gfaWlpaNmyJaKjo+Ht7Y2IiAjEx8djyZIl2Lx5M6Kjo+Hn52fQNgcMGJDtdDc3N4PrK0iCgoKwY8cOODo6wt/fX+5yiIioAGDWFyzu7u6IiorCnj170L17d7nLISIiypXRt2bcv3//tcslJSUZfWnnF198gejoaDRp0gTbt2+Hi4sLAGDWrFkYM2YMBg8ejL179xq0zaVLlxpVS0EkhMDTp0+17RYUFCRzRUREVJAw6wuGlJQUbbuVLFkSvXr1krkiIiKi1zPrrRlPnz7VDo5oiOfPn2Pu3LkAgHnz5mkDFgBGjx6NmjVrYt++fThx4oTJarU2kydPRuPGjQ2+tJWIiMgQzHr57Ny5E+XKlcPu3bvlLoWIiMggZumIUKvVuHDhAvbs2YOyZcsavH5UVBRUKhX8/f1Rp06dLPO7desGANi0aVOea7VGDx8+xKJFi3D+/Hns2rVL7nKIiMgKMevlN2fOHDx48ACLFy+WuxQiIiKD6H1rxn+fJ75s2TIsW7Ys13WEEHjrrbcMLurMmTMAgLp162Y7XzM9JibGoO1+8803iIuLg729PapVq4YuXbrA09PT4PosXbFixRAVFYW///4b/fv3l7scIiIqIJj1BcuaNWswc+ZMfPjhh3KXQkREZBC9OyJefZ74zZs34eTkpH1O9X/Z2dmhVKlS6NSpE0aMGGFwUTdv3gQA+Pj4ZDtfM/3GjRsGbXfcuHE6r0eNGoU5c+Zg8ODBr103PT0d6enp2tdPnjwxaN/54fnz57CzswPwcvTwYcOGyVwREREVJMz6gpX1Dg4OmDBhgswVERERGU7vjohXB6JSKBTo3r272S4FTElJAQA4OTllO9/Z2RkAkJycrNf2OnXqhBYtWqBevXrw9PTEtWvXsHjxYnz//fcYMmQIPDw8EBERkes2pk+fjs8++8yAd5G/jhw5gl69emHt2rWoX7++3OUQEVEBxKy37Kx/+PAhmjdvjuHDh+Odd96RuxwiIiKjGTVGxJ49e/DRRx+Zuhaz+eGHH9ClSxeULVsWjo6OqFatGmbOnIn58+dDCKHXe/n444+hUqm0P7du3cqHyvU3ZcoUxMfH46uvvpK7FCIisgLMesvL+qVLl+Ls2bP44osvLPJqDSIiIn0Z1REREhKCSpUqmboWLc3I2c+ePct2/tOnTwEARYoUydN+3nzzTZQoUQKXLl167aPH7O3t4erqqvNjSX7//XeMHj36tffyEhER6YNZb3lZP2rUKEybNg3btm2zuNqIiIgMofetGTk5f/48rly5guTkZAghsl3G0AETNaNv3759O9v5mum+vr4Gbfe/FAoF/P39kZiYiISEBJQrVy5P28tvarUaCsXLvqQiRYpg5syZMldERETWiFkvH017S5IESZLwySefyFwRERFR3hndEbFz504MHz4ccXFxOS4jhIAkSQafnNSqVQsAcPLkyWzna6bXrFnToO1m59GjRwD+vRe1oEhJSUG7du3w/vvvo0ePHnKXQ0REVohZLy8hBEaPHo0XL17ghx9+0H75QEREVNAZ1RFx/PhxdOjQAZIkoU+fPjh79izOnj2L8ePHIy4uDjt37sSjR48waNAgo54t3rRpU7i5uSEuLg6nT59G7dq1deavW7cOABAeHm5M+Vrnz5/HpUuX4OTkhMqVK+dpW/lt3rx5OHjwIC5duoSwsDBeoklERCbFrJffyZMn8f3330MIge7duyMkJETukoiIiExDGCEyMlIoFAqxfft2IYQQAwcOFAqFQjv/0aNHokePHqJEiRLi5s2bxuxCTJgwQQAQgYGBIiUlRTt95syZAoAICQnRWX7OnDmiUqVKYvz48TrTt2zZInbt2pVl+2fOnBFVqlQRAMSIESMMrk+lUgkAQqVSGbyuKWRkZIjRo0eL6OhoWfZPRESWxdS5xKyXP+uFEOK3334T3333nWz7JyIiy2IJ2WQKRl0RcejQIdSpUwehoaHZzi9atCiWL1+OcuXK4dNPPzVqAMVPP/0UO3fuxKFDh1CxYkUEBwfjxo0bOHLkCDw9PbM8TiwpKQmXLl1CQkKCzvSjR4/is88+g6+vL2rVqgUnJydcu3YNJ0+eREZGBpo3b14gnzShVCo5JgQREZkNs94y9OzZU+4SiIiITM6omw0fPnyIihUral/b2dkB+HeEa+DlyNPBwcHYsWOHUYU5ODhgz549mDhxIpycnLBx40bcuHEDAwcOxMmTJ+Hn56fXdtq2bYvBgwfD1dUVUVFRWLduHa5evYqgoCAsXLgQO3fuhKOjo1E15repU6di0qRJOQ4URkREZCrMenns3bsXHTt2RHJystylEBERmY0kjPhfrY+PD2rVqoUtW7YAePmNxvTp03H69GnUqFFDu1x4eDh2796tc9JiLZ48eQI3NzeoVKp8GZ/hxIkTqF+/PgBg9+7daNGihdn3SUREBYepc4lZn/9Zn5aWBn9/f9y9exfjx4/H9OnTzb5PIiIqWPI7m8zFqCsiKlSogOvXr2tfN2zYEEIILFiwQDvt6tWr2L17t97fZlDu6tWrh/nz52Py5MnshCAiIrNj1uc/BwcHbNy4EV27dsXkyZPlLoeIiMhsjOqIaN++PS5duoQLFy4AAMLCwuDr64v58+ejUaNG6Nq1Kxo0aIC0tDS8+eabJi24MHvnnXcwZcoUucsgIqJCgFkvjwYNGmDdunVwcHCQuxQiIiKzMaojon///vjxxx+hVqsBvLxv9M8//0RAQACOHTuGDRs2IDk5GUOGDMHIkSNNWnBhcvz4cQwYMABpaWlyl0JERIUMsz5/PH78GN26dUN8fLzcpRAREeUbo8aIyM3Fixfx6NEjVKhQAZ6enqbctEUx9705aWlpqFixIm7fvs37RImI6LXy855RZr3p9O3bF6tWrULdunVx/PhxSJJklv0QEZF1sJYxIox6fGduKleubOpNFkoODg5YtmwZvvjiC3zyySdyl0NERKTFrDedGTNm4MaNG5g3bx47IYiIqNAweUcEmU7Lli3RokULnpgQERFZqdKlS+PAgQPMeiIiKlSM7ohIT0/H6tWrsX//fiQkJCA9PT3b5SRJwq5du4wusDB59uwZRo0ahc8//xwlS5YEAJ6YEBGRbJj15vH555+jZcuWCAoKAsCsJyKiwseojog7d+6gVatWuHLlCl43xATDVX/Dhg3D8uXLcerUKRw5coRtR0REsmHWm8fKlSsxefJkfPXVV7hy5QpKly4td0lERET5zqiOiLFjx+Ly5csIDAzE6NGjERAQgCJFipi6tkJn4sSJOHHiBL777jue1BERkayY9ebRpUsXdOzYEcHBweyEICKiQsuop2Z4eHigSJEiuHjxYqF9zrW5RivNzMyEUqk02faIiKhwMHUuMeuZ9UREZHms5akZCmNWSk9PR6NGjQrtiYkpzZ07F2fOnNG+5okJERFZAma96Rw8eBDLli3TvmbWExFRYWfUrRk1atRAUlKSqWspdNauXYv3338frq6uiI2N5SWaRERkMZj1pnHjxg107NgRKpUKRYoUQWRkpNwlERERyc6oKyI++ugj7N+/H0ePHjV1PYVKaGgogoODMXz4cHZCEBGRRWHWm0bZsmXx1ltvISgoCGFhYXKXQ0REZBGMuiKibt26GD16NFq1aoXRo0cjNDQUPj4+UCiy79coW7Zsnoq0VkWLFsWOHTtgZ2cndylEREQ6mPWmIUkSZsyYgbS0NN7mQkRE9P+MGqxSoVBAkiQIIV77dAdJkpCRkWF0gZbK2EFCTp06hRs3bqBz587mK46IiAodUw9exaw3vk2fPHmCRYsWYeTIkTl23BARERnDWgarNOqKiGbNmvHxkka4ffs22rVrh/v372Pjxo0IDw+XuyQiIqJsMeuNo1ar0aVLF+zevRs3b97E7Nmz5S6JiIjI4hjVEbF3714Tl1E4eHl5oUOHDjhx4gSaNWsmdzlEREQ5YtYbR6FQoH///jh16hTeeOMNucshIiKySEbdmkHGXxIjhNCuS0REZCrWcqmmJclLmz5+/BhFixY1T2FERFRoWUve88ZFM0tNTcXy5cuh6e+RJImdEERERFZmxYoVePbsmfY1OyGIiIhyZtStGZ9//rley9nZ2cHDwwO1a9dGgwYNjNlVgaZWq9GrVy/8+eefuHTpEqZNmyZ3SURERHph1utvzpw5GDFiBObPn4+9e/fC1tZW7pKIiIgsmlEdEVOmTMkygNWr3/i/Ok3zulKlSvjll18QGBhobK0FjkKhQMuWLbFjxw60bdtW7nKIiIj0xqzXX7169VC0aFF06NCBnRBERER6MGqMiGXLluHIkSP46aef4Ovri65du2qfH37r1i3873//Q3x8PN5++22UKVMG+/fvx/bt2+Hs7Ixjx46hcuXKJn8j+c2Qe3Pu3r2LUqVK5VNlRERUGJn6nlFmveFZ7+3tzSeNEBGRWVnLGBFGdUScOHECwcHBGDduHCZOnAilUqkzX61WY+rUqfjqq69w4MAB1K9fH7Nnz8aYMWMwYMAALFmyxGRvQC65HQBbtmxBaGgo7OzsZKqOiIgKG1OfmDDrc2/T48ePw8vLCz4+PjJVR0REhVGh7ojo0KEDbt26hZiYmFyXq1mzJnx8fPDXX39BCAF/f3+o1WrEx8cbW6/FyOkAWLZsGQYOHIi2bdvizz//ZGcEERHlC1OfmDDrc27T2NhYBAUFwcXFBXv37oWfn5+MVRIRUWFiLR0RRj014/Dhw6hRo8Zrl6tRowYOHz4M4OX9pNWrV8e9e/eM2WWBUbJkSTg5OaF69eq8T5SIiAosZn3OnJ2d4enpidKlS6NkyZJyl0NERFTgGDVYZUZGhl7fdMTHxyMzM1P72t7eHg4ODsbsssAICwvDqVOnUKFCBd4nSkREBRazPme+vr44ePAgFAoFnJ2d5S6HiIiowDHqioj69esjOjoaa9asyXGZNWvW4PDhwzqP8rpx44ZVfnNw4cIFJCUlaV8HBARAoTCqaYmIiCwCs15XcnIyTp06pX3t6ekJDw8PGSsiIiIquIy6ImLy5Mlo3bo1+vTpg8WLF6Nbt24oU6YMgH9H0t6xYwdsbGwwefJkAEBiYiJOnTqFAQMGmK56CxAfH4+wsDC4ublhx44dHLSKiIisArP+X+np6ejTpw8OHz6MDRs2IDQ0VO6SiIiICjSjOiJCQkKwZs0aDB06FDt27MDOnTt15gshUKxYMSxcuBDNmjUD8PISzxUrVqBevXp5r9qCPH/+HEqlEra2trw8k4iIrAaz/l8ZGRnaKx2LFi0qbzFERERWwKinZmgkJyfj999/R1RUFBISEgAA3t7eaNq0Kbp3716gR/F8nVdHK1WpVFAqlShVqpTcZRERUSFlrlG0mfUv29TBwQHnz59HnTp15C6LiIgKMWt5akaeOiIKM2s5AIiIyDowl0yPbUpERJbGWrLJqFsz6OUlqcDLA4GIiEhumjzi9wumw6wnIiJLYy15r1dHxM2bNwEApUuXhlKp1L7WV9myZQ2vzMIlJycDgHbgLiIiIkuQnJwMNzc3g9dj1mfFrCciIktlxzOv8QAAKI9JREFUbN5bCr1uzVAoFFAoFIiNjdU+mlKSJP12IEnIyMjIc6GWRq1W4+7duyhSpIjebWFuT548QZkyZXDr1q0CfZlOfmF76Y9tZRi2l/7YVobJrb2EEEhOTkapUqWMeoQ0sz4rS8x6gJ8bQ7CtDMP20h/bSn9sK8O8rr3ymveWQq8rIpo1awZJkuDk5KTzujBTKBQW+6hOV1dXfsgNwPbSH9vKMGwv/bGtDJNTe+XlmxFmfVaWnPUAPzeGYFsZhu2lP7aV/thWhsmtvQrylRAaenVE7N27N9fXREREVLAx64mIiCi/FNxrOYiIiIiIiIiowDFpR0RaWhru3btnlfeJFgT29vaYPHky7O3t5S6lQGB76Y9tZRi2l/7YVoaxhPZi1svPEo6DgoJtZRi2l/7YVvpjWxmmsLSXXoNVJicn48KFCyhatCgCAgKyzL9y5Qree+897NmzB5mZmbCzs0NERARmz54Nb29vsxROREREpsOsJyIiovyi1xURy5cvR5MmTbB58+Ys8+7du4fg4GDs3LkTGRkZEEIgPT0da9euRYsWLZCammryoomIiMi0mPVERESUX/TqiNi3bx8UCgX69euXZd7UqVORmJgId3d3/PHHH0hOTsbJkydRv359XLlyBfPnzzd50URERGRazHoiIiLKL3rdmlG5cmU4OTnh5MmTOtPVajWKFy8OlUqF+fPn46233tLOu3PnDvz8/NCoUSPs37/f9JUTERGRyTDriYiIKL/odUVEYmIiKlWqlGV6TEwMHj9+DBsbG/Tq1UtnXunSpdGoUSNcuHDBNJUWQqmpqZg0aRICAgLg4OCAUqVKYfDgwbhz545B2ylXrhwkScrx5+LFi2Z6B/nLVO2lER8fj3feeQfly5eHvb09ihcvjiZNmuCbb74xceX5zxRttXTp0lyPK83P8uXLzfhO8ocpj60dO3agQ4cO8PT0hK2tLTw8PNCmTRts2LDBDJXnP1O2VXR0NCIiIlC8eHE4ODggICAAEyZMwNOnT81Qef46ceIEvvrqK0RGRsLHx0f7eTHWo0ePMHLkSPj6+sLe3h6+vr744IMP8PjxY723wayXB7PeMMx6/THrDcOs1x+zXn+WmPcWQ+jBzs5OdO3aNcv0X375RUiSJOrXr5/ter179xZ2dnb67IL+IzU1VTRu3FgAEN7e3qJHjx6iYcOGAoDw9PQUcXFxem/L19dXABADBgzI9ufu3btmfCf5w5TtJYQQf/31l3BychKSJIl69eqJXr16idDQUOHl5SX8/f3N9C7yh6na6sCBAzkeU507dxYABACD297SmPLYmj17tgAgJEkSgYGBomfPniIwMFBIkiQAiE8++cSM78T8TNlWK1asEEqlUgAQdevWFV26dBFly5YVAETNmjWFSqUy4zsxv4iICO1n5NUfY9y/f19UqFBBABB+fn6iR48eolq1agKACAgIEA8ePNBrO8z6/MesNwyzXn/MesMw6/XHrDeMJea9pdCrFUqXLi2qVauWZfrAgQOFQqEQw4cPz3a9Ll26CE9Pz7xVWEhNmDBBABBNmjQRycnJ2ukzZ84UAERISIje29KcnFgzU7bXhQsXhIODg/D09BRRUVE68zIzM8WxY8dMVbYsTNlWOfnxxx8FANG0adM8b0tupmqvxMREYW9vL2xtbcXevXt15u3bt0/Y29sLSZIK9Mmcqdrq1q1bwsHBQQAQixYt0k5PT08XvXv3FgDEW2+9Zery89VXX30lJk6cKP7880+RkJAg7O3tjf473bdvXwFAREZGihcvXminv//++9r/mOqDWZ//mPWGYdbrj1lvGGa9/pj1hrHEvLcUerVCZGSkUCgU4s8//9ROS0xMFK6urkKhUIiNGzdmu16lSpVErVq1TFJoYZKeni7c3NwEAHHy5Mks82vWrCkAiOPHj+u1PWs/OTF1e7Vr104AEFu2bDF1qbIzdVvlJDAwUAAQP/30U562IzdTttemTZsEANG2bdts53fq1EkAEGvWrMlz3XIwZVtNnTpVABChoaFZ5j148EAUKVJE2NjYiKSkJJPUbgmMPTG5e/euUCgUws7OTty7d09nXlpamvD09BRKpVL8888/r90Wsz5/MesNw6zXH7PeMMx6/THr884S8t5S6DVGxHvvvQchBLp3747+/ftjzJgxaNCgAZKTk1GmTBl06NAhyzrXrl3D5cuXUatWLX12Qa+IioqCSqWCv78/6tSpk2V+t27dAACbNm3K79Iskinb69atW9i2bRv8/PzQvn17k9cqt/w4tq5fv45Dhw7Bzs4OPXr0MHo7lsCU7WVvb6/XPj08PAwr0kKYsq1OnDgBAGjevHmWecWKFUPNmjWRkZGBLVu25K1oK7B161ao1WoEBwejZMmSOvPs7e0RHh6OzMxM/PXXX6/dFrM+fzHrDcOs1x+z3jDMev0x6+Vjyry3FDb6LNSiRQtMmTIFn332GVasWAFJkiCEgKOjI5YsWQIbm6yb+emnnwAAbdu2NW3FhcCZM2cAAHXr1s12vmZ6TEyMQdv95ptvEBcXB3t7e1SrVg1dunSBp6dn3oq1AKZsr71790KtViMwMBAZGRlYv349oqKikJmZierVq6Nnz55wd3c3XfH5zFzH1qtWrFgBAOjQoUOBbivAtO3VsGFDFC1aFLt378a+ffsQEhKinbd//35s27YNFStWRHBwsAkqz3+mbCvNAFU5HT+aEzjNPgszfdp98eLFerU7sz5/MesNw6zXH7PeMMx6/THr5WPKvLcUenVEAMCkSZPQsWNHrF+/Hvfv30eZMmXQt29flC9fPtvl7e3tMXLkSISFhZms2MLi5s2bAAAfH59s52um37hxw6Dtjhs3Tuf1qFGjMGfOHAwePNiIKi2HKdsrNjYWAODi4oLg4GBER0frzJ8wYQLWrVuHFi1a5KVk2Zjr2HqV5uTkjTfeMHoblsKU7eXm5oZFixahT58+aNGiBQIDA+Hj44Pbt2/j0KFDaNq0KZYvXw47OzvTvYF8ZMq20vynKadlr1+/rve2rJ2pP9PM+vzDrDcMs15/zHrDMOv1x6yXT358rvOb3h0RwMuelpx6Yf5r6tSpRhVEQEpKCgDAyckp2/nOzs4AgOTkZL2216lTJ7Ro0QL16tWDp6cnrl27hsWLF+P777/HkCFD4OHhgYiICNMULwNTttejR48AAL/88gtcXFywatUqhIWF4f79+5g6dSpWrFiBLl264Pz58yhdurSJ3kH+MfWx9V9Hjx7F5cuXUaxYsWwv4y5oTN1ekZGR+Pvvv9GjRw9ERUVpp7u6uqJNmzYF8pjSMGVbNWvWDKtWrcLq1avx+eef65ywHT9+HGfPntV7W9bOHJ9pZn3+YNYbhlmvP2a9YZj1+mPWy8fcn2s56DVGBBVsP/zwA7p06YKyZcvC0dER1apVw8yZMzF//nwIIfDRRx/JXaLFUKvVAICMjAwsWLAAvXv3hru7OwICAvDrr7+iQYMGUKlU+PHHH2Wu1DJpviHp0aNHge3tN6eZM2eidevWaNasGWJiYpCSkoKYmBi0bNkSkyZNQmRkpNwlWoS+ffvCx8cHN2/eRKdOnXDu3DkkJydj+/bt6Nq1q/YWAYWCEUakwazXH7M+b5j1uWPW64dZT/zNWiAXFxcAwLNnz7Kdr7mnqkiRInnaz5tvvokSJUrg0qVLiI+Pz9O25GTK9tJsy8XFBd27d88yf9CgQQCAffv2GVWr3Mx5bGVkZGDNmjUArONSTcC07bV37158+OGHqF27NtauXYsaNWrA2dkZNWrUwLp161C7dm1s2bIFf//9t+neQD4y9edw8+bN8PHxwbZt21CjRg24urqibdu2sLOzw5gxYwDkfF9pYZJfeUGmx6w3DLNef8x6wzDr9cesl4815j07IixQ2bJlAQC3b9/Odr5muq+vb572o1Ao4O/vDwBISEjI07bkZMr20ixTtmxZSJKUZX65cuUAAImJicaUKjtzHlvbt29HYmIi/Pz8EBgYaHyRFsSU7fXrr78CALp06ZKld1+pVGq/Idm/f7/R9crJ1MdWrVq1cOnSJSxZsgTvv/8+hg8fjl9++QWnT5/WfktSrVo1E1ResOVXXpDpMesNw6zXH7PeMMx6/THr5WONeW/QGBGUPzSPQTt58mS28zXTa9asmed9ae6T1NxXVBCZsr00jyLStMt/PXz4EMC/vZIFjTmPLc2lmv369TOyOstjyvbSBISbm1u28zXTczr2LJ05ji0nJycMHDgQAwcO1Jl+6NAhANk/8quwyc+8INNi1huGWa8/Zr1hmPX6Y9bLxyrzXpDFSU9PF25ubgKAOHXqVJb5NWvWFADE8ePH87Sfc+fOCUmShJOTk0hPT8/TtuRkyvZ68eKF8PDwEJIkiYsXL2aZP3ToUAFADB482BSl5ztzHVvJycnCyclJABCXL182UbXyM2V79e/fXwAQ/fv3z3Z+v379BAAxffr0vJYti/z6u3XmzBmhUChEtWrV8rQdS2Nvby+MieS7d+8KhUIh7OzsxD///KMzLy0tTXh6egqlUpllHsmPWW8YZr3+mPWGYdbrj1mfd8z7f7EjwkJNmDBBABCBgYEiJSVFO33mzJkCgAgJCdFZfs6cOaJSpUpi/PjxOtO3bNkidu3alWX7Z86cEVWqVBEAxIgRI8zyHvKTqdpLCCGmTZsmAIhWrVoJlUqlnb5jxw5ha2srJEkSR44cMdt7MTdTtpXGsmXLBADRuHFjc5UtG1O11/r16wUAoVQqxaZNm3Tmbdy4USgUCqFQKLI9KS4oTHlsnTp1Srx48UJnWmxsrKhQoYKQJEns3r3bLO9BLq87Mcmtrfr27SsAiK5du+q02YgRIwQAMWDAAHOUTCbArDcMs15/zHrDMOv1x6zPG+b9v9gRYaFSU1NFo0aNBADh7e0tevTooX3t6ekp4uLidJafPHlytgegZrqvr6/o1KmT6NWrl2jYsKGwsbERAETz5s3Fs2fP8vGdmYep2ksIIZ4/fy5at24tAIiSJUuKiIgI0bRpU6FUKgUAMW3atHx6V+ZhyrbSCA0NFQDEvHnzzFx9/jNVe6nVatG9e3cBQAAQ9evXF927dxf169fXTuOx9a+QkBDh6ekpWrduLXr37i2CgoKEUqkUNjY24ueff86nd2Q+mzdvFo0aNdL+SJIkAOhM27x5s3b53Nrq/v37wt/fXwAQ/v7+omfPnqJ69eoCgKhYsaJ48OBBPr4zMgSz3jDMev0x6w3DrNcfs94wzPucsSPCgj179kxMnDhR+Pv7Czs7O+Hl5SUGDhwobt26lWXZnA7aQ4cOicGDB4saNWoIDw8PYWNjI4oVKyaaN28uFi5cKDIyMvLp3ZifKdpL4/nz5+Lrr78W1apVEw4ODsLV1VW0bNkyS+92QWXKtrp7965QKpXC1tZWJCUlmblyeZiqvdRqtVi0aJFo1qyZKFq0qLCxsRHFixcX7du3F3///Xc+vBPzM1VbLVy4UHuCYmtrK0qVKiX69OmT7aWgBdGSJUu0J6U5/SxZskS7/Os+hw8ePBDvv/++KFOmjLCzsxNlypQRI0aMEI8ePcqX90PGY9YbhlmvP2a9YZj1+mPW6495nzNJCCFARERERERERJQP+PhOIiIiIiIiIso37IggIiIiIiIionzDjggiIiIiIiIiyjfsiCAiIiIiIiKifMOOCCIiIiIiIiLKN+yIICIiIiIiIqJ8w44IIiIiIiIiIso37IggIiIiIiIionzDjggiIiIiIiIiyjfsiLByR48ehSRJkCQJn3/+ea7LNm/eXLusJElQKpVwd3dHhQoV0LVrV8ybNw8qlSrXbVy5cgXvvPMOKlasCAcHB7i4uMDPzw9t2rTBF198gatXr+osP2XKFEiShClTpuT1rRZoAwcOhCRJ2Lt3r870cuXKQZIkeYrKRU71mprm+Fi6dKlZ92OpLPX3T0SWhVlfMDDrs8est8zfP5G52chdAJnXr7/+qv33ypUrMWnSpNeu07ZtW3h5eQEAkpOTcevWLWzatAnr16/Hxx9/jB9++AEDBw7Mst727dvRuXNnpKamwtvbGy1btkTRokVx+/ZtHDx4EDt27ICNjQ3Gjx9vsvdHRERU2DHriYiooGFHhBV78eIFfvvtNwCAl5cXLl++jCNHjqBRo0a5rjd+/Hg0b95cZ5pKpcLs2bPxxRdfYNCgQXjx4gWGDh2qnZ+amoo33ngDqamp+OSTTzBlyhTY2tpq5z99+hR//PEHnJ2dTfcGC4Fdu3bhxYsXcpdBREQWillf8DHriagw4q0ZVmzr1q1ISkpC06ZNMXz4cAC635oYws3NDVOmTNFeNjdixAj8888/2vkHDx5EYmIiSpcujWnTpumcmACAs7Mz+vTpg4iICOPeTCHl7++PypUry10GERFZKGZ9wcesJ6LCiB0RVmzFihUAgH79+qFfv34AgDVr1uSp171fv34ICgpCWloaFi5cqJ1+//59AICnp2ceKjaPpUuXau9NjYuLQ48ePVC8eHG4urqiXbt2iI2NBQBkZGTgyy+/REBAABwcHFChQgXMmzcvx+3eunUL7733Hvz9/eHg4IBixYqhY8eOOHToUI7rLF68GLVr14ajoyO8vLwwcOBA3Lt3L8flc7pvcMuWLRg8eDCqVKkCV1dXODs7o1atWvjyyy+Rnp6eaxvcvHkTffr0gaenJxwdHVG/fn1s2rQptybM1d9//42goCC4uLjA3d0dkZGRuHjxYpbl0tLSsGjRIkRERMDPzw+Ojo4oWrQomjVrpv02T19Xr17FlClT0KRJE3h5ecHOzg4+Pj7o378/Ll++nO06kiShXLlyyMzMxNdff42AgADY29ujTJky+Oijj7JtN+DlN3xff/016tevr23rypUr49133812X0eOHEH37t3h7e2trWvIkCG4efNmtttPTU3FhAkTUL58eTg4OMDf3x+TJ0/G8+fPDWoTAEhISMCMGTMQEhKC0qVLw87ODl5eXoiMjMSxY8dyXM+Y99irVy+ULl0a9vb28Pb2RqtWrXT+JgD/tnl2Xj0mX6W5fz0+Ph6rVq1C48aNUaRIERQtWlS7jKHHv751p6eno3jx4nBycsLjx4+z3cahQ4cgSRJCQkJy3A9RfmLWv8SsZ9YDzHpmPbO+QBFklR4/fiwcHByEnZ2dePDggRBCiMDAQAFA/Pnnn9muExISIgCIPXv25LrtuXPnCgCiZcuW2mn79+8XAIRSqRT79+/Xu87JkycLAGLy5Ml6Lb9kyRIBQISEhOi9D806/fv3F8WKFRNVqlQRPXv2FDVq1BAAhKenp0hISBARERHCzc1NdO7cWbRt21bY2dkJAOLnn3/Oss1Dhw4Jd3d3AUBUqlRJREZGiuDgYGFjYyOUSqX47bffsqzz0UcfCQDC1tZWtGnTRnTv3l2UKFFClC1bVoSHh2fb9r6+viK7j2nJkiWFq6urCAwMFD169BBt27bV1tOyZUuRkZGRbRsMGDBAlChRQvj7+4uePXuKJk2aCABCoVCIbdu26d2mAwYMEADE8OHDhSRJokGDBqJXr16iatWqAoBwc3MTp0+f1lnnwoULAoAoVaqUaNGihejZs6cICQkRtra2OR4DmuNjyZIlWdpSkiRRo0YN0bFjR9G1a1dRpUoVAUC4urqKM2fOZNkWAOHr6yt69OghXFxcRMeOHUXHjh2Fm5ubACD69u2bZZ27d++KatWqCQDC3d1dhIeHi27duom6desKhUIhZs+erbP8vHnzhEKhEAqFQjRq1Eh0795d1KxZU3ucxcbG6iyfnp4ugoODtduPjIwUHTp0EI6OjiI8PFyULVs2299/TubPn689JsPCwkSPHj1EnTp1tMdddr9jQ9/jd999JxQKhQAg6tWrJ3r16iVat24tSpQoIdzc3LJt8+xojsn//t41f4feeustoVAoRHBwsOjVq5do2rSpdhlDj39D6h49erQAIObOnZtt3QMHDhQAxIoVK7KdT5SfmPVZ12HWM+uZ9cx6Zn3BwI4IK/XLL78IACIiIkI77ccffxQARPfu3bNdR9+Tk4MHDwoAwtvbWzstIyNDG0xKpVJ06NBBzJo1S+zbt088ffo0x23l58kJADF+/HihVquFEEKo1WrtH5qqVauK6tWri8TERO16O3fuzPaPq0qlEt7e3kKpVGb5A3Xs2DHh7u4uXFxcdLZ1+PBhIUmScHNzEydPntROT05OFi1bttTWp+/JycaNG8WzZ890pj158kR07NhRABDLli3LsQ3GjBkjMjMztfNmz54tAIjg4OBcWlGX5uTkvydvarVaexJWu3ZtnXWSkpLEjh07tO2vce3aNVGuXDmhUCjE9evXdebldHJy+PBhce3atSx1LV68WAAQLVq0yDJPU2+VKlVEQkKCzv6LFi0qAIirV6/qrNOqVSsBQPTo0UMkJyfrzLt+/brOSdDhw4eFUqkUpUuXFsePH9dZVvN5bNSokc70r776SgAQderUEUlJSdrpV65cEaX+r707j4niiuMA/t3FXdiVY7G6goggWi8U4120RGyl1ANUoAhqpVoPbK1N1WirjY2mh9EWTFNjCsY2rZZaU4lSqfVAFI8WA94Fg8dKq6SWWxDBlV//oDOyzOyysyoe+X0S/nnvzcx7s8/9jW9n5teli9hne509e5bOnz8vKd+7dy9ptVrq0aOH5PwrGePhw4dJpVKRm5sbHThwwKLt3bt3ac+ePRZlD3Jx4uLiQtnZ2bLbKp3/Svp98eJFUqlUNHDgQMlxq6qqSK/Xk6enJ9XV1cn2jbG2xLFeug3Heo71HOs51nOsfzrwQsQzSvgHvmPHDrGstLSUNBoNubi4UGVlpdVtWrs4KSwsFL88mrt69ar4S0zzP41GQxEREXTy5EnJvpRenOzcuZN69+5Nr7/+ul3tie5/CQYEBFBDQ4NF3ZkzZ8R+tvzSIiJxhbl50BSC+ZIlS2SPl5SURAAoKSlJLJs5cyYBoFWrVknaX7hwgVQqlaKLE2uKiooIAEVFRVmUC+ege/fuVF9fb1F39+5d8vT0JI1GI6mzRrg4GTlypKSuoaGBunbtSgAoJyfHrv2lpqYSAPryyy8tyq1dnNgyatQoUqlUkjkufM779++XbLNw4ULJcf744w8CQEajkaqrq1s97qRJkwgAZWRkyNZHRkYSAIuLU+FXkKysLEl74RcPJZ+/LdOnTycAdPbsWbFM6RjHjRtHAGjt2rV2HfNBLk7efvttu47RnLX5r7Tfwn8YcnNzLcqFz2TRokWK+8bYo8Cx/j6O9RzriTjWc6znWP804awZz6Di4mIcOXIEBoMBERERYvlzzz2H8ePHY9euXdixYwfmzJnj0P6JCAAkzzP6+/vj2LFjOH78OHbv3o3ff/8deXl5qKmpQUZGBn799Vds27YNsbGxDo9typQpmDJlikPbhoaGSl6sFRAQAADQaDSSt4cL9adOnUJJSYn4/Nu+ffsAAFFRUbLHCQkJAdCU112Qk5MDAIiLi5O079evHwYOHIjTp08rGk9RUREyMzNx6dIl1NbWorGxUfxsioqKZLcJDQ2FVqu1KGvXrh26d++O/Px8lJWVwdvb2+4+yI1Ho9EgJiYGGzZsQE5ODl588UWL+qNHjyI7OxvXr1/HnTt3QEQoKSmx2W85wrw6ffo0ysvLxeehS0pKQES4fPkyBg8eLOnbmDFjJPvq1auXuK3gwIEDAID4+Hi4ubnZ7EtjYyMOHjwIvV6P8PBw2TYhISHYvXs3cnNzMWjQIBQXF6O4uBhGo1G2T/Hx8ViwYIHN48qpr6/H3r17kZubi3///Vd8/vTcuXMAms7xgAEDFI/RbDaLueTnzZunuF9KRUZG2qy3d/470u/ExERkZWUhNTUVw4YNE8uF50vbYvyMtYZjvTyO9RzrOdZzrLcHx/rHjxcinkHbtm0DESEmJgbOzs4WdTNmzMCuXbuwdetWhy9OSktLAQAdOnSQrR85ciRGjhwJAGhoaMD+/fuxbNky/Pnnn5g/fz7Gjx8PV1dXh479IHx8fCRlQj+8vLzg5ORktb75S3FMJhMAYNSoUTaPJ5wnALhx4wYAwM/PT7atv7+/3RcnRISlS5ciOTlZ/DJu6datW7LlXbt2lS0XApOtl//IsTUe4P64gaa0cFFRUcjKyrK6P2v9bikrKwtxcXHii9Ps3Ze1z1lu/H/99ReApreZt6a0tBQ1NTUAILn4k2sLtD4nPDw8YDAYrL5ISc65c+cQGRkpzlE5zc+LkjGWlZWhrq4OHTp0gKenp919clS3bt1ky5XOf0f6PXnyZHh5eSEtLQ1JSUlwdXVFfn4+8vPzERwcjMDAQOUDYuwh41gvj2M9x3qO9Rzr7cGx/vHjhYhnkJC2Kzs7W7JCLayYHjlyBNeuXbP6xWjLqVOnADSt7rdGq9ViwoQJGDJkCHr06IHKykocP34cr7zyiuLjPii12nqSGFt1LTU2NgIAYmJibOZKf1SpuLZv346kpCT4+voiOTkZwcHB6NSpEzQaDRoaGuDs7Gz1S1vJOB+25cuXIysrC6NHj8bq1avRv39/GAwGODk5Yd++fQgPD7fa7+ZqamoQGxuL8vJyrFq1CnFxcfDz84NOp4NKpcK0adOQlpYmu69HNX5hTri6uiI6Otpm20cV2IgIsbGxMJlMSExMRGJiIgICAuDq6gqVSoUVK1bgs88+s+sctwXhnFnj4uIiW/4g899eGo0Gs2fPxqeffooff/wRc+bMwebNmwEAc+fOfaB9M/awcKyXx7GeYz3Heo719uBY//jxQsQzJi8vDwUFBQCa0h5dunRJth0RYdu2bVixYoXiY2zfvh0AZG8xs8bLywt9+/ZFXl6exa8HT6OuXbvi4sWLeP/99zFkyBC7tvH29obJZMK1a9fQt29fSf21a9fsPn56ejoAYNOmTZgwYYJF3ZUrV+zez8Ngrd9CeZcuXcSy9PR0ODk5Yffu3XB3d7dor6TfOTk5KCsrQ0xMDFavXi2pf1jnwNfXFwBw+fLlVtt27NgRLi4uUKvV+Oabb2TTsLUk3BZr7RxWV1cr+oWksLAQhYWFGDp0KDZt2iSplzsvSseo0+lQXl6OyspKixRb1mg0GvHXo5aEX2iUUjr/Hek30HRL5tq1a5Gamopp06bhhx9+gLu7O6ZOnepQvxl7mDjWP3oc6+/jWN+EY708jvXMUY9vyZQ9EkI+8aVLl4KaXkYq+ROeoRLaKvH999/j2LFj0Ov1Frd7trYqee/ePVy9ehWA/G2TT5OwsDAA978k7SE8S/rTTz9J6goLCxU9M1pRUQFA/tZLuf0/SnLHM5vN+PnnnwHA4le6iooKuLu7Sy5MrO3HGlvjv3TpEvLz8+3ely1jx44FAKSlpVkNsIJ27dohNDQU1dXVOHjwoF379/Pzg6+vL27evInDhw9L6pXmW7d1XioqKrB//35JuZIxOjk5ic9Wp6Sk2NUnb29vlJWVoaysTFInPLOqlNL570i/gabP59VXX0Vubi4+/PBDVFVVYfr06dDr9Q71m7GHiWP9o8ex3vbxONZzrBdwrGeO4oWIZ8i9e/eQlpYGoOmFNNaEhITAx8cHBQUFyMvLs2vfVVVVWL16NWbNmgUA+Oqrr9CpUyexPiMjA7GxsTh+/Lhk29raWixYsADl5eXo0qULgoODlQzLQnp6Ovr06YOZM2c6vI8HNX/+fBiNRqxbtw4pKSmS287MZjN+++03nD9/XixLTEwEAGzYsAFnzpwRy2tra/HOO+8our1MeNlSSkqKxXY5OTlYv369Q2Ny1NGjR7FlyxaLso8++gjFxcUICgoSL8qApn5XVFSIv7IJkpOTcejQIbuPKYx/586dFs+NVlZW4s033xRfZPWghg8fjjFjxuDmzZuYN28eamtrLepNJpP4UigAWLlyJdRqNWbNmiX+B6C5mpoabNmyBXV1dWKZ8IKqJUuWoLy8XCy/cuUK1qxZo6i/PXv2hFqtRlZWlsULnO7cuYPExESL/Ts6xuXLl0OlUuGTTz6RfGZmsxmZmZkWZaNHjwYAfPzxxxbl69atw9GjRxWNT+DI/Ffab4Hw7zY5ORkA36rJngwc69sGx/r7ONZzrBdwrGcP1cNMwcEer8zMTAJAvXr1arXt4sWLCQC9++67YpmQSic8PJwSEhIoISGBoqOjacSIEaTVagkAubu703fffSfZX3p6uph+yMvLi8aNG0fTpk2jsLAw8vT0JADUvn17OnjwoMV2QsomHx8fGjFihNU/wYPkFreWNgw20g4Jqatapto6ceIEdezYkQCQr6+vON6XXnpJzFOdnp5usc3SpUvFFGfh4eEUGxtLnTt3pm7dulFERITdKb0uXrxI7du3J6ApJ3pcXByFhISQSqUSj9FyPK2dA+Gzb5nb2xrhvCxYsIBUKhUNHz6c4uPjKTAwUJwnzVNXERFt3bpVnCMhISEUHx9P/fr1I7VaTe+99x4BoISEBIttrKX0CgsLIwBkMBho8uTJNHnyZDIYDNSzZ08xtVbLc2nrc7Z2fv7++2/q3bs3AaAOHTpQZGQkvfbaazR48GBSq9WUnJxs0X7Tpk3k5OREAKh///4UFRVFU6dOpREjRpCzszMBoIqKCrF9fX09jRo1igCQp6cnRUdH08SJE0mn09HEiRPFlF/2mjt3LgEgnU5HEyZMoJiYGOrcuTN17NiR3njjDdlzqXSM69evF1PQDR06lOLj4yksLIyMRiN5eHhYtD1//jzpdDoCmnLNR0dHU69evUin09Fbb71lM6WXtbnoyPxX2m+B2WwmX19fcRvGngQc6+VxrOdYT8SxnmM9x/qnCS9EPEPi4+NtBqDmTp48Sfg/p/Ddu3eJ6P6XgvCnVqvJw8ODAgICKCoqijZu3EhVVVWy+6urq6M9e/bQokWLaNiwYeTt7U3t2rUjNzc3CgoKosWLF5PJZJJsJwSf1v4ET8rFCRFRSUkJLVu2jAIDA0mv15Ner6cePXrQpEmT6Ntvv6Vbt25JtklNTaWgoCBydnYmo9FIM2bMoOvXr1s9jrXc4gUFBRQREUFGo5H0ej0NGjSIUlJSrI7nUV2cHDp0iDIyMig4OJj0ej15eHjQpEmT6MKFC7Lb7dmzh1544QVyc3Mjg8FAY8eOpezsbDp06JCii5Pbt2/TypUr6fnnnydnZ2fy9fWlxMREKi0ttXouHbk4ISKqrq6mNWvWUFBQEOl0OnJ1daU+ffrQwoULqaioSNL+1KlTlJCQQH5+fqTVaslgMFBgYCDNnj2bfvnlF2psbLRoX1tbSx988AF169aNtFot+fv704oVK6i+vl5xbnmz2UxffPEF9evXj1xcXKhz5840ffp0MplMNvO0Kx3jkSNHaMqUKWQ0Gkmj0ZC3tze9/PLLtHnzZknbEydOUGhoKOn1enJ3d6dx48bR6dOnW80tbmsuKp3/jvRbMGPGDAJAX3/9tdU2jLUljvXyONZzrLd2XgQc6znWW8Ox/vFQET0hr1VljDHGniC3b9+Gj48PzGYzbty40Wr+dcYYY4w9XTjWPz78jgjGGGNMxsaNG1FZWYmEhAS+MGGMMcaeQRzrHx++I4Ixxhj7X1lZGZYvX45//vkHmZmZ0Ov1KCgokH1zN2OMMcaePhzrnwy8EMEYY4z9z2QyoXv37tBqtRgwYAA+//xzMSUYY4wxxp5+HOufDLwQwRhjjDHGGGOMsTbD74hgjDHGGGOMMcZYm+GFCMYYY4wxxhhjjLUZXohgjDHGGGOMMcZYm+GFCMYYY4wxxhhjjLUZXohgjDHGGGOMMcZYm+GFCMYYY4wxxhhjjLUZXohgjDHGGGOMMcZYm+GFCMYYY4wxxhhjjLWZ/wAvRKanPtdFmgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -1988,20 +2431,608 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "id": "4c52ba35-77cf-45e4-bc24-b8084a0a6583", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01234
0Adiac0.9980260.0648890.990.1
1ArrowHead0.7307690.0502330.650.03
2Beef1.00.00.570.15
3BeetleFly0.8947370.1602960.90.08
4BirdChicken0.9210530.1435510.850.15
5CBF0.8752650.019850.80.04
6ChlorineConcentration0.8552620.016440.50.0
7Coffee0.7307690.0973010.840.04
8ECG2000.7590140.0624650.50.03
9ECGFiveDays0.8248280.0244290.940.11
10FaceFour0.8434960.0603610.940.1
11GunPoint0.7682290.0621540.750.03
12Ham0.5093460.0147080.50.02
13Herring0.5145830.0496690.520.02
14Lightning20.7804350.0449140.630.07
15Lightning70.9552850.0912630.730.11
16Meat0.9679490.0731.00.04
17MedicalImages0.9734920.0396070.90.03
18MoteStrain0.8403840.0124950.740.01
19Plane1.00.0272361.00.04
20Strawberry0.8618120.0123190.770.03
21Symbols0.9994090.0202560.960.02
22ToeSegmentation10.738290.0365190.950.01
23ToeSegmentation20.7648650.0394960.880.02
24Trace1.00.016881.00.04
25TwoLeadECG0.7832160.0171890.890.01
26Wafer0.5164560.0386970.560.02
27Wine0.5585660.1553280.530.02
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4\n", + "0 Adiac 0.998026 0.064889 0.99 0.1\n", + "1 ArrowHead 0.730769 0.050233 0.65 0.03\n", + "2 Beef 1.0 0.0 0.57 0.15\n", + "3 BeetleFly 0.894737 0.160296 0.9 0.08\n", + "4 BirdChicken 0.921053 0.143551 0.85 0.15\n", + "5 CBF 0.875265 0.01985 0.8 0.04\n", + "6 ChlorineConcentration 0.855262 0.01644 0.5 0.0\n", + "7 Coffee 0.730769 0.097301 0.84 0.04\n", + "8 ECG200 0.759014 0.062465 0.5 0.03\n", + "9 ECGFiveDays 0.824828 0.024429 0.94 0.11\n", + "10 FaceFour 0.843496 0.060361 0.94 0.1\n", + "11 GunPoint 0.768229 0.062154 0.75 0.03\n", + "12 Ham 0.509346 0.014708 0.5 0.02\n", + "13 Herring 0.514583 0.049669 0.52 0.02\n", + "14 Lightning2 0.780435 0.044914 0.63 0.07\n", + "15 Lightning7 0.955285 0.091263 0.73 0.11\n", + "16 Meat 0.967949 0.073 1.0 0.04\n", + "17 MedicalImages 0.973492 0.039607 0.9 0.03\n", + "18 MoteStrain 0.840384 0.012495 0.74 0.01\n", + "19 Plane 1.0 0.027236 1.0 0.04\n", + "20 Strawberry 0.861812 0.012319 0.77 0.03\n", + "21 Symbols 0.999409 0.020256 0.96 0.02\n", + "22 ToeSegmentation1 0.73829 0.036519 0.95 0.01\n", + "23 ToeSegmentation2 0.764865 0.039496 0.88 0.02\n", + "24 Trace 1.0 0.01688 1.0 0.04\n", + "25 TwoLeadECG 0.783216 0.017189 0.89 0.01\n", + "26 Wafer 0.516456 0.038697 0.56 0.02\n", + "27 Wine 0.558566 0.155328 0.53 0.02" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "comparison_table_1" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "id": "168f43f7-d6a7-49de-b95a-336ac6b2cb1c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01234
0Adiac0.9980260.0648890.990.1
1ArrowHead0.7307690.0502330.650.03
2Beef1.00.00.570.15
3BeetleFly0.8947370.1602960.90.08
4BirdChicken0.9210530.1435510.850.15
5CBF0.8752650.019850.80.04
6ChlorineConcentration0.8552620.016440.50.0
7Coffee0.7307690.0973010.840.04
8ECG2000.7590140.0624650.50.03
9ECGFiveDays0.8248280.0244290.940.11
10FaceFour0.8434960.0603610.940.1
11GunPoint0.7682290.0621540.750.03
12Ham0.5093460.0147080.50.02
13Herring0.5145830.0496690.520.02
14Lightning20.7804350.0449140.630.07
15Lightning70.9552850.0912630.730.11
16Meat0.9679490.0731.00.04
17MedicalImages0.9734920.0396070.90.03
18MoteStrain0.8403840.0124950.740.01
19Plane1.00.0272361.00.04
20Strawberry0.8618120.0123190.770.03
21Symbols0.9994090.0202560.960.02
22ToeSegmentation10.738290.0365190.950.01
23ToeSegmentation20.7648650.0394960.880.02
24Trace1.00.016881.00.04
25TwoLeadECG0.7832160.0171890.890.01
26Wafer0.5164560.0386970.560.02
27Wine0.5585660.1553280.530.02
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4\n", + "0 Adiac 0.998026 0.064889 0.99 0.1\n", + "1 ArrowHead 0.730769 0.050233 0.65 0.03\n", + "2 Beef 1.0 0.0 0.57 0.15\n", + "3 BeetleFly 0.894737 0.160296 0.9 0.08\n", + "4 BirdChicken 0.921053 0.143551 0.85 0.15\n", + "5 CBF 0.875265 0.01985 0.8 0.04\n", + "6 ChlorineConcentration 0.855262 0.01644 0.5 0.0\n", + "7 Coffee 0.730769 0.097301 0.84 0.04\n", + "8 ECG200 0.759014 0.062465 0.5 0.03\n", + "9 ECGFiveDays 0.824828 0.024429 0.94 0.11\n", + "10 FaceFour 0.843496 0.060361 0.94 0.1\n", + "11 GunPoint 0.768229 0.062154 0.75 0.03\n", + "12 Ham 0.509346 0.014708 0.5 0.02\n", + "13 Herring 0.514583 0.049669 0.52 0.02\n", + "14 Lightning2 0.780435 0.044914 0.63 0.07\n", + "15 Lightning7 0.955285 0.091263 0.73 0.11\n", + "16 Meat 0.967949 0.073 1.0 0.04\n", + "17 MedicalImages 0.973492 0.039607 0.9 0.03\n", + "18 MoteStrain 0.840384 0.012495 0.74 0.01\n", + "19 Plane 1.0 0.027236 1.0 0.04\n", + "20 Strawberry 0.861812 0.012319 0.77 0.03\n", + "21 Symbols 0.999409 0.020256 0.96 0.02\n", + "22 ToeSegmentation1 0.73829 0.036519 0.95 0.01\n", + "23 ToeSegmentation2 0.764865 0.039496 0.88 0.02\n", + "24 Trace 1.0 0.01688 1.0 0.04\n", + "25 TwoLeadECG 0.783216 0.017189 0.89 0.01\n", + "26 Wafer 0.516456 0.038697 0.56 0.02\n", + "27 Wine 0.558566 0.155328 0.53 0.02" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "comparison_table_2" ] @@ -2018,7 +3049,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "id": "887c4530-28dd-4df7-b1f5-58c74e40f0eb", "metadata": {}, "outputs": [], @@ -2028,7 +3059,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "id": "cf434a5d-68dc-46f4-9a69-a8a1cff32d5d", "metadata": {}, "outputs": [], @@ -2049,26 +3080,73 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "3a25e03a-1c77-414d-a576-22232871b6d9", - "metadata": { - "scrolled": true - }, - "outputs": [], + "execution_count": 52, + "id": "87ec6dc8-75f7-436b-8528-00093a576ba7", + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Legitimate width 2 <-> 256 exceeded", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m:5\u001b[0m\n", + "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:139\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature_transform \u001b[39m=\u001b[39m SignatureTransformer(\n\u001b[1;32m 135\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39msignature_kwargs,\n\u001b[1;32m 136\u001b[0m )\n\u001b[1;32m 138\u001b[0m \u001b[39m# compute signatures\u001b[39;00m\n\u001b[0;32m--> 139\u001b[0m sigs \u001b[39m=\u001b[39m Parallel(n_jobs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_jobs)(\n\u001b[1;32m 140\u001b[0m delayed(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_transform\u001b[39m.\u001b[39;49mfit_transform)(X_train[i])\n\u001b[1;32m 141\u001b[0m \u001b[39mfor\u001b[39;49;00m i \u001b[39min\u001b[39;49;00m \u001b[39mrange\u001b[39;49m(\u001b[39mlen\u001b[39;49m(X_train))\n\u001b[1;32m 142\u001b[0m )\n\u001b[1;32m 143\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignatures_train \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(pd\u001b[39m.\u001b[39mconcat(sigs))\n\u001b[1;32m 144\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1863\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1861\u001b[0m output \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m 1862\u001b[0m \u001b[39mnext\u001b[39m(output)\n\u001b[0;32m-> 1863\u001b[0m \u001b[39mreturn\u001b[39;00m output \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mreturn_generator \u001b[39melse\u001b[39;00m \u001b[39mlist\u001b[39;49m(output)\n\u001b[1;32m 1865\u001b[0m \u001b[39m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m 1866\u001b[0m \u001b[39m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m 1867\u001b[0m \u001b[39m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m 1868\u001b[0m \u001b[39m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m 1869\u001b[0m \u001b[39m# callback.\u001b[39;00m\n\u001b[1;32m 1870\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1792\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1790\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_batches \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 1791\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m-> 1792\u001b[0m res \u001b[39m=\u001b[39m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1793\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_completed_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 1794\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprint_progress()\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:669\u001b[0m, in \u001b[0;36mBaseTransformer.fit_transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 604\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Fit to data, then transform it.\u001b[39;00m\n\u001b[1;32m 605\u001b[0m \n\u001b[1;32m 606\u001b[0m \u001b[39mFits the transformer to X and y and returns a transformed version of X.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 665\u001b[0m \u001b[39m Example: i-th instance of the output is the i-th window running over `X`\u001b[39;00m\n\u001b[1;32m 666\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 667\u001b[0m \u001b[39m# Non-optimized default implementation; override when a better\u001b[39;00m\n\u001b[1;32m 668\u001b[0m \u001b[39m# method is possible for a given algorithm.\u001b[39;00m\n\u001b[0;32m--> 669\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfit(X, y)\u001b[39m.\u001b[39;49mtransform(X, y)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:583\u001b[0m, in \u001b[0;36mBaseTransformer.transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 580\u001b[0m X_inner, y_inner, metadata \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_X_y(X\u001b[39m=\u001b[39mX, y\u001b[39m=\u001b[39my, return_metadata\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 582\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(X_inner, VectorizedDF):\n\u001b[0;32m--> 583\u001b[0m Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_transform(X\u001b[39m=\u001b[39;49mX_inner, y\u001b[39m=\u001b[39;49my_inner)\n\u001b[1;32m 584\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 585\u001b[0m \u001b[39m# otherwise we call the vectorized version of predict\u001b[39;00m\n\u001b[1;32m 586\u001b[0m Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_vectorize(\u001b[39m\"\u001b[39m\u001b[39mtransform\u001b[39m\u001b[39m\"\u001b[39m, X\u001b[39m=\u001b[39mX_inner, y\u001b[39m=\u001b[39my_inner)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_signature_method.py:142\u001b[0m, in \u001b[0;36mSignatureTransformer._transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_transform\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[0;32m--> 142\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_method\u001b[39m.\u001b[39;49mtransform(X)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:696\u001b[0m, in \u001b[0;36mPipeline.transform\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 694\u001b[0m Xt \u001b[39m=\u001b[39m X\n\u001b[1;32m 695\u001b[0m \u001b[39mfor\u001b[39;00m _, _, transform \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_iter():\n\u001b[0;32m--> 696\u001b[0m Xt \u001b[39m=\u001b[39m transform\u001b[39m.\u001b[39;49mtransform(Xt)\n\u001b[1;32m 697\u001b[0m \u001b[39mreturn\u001b[39;00m Xt\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:583\u001b[0m, in \u001b[0;36mBaseTransformer.transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 580\u001b[0m X_inner, y_inner, metadata \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_X_y(X\u001b[39m=\u001b[39mX, y\u001b[39m=\u001b[39my, return_metadata\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 582\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(X_inner, VectorizedDF):\n\u001b[0;32m--> 583\u001b[0m Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_transform(X\u001b[39m=\u001b[39;49mX_inner, y\u001b[39m=\u001b[39;49my_inner)\n\u001b[1;32m 584\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 585\u001b[0m \u001b[39m# otherwise we call the vectorized version of predict\u001b[39;00m\n\u001b[1;32m 586\u001b[0m Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_vectorize(\u001b[39m\"\u001b[39m\u001b[39mtransform\u001b[39m\u001b[39m\"\u001b[39m, X\u001b[39m=\u001b[39mX_inner, y\u001b[39m=\u001b[39my_inner)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_compute.py:97\u001b[0m, in \u001b[0;36m_WindowSignatureTransform._transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 93\u001b[0m signature_group \u001b[39m=\u001b[39m []\n\u001b[1;32m 94\u001b[0m \u001b[39mfor\u001b[39;00m window \u001b[39min\u001b[39;00m window_group:\n\u001b[1;32m 95\u001b[0m \u001b[39m# Signature computation step\u001b[39;00m\n\u001b[1;32m 96\u001b[0m signature \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mstack(\n\u001b[0;32m---> 97\u001b[0m [transform(x[window\u001b[39m.\u001b[39mstart : window\u001b[39m.\u001b[39mend]) \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m data]\n\u001b[1;32m 98\u001b[0m )\u001b[39m.\u001b[39mreshape(data\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m], \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[1;32m 99\u001b[0m \u001b[39m# Rescale if specified\u001b[39;00m\n\u001b[1;32m 100\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrescaling \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpost\u001b[39m\u001b[39m\"\u001b[39m:\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_compute.py:97\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 93\u001b[0m signature_group \u001b[39m=\u001b[39m []\n\u001b[1;32m 94\u001b[0m \u001b[39mfor\u001b[39;00m window \u001b[39min\u001b[39;00m window_group:\n\u001b[1;32m 95\u001b[0m \u001b[39m# Signature computation step\u001b[39;00m\n\u001b[1;32m 96\u001b[0m signature \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mstack(\n\u001b[0;32m---> 97\u001b[0m [transform(x[window\u001b[39m.\u001b[39;49mstart : window\u001b[39m.\u001b[39;49mend]) \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m data]\n\u001b[1;32m 98\u001b[0m )\u001b[39m.\u001b[39mreshape(data\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m], \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[1;32m 99\u001b[0m \u001b[39m# Rescale if specified\u001b[39;00m\n\u001b[1;32m 100\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrescaling \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpost\u001b[39m\u001b[39m\"\u001b[39m:\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_compute.py:81\u001b[0m, in \u001b[0;36m_WindowSignatureTransform._transform..transform\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mtransform\u001b[39m(x):\n\u001b[0;32m---> 81\u001b[0m \u001b[39mreturn\u001b[39;00m esig\u001b[39m.\u001b[39;49mstream2sig(x, depth)[\u001b[39m1\u001b[39m:]\u001b[39m.\u001b[39mreshape(\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m, \u001b[39m1\u001b[39m)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/esig/__init__.py:126\u001b[0m, in \u001b[0;36m_verify_stream_arg..decorator..wrapper\u001b[0;34m(stream, *args, **kwargs)\u001b[0m\n\u001b[1;32m 123\u001b[0m str_types \u001b[39m=\u001b[39m \u001b[39mtuple\u001b[39m(\u001b[39mmap\u001b[39m(\u001b[39mstr\u001b[39m, types))\n\u001b[1;32m 124\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mValues must be of one of the following types \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(str_types))\n\u001b[0;32m--> 126\u001b[0m \u001b[39mreturn\u001b[39;00m func(as_array, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/esig/__init__.py:145\u001b[0m, in \u001b[0;36mstream2sig\u001b[0;34m(stream, depth)\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[39mreturn\u001b[39;00m numpy\u001b[39m.\u001b[39mconcatenate([[\u001b[39m1.0\u001b[39m], numpy\u001b[39m.\u001b[39msum(numpy\u001b[39m.\u001b[39mdiff(stream, axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m), axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)])\n\u001b[1;32m 144\u001b[0m backend \u001b[39m=\u001b[39m get_backend()\n\u001b[0;32m--> 145\u001b[0m \u001b[39mreturn\u001b[39;00m backend\u001b[39m.\u001b[39;49mcompute_signature(stream, depth)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/esig/backends.py:130\u001b[0m, in \u001b[0;36mLibalgebraBackend.compute_signature\u001b[0;34m(self, stream, depth)\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mcompute_signature\u001b[39m(\u001b[39mself\u001b[39m, stream, depth):\n\u001b[0;32m--> 130\u001b[0m \u001b[39mreturn\u001b[39;00m tosig\u001b[39m.\u001b[39;49mstream2sig(stream, depth)\n", + "\u001b[0;31mRuntimeError\u001b[0m: Legitimate width 2 <-> 256 exceeded" + ] + } + ], "source": [ "%%time\n", - "signature_maha_knn = SignatureMahalanobisKNN()\n", - "signature_maha_knn.fit(data.corpus)\n", - "signature_maha_knn.compute_auc(data.test_inlier, data.test_outlier)" + "\n", + "depth = 2\n", + "signature_maha_knn = SignatureMahalanobisKNN(random_state=seed)\n", + "# Measure the time spent on fit\n", + "start_time = time.time()\n", + "signature_maha_knn.fit(\n", + " knn_library=\"pynndescent\",\n", + " X_train=data.corpus,\n", + " signature_kwargs={\n", + " \"augmentation_list\": None,\n", + " \"depth\": depth,\n", + " },\n", + ")\n", + "fit_time = time.time() - start_time\n", + "print(f\"fit_time: {fit_time}\")\n", + "\n", + "# Measure the time spent on conformance\n", + "start_time = time.time()\n", + "inlier_dists = signature_maha_knn.conformance(\n", + " data.test_inlier, n_neighbors=n_neighbours\n", + ")\n", + "outlier_dists = signature_maha_knn.conformance(\n", + " data.test_outlier, n_neighbors=n_neighbours\n", + ")\n", + "compute_auc_time = time.time() - start_time\n", + "print(f\"compute_auc_time: {compute_auc_time}\")\n", + "\n", + "auc = compute_auc_given_dists(\n", + " all_inlier_dists,\n", + " all_outlier_dists,\n", + " plot=True,\n", + " title=f\"Language One-Hot (depth={depth})\",\n", + ")\n", + "print(\"Overall, \", \"depth: \", depth, \"AUC: \", auc)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "87ec6dc8-75f7-436b-8528-00093a576ba7", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From c23f5757e18c39a6dc6089d8ca4b35f324d4b1cd Mon Sep 17 00:00:00 2001 From: rchan Date: Fri, 24 Nov 2023 10:34:19 +0000 Subject: [PATCH 19/22] change default type to float64 and add backend argument --- paper-examples/examples.ipynb | 731 +++++++++--------- .../mahal_distance.py | 3 +- .../sig_mahal_knn.py | 7 +- 3 files changed, 373 insertions(+), 368 deletions(-) diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index 9017b8b..fb07e98 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -94,14 +94,14 @@ "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 9.03144884109497\n", - "compute_auc_time: 9.808788061141968\n", - "depth: 1 , Auc of digit: 0 is 0.9236198434980514\n", + "fit_time: 10.063539028167725\n", + "compute_auc_time: 9.991588115692139\n", + "depth: 1 , Auc of digit: 0 is 0.9236207222288126\n", "doing digit 1 doing signature level 1\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.365417242050171\n" + "fit_time: 1.3015568256378174\n" ] }, { @@ -116,13 +116,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 5.99392294883728\n", + "compute_auc_time: 6.059915065765381\n", "depth: 1 , Auc of digit: 1 is 0.8300113256239612\n", "doing digit 2 doing signature level 1\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3346378803253174\n" + "fit_time: 1.3631317615509033\n" ] }, { @@ -137,20 +137,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 5.971071243286133\n", - "depth: 1 , Auc of digit: 2 is 0.9320068093999173\n", + "compute_auc_time: 6.2524518966674805\n", + "depth: 1 , Auc of digit: 2 is 0.9320072476980582\n", "doing digit 3 doing signature level 1\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.2789149284362793\n", - "compute_auc_time: 5.9304540157318115\n", + "fit_time: 1.3106367588043213\n", + "compute_auc_time: 5.999101161956787\n", "depth: 1 , Auc of digit: 3 is 0.922022303545074\n", "doing digit 4 doing signature level 1\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.2923431396484375\n" + "fit_time: 1.4209661483764648\n" ] }, { @@ -165,13 +165,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 5.915146112442017\n", + "compute_auc_time: 5.9232141971588135\n", "depth: 1 , Auc of digit: 4 is 0.9830396151391684\n", "doing digit 5 doing signature level 1\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.2285139560699463\n" + "fit_time: 1.2171669006347656\n" ] }, { @@ -186,13 +186,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 5.855227947235107\n", + "compute_auc_time: 5.923392057418823\n", "depth: 1 , Auc of digit: 5 is 0.9057290216637331\n", "doing digit 6 doing signature level 1\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.2346031665802002\n" + "fit_time: 1.161789894104004\n" ] }, { @@ -207,34 +207,34 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 5.856933832168579\n", + "compute_auc_time: 5.955906867980957\n", "depth: 1 , Auc of digit: 6 is 0.8962102986355833\n", "doing digit 7 doing signature level 1\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.291642189025879\n", - "compute_auc_time: 5.88370418548584\n", + "fit_time: 1.4109997749328613\n", + "compute_auc_time: 5.941327095031738\n", "depth: 1 , Auc of digit: 7 is 0.8957924255068479\n", "doing digit 8 doing signature level 1\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.2254557609558105\n", - "compute_auc_time: 5.923160076141357\n", + "fit_time: 1.2382440567016602\n", + "compute_auc_time: 5.920679092407227\n", "depth: 1 , Auc of digit: 8 is 0.9399820412035783\n", "doing digit 9 doing signature level 1\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.1814749240875244\n", - "compute_auc_time: 5.878723621368408\n", + "fit_time: 1.2690927982330322\n", + "compute_auc_time: 5.920597791671753\n", "depth: 1 , Auc of digit: 9 is 0.8178161049365983\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -246,76 +246,76 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 1 AUC: 0.9011941225982673\n", + "Overall, depth: 1 AUC: 0.9011941225982674\n", "doing digit 0 doing signature level 2\n", "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 1.372164011001587\n", - "compute_auc_time: 6.132082939147949\n", + "fit_time: 1.308121681213379\n", + "compute_auc_time: 6.258044958114624\n", "depth: 2 , Auc of digit: 0 is 0.9994156440437432\n", "doing digit 1 doing signature level 2\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3040940761566162\n", - "compute_auc_time: 5.918816804885864\n", + "fit_time: 1.3163371086120605\n", + "compute_auc_time: 6.049156904220581\n", "depth: 2 , Auc of digit: 1 is 0.882206498032918\n", "doing digit 2 doing signature level 2\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.4281229972839355\n", - "compute_auc_time: 6.078402996063232\n", + "fit_time: 1.311708927154541\n", + "compute_auc_time: 6.092707872390747\n", "depth: 2 , Auc of digit: 2 is 0.9511227445177669\n", "doing digit 3 doing signature level 2\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.1745800971984863\n", - "compute_auc_time: 6.047379970550537\n", + "fit_time: 1.1984961032867432\n", + "compute_auc_time: 6.022700786590576\n", "depth: 2 , Auc of digit: 3 is 0.9886656275413391\n", "doing digit 4 doing signature level 2\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.4331169128417969\n", - "compute_auc_time: 6.15405797958374\n", + "fit_time: 1.3563220500946045\n", + "compute_auc_time: 6.444512128829956\n", "depth: 2 , Auc of digit: 4 is 0.9971212578104729\n", "doing digit 5 doing signature level 2\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.2062079906463623\n", - "compute_auc_time: 5.991538047790527\n", - "depth: 2 , Auc of digit: 5 is 0.9647887656249262\n", + "fit_time: 1.2241871356964111\n", + "compute_auc_time: 6.081561088562012\n", + "depth: 2 , Auc of digit: 5 is 0.9647887656249261\n", "doing digit 6 doing signature level 2\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.3611791133880615\n", - "compute_auc_time: 6.071725130081177\n", + "fit_time: 1.226757287979126\n", + "compute_auc_time: 6.031784296035767\n", "depth: 2 , Auc of digit: 6 is 0.9924061022258366\n", "doing digit 7 doing signature level 2\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.2972280979156494\n", - "compute_auc_time: 6.051958084106445\n", + "fit_time: 1.324833869934082\n", + "compute_auc_time: 6.246238946914673\n", "depth: 2 , Auc of digit: 7 is 0.9607328695554606\n", "doing digit 8 doing signature level 2\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.3206632137298584\n", - "compute_auc_time: 6.074285984039307\n", + "fit_time: 1.1929960250854492\n", + "compute_auc_time: 6.09051513671875\n", "depth: 2 , Auc of digit: 8 is 0.9951771030993043\n", "doing digit 9 doing signature level 2\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.300351858139038\n", - "compute_auc_time: 5.983568906784058\n", + "fit_time: 1.4631941318511963\n", + "compute_auc_time: 6.044775009155273\n", "depth: 2 , Auc of digit: 9 is 0.8993403813138158\n" ] }, @@ -338,77 +338,77 @@ "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 1.4051527976989746\n", - "compute_auc_time: 6.391190767288208\n", + "fit_time: 1.342965841293335\n", + "compute_auc_time: 6.445879936218262\n", "depth: 3 , Auc of digit: 0 is 0.9978321712119015\n", "doing digit 1 doing signature level 3\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3406829833984375\n", - "compute_auc_time: 6.211621046066284\n", + "fit_time: 1.4032697677612305\n", + "compute_auc_time: 6.378614664077759\n", "depth: 3 , Auc of digit: 1 is 0.970122092330133\n", "doing digit 2 doing signature level 3\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.5092599391937256\n", - "compute_auc_time: 6.318360805511475\n", + "fit_time: 1.4213371276855469\n", + "compute_auc_time: 6.583529949188232\n", "depth: 3 , Auc of digit: 2 is 0.9907229815494015\n", "doing digit 3 doing signature level 3\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.4253010749816895\n", - "compute_auc_time: 6.349896192550659\n", + "fit_time: 1.3599779605865479\n", + "compute_auc_time: 6.415704965591431\n", "depth: 3 , Auc of digit: 3 is 0.9952787566639559\n", "doing digit 4 doing signature level 3\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3248441219329834\n", - "compute_auc_time: 6.372351884841919\n", + "fit_time: 1.3847181797027588\n", + "compute_auc_time: 6.45753288269043\n", "depth: 3 , Auc of digit: 4 is 0.9998316935138888\n", "doing digit 5 doing signature level 3\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.2319657802581787\n", - "compute_auc_time: 6.267655849456787\n", + "fit_time: 1.3755779266357422\n", + "compute_auc_time: 6.4378650188446045\n", "depth: 3 , Auc of digit: 5 is 0.9819583712798636\n", "doing digit 6 doing signature level 3\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.255133867263794\n", - "compute_auc_time: 6.341071128845215\n", + "fit_time: 1.259742021560669\n", + "compute_auc_time: 6.417846918106079\n", "depth: 3 , Auc of digit: 6 is 0.9945587105810065\n", "doing digit 7 doing signature level 3\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.4977219104766846\n", - "compute_auc_time: 6.289638042449951\n", + "fit_time: 1.3221640586853027\n", + "compute_auc_time: 6.397592067718506\n", "depth: 3 , Auc of digit: 7 is 0.9778264970511301\n", "doing digit 8 doing signature level 3\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.249243974685669\n", - "compute_auc_time: 6.3368239402771\n", + "fit_time: 1.28696608543396\n", + "compute_auc_time: 6.392870903015137\n", "depth: 3 , Auc of digit: 8 is 0.9984290759314479\n", "doing digit 9 doing signature level 3\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.4798219203948975\n", - "compute_auc_time: 6.201497793197632\n", + "fit_time: 1.286924123764038\n", + "compute_auc_time: 6.4979729652404785\n", "depth: 3 , Auc of digit: 9 is 0.9264809418391013\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB4RUlEQVR4nO3dd1hTZxsG8DsgeysiiAjuPXHUvag4auvGjbvWWa3WURWtddW6Wm2tW1tbt9U6q9ZdrRP3FupEcYEoM3m/P94vwciQQOAAuX/XlQvOyRlPcjKevFMlhBAgIiIiMkFmSgdAREREpBQmQkRERGSymAgRERGRyWIiRERERCaLiRARERGZLCZCREREZLKYCBEREZHJYiJEREREJouJEBEREZksJkImyMfHBz179lQ6DJPTsGFDNGzYUOkw3mvSpElQqVR4+vSp0qFkOyqVCpMmTTLKsUJDQ6FSqbBy5UqjHC+ny8j7o2fPnvDx8clwDOvXr0fevHkRFRX13m2N+Vow1MGDB6FSqbBx40ZFzv+2K1euIE+ePLh06ZLSoaQbEyEjW7lyJVQqle6WJ08eeHp6omfPnnjw4IHS4WVrr1+/xpQpU1CxYkXY2trCyckJ9erVw+rVq5FTZoK5cuUKJk2ahNDQUKVDSUKtVmPFihVo2LAh8ubNCysrK/j4+KBXr144ffq00uEZxW+//YZ58+YpHYaerIhJm1Rpb+bm5ihcuDDatGmD4ODgTD13cnr27KkXj729PYoWLYr27dtj06ZN0Gg0mXr+N2/eYNKkSTh48GCa91Gr1QgKCsKQIUNgb2+fecEZQMnX85IlS9CgQQMUKFAAVlZWKFKkCHr16pXks61s2bJo2bIlJk6cqEicxpBH6QByq6+//hpFihRBTEwMTpw4gZUrV+Lo0aO4dOkSrK2tFY3t+vXrMDPLXjnw48eP0aRJE1y9ehWdOnXC4MGDERMTg02bNiEwMBA7d+7EmjVrYG5urnSoqbpy5QomT56Mhg0bJvmF+tdffykTFIDo6Gi0bdsWu3fvRv369TFu3DjkzZsXoaGhWL9+PVatWoW7d++iUKFCisVoDL/99hsuXbqEzz//PFOOHx0djTx5DPvYTCkmb29vREdHw8LCwmjxde7cGS1atIBarcbVq1fx008/YdeuXThx4gQqV65stPOkhZWVFZYuXQpAPm///fcf/vzzT7Rv3x4NGzbE1q1b4ejoqNs+I++PJUuW6CVXb968weTJkwEgzaVMf/75J65fv47+/funOw5jy+zXc2rOnTuHIkWK4OOPP4aLiwtCQkKwZMkSbN++HefPn0fBggV12w4YMAAtWrTA7du3UaxYsSyPNcMEGdWKFSsEAHHq1Cm99aNHjxYAxLp16xSKTFnR0dFCrVaneL+/v78wMzMTW7duTXLfyJEjBQAxY8aMzAwxWVFRUQZtv2HDBgFAHDhwIHMCSqdBgwYJAGLu3LlJ7ktISBCzZs0S9+7dE0IIERQUJACI8PDwTItHo9GIN2/eGP24LVu2FN7e3kY9plqtFtHR0enePzNieldISIgAIGbNmqW3ftu2bQKA6N+/f6ae/12BgYHCzs4u2fumT58uAIiOHTtm2vnDw8MFABEUFJTmfT7++GNRt27dNG9v6PHTI6XXzoEDBwQAsWHDhkw9/7tOnz4tAIjp06frrY+LixMuLi5iwoQJWRqPsTARMrKUEqHt27cLAGLatGl6669evSratWsnXFxchJWVlfD19U02GXjx4oX4/PPPhbe3t7C0tBSenp6ie/fuel9WMTExYuLEiaJYsWLC0tJSFCpUSIwaNUrExMToHcvb21sEBgYKIYQ4deqUACBWrlyZ5Jy7d+8WAMSff/6pW3f//n3Rq1cv4ebmJiwtLUXZsmXFsmXL9PbTvkl///138dVXX4mCBQsKlUolXrx4kexzdvz4cQFA9O7dO9n74+PjRYkSJYSLi4vuy/PtD/45c+aIwoULC2tra1G/fn1x8eLFJMdIy/OsvXYHDx4Un332mcifP79wdnYWQggRGhoqPvvsM1GyZElhbW0t8ubNK9q3by9CQkKS7P/uTZsUNWjQQDRo0CDJ87Ru3TrxzTffCE9PT2FlZSUaN24sbt68meQxLFiwQBQpUkRYW1uL6tWri8OHDyc5ZnLu3bsn8uTJIz788MNUt9PSJkI3b94UgYGBwsnJSTg6OoqePXuK169f6227fPly0ahRI5E/f35haWkpypQpI3788cckx/T29hYtW7YUu3fvFr6+vsLKykqXlKX1GEIIsXPnTlG/fn1hb28vHBwcRLVq1cSaNWuEEPL5ffe5f/tLJK3vDwBi0KBB4tdffxVly5YVefLkEVu2bNHd9/aXX2RkpBg2bJjufZk/f37h5+cnzpw5896YtK/hFStW6J3/6tWrokOHDsLV1VVYW1uLkiVLinHjxqV2yVJMhKKiogQAvWt/4sQJ4e/vLxwdHYWNjY2oX7++OHr0qN5+hrwGkpNaIiSEEE2bNhUqlUpcv35dty6513JoaKho1aqVsLW1Ffnz5xeff/657nPp7R8bgYGBSZ7Xd2+pJS3R0dHC0tJSTJo0Kcl9MTEx4vPPPxeurq7C3t5etGrVSty7dy/ZYxry+bh27VoxduxYUaBAAWFraytatWol7t69q/d8pPTaMfSzw1iePn0qAIjRo0cnua9NmzaiYsWKmXbuzMSqsSyirVd1cXHRrbt8+TLq1KkDT09PjBkzBnZ2dli/fj1at26NTZs2oU2bNgCAqKgo1KtXD1evXkXv3r1RtWpVPH36FNu2bcP9+/fh6uoKjUaDjz/+GEePHkX//v1RpkwZXLx4EXPnzsWNGzfwxx9/JBtXtWrVULRoUaxfvx6BgYF6961btw4uLi7w9/cHIKuvPvjgA6hUKgwePBj58+fHrl270KdPH0RGRiYpvp0yZQosLS0xcuRIxMbGwtLSMtkY/vzzTwBAjx49kr0/T5486NKlCyZPnoxjx47Bz89Pd9/q1avx6tUrDBo0CDExMZg/fz4aN26MixcvokCBAgY9z1oDBw5E/vz5MXHiRLx+/RoAcOrUKfzzzz/o1KkTChUqhNDQUPz0009o2LAhrly5AltbW9SvXx9Dhw7F999/j3HjxqFMmTIAoPubkhkzZsDMzAwjR45EREQEvv32W3Tt2hX//vuvbpuffvoJgwcPRr169TB8+HCEhoaidevWcHFxeW911q5du5CQkIDu3bunut27OnbsiCJFimD69Ok4e/Ysli5dCjc3N8ycOVMvrnLlyuHjjz9Gnjx58Oeff2LgwIHQaDQYNGiQ3vGuX7+Ozp0749NPP0W/fv1QqlQpg46xcuVK9O7dG+XKlcPYsWPh7OyMc+fOYffu3ejSpQu++uorRERE4P79+5g7dy4A6Np6GPr++Pvvv7F+/XoMHjwYrq6uKTbEHTBgADZu3IjBgwejbNmyePbsGY4ePYqrV6+iatWqqcaUnAsXLqBevXqwsLBA//794ePjg9u3b+PPP//E1KlT03bh3nL79m0AQL58+XSPq3nz5vD19UVQUBDMzMywYsUKNG7cGEeOHEGNGjX09k/LayA9unfvjr/++gt79+5FyZIlk93m9evXaNy4MR49eoRhw4bB3d0dv/32Gw4cOJDqsfPnz4+ffvoJn332Gdq0aYO2bdsCACpWrJjiPmfOnEFcXByqVq2a5L6+ffvi119/RZcuXVC7dm38/fffaNmyZZLtDP18nDp1KlQqFUaPHo0nT55g3rx58PPzQ3BwMGxsbNL02knLZ8ebN2/w5s2bVJ8zADA3N9f7ftJ69uwZ1Go17t69i6+//hoA0KRJkyTb+fr6YuvWrYiMjNSr8swRlM7EchttqcC+fftEeHi4uHfvnti4caPInz+/sLKy0lU/CCFEkyZNRIUKFfR+kWo0GlG7dm1RokQJ3bqJEycKAGLz5s1JzqfRaIQQQvzyyy/CzMxMHDlyRO/+RYsWCQDi2LFjunVvlwgJIcTYsWOFhYWFeP78uW5dbGyscHZ21iul6dOnj/Dw8BBPnz7VO0enTp2Ek5OTrrRG+2ulaNGiaar+aN26tQCQYomREEJs3rxZABDff/+9ECLxV5+NjY24f/++brt///1XABDDhw/XrUvr86y9dnXr1hUJCQl650/ucWhLslavXq1bl1rVWEolQmXKlBGxsbG69fPnzxcAdCVbsbGxIl++fKJ69eoiPj5et93KlSsFgPeWCA0fPlwAEOfOnUt1Oy1tacC7JXRt2rQR+fLl01uX3PPi7+8vihYtqrfO29tbABC7d+9Osn1ajvHy5Uvh4OAgatasmaSaSvseECLlqgRD3h8AhJmZmbh8+XKS4+CdUgAnJycxaNCgJNu9LaWYkisRql+/vnBwcBD//fdfio8xOdpjTZ48WYSHh4uwsDBx8OBBUaVKFQFAbNq0SWg0GlGiRAnh7++vd7w3b96IIkWK6JUaGfIaSM77SoTOnTuX5H367vtj9uzZAoD4448/dOuio6NF6dKlUy0REsLwqrGlS5fqvee0goODBQAxcOBAvfVdunRJcnxDPx89PT1FZGSkbrv169cLAGL+/Pm6de+rGnvfZ4cQidfyfbeUqm+trKx02+TLl0/3Gfyu3377TQAQ//77b7L3Z2fZq8VsLuLn54f8+fPDy8sL7du3h52dHbZt26b79f78+XP8/fff6NixI169eoWnT5/i6dOnePbsGfz9/XHz5k1dL7NNmzahUqVKSUouANmFEwA2bNiAMmXKoHTp0rpjPX36FI0bNwaAVH9FBQQEID4+Hps3b9at++uvv/Dy5UsEBAQAAIQQ2LRpE1q1agUhhN45/P39ERERgbNnz+odNzAwEDY2Nu99rl69egUAcHBwSHEb7X2RkZF661u3bg1PT0/dco0aNVCzZk3s3LkTgGHPs1a/fv2SNMp++3HEx8fj2bNnKF68OJydnZM8bkP16tVLr7SsXr16AIA7d+4AAE6fPo1nz56hX79+eg11u3btmuwvuHdpn7PUnt/kDBgwQG+5Xr16ePbsmd41ePt5iYiIwNOnT9GgQQPcuXMHERERevsXKVJEV7r4trQcY+/evXj16hXGjBmTpLOB9j2QGkPfHw0aNEDZsmXfe1xnZ2f8+++/ePjw4Xu3fZ/w8HAcPnwYvXv3RuHChfXuS8tjBICgoCDkz58f7u7uaNiwIW7fvo2ZM2eibdu2CA4Oxs2bN9GlSxc8e/ZM9xy8fv0aTZo0weHDh5P05krLayA9tCUb2vd+cnbv3g1PT098/PHHunXW1tbo169fhs6dnGfPngFAkveT9nNk6NCheuvfLd1Jz+djjx499N6T7du3h4eHh+6cafG+zw7tefbu3fve25o1a5I9x65du7Bz507Mnj0bhQsX1pWSv0v73OXEYTdYNZZJFi5ciJIlSyIiIgLLly/H4cOHYWVlpbv/1q1bEEJgwoQJmDBhQrLHePLkCTw9PXH79m20a9cu1fPdvHkTV69eRf78+VM8VkoqVaqE0qVLY926dejTpw8AWS3m6uqq+6IIDw/Hy5cvsXjxYixevDhN5yhSpEiqMWtpPwxevXoFZ2fnZLdJKVkqUaJEkm1LliyJ9evXAzDseU4t7ujoaEyfPh0rVqzAgwcP9Lrzv/uFb6h3v/S0HygvXrwAAPz3338AgOLFi+ttlydPnjSNnaItpk7tS8fQuLTHPHbsGIKCgnD8+PEkxe8RERFwcnLSLaf0ekjLMbRVPOXLlzfoMWgZ+v5I62v322+/RWBgILy8vODr64sWLVqgR48eKFq0qMExar+80vsYAaB///7o0KEDzMzM4OzsjHLlyuk+d27evAkASarA3xYREaGXDKTlNZAe2nF6UkvO//vvPxQrVixJEvju+8CY3n5fa2MwMzNL0hNKW62rlZ7Px3c/u1QqFYoXL27Q0Bvv++wAgKJFi6br9ajVqFEjAEDz5s3xySefoHz58rC3t8fgwYP1ttM+d2lN2rMTJkKZpEaNGqhWrRoAWWpRt25ddOnSBdevX4e9vb3ul9fIkSOT/ZUMGPaG12g0qFChAubMmZPs/V5eXqnuHxAQgKlTp+Lp06dwcHDAtm3b0LlzZ10JhDbebt26pfhB+m4dfFpKgwDZhuaPP/7AhQsXUL9+/WS3uXDhAgCk6Vf629LzPCcX95AhQ7BixQp8/vnnqFWrFpycnKBSqdCpU6cMj4mS0pAA734op1fp0qUBABcvXjSoC/X74rp9+zaaNGmC0qVLY86cOfDy8oKlpSV27tyJuXPnJnleknteDT1Gehn6/kjra7djx46oV68etmzZgr/++guzZs3CzJkzsXnzZjRv3jzDcRuqRIkSem3o3qZ9LmfNmpXi6+DdNiiZ9drUDr6XmUmNIbRtqF68eJGuISTS8/loDGm5PlFRUWkaINLc3DzFHwpaxYoVQ5UqVbBmzZokiZA2+XJ1dX3vubIbJkJZwNzcHNOnT0ejRo2wYMECjBkzRpehW1hYpPjBpVWsWLH3jtpZrFgxnD9/Hk2aNElXRh4QEIDJkydj06ZNKFCgACIjI9GpUyfd/fnz54eDgwPUavV74zXURx99hOnTp2P16tXJJkJqtRq//fYbXFxcUKdOHb37tL9y33bjxg1dSYkhz3NqNm7ciMDAQMyePVu3LiYmBi9fvtTbLjN+DXl7ewOQpVvaX2cAkJCQgNDQ0Pd+wDZv3hzm5ub49ddfDW4wnZo///wTsbGx2LZtm94v0/c1Zk3PMbS/yC9dupTql2dKz39G3x+p8fDwwMCBAzFw4EA8efIEVatWxdSpU3WJUFrPp32tZtYIvdrn0NHR0ejvYUP98ssvUKlU+PDDD1PcxtvbG1euXIEQQu85vHXr1nuPb+g11v5YCAkJQYUKFfRi0Gg0uH37tl4p0PXr1/X2T8/n47ufXUII3Lp1S+/9bIzX6nfffacbUyk13t7eaSqNio6ORmxsbJL1ISEhMDMzS7Hxe3bGNkJZpGHDhqhRowbmzZuHmJgYuLm5oWHDhvj555/x6NGjJNuHh4fr/m/Xrh3Onz+PLVu2JNlOm/l37NgRDx48wJIlS5JsEx0dnWK9rlaZMmVQoUIFrFu3DuvWrYOHh4deUmJubo527dph06ZNyX5Qvx2voWrXrg0/Pz+sWLEC27dvT3L/V199hRs3buDLL79M8kv9jz/+0Gvjc/LkSfz777+6LyFDnufUmJubJ/kV/MMPP0CtVuuts7OzA4AkCVJGVKtWDfny5cOSJUuQkJCgW79mzRq9IvCUeHl5oV+/fvjrr7/www8/JLlfo9Fg9uzZuH//vkFxaX+NvltNuGLFCqMfo2nTpnBwcMD06dMRExOjd9/b+9rZ2SVbVZnR90dy1Gp1knO5ubmhYMGCel8UKcX0rvz586N+/fpYvnw57t69q3efMUoHfX19UaxYMXz33XfJlhBk5D1siBkzZuCvv/5CQEBAslXbWv7+/njw4AG2bdumWxcTE5PsNXyXra0tgLS/D319fWFpaZlkhHXt58j333+vt/7d0Z7T8/mo7fGqtXHjRjx69EivJDGtr53UpKeNUEJCQrKfLSdPnsTFixd1tR1vO3PmDMqVK6dXHZ5TsEQoC40aNQodOnTAypUrMWDAACxcuBB169ZFhQoV0K9fPxQtWhSPHz/G8ePHcf/+fZw/f16338aNG9GhQwf07t0bvr6+eP78ObZt24ZFixahUqVK6N69O9avX48BAwbgwIEDqFOnDtRqNa5du4b169djz549yb543xYQEICJEyfC2toaffr0STL69IwZM3DgwAHUrFkT/fr1Q9myZfH8+XOcPXsW+/btw/Pnz9P93KxevRpNmjTBJ598gi5duqBevXqIjY3F5s2bcfDgQQQEBGDUqFFJ9itevDjq1q2Lzz77DLGxsZg3bx7y5cuHL7/8UrdNWp/n1Hz00Uf45Zdf4OTkhLJly+L48ePYt2+frkhdq3LlyjA3N8fMmTMREREBKysrNG7cGG5ubul+biwtLTFp0iQMGTIEjRs3RseOHREaGoqVK1cm24YiObNnz8bt27cxdOhQbN68GR999BFcXFxw9+5dbNiwAdeuXdMrAUyLpk2bwtLSEq1atcKnn36KqKgoLFmyBG5ubskmnRk5hqOjI+bOnYu+ffuievXq6NKlC1xcXHD+/Hm8efMGq1atAiC/0NatW4cRI0agevXqsLe3R6tWrYzy/njXq1evUKhQIbRv3x6VKlWCvb099u3bh1OnTumVHKYUU3K+//571K1bF1WrVkX//v1RpEgRhIaGYseOHRmeKsPMzAxLly5F8+bNUa5cOfTq1Quenp548OABDhw4AEdHR91QFsaQkJCAX3/9FYBMYP777z9s27YNFy5cQKNGjVJsS6P16aefYsGCBejcuTOGDRsGDw8PrFmzRtdYPrXXvY2NDcqWLYt169ahZMmSyJs3L8qXL59i+ytra2s0bdoU+/bt03URB+T7uXPnzvjxxx8RERGB2rVrY//+/cmWShn6+Zg3b17UrVsXvXr1wuPHjzFv3jwUL15crzG4Ia+dlKSnjVBUVBS8vLwQEBCAcuXKwc7ODhcvXsSKFSvg5OSUpL1lfHw8Dh06hIEDBxp0nmwjS/uomYCUBlQUQo5QW6xYMVGsWDFd9+zbt2+LHj16CHd3d2FhYSE8PT3FRx99JDZu3Ki377Nnz8TgwYOFp6enbjC4wMBAva6acXFxYubMmaJcuXLCyspKuLi4CF9fXzF58mQRERGh2+7d7vNaN2/e1HWTfHeANa3Hjx+LQYMGCS8vL2FhYSHc3d1FkyZNxOLFi3XbpHfU01evXolJkyaJcuXKCRsbG+Hg4CDq1KkjVq5cmaT78NsDyM2ePVt4eXkJKysrUa9ePXH+/Pkkx07L85zatXvx4oXo1auXblA1f39/ce3atWSfyyVLloiiRYsKc3PzNA2o+O7zlNJAe99//73w9vYWVlZWokaNGuLYsWPC19dXNGvWLA3PrhxBeunSpaJevXrCyclJWFhYCG9vb9GrVy+9rvUpjSytfX7eHkRy27ZtomLFisLa2lr4+PiImTNniuXLlyfZTjugYnLSegzttrVr1xY2NjbC0dFR1KhRQ/z++++6+6OiokSXLl2Es7Nzki7BaX1/4P8DKiYHb3WZjo2NFaNGjRKVKlUSDg4Ows7OTlSqVCnJYJApxZTSdb506ZJo06aNcHZ2FtbW1qJUqVLvHbE3pQEVk3Pu3DnRtm1bkS9fPmFlZSW8vb1Fx44dxf79+3XbGPIaSE5gYKBe12xbW1vh4+Mj2rVrJzZu3JjsKPPJDah4584d0bJlS2FjYyPy588vvvjiC7Fp0yYBQJw4cULvfO92//7nn3+Er6+vsLS0TFNX+s2bNwuVSqU3qKEQssv+0KFDRb58+YSdnV2qAyoa8vn4+++/i7Fjxwo3NzdhY2MjWrZsmWTYhJReO4Z+dhgqNjZWDBs2TFSsWFE4OjrqPiv69OmT7LXftWuXwP8H4MyJVELkkNksid4SGhqKIkWKYNasWRg5cqTS4ShCo9Egf/78aNu2bZqqC4hyg3nz5mH48OG4f/++Xm/PjFKr1Shbtiw6duyIKVOmGO247zp48CAaNWqEDRs2oH379pl2nqzUunVrqFSqZJtv5ARsI0SUA8TExCRpJ7J69Wo8f/48zZNKEuU00dHRessxMTH4+eefUaJECaMmQYBs5/P1119j4cKFaeplRdLVq1exffv2TE0eMxvbCBHlACdOnMDw4cPRoUMH5MuXD2fPnsWyZctQvnx5dOjQQenwiDJF27ZtUbhwYVSuXBkRERH49ddfce3atRQH/8uogIAA3SCylDZlypTR68SREzERIsoBfHx84OXlhe+//x7Pnz9H3rx50aNHD8yYMSPFOdyIcjp/f38sXboUa9as0VVdrV27lskKGZWibYQOHz6MWbNm4cyZM3j06BG2bNmC1q1bp7rPwYMHMWLECFy+fBleXl4YP348evbsmSXxEhERUe6iaBuh169fo1KlSli4cGGatg8JCUHLli3RqFEjBAcH4/PPP0ffvn2xZ8+eTI6UiIiIcqNs02tM2+I8tRKh0aNHY8eOHXoDVnXq1AkvX77E7t27syBKIiIiyk1yVBuh48ePJxm+3N/fP8lMwG+LjY3VG+VVo9Hg+fPnyJcvX46cHI6IiMgUCSHw6tUrFCxYMMmAvxmRoxKhsLAwFChQQG+ddl6s6OjoZCdKnD59eprmWSEiIqLs7969e+maHDclOSoRSo+xY8dixIgRuuWIiAgULlwY9+7dg6Ojo4KREeU8QgBqNZCQAERHAzExQFQUEBcHxMfL9fHxgHZ6JCHkOu1NrQbu3gXy5pXL2v1u3ADc3eXys2fAgweJy3FxwK1bgLU14OAAaDTyOELI/7XLT58CYWFAoUJyWRunRiP/cmgY5ZibJ71FRAAFCgBmZnLZzCzpTbv+1SvgxQugZEm5rFLpb5fcsnYdAFy/DmjnMtXel9xNe39K26V1f+3tzRv5OL299eN89682zpS2efAA8PExLJa03t49zosXgJvb+8/17jqt9OyX3DZxcYCjI+B8eCuian0Ila0t3ryJRJMmXnBwcMjQ6/FdOSoRcnd3x+PHj/XWPX78GI6OjsmWBgGAlZUVrKyskqx3dHRkIkTZnlotE4U3b4DXr2XiEREhv9hjY+WHxYMHMknQJhWxscDt2zJpuHhRftloE4rjx4FSpfSTlvh44MQJoFw5ua92GiVHx8SEQptUZI8WhakzcO7YJKytAQsLIE+exNujR0CZMoClpbzPwgK4dAmoVStxWwsL+cV98yZQtWrSY/z3H1C+fNIv+beTAO3/4eFAwYLyGO/e9+5NpZKvi7x5k/+iezsxSM/92pulZfLnTykZsbFJjJnIYK9fA4MGAatWAX37AkuWIDJS3mXsZi05KhGqVasWdu7cqbdu7969qFWrlkIRkSkSQn7xvH4tf6lqSzbi4mSpRHw8EBoqv/wuXADy5ZP3xcQAwcGAlxdw9qxcf/cuEBkJuLjIJET7JW5pKY+TGYlHMvNFAgAuX9Zf1n7opEb7hff6NeDpmZgkWFjIX+HlysmE7O2EwNwcuHYNqF5dbqdNLkJCZAKh/d0SEwMULizvt7SU53B2lolKcsmBubm8Fvb2Mibtud7+a2Ym99cuv7sNmw0SZQOXLgEdOwJXr8o3beHCmforTNFEKCoqSm8W35CQEAQHByNv3rwoXLgwxo4diwcPHmD16tUAgAEDBmDBggX48ssv0bt3b/z9999Yv349duzYodRDoBxGCFmi8vx5YunK06cyORACuHJFfnGfPi2rWF6+lKUlL1/KqpqwsMyJ652JqREXl/x2jo4yUQgPl9UEVlYySbhyBahXLzGpMDeXsVaqJB9jmTKJ2z57BhQrpl+SkSePTLzy509MNOztE6sxtInC2zdra3k8Jg9EZBRCAMuXA0OGyLp3Dw/gt9+ATJ5GSNFE6PTp02jUqJFuWduWJzAwECtXrsSjR49w9+5d3f1FihTBjh07MHz4cMyfPx+FChXC0qVL4e/vn+Wxk3I0GllV9Pgx8PChLEkJCUksgXn2TH5RHz8u6+ZjYoDDh+WPirdeTgZLLQlydU0sxYmMlCUbT57IUo8HDwBfX5mIWFjIOviyZeX73Ntbxp03L2BnJ7cxN5f/v126Ym2dWFJCRJTrREUBAwYA2ulTmjYFfvlFNljKZNlmHKGsEhkZCScnJ0RERLCNUDby4oVsh3H3riydefhQtm9RqWSVyPHjMgF6aySEDMubV1ahPHki283ExgIffCDfj5UqyYSmVCm5jbW1LCFydZXLjo6Ara1MYoiIKIPu3wcqV5bF7998A3z5ZZIGZpn1/c2PccpUERGyvczdu/IWFwecPy+TjDNnZCPcBw8yfp4PPpANhBs2lFVdJUsCRYvK4xcvLhMZlUq2z/HxAZycMn5OIiIykkKFgN9/l78069bN0lMzEaJ0e/QI2LdPVvGcOSOXzc2BQ4dkCU96ubjIrq7u7rLKuFo12RDXykomN3nzJpbMsEcKEVEOFBkJ9O8PdOoEaGeU+PBDRUJhIkTJSkiQPXv+/Vf2Jrp7F9i2TbZtiYqSpS+GcHOTpTOOjjLZj42Vx8qbV7afKVVK9qIiIqJc7swZICBAfpEcOCDbA9naKhYOEyET9OqVTHKCg2U1lY2NfC2GhclqKgcHuU1yzp9Pus7JCfD3l215ihUDKlSQ60qUkI2BXVwy9eEQEVFOIASwYAEwcqRsJ+HtDaxdq2gSBDARMgkPHwJz5sgu4YcOvX/7d5Mge3vZ/bpGDZncVKsmezXlyyerddl9moiIUvXyJdCnD7B5s1xu3Vp2lc8Gv5SZCOUyQshSx+++A7ZulV3HU2JuLl+DlSvLMWgAWUXl7S1HtS1YkL2iiIgog16+BKpUkT1nLCzkF9SQIdnmVzS/5nIwIYC9e4ENG2RpT3Dw+/f59FM5ns7nnyteGklERKbA2Rlo3hzYswdYt05WK2QjTIRymNu35bQrBw++f9sKFYB27YDevWW3cSIioizx7JnsdVOggFyeM0f2ksmGY5cwEcoB9u2TDezfnYbhbW3bAjVryh5ZVavKcXOIiIiy3D//yG7xxYvLagvtnDzZ9IuJiVA2dP8+8PXXwP79wJ07yW/j4gKsWCF7a2XT1xYREZkSjQaYNQv46is5XoqVlRxgrlAhpSNLFROhbCIhAQgKAqZNS3mbbt3kyOPe3lkXFxER0XuFhwOBgcCuXXK5c2fg55/leCzZHBMhBQkBrFolGzAnN9t44cJAr16yWqxMmayPj4iI6L2OHJFVYQ8fyiqK77+XjVmzSa+w92EipJC//pLVWsmZOxf47DPONk5ERNmcWg0MHCiToNKlgfXrZU+dHIQzNWWhZ8/k5KAqVdIkqHt3OQu6ELJrO5MgIiLK9szN5WSpffsCp07luCQIYIlQlrhzRw5amNy0FXPnysSHiIgoR/j7b+DmTdmuAwDKlweWLFE2pgxgIpTJ9uwBmjXTX+fsDGzaBDRurEhIREREhlOrZZfmKVNkSZCvb7YbHDE9mAhlAiFk766JE/XXlyolZ3PPhuNJERERpezhQ6Br18TRfHv2BMqWVTIio2EiZGRPniQOpPm2efOAYcOyPBwiIqKM2bNHNmQND5ezcP/8M9Cli9JRGQ0bSxvRq1dJk6Bly2QJEZMgIiLKcSZNku07wsOBSpXkrN65KAkCmAgZzfz5gKNj4nK9ejIB6t1buZiIiIgyxNlZ/h0wADhxAihZUtFwMgOrxjLo9m05ncrbWrcGtmxRJBwiIqKMef0asLOT/w8bBlSpAjRooGxMmYglQhmg0SRNgtatYxJEREQ5UHw8MGqUnLlbO96LSpWrkyCAJUIZYm6e+H/FisD588rFQkRElG7//SenyThxQi7/8YdsIG0CWCKUTu8OgsgkiIiIcqStW+WovydOyPFdNm0ymSQIYCKULqGhsnG0llqtWChERETpExcnf9W3bg28fAnUqAGcOwe0batwYFmLiVA6FCmS+P/p04AZn0UiIsppRo9O/FX/xRdyFvm3v+BMBL/CDeTjk/i/jY0cYZyIiCjHGTMGKFcO2LYN+O47wNJS6YgUwUTIAAMHyvZkWs+eKRcLERGRQWJi5EzxWgUKABcuAK1aKRdTNsBeY2n05g3w00+Jy/fuyRIhIiKibO/mTaBjRyA4WC537iz/sm0HS4TSqkOHxP9PnAAKFVIuFiIiojT7/Xc5NlBwMODqCuTNq3RE2QoToTQIDwd27kxcrllTuViIiIjSJDoa6N9fzg0WFQXUry+TIX9/pSPLVpgIpYGbW+L/ixYpFwcREVGaXLsmf7UvWSJHhx4/Hti/H/D0VDqybIdthN7j7V5hZmbAp58qFwsREVGa3L4NXLwof8mvWQP4+SkdUbbFRCgVEyYAZ88mLsfHKxcLERFRmrVsKUuDWrYEPDyUjiZbY9VYCkJCgG++SVw+d46N64mIKJu6fBmoV09/jJe+fZkEpQG/2pOh0QBFiyYunzsnp2EhIiLKVoQAli8HqlcHjh5NOhEmvRerxpJx717i/+PGMQkiIqJsKCoKGDBAtgECgKZNgZ9/VjamHIglQsm4ezfx/6lTlYuDiIgoWefPy948a9YA5ubAtGnArl363ZwpTVgilIz69ZWOgIiIKAVHjgAffgjExsru8GvXAnXrKh1VjsVE6B0aTeL/Xl7KxUFERJSs6tWB0qVlErRqlRwtmtKNidA7/vwz8f8LF5SLg4iISOfqVaBkSVkNZm0N7Nsnp8pgd+YM4zP4jnXrEv93dlYsDCIiItkrbMEC2Wvn7Uarrq5MgoyEJULv2LRJ/n17RGkiIqIs9/Il0KcPsHmzXD5/XrbfYAJkVHw23xEXJ/++PY4QERFRljp5EqhSRSZBFhbAvHnAxo1MgjIBn9EUcEwqIiLKckIAc+fKXmChoUCRIsCxY8CwYXLyVDI6JkJv0VaLAUD58srFQUREJiokRI7kGx8PtGsnJ7ysXl3pqHI1thF6y9Onif87OioXBxERmaiiRYGFC4HoaGDgQJYCZQEmQm8ZMED+bd5c2TiIiMhEaDTA7NlywtQPPpDrevdWNiYTw0ToLUWKyFLJc+eUjoSIiHK98HAgMFBOjeHtDVy6BNjbKx2VyWEi9JaQEPl32TJl4yAiolzu8GGgc2fg4UM5QOJXXwF2dkpHZZLYWDoZefMqHQEREeVKGo0cGLFRI5kElSoF/Psv0K8f2wMphCVC//fmTeL/np7KxUFERLlUVBTQti2wd69c7t4d+PFHVocpjInQ/718mfh/oUKKhUFERLmVnR1gYyNvP/4I9OypdEQEJkI6168n/s/SSSIiMgq1Wk5ZYGMjv1xWrADCwoCyZZWOjP6PbYT+b/RopSMgIqJc5dEjwM9Ptv8RQq7Lm5dJUDbDEiHItmunTikdBRER5Rp//QV06ya7yNvZAXfuAMWKKR0VJYMlQpDTuGj98YdiYRARUU6XkCC7wjdrJpOgihWB06eZBGVjLBECcPBg4v+ffKJYGERElJPdvw906QIcOSKXP/1UTqBqY6NsXJQqJkKQyTogh3MgIiIymEYj52e6dAlwcACWLAECApSOitKAVWOQg3oCQNOmysZBREQ5lJkZMG8eUK2anDGeSVCOwUQIwKFD8m+JEsrGQUREOcjdu7JRtFaTJnKU6OLFlYuJDMZECICtrfwbGalsHERElENs2wZUrgy0bw/cupW43oxfqzmNyV+xFy8SJ1v19VU2FiIiyubi4oDhw2XPmhcvgNKlgTxsbpuTKZ4ILVy4ED4+PrC2tkbNmjVx8uTJVLefN28eSpUqBRsbG3h5eWH48OGIiYlJ9/m7d0/8/4MP0n0YIiLK7UJCgLp1ZVsgQCZER48CPj5KRkUZpGgitG7dOowYMQJBQUE4e/YsKlWqBH9/fzx58iTZ7X/77TeMGTMGQUFBuHr1KpYtW4Z169Zh3Lhx6Y7h7RJNZ+d0H4aIiHKzTZuAKlXk6LsuLsDWrcCcOYClpdKRUQYpmgjNmTMH/fr1Q69evVC2bFksWrQItra2WL58ebLb//PPP6hTpw66dOkCHx8fNG3aFJ07d35vKVJqtHOMjRyZ7kMQEVFu988/QEQEUKsWEBwMfPyx0hGRkSiWCMXFxeHMmTPw8/NLDMbMDH5+fjh+/Hiy+9SuXRtnzpzRJT537tzBzp070aJFixTPExsbi8jISL2blkaTuF2rVhl8QERElLto5wcDgOnTgfnzZTfjwoWVi4mMTrFE6OnTp1Cr1ShQoIDe+gIFCiAsLCzZfbp06YKvv/4adevWhYWFBYoVK4aGDRumWjU2ffp0ODk56W5eXl66+77/PnG7atUy9niIiCgXWbsWaNECiI+Xy5aWwNChgIWFsnGR0SneWNoQBw8exLRp0/Djjz/i7Nmz2Lx5M3bs2IEpU6akuM/YsWMRERGhu927d0933/Dhidtpu9ATEZEJi46WU2N07gzs3i1HiKZcTbE+f66urjA3N8fjx4/11j9+/Bju7u7J7jNhwgR0794dffv2BQBUqFABr1+/Rv/+/fHVV1/BLJnxG6ysrGBlZZVkfVxc4v/t2mXggRARUe5w/TrQsSNw4QKgUgHjxgH9+ysdFWUyxUqELC0t4evri/379+vWaTQa7N+/H7Vq1Up2nzdv3iRJdszNzQEA4u263DS4eDHx/8WLDdqViIhym19/lYPJXbgAuLkBe/YA33zDMYJMgKJXeMSIEQgMDES1atVQo0YNzJs3D69fv0avXr0AAD169ICnpyemT58OAGjVqhXmzJmDKlWqoGbNmrh16xYmTJiAVq1a6RKitNLWkFlbA3nzGvVhERFRTjJ1KjB+vPy/USNgzRrAw0PZmCjLKJoIBQQEIDw8HBMnTkRYWBgqV66M3bt36xpQ3717V68EaPz48VCpVBg/fjwePHiA/Pnzo1WrVpg6darB5z58WP7NwFiMRESUG7RvD3z7LTBihEyIDPxhTTmbShhap5TDRUZGwsnJCWPGRGDGDEeUKAHcuKF0VERElGWEkFVglSolrnv2DMiXT7mY6L20398RERFwdHQ02nFzVK8xY9KWCDVpomwcRESUhaKigB49gKpV5ZhAWkyCTJbJJkKPHun/JSKiXO7CBTlo3K+/yuVLl5SNh7IFk02EtG2DKlRQNg4iIspkQsjuwTVqyC7ynp7AwYPAoEFKR0bZgMn2C9SWBJUvr2wcRESUiSIj5QCJa9fK5ebNgdWrAVdXZeOibMNkS4RcXORfHx9FwyAiosy0datMgszNZc+w7duZBJEeky0RevFC/nVwUDYOIiLKRN26AefOAR06yJnjid5hsiVCWtbWSkdARERG8/IlMHhw4q9dlQqYM4dJEKXIZEuEtIoWVToCIiIyilOngIAAICQEePo0sV0QUSpMukSI7YOIiHIBIYB584A6dWQSVKQI8MUXSkdFOYRJlwixNIiIKId7/hzo1QvYtk0ut2sHLF0KODsrGhblHCadCBERUQ528SLw0UfA3buApaVsCzRwoGwXRJRGTISIiChnKlhQVosVKwasXy+nzSAyEBMhIiLKOV69AuztZalPvnzArl2AlxdgxEk4ybSYdGNpIiLKQY4cAcqUAVauTFxXrhyTIMoQk06E/v5b6QiIiOi9NBpg2jSgUSPgwQPghx8AtVrpqCiXMOlEaMIEpSMgIqJUPXkCNGsGfPWVTH66dQMOH5ZTZhAZgUm3EWJpKhFRNnbgANClCxAWBtjYAAsWyK7y7BVGRmTSiRAREWVT//0HNG0KJCQAZcvKXmHlyikdFeVCTISIiCj78fYGxo4F7t+XbYLs7JSOiHIpJkJERJQ97Nsn5z4qXlwuT57MajDKdCbdWFo7OTERESkoIQEYP15WhQUEALGxcj2TIMoCJl0iVKmS0hEQEZm4Bw+Azp3lGEEAUL26HC2aKIuYdCJkaal0BEREJmzXLqBHD+DpU8DBAVi8GOjUSemoyMSYdNUYS12JiBQQHw+MHg20aCGToCpVgDNnmASRIkw6ESpWTOkIiIhMkBByjCAAGDQI+OcfoEQJZWMik2XSVWNERJSFhJBF8ZaWwLp1wNmzQLt2SkdFJo6JEBERZa64OGDMGMDaWs4ZBgBFisgbkcKYCBERUeYJCZFtf06elKVBPXoApUsrHRWRjkm3ESIioky0ebNsCH3yJODsDGzZwiSIsh0mQkREZFyxscCQIbL9T0QE8MEHQHAw8MknSkdGlASrxoiIyHiEkCNEHz4sl7/8EvjmG8DCQtm4iFJg0okQ35dEREamUgF9+wKXLwOrV8uxgoiyMZUQpjWWeWRkJJycnABEIDraEdbWSkdERJTDRUcDoaFAmTKJ654/B/LmVSwkyn20398RERFwdHQ02nFNuo2QmUk/eiIiI7h+XbYB8vMDwsMT1zMJohzCpFMBzjVGRJQBv/4K+PoCFy7IaTNCQpSOiMhgJpsIFSyodARERDnUmzdAnz5A9+7A69dAw4ayV1iNGkpHRmQwk02EiIgoHa5ckQnP8uWyYXRQELBvH39dUo5l0r3GiIjIQDNnyh5h7u7AmjVA48ZKR0SUIUyEiIgo7b7/HsiTR84ZVqCA0tEQZRirxoiIKGUXLwKjRsmBEgHAyQlYtoxJEOUaLBEiIqKkhACWLgWGDgViYoBSpeRAiUS5DBMhIiLSFxkJfPopsHatXG7enPOEUa5lslVjDx8qHQERUTZ07pwcG2jtWsDcXDaO3r4dyJ9f6ciIMkWGSoRiYmJgnUPnqChaVOkIiIiymV9+kdVfcXGAl5dMhmrXVjoqokxlcImQRqPBlClT4OnpCXt7e9y5cwcAMGHCBCxbtszoAWYWDnlBRPSOIkUAtRpo1UoOkMgkiEyAwYnQN998g5UrV+Lbb7+F5VtzVJQvXx5Lly41anBERJTJIiIS/69bFzh+HNi6lXOFkckwOBFavXo1Fi9ejK5du8Lc3Fy3vlKlSrh27ZpRgyMiokwiBDB/PuDjI0eL1qpeXY4YTWQiDE6EHjx4gOLFiydZr9FoEB8fb5SgskJUlNIREBEp5PlzoE0b4PPPgZcvgZUrFQ6ISDkGJ0Jly5bFkSNHkqzfuHEjqlSpYpSgsoKZyfaXIyKTduIEUKWKrP6ytAR++EH2DCMyUQb3Gps4cSICAwPx4MEDaDQabN68GdevX8fq1auxffv2zIgxU1SooHQERERZSKMB5swBxo4FEhKAYsWAdetkV3kiE2Zwucgnn3yCP//8E/v27YOdnR0mTpyIq1ev4s8//8SHH36YGTESEVFG/fqrnCojIQHo2BE4c4ZJEBHSOY5QvXr1sHfvXmPHQkREmaVLFzlbfJs2ctRoNogmApCOEqGiRYvi2bNnSda/fPkSRTlKIRFR9qDRyLnCYmPlcp48wO7dwIABTIKI3mJwIhQaGgq1Wp1kfWxsLB48eGCUoIiIKAOePJHzg/XrB4wenbieCRBREmmuGtu2bZvu/z179sDJyUm3rFarsX//fvj4+Bg1OCIiMtDBg7Ia7NEjwMYGqFhR6YiIsrU0J0KtW7cGAKhUKgQGBurdZ2FhAR8fH8yePduowRERURqp1cDUqcDkybJarEwZYMMGoFw5pSMjytbSnAhpNBoAQJEiRXDq1Cm4urpmWlBERGSAsDCga1fg77/lcq9ecnwgOztl4yLKAQzuNRYSEpIZcRARUXq9eQOcPg3Y2gKLFgHduysdEVGOka7u869fv8ahQ4dw9+5dxMXF6d03dOhQowRGRESpECKx8XPRosD69YC3N1C6tLJxEeUwBidC586dQ4sWLfDmzRu8fv0aefPmxdOnT2Fraws3NzcmQkREme3BA6BbNzlKdNOmcp2/v7IxEeVQBnefHz58OFq1aoUXL17AxsYGJ06cwH///QdfX1989913mRFjpvh/kyciopxl926gcmXZO2zgQDlSNBGlm8GJUHBwML744guYmZnB3NwcsbGx8PLywrfffotx48ZlRoyZ4sULpSMgIjJAfDwwZowcH+jpU5kM7dwpB0okonQzOBGysLCA2f+nbndzc8Pdu3cBAE5OTrh3755xo8tE1asrHQERURrduwc0bJg4S/zAgcDx40DJkoqGRZQbGJwIValSBadOnQIANGjQABMnTsSaNWvw+eefo3z58gYHsHDhQvj4+MDa2ho1a9bEyZMnU93+5cuXGDRoEDw8PGBlZYWSJUti586dBp+XiChHePBAlv788w/g6CjHBlq4ELC2VjoyolzB4ERo2rRp8PDwAABMnToVLi4u+OyzzxAeHo6ff/7ZoGOtW7cOI0aMQFBQEM6ePYtKlSrB398fT548SXb7uLg4fPjhhwgNDcXGjRtx/fp1LFmyBJ6enoY+DCKinMHTE2jVCqhWDTh3DmjfXumIiHIVlRBCKHXymjVronr16liwYAEAOWijl5cXhgwZgjFjxiTZftGiRZg1axauXbsGCwuLdJ0zMjISTk5OmDw5AhMnOmYofiKiTBEaCtjbA9qBa9+8AczNASsrRcMiUpL2+zsiIgKOjsb7/ja4RCglZ8+exUcffZTm7ePi4nDmzBn4+fklBmNmBj8/Pxw/fjzZfbZt24ZatWph0KBBKFCgAMqXL49p06YlOwmsVmxsLCIjI/VuRETZ1pYtsiosMDCxe6utLZMgokxiUCK0Z88ejBw5EuPGjcOdO3cAANeuXUPr1q1RvXp13TQcafH06VOo1WoUKFBAb32BAgUQFhaW7D537tzBxo0boVarsXPnTkyYMAGzZ8/GN998k+J5pk+fDicnJ93Ny8srzTESEWWZ2Fhg6FCgbVsgIgJ49kz+JaJMleZEaNmyZWjevDlWrlyJmTNn4oMPPsCvv/6KWrVqwd3dHZcuXcr0RssajQZubm5YvHgxfH19ERAQgK+++gqLFi1KcZ+xY8ciIiJCd8tJPduIyETcvg3UqSPnBwOAkSOBI0cAFxdl4yIyAWkegGL+/PmYOXMmRo0ahU2bNqFDhw748ccfcfHiRRQqVMjgE7u6usLc3ByPHz/WW//48WO4u7snu4+HhwcsLCxgbm6uW1emTBmEhYUhLi4OlpaWSfaxsrKCFYuUiSi7Wr8e6NsXePUKyJcPWLUKaNlS6aiITEaaS4Ru376NDh06AADatm2LPHnyYNasWelKggDA0tISvr6+2L9/v26dRqPB/v37UatWrWT3qVOnDm7duqVXBXfjxg14eHgkmwQREWVrMTFymoxXr2SJUHAwkyCiLJbmRCg6Ohq2trYAAJVKBSsrK103+vQaMWIElixZglWrVuHq1av47LPP8Pr1a/Tq1QsA0KNHD4wdO1a3/WeffYbnz59j2LBhuHHjBnbs2IFp06Zh0KBBGYqDiEgR1tbAunXAuHFyyox0/rAkovQzaGz2pUuXwt7eHgCQkJCAlStXwlXbvfP/DJl0NSAgAOHh4Zg4cSLCwsJQuXJl7N69W9eA+u7du7pRrAHAy8sLe/bswfDhw1GxYkV4enpi2LBhGD16tCEPg4hIOb/9JrvD9+0rl6tVkzciUkSaxxHy8fGBSqVK/WAqla43WXbFcYSISBFv3gDDhgFLlwKWlrIarEwZpaMiyjEyaxyhNJcIhYaGGu2kREQm5epVoGNH4NIlQKWS7YI4TxhRtsBpi4mIMtOqVXKS1DdvgAIFZNVY48ZKR0VE/8dEiIgoMwgB9OsHLFsml/38gF9/lckQEWUbRptig4iI3qJSAUWLAmZmwJQpwO7dTIKIsiGWCBERGYsQcloMZ2e5PGYM0KwZULWqomERUcpYIkREZAyvXgFduwL16sn2QIAsDWISRJStpSsRun37NsaPH4/OnTvjyZMnAIBdu3bh8uXLRg2OiChHCA4GfH2B33+XPcQOH1Y6IiJKI4MToUOHDqFChQr4999/sXnzZkRFRQEAzp8/j6CgIKMHSESUbQkB/PQT8MEHwM2bgJeXTIKaNVM6MiJKI4MToTFjxuCbb77B3r179eb3aty4MU6cOGHU4IiIsq2ICCAgQHaNj40FWrUCzp0DatdWOjIiMoDBidDFixfRpk2bJOvd3Nzw9OlTowRFRJTtDR4MbNgA5MkDzJ4NbN0qZ48nohzF4ETI2dkZjx49SrL+3Llz8PT0NEpQRETZ3vTpsl3Q0aPAiBGyuzwR5TgGJ0KdOnXC6NGjERYWBpVKBY1Gg2PHjmHkyJHo0aNHZsRIRKS8Fy/kKNFahQoBp04BNWsqFxMRZZjBidC0adNQunRpeHl5ISoqCmXLlkX9+vVRu3ZtjB8/PjNiJCJS1r//AlWqAD17yiowLZYCEeV4Bg+oaGlpiSVLlmDChAm4dOkSoqKiUKVKFZQoUSIz4iMiUo4QwJw5cmDEhASgWDFZEkREuYbBidDRo0dRt25dFC5cGIULF86MmIiIlPfsmSwB2r5dLnfsCCxZAjg6KhoWERmXwVVjjRs3RpEiRTBu3DhcuXIlM2IiIlLWsWNA5coyCbKykmMFrV3LJIgoFzI4EXr48CG++OILHDp0COXLl0flypUxa9Ys3L9/PzPiIyLKeg8fAvfvAyVKACdOAAMGsD0QUS5lcCLk6uqKwYMH49ixY7h9+zY6dOiAVatWwcfHB40bN86MGImIMp8Qif936ACsXAmcOSNLhogo18rQpKtFihTBmDFjMGPGDFSoUAGHDh0yVlxERFnn0CE5JtDbY6QFBgIODsrFRERZIt2J0LFjxzBw4EB4eHigS5cuKF++PHbs2GHM2IiIMpdaDUyZAjRuLKfHmDhR6YiIKIsZ3Gts7NixWLt2LR4+fIgPP/wQ8+fPxyeffAJbW9vMiI+IKHOEhQHdugH798vlnj2BefOUjIiIFGBwInT48GGMGjUKHTt2hKura2bERESUufbvB7p2BR4/BmxtZa8wjoxPZJIMToSOHTuWGXEQEWWNLVuAdu1k4+jy5YH164EyZZSOiogUkqZEaNu2bWjevDksLCywbdu2VLf9+OOPjRIYEVGm+PBDoFQpoF49YP58wMZG6YiISEFpSoRat26NsLAwuLm5oXXr1ilup1KpoFarjRUbEZFxnDole4WZmQH29nJsICcnpaMiomwgTb3GNBoN3NzcdP+ndGMSRETZSkICMHYsUKOGnDNMi0kQEf2fwd3nV69ejdjY2CTr4+LisHr1aqMERUSUYffuAQ0bAjNmyGWOfk9EyTA4EerVqxciIiKSrH/16hV69epllKCIiDJkxw45IvSxY3J+sA0b2DWeiJJlcCIkhIAqmTl37t+/DycWNxORkuLigJEjgY8+Ap4/B6pVkwMltm+vdGRElE2luft8lSpVoFKpoFKp0KRJE+TJk7irWq1GSEgImjVrlilBEhGlydWrwPffy/+HDQNmzpSzxxMRpSDNiZC2t1hwcDD8/f1hb2+vu8/S0hI+Pj5o166d0QMkIkqzSpWABQsANzcglR6uRERaaU6EgoKCAAA+Pj4ICAiAtbV1pgVFRJQmsbHAuHFA9+6Js8T3769oSESUsxg8snRgYGBmxEFEZJjbt4GAAODMGWD7duDSJcDCQumoiCiHSVMilDdvXty4cQOurq5wcXFJtrG01vPnz40WHBFRsjZsAPr2BSIjgbx55RhBTIKIKB3SlAjNnTsXDg4Ouv9TS4SIiDJNTAwwYoScJBUA6tQBfv8d8PJSNi4iyrHSlAi9XR3Ws2fPzIqFiChl4eFA06ZAcLBcHjsW+PprII/BNfxERDoGjyN09uxZXLx4Ube8detWtG7dGuPGjUNcXJxRgyMi0smbF3B1BfLnB3bvBqZNYxJERBlmcCL06aef4saNGwCAO3fuICAgALa2ttiwYQO+/PJLowdIRCbszRsgOlr+b24OrFkjS4T8/RUNi4hyD4MToRs3bqDy/7upbtiwAQ0aNMBvv/2GlStXYtOmTcaOj4hM1dWrQM2awOefJ65zcwMKFlQsJCLKfdI1xYZGowEA7Nu3Dy1atAAAeHl54enTp8aNjohM06pVcnqMS5eArVtl+yAiokxgcCJUrVo1fPPNN/jll19w6NAhtGzZEgAQEhKCAgUKGD1AIjIhr18DPXvK25s3QJMmsiosf36FAyOi3MrgRGjevHk4e/YsBg8ejK+++grFixcHAGzcuBG1a9c2eoBEZCIuXQKqV5elQWZmwJQpwJ49gLu70pERUS5mcJeLihUr6vUa05o1axbMzc2NEhQRmZi4OKB5c+D+fdkG6LffgAYNlI6KiExAuvuenjlzBlevXgUAlC1bFlWrVjVaUERkYiwtgUWLgIULZYkQq8KIKIsYnAg9efIEAQEBOHToEJydnQEAL1++RKNGjbB27Vrk5wcYEaXF+fPAkyfAhx/K5ZYtgRYtAI5cT0RZyOA2QkOGDEFUVBQuX76M58+f4/nz57h06RIiIyMxdOjQzIiRiHITIWTpT82actLUu3cT72MSRERZzOASod27d2Pfvn0oU6aMbl3ZsmWxcOFCNG3a1KjBEVEuExEB9O8PrF8vlz/8ELCzUzYmIjJpBpcIaTQaWCQzy7OFhYVufCEioiTOnAGqVpVJUJ48wOzZwLZtQL58SkdGRCbM4ESocePGGDZsGB4+fKhb9+DBAwwfPhxNmjQxanBElEv88ANQuzZw5w7g7Q0cPSpnkWdVGBEpzOBEaMGCBYiMjISPjw+KFSuGYsWKoUiRIoiMjMQPP/yQGTESUU53+bLsIt+6NXDunGwfRESUDRjcRsjLywtnz57F/v37dd3ny5QpAz8/P6MHR0Q5mBCJJT5z58oSoe7dWQpERNmKQYnQunXrsG3bNsTFxaFJkyYYMmRIZsVFRDmVEDLx2bsX2L5dzhpvYwP06KF0ZERESaQ5Efrpp58waNAglChRAjY2Nti8eTNu376NWbNmZWZ8RJSTPHsm5wnbvl0ub94MdOigaEhERKlJcxuhBQsWICgoCNevX0dwcDBWrVqFH3/8MTNjI6Kc5J9/gCpVZBJkZQX89BPQvr3SURERpSrNidCdO3cQGBioW+7SpQsSEhLw6NGjTAmMiHIIjQaYOROoXx+4dw8oUQI4cQIYMIDtgYgo20tzIhQbGwu7twY+MzMzg6WlJaKjozMlMCLKIYYOBcaMAdRqoEsXOV5Q5cpKR0VElCYGNZaeMGECbG1tdctxcXGYOnUqnJycdOvmzJljvOiIKPvr3x/4/Xfg22+B3r1ZCkREOUqaE6H69evj+vXreutq166NO3fu6JZV/AAkyv3UauD06cSxgCpWBEJDAQcHRcMiIkqPNCdCBw8ezMQwiChHePwY6NYNOHhQjg6tTYaYBBFRDmXwyNJEZKL+/huoVAnYtw+wtATu31c6IiKiDGMiRESpU6uBoCDAz0+WCJUvL6vG2rVTOjIiogwzeIoNIjIhDx8CXbvKqjAA6NsXmD8feKvTBBFRTsZEiIhStnmzTILs7YGff5bd44mIcpFsUTW2cOFC+Pj4wNraGjVr1sTJkyfTtN/atWuhUqnQunXrzA2QyFQNGgSMHCnHBmISRES5ULoSoSNHjqBbt26oVasWHjx4AAD45ZdfcPToUYOPtW7dOowYMQJBQUE4e/YsKlWqBH9/fzx58iTV/UJDQzFy5EjUq1cvPQ+BiJJz/76cK+zVK7msUgGzZgElSyoaFhFRZjE4Edq0aRP8/f1hY2ODc+fOITY2FgAQERGBadOmGRzAnDlz0K9fP/Tq1Qtly5bFokWLYGtri+XLl6e4j1qtRteuXTF58mQULVrU4HMSUTJ27JAjQq9aBXzxhdLREBFlCYMToW+++QaLFi3CkiVLYGFhoVtfp04dnD171qBjxcXF4cyZM/Dz80sMyMwMfn5+OH78eIr7ff3113Bzc0OfPn3ee47Y2FhERkbq3YjoLfHxwKhRwEcfydnjfX2B0aOVjoqIKEsYnAhdv34d9evXT7LeyckJL1++NOhYT58+hVqtRoECBfTWFyhQAGFhYcnuc/ToUSxbtgxLlixJ0zmmT58OJycn3c3Ly8ugGIlytf/+k5OlfvedXB46FDh2DChWTNm4iIiyiMGJkLu7O27dupVk/dGjRzO9murVq1fo3r07lixZAldX1zTtM3bsWEREROhu9+7dy9QYiXKMI0dkVdiJE4CzM7Bli+wab2WldGRERFnG4O7z/fr1w7Bhw7B8+XKoVCo8fPgQx48fx8iRIzFhwgSDjuXq6gpzc3M8fvxYb/3jx4/h7u6eZPvbt28jNDQUrVq10q3TaDTygeTJg+vXr6PYO79kraysYMUPdqKkSpSQSU/NmsDatYCPj9IRERFlOYMToTFjxkCj0aBJkyZ48+YN6tevDysrK4wcORJDhgwx6FiWlpbw9fXF/v37dV3gNRoN9u/fj8GDByfZvnTp0rh48aLeuvHjx+PVq1eYP38+q72I3ufZMyBfPvm/u7scI6hoUTllBhGRCTI4EVKpVPjqq68watQo3Lp1C1FRUShbtizs7e3TFcCIESMQGBiIatWqoUaNGpg3bx5ev36NXr16AQB69OgBT09PTJ8+HdbW1ihfvrze/s7OzgCQZD0RvWPjRqBPH2DxYiAgQK4rXVrZmIiIFJbukaUtLS1RtmzZDAcQEBCA8PBwTJw4EWFhYahcuTJ2796ta0B99+5dmJlli3EfiXKmmBjZHf7HH+XyqlVAx45yjCAiIhOnEkIIQ3Zo1KgRVKl8gP79998ZDiozRUZGwsnJCZMnR2DiREelwyHKXDdvyqQnOFgujxkDfP018NbQF0REOYH2+zsiIgKOjsb7/ja4RKhy5cp6y/Hx8QgODsalS5cQGBhorLiIKKN+/x3o3x+IigJcXYFffgGaNVM6KiKibMXgRGju3LnJrp80aRKioqIyHBARGcGFC4lzg9WvD/z2G+DpqWxMRETZkNEa33Tr1i3VaTGIKAtVrCgnS50wAdi/n0kQEVEK0t1Y+l3Hjx+HtbW1sQ5HRIZaswaoVw8oXFguf/stG0QTEb2HwYlQ27Zt9ZaFEHj06BFOnz5t8ICKRGQEr18DQ4YAK1YAtWvLsYEsLJgEERGlgcGJkJOTk96ymZkZSpUqha+//hpNmzY1WmBElAaXL8teYVeuAGZmgL+//EtERGliUCKkVqvRq1cvVKhQAS4uLpkVExG9jxCyBGjwYCA6GvDwkA2iGzZUOjIiohzFoJ+O5ubmaNq0qcGzzBOREb1+DfToIUeJjo6WpUDBwUyCiIjSweAy9PLly+POnTuZEQsRpYWZmeweb24OTJ8O7NwJuLkpHRURUY5kcBuhb775BiNHjsSUKVPg6+sLOzs7vfuNOdojEf2fEPJmZgbY2ADr1wPh4UDdukpHRkSUo6U5Efr666/xxRdfoEWLFgCAjz/+WG+qDSEEVCoV1Gq18aMkMmUREXKE6AoVgPHj5bpSpeSNiIgyJM2J0OTJkzFgwAAcOHAgM+MhoredOSNnir99G9i2TbYL8vBQOioiolwjzYmQdm7WBg0aZFowRPR/QgALFsjRoePiAG9vYO1aJkFEREZmUBuh1GadJyIjeflSlvxs3iyXW7cGli8HOGQFEZHRGZQIlSxZ8r3J0PPnzzMUEJFJS0iQo0NfvSpHh/7uOzlqNH+EEBFlCoMSocmTJycZWZqIjChPHmDYMDlP2Lp1QLVqSkdERJSrGZQIderUCW4cr4TIuJ4/Bx49AsqVk8v9+wPdugHvDE1BRETGl+YBFdk+iCgT/PMPULky8NFHsm0QIKvBmAQREWWJNCdC2l5jRGQEGg0wcyZQvz5w755sD/TkidJRERGZnDRXjWk0msyMg8h0hIcDgYHArl1yuXNn4OefAQcHZeMiIjJBBk+xQUQZcPiwTHwePgSsrYEffpBd5Vn1TESkCCZCRFlpzhyZBJUuLecLq1BB6YiIiEwaEyGirLRsGVC0KPD114C9vdLREBGZvDQ3liaidPj7b+CLL+SUGQCQL58sFWISRESULbBEiCgzqNWy1GfKFJkE1awJdOyodFRERPQOJkJExvbwIdC1K3DwoFzu00eOE0RERNkOEyEiY/rrLzkqdHi4HBTx559lUkRERNkS2wgRGcusWUCzZjIJqlQJOHuWSRARUTbHRIjIWKpUkX8/+ww4cQIoWVLZeIiI6L1YNUaUEU+eANqJiP38gIsXEydPJSKibI8lQkTpER8PjBolS31u305czySIiChHYSJEZKj//gPq1QO++w6IiAD+/FPpiIiIKJ1Mtmrs1SulI6Ac6Y8/gF69gJcvAScnYPlyoG1bpaMiIqJ0MtkSoUqVlI6AcpS4OODzz4E2bWQSVKMGcO4ckyAiohzOZBMhIoMsWADMny//HzECOHIEKFJE2ZiIiCjDTLZqjMgggwcDe/cCAwcCrVopHQ0RERkJS4SIkhMTIydHjY+Xy5aWwK5dTIKIiHIZlggRvevmTSAgQLYBCg8Hpk9XOiIiIsokLBEietvatUDVqjIJcnUF6tdXOiIiIspETISIACA6Gvj0U6BzZyAqSo4TFBwMNG+udGRERJSJmAgR3bgB1KwJLF4MqFTA+PHA338Dnp5KR0ZERJmMbYSINBrgzh05Z9iaNXLOMCIiMglMhMg0aTSA2f8LREuXBjZvBipUADw8lI2LiIiyFKvGyPRcvgxUrgwcPpy4rmlTJkFERCaIiRCZDiGAZcuA6tWBixeBL76Q64iIyGQxESLT8OoV0L070Lev7CHWtCmwY4dsHE1ERCaLiRDlfufPA9WqyYbQ5ubAtGlylGg3N6UjIyIihbGxNOVuV6/KrvGxsbI7/Nq1QN26SkdFRETZBBMhyt1KlwY+/hh4/RpYtUqOFk1ERPR/TIQo9zl3DihSBHB2lm2AVq0CrKwSu8sTERH9H78ZKPcQAliwAPjgA9koWtsjzMaGSRARESWLJUKUO7x8CfTpIwdGBICEBCAmRiZBREREKeDPZMr5Tp4EqlSRSZCFBTBvHrBlC5MgIiJ6LyZClHMJAcydK3uBhYbKdkHHjgHDhnF8ICIiShMmQpRzRUQAc+YA8fFAu3bA2bNy1GgiIqI0YhshyrmcnYHff5cDJg4cyFIgIiIyGBMhyjk0GuC77wB3d6BHD7mubl0OkEhEROnGRIhyhvBwIDBQTo1haws0agR4eSkdFRER5XBMhCj7O3IE6NQJePgQsLaWvcIKFVI6KiIiygXYWJqyL40GmDoVaNhQJkGlSgH//gv068f2QEREZBQsEaLsSa0GWrYE9uyRy927Az/+CNjbKxsXERHlKiwRouzJ3ByoVk22B1qxAli9mkkQEREZHRMhyj7UatkoWmvSJCA4GOjZU6GAiIgot8sWidDChQvh4+MDa2tr1KxZEydPnkxx2yVLlqBevXpwcXGBi4sL/Pz8Ut2ecohHj4APPwSaNwdiY+W6PHmAEiWUjYuIiHI1xROhdevWYcSIEQgKCsLZs2dRqVIl+Pv748mTJ8luf/DgQXTu3BkHDhzA8ePH4eXlhaZNm+LBgwdZHDkZzV9/AZUqAQcOANeuyQESiYiIsoBKCCGUDKBmzZqoXr06FixYAADQaDTw8vLCkCFDMGbMmPfur1ar4eLiggULFqCHdpC9VERGRsLJyQm//BKBbt0cMxw/ZUBCAhAUBEyfLucNq1gRWL9e9g4jIiJ6i/b7OyIiAo6Oxvv+VrREKC4uDmfOnIGfn59unZmZGfz8/HD8+PE0HePNmzeIj49H3rx5k70/NjYWkZGRejfKBu7fBxo3BqZNk0nQp58CJ04wCSIioiylaCL09OlTqNVqFChQQG99gQIFEBYWlqZjjB49GgULFtRLpt42ffp0ODk56W5eHI04e+jXTw6U6OAArF0LLFoE2NgoHRUREZkYxdsIZcSMGTOwdu1abNmyBdbW1sluM3bsWEREROhu9+7dy+IoKVkLF8ppMs6eBQIClI6GiIhMlKIDKrq6usLc3ByPHz/WW//48WO4u7unuu93332HGTNmYN++fahYsWKK21lZWcHKysoo8VIG3L0rG0X37SuXixYF/v5b2ZiIiMjkKVoiZGlpCV9fX+zfv1+3TqPRYP/+/ahVq1aK+3377beYMmUKdu/ejWrVqmVFqJQR27YBlSsD/fvLZIiIiCibUHyKjREjRiAwMBDVqlVDjRo1MG/ePLx+/Rq9evUCAPTo0QOenp6YPn06AGDmzJmYOHEifvvtN/j4+OjaEtnb28OeIw9nL3FxwOjRcpJUAKheneMCERFRtqJ4IhQQEIDw8HBMnDgRYWFhqFy5Mnbv3q1rQH337l2YmSUWXP3000+Ii4tD+/bt9Y4TFBSESZMmZWXolJqQENn259QpuTx8ODBjBmBpqWxcREREb1F8HKGsxnGEssAff8hpMSIiABcXYOVK4OOPFQ6KiIhysswaR0jxEiHKhSIjZRJUq5bsGl+4sNIRERERJYuJEBmHWi1njAeAHj0Aa2ugTRvAwkLZuIiIiFKRo8cRomxi7VqgQgXg6dPEdR07MgkiIqJsj4kQpV90tJwao3Nn4OpVYM4cpSMiIiIyCKvGKH2uXZOlPhcvAioVMG4cwF57RESUwzARIsP98gvw2WfA69eAmxvw66/Ahx8qHRUREZHBmAiRYX7+GRgwQP7fqBGwZg3g4aFsTEREROnENkJkmE6dgOLFZTXY3r1MgoiIKEdjiRClTgg5OWrjxrItkJMTcOECYGOjdGREREQZxhIhSllUFBAYCPj5AYsWJa5nEkRERLkES4QoeRcuyF5h168DZmayYTQREVEuw0SI9AkBLF4MDBsGxMYCnp7A778D9eopHRkREZHRMRGiRJGRQP/+wLp1crl5c2D1asDVVdm4iIiIMgnbCFGiS5eADRvknGHffgts384kiIiIcjWWCFGi2rWBBQuAypXlzPFERES5HEuETNnLl0D37nKeMK3PPmMSREREJoMlQqbq1CkgIAAICQGuXAFOn5bjBBEREZkQlgiZGiGAefOAOnVkEuTjI8cIYhJEREQmiCVCpuT5c6BXL2DbNrncti2wbBng7KxoWEREREphImQqQkKAhg2Bu3cBS0tgzhxg4ECWBBERkUljImQqvLyAwoUBCwtg/XqgalWlIyIiIlIcE6Hc7NkzwMFBlgDlySPHCLK1BRwdlY6MiIgoW2Bj6dzqyBGgUiVg9OjEde7uTIKIiIjewkQot9FogGnTgEaNgAcPgN27OWEqERFRCpgI5SZPngDNmgFffQWo1UC3bnK8IDs7pSMjIiLKlthGKLc4cADo0gUICwNsbICFC4GePdkrjIiIKBVMhHKDyEigXTvgxQugbFnZK6xcOaWjIiIiyvaYCOUGjo7Azz8Du3YBP/zAqjAiIqI0YiKUU+3bB5iZAY0by+UOHeSNiIiI0oyNpXOahARg/HigaVOgc2fg0SOlIyIiIsqxWCKUkzx4IJOfI0fkcuvWnCeMiIgoA5gI5RS7dgE9egBPnwL29sCSJUCnTkpHRURElKOxaiy702jk6NAtWsgkqEoV4OxZJkFERERGwEQouzMzk2MDAcCgQcA//wAlSigbExERUS7BqrHsKiFBTpQKyMERO3QAPvpI2ZiIiDKZWq1GfHy80mGQQiwsLGBubp6l52QilN3ExQFjxgC3bgFbt8qRoe3tmQQRUa4XFRWF+/fvQwihdCikEJVKhUKFCsHe3j7LzslEKDsJCQECAuT8YABw8KCcPJWIKJdTq9W4f/8+bG1tkT9/fqg4PZDJEUIgPDwc9+/fR4kSJbKsZIiJUHaxeTPQuzcQESG7xK9cySSIiExGfHw8hBDInz8/bGxslA6HFJI/f36EhoYiPj4+yxIhNpZWWmwsMGSInCssIgL44AMgOBj45BOlIyMiynIsCTJtSlx/JkJK69oVWLBA/j9qFHD4MODtrWxMREREJoKJkNJGjwY8PIDt24FvvwUsLJSOiIiIyGQwEcpq0dHAoUOJy9WrA3fuAC1bKhcTERFlyPHjx2Fubo6WyXyWHzx4ECqVCi9fvkxyn4+PD+bNm6e37sCBA2jRogXy5csHW1tblC1bFl988QUePHiQSdEDMTExGDRoEPLlywd7e3u0a9cOjx8/TnWfx48fo2fPnihYsCBsbW3RrFkz3Lx5U2+bsLAwdO/eHe7u7rCzs0PVqlWxadOmTHsc6cFEKCtdvy7bAPn7y3ZAWtbWioVEREQZt2zZMgwZMgSHDx/Gw4cP032cn3/+GX5+fnB3d8emTZtw5coVLFq0CBEREZg9e7YRI9Y3fPhw/Pnnn9iwYQMOHTqEhw8fom3btiluL4RA69atcefOHWzduhXnzp2Dt7c3/Pz88Pr1a912PXr0wPXr17Ft2zZcvHgRbdu2RceOHXHu3LlMeywGEyYmIiJCABC//BKRtSf+9Vch7OyEAITIn1+IAwey9vxERNlYdHS0uHLlioiOjlY6FIO9evVK2Nvbi2vXromAgAAxdepUvfsPHDggAIgXL14k2dfb21vMnTtXCCHEvXv3hKWlpfj888+TPU9y+xvDy5cvhYWFhdiwYYNu3dWrVwUAcfz48WT3uX79ugAgLl26pFunVqtF/vz5xZIlS3Tr7OzsxOrVq/X2zZs3r942b0vtdaD9/o6IMO73N0uEMtubN0DfvkC3bsDr10DDhrI0qGFDhQMjIsq+hJAfmUrcDB3Pcf369ShdujRKlSqFbt26Yfny5ekaFHLDhg2Ii4vDl19+mez9zs7OKe7bvHlz2Nvbp3grV65civueOXMG8fHx8PPz060rXbo0ChcujOPHjye7T2xsLADA+q0aDTMzM1hZWeHo0aO6dbVr18a6devw/PlzaDQarF27FjExMWiYjb4DOY5QZrpyBejYEbh8WY4QPXEiMGECkMXDhxMR5TRv3shB9ZUQFQXY2aV9+2XLlqFbt24AgGbNmiEiIgKHDh0y+Mv+5s2bcHR0hIeHh0H7AcDSpUsRHR2d4v0WqXTECQsLg6WlZZJEq0CBAgjTznX5Dm2iNHbsWPz888+ws7PD3Llzcf/+fTx69Ei33fr16xEQEIB8+fIhT548sLW1xZYtW1C8eHHDHmAmYiKUmbZulUmQuzuwZg3QuLHSERERkRFdv34dJ0+exJYtWwAAefLkQUBAAJYtW2ZwIiSESPc4Op6enunaL70sLCywefNm9OnTB3nz5oW5uTn8/PzQvHlzvdKwCRMm4OXLl9i3bx9cXV3xxx9/oGPHjjhy5AgqVKiQpTGnhIlQZvryS1nOOmQIUKCA0tEQEeUYtrayZEapc6fVsmXLkJCQgIIFC+rWCSFgZWWFBQsWwMnJCY6OjgCAiIiIJKUuL1++hJOTEwCgZMmSiIiIwKNHjwwuFWrevDmOHDmS4v3e3t64fPlysve5u7sjLi4OL1++1Ivv8ePHcHd3T/GYvr6+CA4ORkREBOLi4pA/f37UrFkT1apVAwDcvn0bCxYswKVLl3RVc5UqVcKRI0ewcOFCLFq0yKDHmFmYCBnTxYvA118Dq1cDNjayCuybb5SOiogox1GpDKueUkJCQgJWr16N2bNno2nTpnr3tW7dGr///jsGDBiAEiVKwMzMDGfOnIH3WwPm3rlzBxEREShZsiQAoH379hgzZgy+/fZbzJ07N8n53k1U3paRqjFfX19YWFhg//79aNeuHQBZ0nX37l3UqlUrxf20tInczZs3cfr0aUyZMgUA8ObNGwCy7dDbzM3NodFo3nvcLGPUptc5QKb0GtNohFi8WAhra9kr7MsvjXdsIiITkBN7jW3ZskVYWlqKly9fJrnvyy+/FNWqVdMt9+/fX/j4+IitW7eKO3fuiEOHDokPPvhAfPDBB0Kj0ei2W7hwoVCpVKJ3797i4MGDIjQ0VBw9elT0799fjBgxItMey4ABA0ThwoXF33//LU6fPi1q1aolatWqpbdNqVKlxObNm3XL69evFwcOHBC3b98Wf/zxh/D29hZt27bV3R8XFyeKFy8u6tWrJ/79919x69Yt8d133wmVSiV27NiRbBxK9BpjIpTxAwrRqZNMgAAhmjUT4skT4xybiMhE5MRE6KOPPhItWrRI9r5///1XABDnz58XQsjHFxQUJEqXLi1sbGxEkSJFRP/+/UV4eHiSfffu3Sv8/f2Fi4uLsLa2FqVLlxYjR44UDx8+zLTHEh0dLQYOHChcXFyEra2taNOmjXj06JHeNgDEihUrdMvz588XhQoVEhYWFqJw4cJi/PjxIjY2Vm+fGzduiLZt2wo3Nzdha2srKlasmKQ7/btxZHUipBIiHX38crDIyEg4OTnhl18i0K2bY8YOdu6c7BV265asBps2DRg5EjDjqARERIaIiYlBSEgIihQpotclm0xLaq8D7fd3RESErt2VMbCNUHpt2QJ06gTExQFeXsDatUDt2kpHRURERAZgIpRe1arJQS7q1AFWrADy5VM6IiIiIjIQEyFDPHgAaMdq8PICTp4EihaV3RuIiIgox2FjlrQQApg/XyY927Ylri9WjEkQERFRDsZE6H2ePwfatAE+/1y2B3o7ESIiIqIcjYlQak6cAKpUkVNlWFoCP/wALFmidFRERLmWiXVkpncocf2ZCCVHowG++w6oVw+4e1dWgf3zDzB4MKvCiIgygfn/J6OOi4tTOBJSkvb6m2fh5ORsLJ2cw4eBUaPk/x07ylIgI45ZQERE+rQzk4eHh8PCwiLJtAyU+2k0GoSHh8PW1hZ58mRdesJEKDkNGwLDhgGlSwOffspSICKiTKZSqeDh4YGQkBD8999/SodDCjEzM0PhwoWhysLvXSZCgKwKmz8f6NwZ0M60O2+eoiEREZkaS0tLlChRgtVjJszS0jLLSwOzRSK0cOFCzJo1C2FhYahUqRJ++OEH1KhRI8XtN2zYgAkTJiA0NBQlSpTAzJkz0aJFi/Sd/MkToHt34K+/gO3bgb17OUUGEZFCzMzMOMUGZSnFv/HXrVuHESNGICgoCGfPnkWlSpXg7++PJ0+eJLv9P//8g86dO6NPnz44d+4cWrdujdatW+PSpUuGn/zgQaByZZkE2dgAXbuyGoyIiMiEKD7pas2aNVG9enUsWLAAgGws5eXlhSFDhmDMmDFJtg8ICMDr16+xfft23boPPvgAlStXxqJFi957Pu2kbf+2HYsaf8yU1WJlygDr1wPlyxvvgREREZHRZNakq4qWCMXFxeHMmTPw8/PTrTMzM4Ofnx+OHz+e7D7Hjx/X2x4A/P39U9w+JaU3T5dJUK9ewKlTTIKIiIhMkKJthJ4+fQq1Wo0CBQrorS9QoACuXbuW7D5hYWHJbh8WFpbs9rGxsYiNjdUtR0REAACeW1gDC+bLGeTVaiAyMiMPhYiIiDJR5P+/p41dkZUtGktnpunTp2Py5MlJ1heJj5Fd4z/9VIGoiIiIKD2ePXsGJycnox1P0UTI1dUV5ubmePz4sd76x48fw13bjf0d7u7uBm0/duxYjBgxQrf88uVLeHt74+7du0Z9IslwkZGR8PLywr1794xa30vpw+uRffBaZB+8FtlHREQEChcujLx58xr1uIomQpaWlvD19cX+/fvRunVrALKx9P79+zF48OBk96lVqxb279+Pzz//XLdu7969qFWrVrLbW1lZwcrKKsl6JycnvqizCUdHR16LbITXI/vgtcg+eC2yD2OPM6R41diIESMQGBiIatWqoUaNGpg3bx5ev36NXr16AQB69OgBT09PTJ8+HQAwbNgwNGjQALNnz0bLli2xdu1anD59GosXL1byYRAREVEOpHgiFBAQgPDwcEycOBFhYWGoXLkydu/erWsQfffuXb3sr3bt2vjtt98wfvx4jBs3DiVKlMAff/yB8uz1RURERAZSPBECgMGDB6dYFXbw4MEk6zp06IAOHTqk61xWVlYICgpKtrqMshavRfbC65F98FpkH7wW2UdmXQvFB1QkIiIiUoriU2wQERERKYWJEBEREZksJkJERERkspgIERERkcnKlYnQwoUL4ePjA2tra9SsWRMnT55MdfsNGzagdOnSsLa2RoUKFbBz584sijT3M+RaLFmyBPXq1YOLiwtcXFzg5+f33mtHhjH0vaG1du1aqFQq3cCnlHGGXouXL19i0KBB8PDwgJWVFUqWLMnPKiMx9FrMmzcPpUqVgo2NDby8vDB8+HDExMRkUbS51+HDh9GqVSsULFgQKpUKf/zxx3v3OXjwIKpWrQorKysUL14cK1euNPzEIpdZu3atsLS0FMuXLxeXL18W/fr1E87OzuLx48fJbn/s2DFhbm4uvv32W3HlyhUxfvx4YWFhIS5evJjFkec+hl6LLl26iIULF4pz586Jq1evip49ewonJydx//79LI48dzL0emiFhIQIT09PUa9ePfHJJ59kTbC5nKHXIjY2VlSrVk20aNFCHD16VISEhIiDBw+K4ODgLI489zH0WqxZs0ZYWVmJNWvWiJCQELFnzx7h4eEhhg8fnsWR5z47d+4UX331ldi8ebMAILZs2ZLq9nfu3BG2trZixIgR4sqVK+KHH34Q5ubmYvfu3QadN9clQjVq1BCDBg3SLavValGwYEExffr0ZLfv2LGjaNmypd66mjVrik8//TRT4zQFhl6LdyUkJAgHBwexatWqzArRpKTneiQkJIjatWuLpUuXisDAQCZCRmLotfjpp59E0aJFRVxcXFaFaDIMvRaDBg0SjRs31ls3YsQIUadOnUyN09SkJRH68ssvRbly5fTWBQQECH9/f4POlauqxuLi4nDmzBn4+fnp1pmZmcHPzw/Hjx9Pdp/jx4/rbQ8A/v7+KW5PaZOea/GuN2/eID4+3ugT7Jmi9F6Pr7/+Gm5ubujTp09WhGkS0nMttm3bhlq1amHQoEEoUKAAypcvj2nTpkGtVmdV2LlSeq5F7dq1cebMGV312Z07d7Bz5060aNEiS2KmRMb6/s4WI0sby9OnT6FWq3XTc2gVKFAA165dS3afsLCwZLcPCwvLtDhNQXquxbtGjx6NggULJnmhk+HScz2OHj2KZcuWITg4OAsiNB3puRZ37tzB33//ja5du2Lnzp24desWBg4ciPj4eAQFBWVF2LlSeq5Fly5d8PTpU9StWxdCCCQkJGDAgAEYN25cVoRMb0np+zsyMhLR0dGwsbFJ03FyVYkQ5R4zZszA2rVrsWXLFlhbWysdjsl59eoVunfvjiVLlsDV1VXpcEyeRqOBm5sbFi9eDF9fXwQEBOCrr77CokWLlA7N5Bw8eBDTpk3Djz/+iLNnz2Lz5s3YsWMHpkyZonRolE65qkTI1dUV5ubmePz4sd76x48fw93dPdl93N3dDdqe0iY910Lru+++w4wZM7Bv3z5UrFgxM8M0GYZej9u3byM0NBStWrXSrdNoNACAPHny4Pr16yhWrFjmBp1Lpee94eHhAQsLC5ibm+vWlSlTBmFhYYiLi4OlpWWmxpxbpedaTJgwAd27d0ffvn0BABUqVMDr16/Rv39/fPXVV3qThFPmSun729HRMc2lQUAuKxGytLSEr68v9u/fr1un0Wiwf/9+1KpVK9l9atWqpbc9AOzduzfF7Slt0nMtAODbb7/FlClTsHv3blSrVi0rQjUJhl6P0qVL4+LFiwgODtbdPv74YzRq1AjBwcHw8vLKyvBzlfS8N+rUqYNbt27pklEAuHHjBjw8PJgEZUB6rsWbN2+SJDvaBFVw6s4sZbTvb8PacWd/a9euFVZWVmLlypXiypUron///sLZ2VmEhYUJIYTo3r27GDNmjG77Y8eOiTx58ojvvvtOXL16VQQFBbH7vJEYei1mzJghLC0txcaNG8WjR490t1evXin1EHIVQ6/Hu9hrzHgMvRZ3794VDg4OYvDgweL69eti+/btws3NTXzzzTdKPYRcw9BrERQUJBwcHMTvv/8u7ty5I/766y9RrFgx0bFjR6UeQq7x6tUrce7cOXHu3DkBQMyZM0ecO3dO/Pfff0IIIcaMGSO6d++u217bfX7UqFHi6tWrYuHChew+r/XDDz+IwoULC0tLS1GjRg1x4sQJ3X0NGjQQgYGBetuvX79elCxZUlhaWopy5cqJHTt2ZHHEuZch18Lb21sASHILCgrK+sBzKUPfG29jImRchl6Lf/75R9SsWVNYWVmJokWLiqlTp4qEhIQsjjp3MuRaxMfHi0mTJolixYoJa2tr4eXlJQYOHChevHiR9YHnMgcOHEj2O0D7/AcGBooGDRok2ady5crC0tJSFC1aVKxYscLg86qEYFkeERERmaZc1UaIiIiIyBBMhIiIiMhkMREiIiIik8VEiIiIiEwWEyEiIiIyWUyEiIiIyGQxESIiIiKTxUSIiPSsXLkSzs7OSoeRbiqVCn/88Ueq2/Ts2ROtW7fOkniIKHtjIkSUC/Xs2RMqlSrJ7datW0qHhpUrV+riMTMzQ6FChdCrVy88efLEKMd/9OgRmjdvDgAIDQ2FSqVCcHCw3jbz58/HypUrjXK+lEyaNEn3OM3NzeHl5YX+/fvj+fPnBh2HSRtR5spVs88TUaJmzZphxYoVeuvy58+vUDT6HB0dcf36dWg0Gpw/fx69evXCw4cPsWfPngwfO6VZw9/m5OSU4fOkRbly5bBv3z6o1WpcvXoVvXv3RkREBNatW5cl5yei92OJEFEuZWVlBXd3d72bubk55syZgwoVKsDOzg5eXl4YOHAgoqKiUjzO+fPn0ahRIzg4OMDR0RG+vr44ffq07v6jR4+iXr16sLGxgZeXF4YOHYrXr1+nGptKpYK7uzsKFiyI5s2bY+jQodi3bx+io6Oh0Wjw9ddfo1ChQrCyskLlypWxe/du3b5xcXEYPHgwPDw8YG1tDW9vb0yfPl3v2NqqsSJFigAAqlSpApVKhYYNGwLQL2VZvHgxChYsqDezOwB88skn6N27t25569atqFq1KqytrVG0aFFMnjwZCQkJqT7OPHnywN3dHZ6envDz80OHDh2wd+9e3f1qtRp9+vRBkSJFYGNjg1KlSmH+/Pm6+ydNmoRVq1Zh69atutKlgwcPAgDu3buHjh07wtnZGXnz5sUnn3yC0NDQVOMhoqSYCBGZGDMzM3z//fe4fPkyVq1ahb///htffvllitt37doVhQoVwqlTp3DmzBmMGTMGFhYWAIDbt2+jWbNmaNeuHS5cuIB169bh6NGjGDx4sEEx2djYQKPRICEhAfPnz8fs2bPx3Xff4cKFC/D398fHH3+MmzdvAgC+//57bNu2DevXr8f169exZs0a+Pj4JHvckydPAgD27duHR48eYfPmzUm26dChA549e4YDBw7o1j1//hy7d+9G165dAQBHjhxBjx49MGzYMFy5cgU///wzVq5cialTp6b5MYaGhmLPnj2wtLTUrdNoNChUqBA2bNiAK1euYOLEiRg3bhzWr18PABg5ciQ6duyIZs2a4dGjR3j06BFq166N+Ph4+Pv7w8HBAUeOHMGxY8dgb2+PZs2aIS4uLs0xERGQK2efJzJ1gYGBwtzcXNjZ2elu7du3T3bbDRs2iHz58umWV6xYIZycnHTLDg4OYuXKlcnu26dPH9G/f3+9dUeOHBFmZmYiOjo62X3ePf6NGzdEyZIlRbVq1YQQQhQsWFBMnTpVb5/q1auLgQMHCiGEGDJkiGjcuLHQaDTJHh+A2LJlixBCiJCQEAFAnDt3Tm+bwMBA8cknn+iWP/nkE9G7d2/d8s8//ywKFiwo1Gq1EEKIJk2aiGnTpukd45dffhEeHh7JxiCEEEFBQcLMzEzY2dkJa2tr3Uzac+bMSXEfIYQYNGiQaNeuXYqxas9dqlQpvecgNjZW2NjYiD179qR6fCLSxzZCRLlUo0aN8NNPP+mW7ezsAMjSkenTp+PatWuIjIxEQkICYmJi8ObNG9ja2iY5zogRI9C3b1/88ssvuuqdYsWKAZDVZhcuXMCaNWt02wshoNFoEBISgjJlyiQbW0REBOzt7aHRaBATE4O6deti6dKliIyMxMOHD1GnTh297evUqYPz588DkNVaH374IUqVKoVmzZrho48+QtOmTTP0XHXt2hX9+vXDjz/+CCsrK6xZswadOnWCmZmZ7nEeO3ZMrwRIrVan+rwBQKlSpbBt2zbExMTg119/RXBwMIYMGaK3zcKFC7F8+XLcvXsX0dHRiIuLQ+XKlVON9/z587h16xYcHBz01sfExOD27dvpeAaITBcTIaJcys7ODsWLF9dbFxoaio8++gifffYZpk6dirx58+Lo0aPo06cP4uLikv1CnzRpErp06YIdO3Zg165dCAoKwtq1a9GmTRtERUXh008/xdChQ5PsV7hw4RRjc3BwwNmzZ2FmZgYPDw/Y2NgAACIjI9/7uKpWrYqQkBDs2rUL+/btQ8eOHeHn54eNGze+d9+UtGrVCkII7NixA9WrV8eRI0cwd+5c3f1RUVGYPHky2rZtm2Rfa2vrFI9raWmpuwYzZsxAy5YtMXnyZEyZMgUAsHbtWowcORKzZ89GrVq14ODggFmzZuHff/9NNd6oqCj4+vrqJaBa2aVBPFFOwUSIyIScOXMGGo0Gs2fP1pV2aNujpKZkyZIoWbIkhg8fjs6dO2PFihVo06YNqlatiitXriRJuN7HzMws2X0cHR1RsGBBHDt2DA0aNNCtP3bsGGrUqKG3XUBAAAICAtC+fXs0a9YMz58/R968efWOp22Po1arU43H2toabdu2xZo1a3Dr1i2UKlUKVatW1d1ftWpVXL9+3eDH+a7x48ejcePG+Oyzz3SPs3bt2hg4cKBum3dLdCwtLZPEX7VqVaxbtw5ubm5wdHTMUExEpo6NpYlMSPHixREfH48ffvgBd+7cwS+//IJFixaluH10dDQGDx6MgwcP4r///sOxY8dw6tQpXZXX6NGj8c8//2Dw4MEIDg7GzZs3sXXrVoMbS79t1KhRmDlzJtatW4fr169jzJgxCA4OxrBhwwAAc+bMwe+//45r167hxo0b2LBhA9zd3ZMdBNLNzQ02NjbYvXs3Hj9+jIiIiBTP27VrV+zYsQPLly/XNZLWmjhxIlavXo3Jkyfj8uXLuHr1KtauXYvx48cb9Nhq1aqFihUrYtq0aQCAEiVK4PTp09izZw9u3LiBCRMm4NSpU3r7+Pj44MKFC7h+/TqePn2K+Ph4dO3aFa6urvjkk09w5MgRhISE4ODBgxg6dCju379vUExEJk/pRkpEZHzJNbDVmjNnjvDw8BA2NjbC399frF69WgAQL168EELoN2aOjY0VnTp1El5eXsLS0lIULFhQDB48WK8h9MmTJ8WHH34o7O3thZ2dnahYsWKSxs5ve7ex9LvUarWYNGmS8PT0FBYWFqJSpUpi165duvsXL14sKleuLOzs7ISjo6No0qSJOHv2rO5+vNVYWgghlixZIry8vISZmZlo0KBBis+PWq0WHh4eAoC4fft2krh2794tateuLWxsbISjo6OoUaOGWLx4cYqPIygoSFSqVCnJ+t9//11YWVmJu3fvipiYGNGzZ0/h5OQknJ2dxWeffSbGjBmjt9+TJ090zy8AceDAASGEEI8ePRI9evQQrq6uwsrKShQtWlT069dPREREpBgTESWlEkIIZVMxIiIiImWwaoyIiIhMFhMhIiIiMllMhIiIiMhkMREiIiIik8VEiIiIiEwWEyEiIiIyWUyEiIiIyGQxESIiIiKTxUSIiIiITBYTISIiIjJZTISIiIjIZDERIiIiIpP1P9DyrpE6bz15AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -420,82 +420,82 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 3 AUC: 0.9833291298913164\n", + "Overall, depth: 3 AUC: 0.9833291162703119\n", "doing digit 0 doing signature level 4\n", "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 1.5825400352478027\n", - "compute_auc_time: 6.715334177017212\n", + "fit_time: 1.4814271926879883\n", + "compute_auc_time: 6.84686803817749\n", "depth: 4 , Auc of digit: 0 is 0.9949666301993401\n", "doing digit 1 doing signature level 4\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.5532629489898682\n", - "compute_auc_time: 6.574487209320068\n", + "fit_time: 1.472062110900879\n", + "compute_auc_time: 6.747668981552124\n", "depth: 4 , Auc of digit: 1 is 0.9852398718065597\n", "doing digit 2 doing signature level 4\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.321923017501831\n", - "compute_auc_time: 6.628010988235474\n", + "fit_time: 1.555401086807251\n", + "compute_auc_time: 6.726560831069946\n", "depth: 4 , Auc of digit: 2 is 0.9894510403444672\n", "doing digit 3 doing signature level 4\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.2782950401306152\n", - "compute_auc_time: 6.687088966369629\n", + "fit_time: 1.5977261066436768\n", + "compute_auc_time: 6.752060890197754\n", "depth: 4 , Auc of digit: 3 is 0.9959752718291617\n", "doing digit 4 doing signature level 4\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.6324059963226318\n", - "compute_auc_time: 6.654690980911255\n", + "fit_time: 1.5598111152648926\n", + "compute_auc_time: 6.753681182861328\n", "depth: 4 , Auc of digit: 4 is 0.999876399924262\n", "doing digit 5 doing signature level 4\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.2856931686401367\n", - "compute_auc_time: 6.640314340591431\n", + "fit_time: 1.5049867630004883\n", + "compute_auc_time: 7.039808034896851\n", "depth: 4 , Auc of digit: 5 is 0.9878785018945739\n", "doing digit 6 doing signature level 4\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.3116629123687744\n", - "compute_auc_time: 6.632941007614136\n", + "fit_time: 1.3394172191619873\n", + "compute_auc_time: 6.674200057983398\n", "depth: 4 , Auc of digit: 6 is 0.9949408526851601\n", "doing digit 7 doing signature level 4\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.507436990737915\n", - "compute_auc_time: 6.618512868881226\n", + "fit_time: 1.553976058959961\n", + "compute_auc_time: 6.760324954986572\n", "depth: 4 , Auc of digit: 7 is 0.9857894976752666\n", "doing digit 8 doing signature level 4\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.292693853378296\n", - "compute_auc_time: 6.697542190551758\n", + "fit_time: 1.4829590320587158\n", + "compute_auc_time: 7.0328850746154785\n", "depth: 4 , Auc of digit: 8 is 0.998694504683594\n", "doing digit 9 doing signature level 4\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.368224859237671\n", - "compute_auc_time: 6.595253944396973\n", + "fit_time: 1.5755929946899414\n", + "compute_auc_time: 6.970922946929932\n", "depth: 4 , Auc of digit: 9 is 0.9442176063973977\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -507,82 +507,82 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 4 AUC: 0.9873373238881291\n", + "Overall, depth: 4 AUC: 0.9873373465898034\n", "doing digit 0 doing signature level 5\n", "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 1.6824851036071777\n", - "compute_auc_time: 9.371766090393066\n", + "fit_time: 1.8557980060577393\n", + "compute_auc_time: 15.691333770751953\n", "depth: 5 , Auc of digit: 0 is 0.9947574922781535\n", "doing digit 1 doing signature level 5\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.7435991764068604\n", - "compute_auc_time: 9.242139101028442\n", + "fit_time: 1.6090118885040283\n", + "compute_auc_time: 14.628620147705078\n", "depth: 5 , Auc of digit: 1 is 0.9900453726235474\n", "doing digit 2 doing signature level 5\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.6792869567871094\n", - "compute_auc_time: 9.047877073287964\n", + "fit_time: 2.0345211029052734\n", + "compute_auc_time: 11.240407943725586\n", "depth: 5 , Auc of digit: 2 is 0.9912226414300441\n", "doing digit 3 doing signature level 5\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.5338101387023926\n", - "compute_auc_time: 8.582865953445435\n", + "fit_time: 1.4860689640045166\n", + "compute_auc_time: 14.095582962036133\n", "depth: 5 , Auc of digit: 3 is 0.9964675386283546\n", "doing digit 4 doing signature level 5\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.6837000846862793\n", - "compute_auc_time: 9.270012140274048\n", - "depth: 5 , Auc of digit: 4 is 0.9999263659123263\n", + "fit_time: 1.7567501068115234\n", + "compute_auc_time: 14.24120306968689\n", + "depth: 5 , Auc of digit: 4 is 0.9999254893160445\n", "doing digit 5 doing signature level 5\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.7708702087402344\n", - "compute_auc_time: 8.772486925125122\n", + "fit_time: 1.5514466762542725\n", + "compute_auc_time: 10.272958993911743\n", "depth: 5 , Auc of digit: 5 is 0.9896433104789049\n", "doing digit 6 doing signature level 5\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.492610216140747\n", - "compute_auc_time: 9.380972862243652\n", + "fit_time: 1.588888168334961\n", + "compute_auc_time: 9.079653024673462\n", "depth: 5 , Auc of digit: 6 is 0.9954961823439054\n", "doing digit 7 doing signature level 5\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.7382721900939941\n", - "compute_auc_time: 9.786658763885498\n", + "fit_time: 1.7415499687194824\n", + "compute_auc_time: 9.925087928771973\n", "depth: 5 , Auc of digit: 7 is 0.9868265110766707\n", "doing digit 8 doing signature level 5\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.470499038696289\n", - "compute_auc_time: 8.815712928771973\n", + "fit_time: 1.5423738956451416\n", + "compute_auc_time: 9.317086935043335\n", "depth: 5 , Auc of digit: 8 is 0.9993119559651817\n", "doing digit 9 doing signature level 5\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.6470270156860352\n", - "compute_auc_time: 8.853724002838135\n", + "fit_time: 1.5196259021759033\n", + "compute_auc_time: 9.053930044174194\n", "depth: 5 , Auc of digit: 9 is 0.9467071774946538\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -594,9 +594,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Overall, depth: 5 AUC: 0.9887056900094\n", - "CPU times: user 11min 4s, sys: 4min 5s, total: 15min 10s\n", - "Wall time: 7min 26s\n" + "Overall, depth: 5 AUC: 0.9887056355253816\n", + "CPU times: user 14min 11s, sys: 3min 49s, total: 18min\n", + "Wall time: 8min\n" ] } ], @@ -666,7 +666,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{1: 0.9011941225982673, 2: 0.964656389818477, 3: 0.9833291298913164, 4: 0.9873373238881291, 5: 0.9887056900094}\n" + "{1: 0.9011941225982674, 2: 0.964656389818477, 3: 0.9833291162703119, 4: 0.9873373465898034, 5: 0.9887056355253816}\n" ] } ], @@ -686,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -696,7 +696,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "id": "a4675b42", "metadata": {}, "outputs": [ @@ -705,7 +705,7 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 2\n", - "fit_time: 1.8434288501739502\n" + "fit_time: 1.716937780380249\n" ] } ], @@ -742,7 +742,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 10, "id": "fa3d0039-5d50-4aa8-ac91-f76a83513315", "metadata": {}, "outputs": [ @@ -751,13 +751,13 @@ "text/plain": [ "array([0.02203349, 0.02636506, 0.01619603, 0.01555797, 0.11322956,\n", " 0.03182318, 0.02529738, 0.09760276, 0.01769069, 0.0184093 ,\n", - " 0.03047298, 0.01305365, 0.02557788, 0.07339483, 0.01822537,\n", + " 0.03047298, 0.01305365, 0.02557788, 0.07339484, 0.01822537,\n", " 0.07480418, 0.02407774, 0.17452867, 0.03732281, 0.10320762,\n", - " 0.01851509, 0.01398619, 0.01354817, 0.01247237, 0.02372335,\n", - " 0.01140402, 0.02230902, 0.04476067, 0.0622557 , 0.02477818])" + " 0.01851509, 0.01398619, 0.01354816, 0.01247237, 0.02372335,\n", + " 0.01140402, 0.02230901, 0.04476067, 0.0622557 , 0.02477818])" ] }, - "execution_count": 17, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -805,7 +805,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -847,7 +847,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -861,7 +861,7 @@ " 0.01140395, 0.02230897, 0.0447607 , 0.06225568, 0.02477822])" ] }, - "execution_count": 19, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -879,23 +879,23 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([-1.02955230e-07, 7.06101742e-08, -4.65146504e-08, -1.53675729e-08,\n", - " 8.36883754e-03, -7.65752497e-08, 5.45321150e-08, 6.58404715e-03,\n", - " -1.37017948e-08, -6.32657278e-08, -4.05939281e-08, 8.27130721e-08,\n", - " 4.21097337e-08, -1.14308784e-08, -1.15933769e-07, 3.02990479e-08,\n", - " 4.71664630e-08, 1.10103530e-02, -3.29369544e-08, 1.74788367e-02,\n", - " 3.79573153e-08, -1.22617305e-07, -1.03330218e-07, 2.92517347e-09,\n", - " 5.37633529e-08, -7.02766429e-08, -4.83415681e-08, 3.01917514e-08,\n", - " -1.84955282e-08, 4.06431382e-08])" + "array([-1.02698604e-07, 7.06201024e-08, -4.48023166e-08, -1.52162402e-08,\n", + " 8.36883323e-03, -7.46429760e-08, 5.43689659e-08, 6.58404394e-03,\n", + " -1.29966361e-08, -6.40953989e-08, -3.90337506e-08, 8.24570676e-08,\n", + " 4.13584945e-08, -1.25793449e-08, -1.17102862e-07, 2.81579632e-08,\n", + " 4.75885919e-08, 1.10103507e-02, -3.11002757e-08, 1.74788333e-02,\n", + " 3.86669326e-08, -1.21665173e-07, -1.00438225e-07, 3.97413871e-09,\n", + " 5.21471378e-08, -6.93480474e-08, -4.72183132e-08, 2.90194190e-08,\n", + " -2.10565009e-08, 4.07364884e-08])" ] }, - "execution_count": 20, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -906,23 +906,23 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([-4.53691477e-09, 3.72328764e-09, -1.50670353e-09, -4.78176286e-10,\n", - " 1.96523701e-03, -4.87373026e-09, 2.75904183e-09, 1.32859197e-03,\n", - " -4.84788199e-10, -2.32935153e-09, -2.47403422e-09, 2.15942222e-09,\n", - " 2.15415704e-09, -1.67793471e-09, -4.22585897e-09, 4.53299184e-09,\n", - " 2.27132622e-09, 3.96447245e-03, -2.45859857e-09, 3.91340789e-03,\n", - " 1.40556774e-09, -3.42988212e-09, -2.79985920e-09, 7.29676800e-11,\n", - " 2.55089683e-09, -1.60286712e-09, -2.15690321e-09, 2.70280676e-09,\n", - " -2.30290380e-09, 2.01412728e-09])" + "array([-4.52560604e-09, 3.72381116e-09, -1.45123750e-09, -4.73467427e-10,\n", + " 1.96523603e-03, -4.75074807e-09, 2.75078734e-09, 1.32859135e-03,\n", + " -4.59838713e-10, -2.35989886e-09, -2.37894771e-09, 2.15273864e-09,\n", + " 2.11572683e-09, -1.84651773e-09, -4.26847328e-09, 4.21266765e-09,\n", + " 2.29165403e-09, 3.96447167e-03, -2.32149854e-09, 3.91340718e-03,\n", + " 1.43184499e-09, -3.40324873e-09, -2.72149679e-09, 9.91338369e-11,\n", + " 2.47421274e-09, -1.58168768e-09, -2.10678580e-09, 2.59785800e-09,\n", + " -2.62177412e-09, 2.01875338e-09])" ] }, - "execution_count": 21, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -933,7 +933,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -947,7 +947,7 @@ " 0.00013005, 0.00049769, 0.00200352, 0.00387577, 0.00061396])" ] }, - "execution_count": 22, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -965,22 +965,22 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 16, "id": "7b24a162-ab61-42ec-92d0-31067441e1ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.67234355, 0.24378292, 0.12239675, 0.25943279, 0.24765937,\n", - " 0.1254194 , 0.21369962, 0.2074082 , 0.70915455, 0.71401428,\n", - " 0.23341584, 0.55010932, 0.183303 , 0.28309619, 0.24274553,\n", - " 0.27733141, 0.74215366, 0.43625736, 0.62571778, 0.26774459,\n", - " 0.22821209, 0.70655546, 0.45673412, 0.43718578, 0.09406633,\n", - " 0.17178055, 0.20218662, 0.50789135, 0.46324354, 0.28108907])" + "array([0.67234357, 0.24378294, 0.12239674, 0.2594328 , 0.24765937,\n", + " 0.12541939, 0.21369961, 0.20740823, 0.70915457, 0.71401431,\n", + " 0.23341582, 0.55010934, 0.18330298, 0.28309617, 0.24274554,\n", + " 0.27733141, 0.74215369, 0.43625734, 0.62571779, 0.26774461,\n", + " 0.22821211, 0.70655548, 0.45673413, 0.43718576, 0.09406633,\n", + " 0.17178055, 0.2021866 , 0.50789138, 0.46324354, 0.2810891 ])" ] }, - "execution_count": 23, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -1035,7 +1035,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -1077,7 +1077,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1091,7 +1091,7 @@ " 0.17178056, 0.2021866 , 0.57933628, 0.51903326, 0.2810891 ])" ] }, - "execution_count": 25, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1102,23 +1102,23 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 4.50761483e-02, 1.41871383e-08, -1.62484084e-08, 1.70116942e-08,\n", - " -1.01572042e-08, -2.02923470e-08, -1.80967602e-08, 4.01072114e-08,\n", - " 1.81668306e-08, 3.49114395e-02, -4.51935286e-09, 8.10120038e-02,\n", - " -2.81344381e-08, -2.32657197e-08, -4.97864919e-09, -3.43226980e-09,\n", - " 8.20637593e-02, 2.07029603e-02, 2.48309856e-02, 1.05995966e-08,\n", - " 2.38833046e-08, 7.61898031e-03, 8.47022778e-02, 2.89426981e-02,\n", - " -2.58176006e-08, 3.81950485e-09, -2.43117602e-08, 7.14449349e-02,\n", - " 5.57897248e-02, 2.18613811e-08])" + "array([ 4.50761275e-02, -6.08927639e-09, -7.72790068e-09, -5.17113019e-10,\n", + " -9.18373180e-09, -9.48045786e-09, -4.75888406e-09, 1.14024833e-08,\n", + " 1.77743376e-10, 3.49114167e-02, 8.53382895e-09, 8.10119833e-02,\n", + " -4.34167857e-09, -5.11723497e-10, -1.01032923e-08, 2.49688659e-10,\n", + " 8.20637253e-02, 2.07029803e-02, 2.48309681e-02, -8.65450989e-09,\n", + " 4.68641612e-09, 7.61895942e-03, 8.47022696e-02, 2.89427237e-02,\n", + " -2.48877985e-08, 6.82265699e-09, 5.94662181e-10, 7.14449057e-02,\n", + " 5.57897246e-02, -7.37194078e-09])" ] }, - "execution_count": 26, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1129,23 +1129,23 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 6.26451741e-02, 6.91716428e-09, -3.97750445e-09, 8.82678276e-09,\n", - " -5.03105356e-09, -5.09010742e-09, -7.73454124e-09, 1.66371310e-08,\n", - " 2.57661814e-08, 5.10733416e-02, -2.10977703e-09, 9.56938620e-02,\n", - " -1.03142531e-08, -1.31728727e-08, -2.41708965e-09, -1.90375245e-09,\n", - " 1.28542299e-01, 1.84922500e-02, 3.16909560e-02, 5.67596936e-09,\n", - " 1.09009184e-08, 1.08245131e-02, 8.45473161e-02, 2.61443520e-02,\n", - " -4.85713332e-09, 1.31223333e-09, -9.83102471e-09, 7.76769075e-02,\n", - " 5.48009526e-02, 1.22899913e-08])" + "array([ 6.26451461e-02, -2.96892338e-09, -1.89173964e-09, -2.68312150e-10,\n", + " -4.54887442e-09, -2.37806632e-09, -2.03394328e-09, 4.72993795e-09,\n", + " 2.52095012e-10, 5.10733090e-02, 3.98386147e-09, 9.56938395e-02,\n", + " -1.59168519e-09, -2.89733917e-10, -4.90505807e-09, 1.38493023e-10,\n", + " 1.28542248e-01, 1.84922675e-02, 3.16909341e-02, -4.63439662e-09,\n", + " 2.13899385e-09, 1.08244836e-02, 8.45473085e-02, 2.61443743e-02,\n", + " -4.68220719e-09, 2.34399960e-09, 2.40465446e-10, 7.76768778e-02,\n", + " 5.48009524e-02, -4.14434438e-09])" ] }, - "execution_count": 27, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1156,21 +1156,21 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.45204585, 0.05943011, 0.01498096, 0.06730537, 0.06133517,\n", - " 0.01573003, 0.04566753, 0.04301816, 0.50290017, 0.5098164 ,\n", - " 0.05448295, 0.30262027, 0.03359999, 0.08014345, 0.05892539,\n", - " 0.07691271, 0.55079205, 0.19032048, 0.39152273, 0.07168716,\n", - " 0.05208076, 0.49922062, 0.20860605, 0.19113141, 0.00884847,\n", - " 0.02950856, 0.04087943, 0.25795362, 0.21459458, 0.07901107])" + "array([0.45204587, 0.05943012, 0.01498096, 0.06730538, 0.06133516,\n", + " 0.01573002, 0.04566752, 0.04301818, 0.5029002 , 0.50981643,\n", + " 0.05448295, 0.30262029, 0.03359998, 0.08014344, 0.05892539,\n", + " 0.07691271, 0.5507921 , 0.19032046, 0.39152276, 0.07168717,\n", + " 0.05208077, 0.49922065, 0.20860606, 0.19113139, 0.00884847,\n", + " 0.02950856, 0.04087942, 0.25795365, 0.21459458, 0.07901108])" ] }, - "execution_count": 28, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1190,7 +1190,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1198,7 +1198,7 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 4\n", - "fit_time: 1.430413007736206\n" + "fit_time: 1.2553520202636719\n" ] } ], @@ -1238,21 +1238,21 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.03967368, 0.05504551, 0.03504564, 0.02803283, 0.79020922,\n", - " 0.09154701, 0.03940445, 0.60588296, 0.05382921, 0.06642338,\n", - " 0.07546608, 0.04712497, 0.05999965, 0.27495271, 0.04513804,\n", - " 0.39363567, 0.08103536, 1.12660816, 0.13128976, 0.72245753,\n", - " 0.06584402, 0.03196867, 0.027194 , 0.06510804, 0.05253451,\n", - " 0.03191912, 0.04620369, 0.1064269 , 0.21951494, 0.04757212])" + "array([0.03967367, 0.05504537, 0.03504562, 0.02803288, 0.79020931,\n", + " 0.09154714, 0.03940437, 0.60588313, 0.05382932, 0.0664232 ,\n", + " 0.07546581, 0.04712501, 0.05999963, 0.27495292, 0.04513797,\n", + " 0.39363584, 0.08103539, 1.12660827, 0.13128929, 0.72245765,\n", + " 0.06584397, 0.0319688 , 0.02719407, 0.06510798, 0.05253445,\n", + " 0.03191909, 0.04620362, 0.10642687, 0.21951508, 0.04757213])" ] }, - "execution_count": 30, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1300,7 +1300,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -1342,7 +1342,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1356,7 +1356,7 @@ " 0.03191909, 0.04620365, 0.10642693, 0.21951484, 0.04757213])" ] }, - "execution_count": 32, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1374,23 +1374,23 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([-8.93063967e-08, -2.17409717e-07, -5.66903558e-08, 7.38938851e-08,\n", - " -8.42573458e-08, -5.26114575e-08, -8.64452235e-08, -1.01664387e-07,\n", - " 3.46922363e-08, -3.20217935e-07, -1.55203279e-07, 7.14810783e-08,\n", - " -2.98499856e-08, 3.92668074e-07, 1.52293966e-08, 3.18778138e-07,\n", - " -1.08174473e-07, -1.44161407e-07, -5.46668106e-07, 2.47656750e-07,\n", - " -7.85003826e-09, 7.02585983e-08, 3.99192888e-08, -3.94153994e-08,\n", - " -1.35485741e-07, -2.21287160e-08, -3.94063128e-08, 3.61699707e-08,\n", - " -9.88227740e-08, 3.03806841e-09])" + "array([-7.68822677e-08, -7.29154133e-08, -3.01010823e-08, 2.25582237e-08,\n", + " -1.75527447e-07, -1.74475403e-07, -1.03651831e-08, -2.69768624e-07,\n", + " -7.08082831e-08, -1.33603602e-07, 1.14141816e-07, 3.97771448e-08,\n", + " -1.01507058e-08, 1.83509061e-07, 8.58520603e-08, 1.46178658e-07,\n", + " -1.38500575e-07, -2.50542729e-07, -7.64500813e-08, 1.26416519e-07,\n", + " 4.15011214e-08, -5.37298039e-08, -3.83827406e-08, 1.13304001e-08,\n", + " -7.41194778e-08, 2.26507350e-09, 3.39079999e-08, 6.54568523e-08,\n", + " -2.45914014e-07, -4.55573797e-09])" ] }, - "execution_count": 33, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1401,23 +1401,23 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([-7.08621943e-09, -2.39348100e-08, -3.97349662e-09, 4.14291429e-09,\n", - " -1.33161856e-07, -9.63284089e-09, -6.81264560e-09, -1.23193429e-07,\n", - " 3.73491272e-09, -4.25398150e-08, -2.34251424e-08, 6.73709298e-09,\n", - " -3.58197643e-09, 2.15930456e-07, 1.37485058e-09, 2.50964995e-07,\n", - " -1.75319019e-08, -3.24826814e-07, -1.43543547e-07, 3.57843028e-07,\n", - " -1.03375612e-09, 4.49215304e-09, 2.17113154e-09, -5.13251689e-09,\n", - " -1.42353353e-08, -1.41265765e-09, -3.64143261e-09, 7.69891680e-09,\n", - " -4.33861402e-08, 2.89054748e-10])" + "array([-6.10039766e-09, -8.02730577e-09, -2.10982100e-09, 1.26474434e-09,\n", + " -2.77406814e-07, -3.19454164e-08, -8.16867004e-10, -3.26896443e-07,\n", + " -7.62311814e-09, -1.77487390e-08, 1.72276227e-08, 3.74899791e-09,\n", + " -1.21807706e-09, 1.00912738e-07, 7.75038337e-09, 1.15082340e-07,\n", + " -2.24468758e-08, -5.64526956e-07, -2.00741474e-08, 1.82661179e-07,\n", + " 5.46519911e-09, -3.43535134e-09, -2.08756472e-09, 1.47539916e-09,\n", + " -7.78764610e-09, 1.44598185e-10, 3.13334564e-09, 1.39327398e-08,\n", + " -1.07963610e-07, -4.33452318e-10])" ] }, - "execution_count": 34, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1428,23 +1428,23 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([1.57400115e-03, 3.03000812e-03, 1.22819702e-03, 7.85839326e-04,\n", - " 6.24430611e-01, 8.38085575e-03, 1.55271072e-03, 3.67094163e-01,\n", - " 2.89758411e-03, 4.41206589e-03, 5.69512943e-03, 2.22076314e-03,\n", - " 3.59995788e-03, 7.55989926e-02, 2.03744301e-03, 1.54949042e-01,\n", - " 6.56672877e-03, 1.26924594e+00, 1.72370002e-02, 5.21944880e-01,\n", - " 4.33543521e-03, 1.02199596e-03, 7.39513413e-04, 4.23905627e-03,\n", - " 2.75987460e-03, 1.01883001e-03, 2.13478101e-03, 1.13266844e-02,\n", - " 4.81868075e-02, 2.26310705e-03])" + "array([1.57400016e-03, 3.02999222e-03, 1.22819516e-03, 7.85842204e-04,\n", + " 6.24430755e-01, 8.38087807e-03, 1.55270473e-03, 3.67094367e-01,\n", + " 2.89759546e-03, 4.41204110e-03, 5.69508877e-03, 2.22076613e-03,\n", + " 3.59995552e-03, 7.55991076e-02, 2.03743663e-03, 1.54949178e-01,\n", + " 6.56673369e-03, 1.26924618e+00, 1.72368768e-02, 5.21945055e-01,\n", + " 4.33542871e-03, 1.02200389e-03, 7.39517672e-04, 4.23904966e-03,\n", + " 2.75986815e-03, 1.01882846e-03, 2.13477424e-03, 1.13266782e-02,\n", + " 4.81868721e-02, 2.26310777e-03])" ] }, - "execution_count": 35, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1462,21 +1462,21 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([15.6873491 , 2.88892816, 0.55714133, 1.50823109, 1.56758003,\n", - " 1.00905707, 2.91069481, 2.05114589, 18.6500547 , 17.46589895,\n", - " 2.3150778 , 11.18594351, 2.08877219, 3.58965701, 2.07437675,\n", - " 1.70494207, 16.20276447, 11.34922213, 14.22447325, 1.79131631,\n", - " 1.72692849, 17.42246739, 10.45685982, 11.10302002, 0.40264413,\n", - " 1.66121199, 2.47344412, 8.7943693 , 10.39406576, 3.76990881])" + "array([15.68734774, 2.88892802, 0.55714101, 1.50823125, 1.5675811 ,\n", + " 1.00905713, 2.91069471, 2.05114721, 18.6500535 , 17.46589804,\n", + " 2.31507787, 11.18594221, 2.08877256, 3.5896572 , 2.07437671,\n", + " 1.70494233, 16.20276287, 11.34922168, 14.22447212, 1.79131614,\n", + " 1.72692897, 17.4224665 , 10.45685905, 11.10301968, 0.40264396,\n", + " 1.66121212, 2.47344445, 8.79436824, 10.39406515, 3.76990887])" ] }, - "execution_count": 36, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1531,7 +1531,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -1573,7 +1573,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -1587,7 +1587,7 @@ " 1.66121225, 2.47344389, 8.79436819, 10.39406662, 3.76990895])" ] }, - "execution_count": 38, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -1598,23 +1598,23 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([-8.21747985e-07, -2.69834035e-07, -1.48919698e-07, 4.56305748e-07,\n", - " -5.51919370e-07, 1.47626646e-07, -3.51786952e-07, 1.19242829e-06,\n", - " -4.39633794e-07, 6.22026988e-07, -8.38908520e-08, -8.58251527e-07,\n", - " 4.91076205e-07, -2.11618727e-08, -7.59827870e-07, -2.84967868e-07,\n", - " 7.92148022e-07, -7.91957465e-07, -1.30804852e-06, -7.24779423e-07,\n", - " 1.63624314e-06, -1.20129025e-06, 7.00472224e-07, 1.53653374e-08,\n", - " 9.44603640e-08, 2.59341062e-07, -2.26735458e-07, -1.10553937e-06,\n", - " 8.65130316e-07, 1.41124838e-07])" + "array([ 5.42484775e-07, -1.29776750e-07, 1.75441668e-07, 2.94098708e-07,\n", + " -1.62299082e-06, 8.76969586e-08, -2.51089855e-07, -1.30321758e-07,\n", + " 7.60598049e-07, 1.53263119e-06, -1.56555142e-07, 4.40688039e-07,\n", + " 1.22148594e-07, -2.11279730e-07, -7.22020625e-07, -5.40076410e-07,\n", + " 2.38531468e-06, -3.37048846e-07, -1.81282125e-07, -5.52109745e-07,\n", + " 1.15006647e-06, -3.10771561e-07, 1.47711321e-06, 3.62471932e-07,\n", + " 2.64911725e-07, 1.32784811e-07, -5.56680642e-07, -5.20487173e-08,\n", + " 1.47285028e-06, 8.01633524e-08])" ] }, - "execution_count": 39, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -1625,23 +1625,23 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([-2.57820944e-05, -1.55906221e-06, -1.65938616e-07, 1.37642924e-06,\n", - " -1.73035526e-06, 2.97927442e-07, -2.04788878e-06, 4.89169016e-06,\n", - " -1.63983884e-05, 2.17285215e-05, -3.88427690e-07, -1.92007055e-05,\n", - " 2.05149288e-06, -1.51927727e-07, -3.15233796e-06, -9.71707332e-07,\n", - " 2.56699763e-05, -1.79762017e-05, -3.72126005e-05, -2.59661788e-06,\n", - " 5.65135246e-06, -4.18588791e-05, 1.46494802e-05, 3.41203290e-07,\n", - " 7.60678305e-08, 8.61641034e-07, -1.12163492e-06, -1.94450418e-05,\n", - " 1.79844435e-05, 1.06405556e-06])" + "array([ 1.70202949e-05, -7.49831361e-07, 1.95491525e-07, 8.87137809e-07,\n", + " -5.08833685e-06, 1.76982489e-07, -1.46169176e-06, -5.34618203e-07,\n", + " 2.83703892e-05, 5.35375625e-05, -7.24874663e-07, 9.85902207e-06,\n", + " 5.10281278e-07, -1.51684356e-06, -2.99548501e-06, -1.84159797e-06,\n", + " 7.72973819e-05, -7.65048404e-06, -5.15728505e-06, -1.97800588e-06,\n", + " 3.97216755e-06, -1.08288141e-05, 3.08919314e-05, 8.04906610e-06,\n", + " 2.13330280e-07, 4.41167494e-07, -2.75383698e-06, -9.15471176e-07,\n", + " 3.06178058e-05, 6.04417075e-07])" ] }, - "execution_count": 40, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1652,23 +1652,23 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([2.46092922e+02, 8.34590591e+00, 3.10406463e-01, 2.27476101e+00,\n", - " 2.45730716e+00, 1.01819616e+00, 8.47214427e+00, 4.20719945e+00,\n", - " 3.47824540e+02, 3.05057626e+02, 5.35958520e+00, 1.25125332e+02,\n", - " 4.36296926e+00, 1.28856375e+01, 4.30303889e+00, 2.90682747e+00,\n", - " 2.62529576e+02, 1.28804843e+02, 2.02335639e+02, 3.20881412e+00,\n", - " 2.98228200e+00, 3.03542370e+02, 1.09345917e+02, 1.23277054e+02,\n", - " 1.62122293e-01, 2.75962529e+00, 6.11792581e+00, 7.73409313e+01,\n", - " 1.08036603e+02, 1.42122124e+01])" + "array([2.46092879e+02, 8.34590510e+00, 3.10406102e-01, 2.27476150e+00,\n", + " 2.45731052e+00, 1.01819628e+00, 8.47214368e+00, 4.20720487e+00,\n", + " 3.47824496e+02, 3.05057594e+02, 5.35958553e+00, 1.25125303e+02,\n", + " 4.36297080e+00, 1.28856388e+01, 4.30303874e+00, 2.90682834e+00,\n", + " 2.62529525e+02, 1.28804833e+02, 2.02335607e+02, 3.20881350e+00,\n", + " 2.98228368e+00, 3.03542339e+02, 1.09345901e+02, 1.23277046e+02,\n", + " 1.62122156e-01, 2.75962571e+00, 6.11792744e+00, 7.73409128e+01,\n", + " 1.08036590e+02, 1.42122129e+01])" ] }, - "execution_count": 41, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -1689,7 +1689,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 35, "id": "9f49674f-86c7-4d6e-88f9-98218ab69be3", "metadata": {}, "outputs": [], @@ -1705,7 +1705,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 36, "id": "60165b32-c950-4b0c-9526-3edcb7674e62", "metadata": {}, "outputs": [ @@ -1719,12 +1719,12 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 28.16247797012329\n" + "fit_time: 20.626681804656982\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1736,20 +1736,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 334.30816102027893\n", - "lead_lag: True inv_rest: True thres_distance: 4000 auc: 0.58982578\n", + "compute_auc_time: 335.9436459541321\n", + "lead_lag: True inv_rest: True thres_distance: 4000 auc: 0.8228045999999999\n", "Threshold distance: 8000\n", "lead_lag: True\n", "inv_reset: True\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 19.43948984146118\n" + "fit_time: 23.2948579788208\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1761,20 +1761,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 324.3790829181671\n", - "lead_lag: True inv_rest: True thres_distance: 8000 auc: 0.62241958\n", + "compute_auc_time: 338.6563048362732\n", + "lead_lag: True inv_rest: True thres_distance: 8000 auc: 0.8354452200000001\n", "Threshold distance: 16000\n", "lead_lag: True\n", "inv_reset: True\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 20.56976008415222\n" + "fit_time: 27.60756516456604\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1786,20 +1786,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 328.6247320175171\n", - "lead_lag: True inv_rest: True thres_distance: 16000 auc: 0.74234436\n", + "compute_auc_time: 293.8441872596741\n", + "lead_lag: True inv_rest: True thres_distance: 16000 auc: 0.8360074\n", "Threshold distance: 32000\n", "lead_lag: True\n", "inv_reset: True\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 21.32947611808777\n" + "fit_time: 24.40476894378662\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAHcCAYAAAB1fsZ+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACbsUlEQVR4nOzdd1hT1xsH8C97iAxFUBHFvVdxK27FrdUq7lFn3fpzW3dbte46arWOarXuVWedddatdW/coqiAIjvn98dpAoEwgoELyffzPDy59+bm5s0geXPOue8xE0IIEBEREVG6M1c6ACIiIiJTxUSMiIiISCFMxIiIiIgUwkSMiIiISCFMxIiIiIgUwkSMiIiISCFMxIiIiIgUwkSMiIiISCFMxIiIiIgUwkSM6DN4eXmhe/fuSodhcmrXro3atWsrHUayJk+eDDMzMwQGBiodSoZjZmaGyZMnG+RY/v7+MDMzw+rVqw1yPKL0xESMMqzVq1fDzMxM82dpaQkPDw90794dz58/Vzq8DC00NBTTpk1DmTJlYG9vDycnJ/j4+GDNmjXILLOa3bx5E5MnT4a/v7/SoSQQExODVatWoXbt2siWLRtsbGzg5eWFHj164MKFC0qHZxDr16/H/PnzlQ5DS0aMiehzWSodAFFypk6divz58yM8PBz//PMPVq9ejZMnT+L69euwtbVVNLY7d+7A3Dxj/Z4JCAhAvXr1cOvWLbRv3x4DBw5EeHg4tm7dim7dumHv3r1Yt24dLCwslA41STdv3sSUKVNQu3ZteHl5aV33119/KRMUgLCwMLRu3Rr79+9HzZo1MW7cOGTLlg3+/v7YtGkTfvvtNzx58gR58uRRLEZDWL9+Pa5fv46hQ4emyfHDwsJgaanfV1BiMeXLlw9hYWGwsrIyYIRE6YOJGGV4jRs3RoUKFQAAvXr1gqurK2bOnIldu3ahXbt2isZmY2OT7vcZHh4Oa2vrRBPAbt264datW9i+fTtatGih2T548GCMHDkSs2fPRvny5TF69Oj0ChmAbKXLkiWLQY5lbW1tkOOkxsiRI7F//37MmzcvQUIwadIkzJs3L13jEUIgPDwcdnZ26Xq/qaFSqRAZGQlbW1uD/ogyMzNT/EcZUaoJogxq1apVAoA4f/681vbdu3cLAOKHH37Q2n7r1i3Rpk0b4eLiImxsbIS3t7fYuXNnguO+f/9eDB06VOTLl09YW1sLDw8P0aVLF/HmzRvNPuHh4WLixImiYMGCwtraWuTJk0eMHDlShIeHax0rX758olu3bkIIIc6fPy8AiNWrVye4z/379wsA4s8//9Rse/bsmejRo4dwc3MT1tbWokSJEmLFihVatzt69KgAIP744w8xfvx4kTt3bmFmZibev3+v8zk7c+aMACC+/vprnddHRUWJwoULCxcXF/Hp0ychhBCPHj0SAMSsWbPE3LlzRd68eYWtra2oWbOmuHbtWoJjpOR5Vr92x44dE998843IkSOHcHZ2FkII4e/vL7755htRpEgRYWtrK7Jlyya++uor8ejRowS3j/939OhRIYQQtWrVErVq1UrwPG3cuFF89913wsPDQ9jY2Ii6deuKe/fuJXgMixYtEvnz5xe2traiYsWK4vjx4wmOqcvTp0+FpaWlaNCgQZL7qU2aNEkAEPfu3RPdunUTTk5OwtHRUXTv3l2EhoZq7bty5UpRp04dkSNHDmFtbS2KFy8ulixZkuCY+fLlE02bNhX79+8X3t7ewsbGRsybN0+vYwghxN69e0XNmjWFg4ODyJo1q6hQoYJYt26dEEI+v/Gf+3z58mlum9L/DwBiwIAB4vfffxclSpQQlpaWYvv27ZrrJk2apNk3JCREDBkyRPN/mSNHDlG/fn1x8eLFZGNSv4dXrVqldf+3bt0Sbdu2Fa6ursLW1lYUKVJEjBs3LqmXjCjdsUWMMh31mCEXFxfNths3bqB69erw8PDAmDFjkCVLFmzatAmtWrXC1q1b8eWXXwIAPn78CB8fH9y6dQtff/01vvjiCwQGBmLXrl149uwZXF1doVKp0KJFC5w8eRJ9+vRB8eLFce3aNcybNw93797Fjh07dMZVoUIFFChQAJs2bUK3bt20rtu4cSNcXFzg6+sLQHYfVqlSBWZmZhg4cCBy5MiBffv2oWfPnggJCUnQ0jJt2jRYW1tjxIgRiIiISLRF6M8//wQAdO3aVef1lpaW6NixI6ZMmYJTp06hfv36muvWrFmDDx8+YMCAAQgPD8eCBQtQt25dXLt2De7u7no9z2r9+/dHjhw5MHHiRISGhgIAzp8/j9OnT6N9+/bIkycP/P398fPPP6N27dq4efMm7O3tUbNmTQwePBg//fQTxo0bh+LFiwOA5jIxM2bMgLm5OUaMGIHg4GD8+OOP6NSpE86ePavZ5+eff8bAgQPh4+ODYcOGwd/fH61atYKLi0uy3Yn79u1DdHQ0unTpkuR+8bVr1w758+fH9OnTcenSJfz6669wc3PDzJkzteIqWbIkWrRoAUtLS/z555/o378/VCoVBgwYoHW8O3fuoEOHDujbty969+6NokWL6nWM1atX4+uvv0bJkiUxduxYODs74/Lly9i/fz86duyI8ePHIzg4GM+ePdO08Dk4OACA3v8fR44cwaZNmzBw4EC4urom6GZW69evH7Zs2YKBAweiRIkSePv2LU6ePIlbt27hiy++SDImXf7991/4+PjAysoKffr0gZeXFx48eIA///wT33//fcpeOKL0oHQmSJQYdavIoUOHxJs3b8TTp0/Fli1bRI4cOYSNjY14+vSpZt969eqJ0qVLa/0iV6lUolq1aqJw4cKabRMnThQAxLZt2xLcn0qlEkIIsXbtWmFubi5OnDihdf3SpUsFAHHq1CnNtrgtYkIIMXbsWGFlZSXevXun2RYRESGcnZ21Wql69uwpcuXKJQIDA7Xuo3379sLJyUnTWqVu6SlQoIBmW1JatWolACTaYiaEENu2bRMAxE8//SSEiG1NsLOzE8+ePdPsd/bsWQFADBs2TLMtpc+z+rWrUaOGiI6O1rp/XY9D3ZK3Zs0azbbNmzdrtYLFlViLWPHixUVERIRm+4IFCwQATcteRESEyJ49u6hYsaKIiorS7Ld69WoBINkWsWHDhgkA4vLly0nup6ZuEYvfQvnll1+K7Nmza23T9bz4+vqKAgUKaG3Lly+fACD279+fYP+UHCMoKEhkzZpVVK5cWYSFhWntq/4fEEKIpk2barWCqenz/wFAmJubixs3biQ4DuK1iDk5OYkBAwYk2C+uxGLS1SJWs2ZNkTVrVvH48eNEHyNRRpCxRhkT6VC/fn3kyJEDnp6e+Oqrr5AlSxbs2rVL03rx7t07HDlyBO3atcOHDx8QGBiIwMBAvH37Fr6+vrh3757mLMutW7eibNmyCVpuADnOBAA2b96M4sWLo1ixYppjBQYGom7dugCAo0ePJhqrn58foqKisG3bNs22v/76C0FBQfDz8wMgx/Rs3boVzZs3hxBC6z58fX0RHByMS5cuaR23W7duKRoD9OHDBwBA1qxZE91HfV1ISIjW9latWsHDw0OzXqlSJVSuXBl79+4FoN/zrNa7d+8EJwXEfRxRUVF4+/YtChUqBGdn5wSPW189evTQai308fEBADx8+BAAcOHCBbx9+xa9e/fWGijeqVMnrRbWxKifs6SeX1369eunte7j44O3b99qvQZxn5fg4GAEBgaiVq1aePjwIYKDg7Vunz9/fk3ralwpOcbBgwfx4cMHjBkzJsG4KvX/QFL0/f+oVasWSpQokexxnZ2dcfbsWbx48SLZfZPz5s0bHD9+HF9//TXy5s2rdV1KHiNRemLXJGV4ixcvRpEiRRAcHIyVK1fi+PHjWoPk79+/DyEEJkyYgAkTJug8xuvXr+Hh4YEHDx6gTZs2Sd7fvXv3cOvWLeTIkSPRYyWmbNmyKFasGDZu3IiePXsCkN2Srq6umi+qN2/eICgoCMuWLcOyZctSdB/58+dPMmY1dYLw4cMHODs769wnsWStcOHCCfYtUqQINm3aBEC/5zmpuMPCwjB9+nSsWrUKz58/1yqnET/h0Ff8L111cvX+/XsAwOPHjwEAhQoV0trP0tIy0S6zuBwdHQHEPoeGiEt9zFOnTmHSpEk4c+YMPn36pLV/cHAwnJycNOuJvR9ScowHDx4AAEqVKqXXY1DT9/8jpe/dH3/8Ed26dYOnpye8vb3RpEkTdO3aFQUKFNA7RnXindrHSJSemIhRhlepUiXNWZOtWrVCjRo10LFjR9y5cwcODg5QqVQAgBEjRuhsJQASfvEmRaVSoXTp0pg7d67O6z09PZO8vZ+fH77//nsEBgYia9as2LVrFzp06KBpgVHH27lz5wRjydTKlCmjtZ7SM+KKFy+OHTt24N9//0XNmjV17vPvv/8CQIpaKeJKzfOsK+5BgwZh1apVGDp0KKpWrQonJyeYmZmhffv2mvtIrcRKcggD1U4rVqwYAODatWsoV65cim+XXFwPHjxAvXr1UKxYMcydOxeenp6wtrbG3r17MW/evATPi67nVd9jpJa+/x8pfe+2a9cOPj4+2L59O/766y/MmjULM2fOxLZt29C4cePPjpsoo2IiRpmKhYUFpk+fjjp16mDRokUYM2aM5hezlZWV1uBzXQoWLIjr168nu8/Vq1dRr169VHVj+Pn5YcqUKdi6dSvc3d0REhKC9u3ba67PkSMHsmbNipiYmGTj1VezZs0wffp0rFmzRmciFhMTg/Xr18PFxQXVq1fXuu7evXsJ9r97966mpUif5zkpW7ZsQbdu3TBnzhzNtvDwcAQFBWntlxZdSPny5QMgW/fq1Kmj2R4dHQ1/f/8ECXB8jRs3hoWFBX7//Xe9B+wn5c8//0RERAR27dql1XqWVDd4ao9RsGBBAMD169eT/IGS2PP/uf8fScmVKxf69++P/v374/Xr1/jiiy/w/fffaxKxlN6f+r2a3P86UUbAMWKU6dSuXRuVKlXC/PnzER4eDjc3N9SuXRu//PILXr58mWD/N2/eaJbbtGmDq1evYvv27Qn2U7dOtGvXDs+fP8fy5csT7BMWFqY5+y8xxYsXR+nSpbFx40Zs3LgRuXLl0kqKLCws0KZNG2zdulXnF0XcePVVrVo11K9fH6tWrcLu3bsTXD9+/HjcvXsXo0aNStBSsWPHDq0xXufOncPZs2c1X4L6PM9JsbCwSNBCtXDhQsTExGhtU9cci5+gfY4KFSoge/bsWL58OaKjozXb161bp+m+TIqnpyd69+6Nv/76CwsXLkxwvUqlwpw5c/Ds2TO94lK3mMXvpl21apXBj9GwYUNkzZoV06dPR3h4uNZ1cW+bJUsWnV3Fn/v/oUtMTEyC+3Jzc0Pu3LkRERGRbEzx5ciRAzVr1sTKlSvx5MkTresM1TpKZChsEaNMaeTIkWjbti1Wr16Nfv36YfHixahRowZKly6N3r17o0CBAggICMCZM2fw7NkzXL16VXO7LVu2oG3btvj666/h7e2Nd+/eYdeuXVi6dCnKli2LLl26YNOmTejXrx+OHj2K6tWrIyYmBrdv38amTZtw4MABTVdpYvz8/DBx4kTY2tqiZ8+eCYqvzpgxA0ePHkXlypXRu3dvlChRAu/evcOlS5dw6NAhvHv3LtXPzZo1a1CvXj20bNkSHTt2hI+PDyIiIrBt2zYcO3YMfn5+GDlyZILbFSpUCDVq1MA333yDiIgIzJ8/H9mzZ8eoUaM0+6T0eU5Ks2bNsHbtWjg5OaFEiRI4c+YMDh06hOzZs2vtV65cOVhYWGDmzJkIDg6GjY0N6tatCzc3t1Q/N9bW1pg8eTIGDRqEunXrol27dvD398fq1atRsGDBFLW4zJkzBw8ePMDgwYOxbds2NGvWDC4uLnjy5Ak2b96M27dva7WApkTDhg1hbW2N5s2bo2/fvvj48SOWL18ONzc3nUnv5xzD0dER8+bNQ69evVCxYkV07NgRLi4uuHr1Kj59+oTffvsNAODt7Y2NGzdi+PDhqFixIhwcHNC8eXOD/H/E9+HDB+TJkwdfffUVypYtCwcHBxw6dAjnz5/XajlNLCZdfvrpJ9SoUQNffPEF+vTpg/z588Pf3x979uzBlStX9IqPKE0pcq4mUQokVtBVCCFiYmJEwYIFRcGCBTXlER48eCC6du0qcubMKaysrISHh4do1qyZ2LJli9Zt3759KwYOHCg8PDw0xSi7deumVUoiMjJSzJw5U5QsWVLY2NgIFxcX4e3tLaZMmSKCg4M1+8UvX6F27949TdHJkydP6nx8AQEBYsCAAcLT01NYWVmJnDlzinr16olly5Zp9lGXZdi8ebNez92HDx/E5MmTRcmSJYWdnZ3ImjWrqF69uli9enWC0/fjFnSdM2eO8PT0FDY2NsLHx0dcvXo1wbFT8jwn9dq9f/9e9OjRQ7i6ugoHBwfh6+srbt++rfO5XL58uShQoICwsLBIUUHX+M9TYoU+f/rpJ5EvXz5hY2MjKlWqJE6dOiW8vb1Fo0aNUvDsChEdHS1+/fVX4ePjI5ycnISVlZXIly+f6NGjh1ZpC3X5irjFguM+P3GL2O7atUuUKVNG2NraCi8vLzFz5kyxcuXKBPupC7rqktJjqPetVq2asLOzE46OjqJSpUrijz/+0Fz/8eNH0bFjR+Hs7JygoGtK/z/wX0FXXRCnfEVERIQYOXKkKFu2rMiaNavIkiWLKFu2bIJitInFlNjrfP36dfHll18KZ2dnYWtrK4oWLSomTJigMx4ipZgJwXZaIlPm7++P/PnzY9asWRgxYoTS4ShCpVIhR44caN26tc4uNyKitMIxYkRkUsLDwxOME1qzZg3evXuH2rVrKxMUEZksjhEjIpPyzz//YNiwYWjbti2yZ8+OS5cuYcWKFShVqhTatm2rdHhEZGKYiBGRSfHy8oKnpyd++uknvHv3DtmyZUPXrl0xY8aMROfwJCJKKxwjRkRERKQQjhEjIiIiUggTMSIiIiKFKJKIHTt2DGZmZtiyZYsSd59AWsQzefLkFE/HYWZmhsmTJ6fqftSxHzt2TLOte/fuKZrAmIyX+n3h7++f7L5eXl7o3r17msekS2re+5/z/2KqunfvnqIzQnV9npBpefr0KWxtbXHq1Klk961du7aiZxqbmZlh4MCBit2/WlRUFDw9PbFkyZJU3d5giZiZmVmK/vgPnjHdvHkTkydPTtEXd2a2fPly1KpVC+7u7rCxsUH+/PnRo0ePBI/76dOnmDJlCipVqgQXFxe4urqidu3aOHTokM7jBgUFoU+fPsiRIweyZMmCOnXq4NKlSzr33bVrF7744gvY2toib968mDRpktZ0O6k5JqW/1atXp+gzjz+KMrcXL15g8uTJqa7Gr05uU/KXEUydOhWVK1dOMBetUk6fPo3JkycbdKqzlDp+/DhatGgBT09P2NraImfOnGjUqFGCJNXKygrDhw/H999/n2DasJQw2FmTa9eu1Vpfs2YNDh48mGB78eLFcevWLUPdLemwfPlyqFQqvW5z8+ZNTJkyBbVr1zbqL47Lly8jf/78aNGiBVxcXPDo0SMsX74cu3fvxtWrV5E7d24AwM6dOzFz5ky0atUK3bp1Q3R0NNasWYMGDRpg5cqV6NGjh+aYKpUKTZs2xdWrVzFy5Ei4urpiyZIlqF27Ni5evIjChQtr9t23bx9atWqF2rVrY+HChbh27Rq+++47vH79Gj///HOqjknKqFmzZoLPt169eqFSpUro06ePZpuDg0N6h5ZqNWvWRFhYGM8ejePFixeYMmUKvLy8UK5cOb1vX7x48QTvk7Fjx8LBwQHjx483UJSG8ebNG/z222+aaa4ygtOnT2PKlCno3r07nJ2d0/W+7969C3Nzc/Tr1w85c+bE+/fv8fvvv6NmzZrYs2cPGjVqpNm3R48eGDNmDNavX4+vv/5avztKq5L9AwYMEIkdPrXTtqiFhoZ+TmgGj0cX9dQmKYE4U33oSx27euqX1Nq8ebNBjpMZXbhwQQAQ06dP12y7fv16gmlpwsPDRbFixUSePHm0tm/cuDHB++f169fC2dlZdOjQQWvfEiVKiLJly4qoqCjNtvHjxwszMzNx69atVB1TF/X7Iv60NrokNk1TekjNe/9z/l/SWpYsWZJ9LqOiokRERET6BPSfbt26aU0JldnExMSIsLAwRe77/PnzOqdP+hwlS5ZM9vVQ4jHPnTtX2NnZiQ8fPqRo//hTjaWFWbNmJfpZhiSm0EoroaGhwt3dXfj6+ia4rlmzZsLHx0fvYyo6WF+lUuH7779Hnjx5YGtri3r16uH+/fta+9SuXRulSpXCxYsXUbNmTdjb22PcuHEAgIiICEyaNAmFChWCjY0NPD09MWrUKERERGgd4+DBg6hRowacnZ3h4OCAokWLao6hbzwAsHnzZnh7e8POzg6urq7o3Lkznj9/nuzjjYiIwLBhw5AjRw5kzZoVLVq0wLNnz1L8fD179gytWrVClixZ4ObmhmHDhiV4rIDuMWIbNmyAt7c3smbNCkdHR5QuXRoLFiwAILtY1IUs69Spk6AbeefOnWjatCly584NGxsbFCxYENOmTUNMTIzWfahfq5s3b6JOnTqwt7eHh4cHfvzxxwQxhoeHY/LkyShSpAhsbW2RK1cutG7dGg8ePNDso1KpMH/+fJQsWRK2trZwd3dH37598f79e61jBQcH4/bt2wgODk7xcxmX+rmK2/RdsmRJuLq6au1nY2ODJk2a4NmzZ/jw4YNm+5YtW+Du7o7WrVtrtuXIkQPt2rXDzp07Na/RzZs3cfPmTfTp0weWlrGN0f3794cQQmuMYkqPmVaCgoIwdOhQeHp6wsbGBoUKFcLMmTMTtLTOnj0b1apVQ/bs2WFnZwdvb2+dYy0/972flMePH6N///4oWrQo7OzskD17drRt21ZnN/u///6LWrVqwc7ODnny5MF3332HVatWJRhP97nvKTV/f3+YmZlh9uzZmD9/PgoWLAgbGxvcvHlT07UZP87ExmmdPXsWjRo1gpOTE+zt7VGrVq0UjePRh677Tsn/dUBAACwtLTFlypQEx7xz5w7MzMywaNGiFMehHvuzbt06lCxZEjY2Nti/fz8A4Pnz5/j66681wwtKliyJlStXJjjGwoULUbJkSdjb28PFxQUVKlTA+vXrtfZJ7ljHjh1DxYoVAcgWD/Vn4+rVqwEAnz59wu3btxEYGJjix6bvY07s/aB+b6ljUbt9+za++uorZMuWDba2tqhQoQJ27dqVohh27NiBypUr62zFXbZsGQoWLAg7OztUqlQJJ06c0HmMlH4vx328RYsWha2tLby9vXH8+HHNPpMnT8bIkSMBAPnz59c8//H/Z3bs2IFSpUppXkP1eyUt2NvbI0eOHDq7Shs0aICTJ0/i3bt3eh1T0YKuM2bMgLm5OUaMGIHg4GD8+OOP6NSpE86ePau139u3b9G4cWO0b98enTt3hru7O1QqFVq0aIGTJ0+iT58+KF68OK5du4Z58+bh7t272LFjBwDgxo0baNasGcqUKYOpU6fCxsYG9+/f1/kBlpJ4Vq9ejR49eqBixYqYPn06AgICsGDBApw6dQqXL19Osum0V69e+P3339GxY0dUq1YNR44cQdOmTVP0XIWFhaFevXp48uQJBg8ejNy5c2Pt2rU4cuRIsrc9ePAgOnTogHr16mHmzJkAgFu3buHUqVMYMmQIatasicGDB+Onn37CuHHjULx4cQDQXK5evRoODg4YPnw4HBwccOTIEUycOBEhISGYNWuW1n29f/8ejRo1QuvWrdGuXTts2bIFo0ePRunSpdG4cWMAQExMDJo1a4bDhw+jffv2GDJkCD58+ICDBw/i+vXrKFiwIACgb9++mud78ODBePToERYtWoTLly/j1KlTsLKyAgBs374dPXr0wKpVq1I86Pzt27eIiYnBkydPMHXqVABAvXr1kr3dq1evYG9vD3t7e822y5cv44svvoC5ufbvmkqVKmHZsmW4e/cuSpcujcuXLwMAKlSooLVf7ty5kSdPHs31+hwzLXz69Am1atXC8+fP0bdvX+TNmxenT5/G2LFj8fLlS8yfP1+z74IFC9CiRQt06tQJkZGR2LBhA9q2bYvdu3drvbc/572fnPPnz+P06dNo37498uTJA39/f/z888+oXbs2bt68qXmtnj9/rvmhMXbsWGTJkgW//vorbGxsEhwzNe+ppKxatQrh4eHo06cPbGxskC1bNr1uf+TIETRu3Bje3t6YNGkSzM3NsWrVKtStWxcnTpxApUqVPjvGpCT3f+3u7o5atWph06ZNmDRpktZtN27cCAsLC71nLThy5Ag2bdqEgQMHwtXVFV5eXggICECVKlU0X+I5cuTAvn370LNnT4SEhGDo0KEA5PCMwYMH46uvvsKQIUMQHh6Of//9F2fPnkXHjh0BIEXHKl68OKZOnYqJEyeiT58+8PHxAQBUq1YNAHDu3DnUqVMHkyZNMsgJJLoesz5jo27cuIHq1avDw8MDY8aMQZYsWbBp0ya0atUKW7duxZdffpnobaOionD+/Hl88803Ca5bsWIF+vbti2rVqmHo0KF4+PAhWrRogWzZssHT01OzX0q/l9X+/vtvbNy4EYMHD4aNjQ2WLFmCRo0a4dy5cyhVqhRat26Nu3fv4o8//sC8efM0P45z5MihOcbJkyexbds29O/fH1mzZsVPP/2ENm3a4MmTJ8iePbvmsaX0R1W2bNkSfO6GhIQgMjISgYGBWLNmDa5fv66zMcfb2xtCCJw+fRrNmjVL0f0BULZrsnjx4lpN9AsWLBAAxLVr1zTbatWqJQCIpUuXah1j7dq1wtzcXJw4cUJr+9KlSwUAcerUKSGEEPPmzRMAEnQzpSaeyMhI4ebmJkqVKqXVZLx7924BQEycOFGzLX7X5JUrVwQA0b9/f6377tixY4q6WubPny8AiE2bNmm2hYaGikKFCiXoUuzWrZvIly+fZn3IkCHC0dFRREdHJ3r8pLomP336lGBb3759hb29vQgPD9dsU79Wa9as0WyLiIgQOXPmFG3atNFsW7lypQAg5s6dm+C4KpVKCCHEiRMnBACxbt06rev379+fYPuqVav07jqwsbERAAQAkT17dvHTTz8le5t79+4JW1tb0aVLF63tWbJkEV9//XWC/ffs2SMAiP379wshYpvYnzx5kmDfihUriipVquh9zMR8TtfktGnTRJYsWcTdu3e19hszZoywsLDQij/+eyMyMlKUKlVK1K1bV7Ptc9/78cW/ja7355kzZxK8FwcNGiTMzMzE5cuXNdvevn0rsmXLluC5Ss17SoiEXZOPHj0SAISjo6N4/fq11r7q+4j/GsUfbqBSqUThwoWFr6+v5v9D/bjz588vGjRokGxcKe2a1DXUIaX/17/88kuCz28hZHd83PdDSgAQ5ubm4saNG1rbe/bsKXLlyiUCAwO1trdv3144OTlp3gstW7YUJUuWTPI+UnqspLom1c+Xvu9hXV2TiT3mxIafqN9bceOqV6+eKF26tNbnskqlEtWqVROFCxdOMqb79+8LAGLhwoVa29Xfe+XKldP6fly2bJkAoPU4Uvq9rH68AMSFCxc02x4/fixsbW3Fl19+qdmWXNektbW1uH//vmbb1atXEzwO9XOYkj9d9+Pr66u53traWvTt21dnt/GLFy8EADFz5swE1yVF0a7JHj16aA0KVf/aePjwodZ+NjY2WoOjAdk9WLx4cRQrVgyBgYGav7p16wIAjh49CgCaFqqdO3cmO4A9uXguXLiA169fo3///rC1tdXs17RpUxQrVgx79uxJ9Nh79+4FAAwePFhru/oXXHL27t2LXLly4auvvtJss7e31xoUnBhnZ2eEhobi4MGDKbqv+Ozs7DTLHz58QGBgIHx8fDTN8nE5ODigc+fOmnVra2tUqlRJ6zXdunUrXF1dMWjQoAT3pT5zaPPmzXByckKDBg20Xl9vb284ODhoXl9AdsUKIfRqudi3bx/27t2LOXPmIG/evAgNDU1y/0+fPqFt27aws7PDjBkztK4LCwvT2aqifo+EhYVpXSa2r/p6fY6ZFjZv3gwfHx+4uLhoPff169dHTEyMVtdB3PfG+/fvERwcDB8fH62zOz/3vZ+cuDFERUXh7du3KFSoEJydnbXi2L9/P6pWrao14Dpbtmzo1KlTgmOm5j2VlDZt2mj9itfHlStXcO/ePXTs2BFv377VvB6hoaGoV68ejh8/rvfJOfpKyf9169atYWlpiY0bN2q2Xb9+HTdv3oSfn5/e91mrVi2UKFFCsy6EwNatW9G8eXMIIbTem76+vggODta83s7Oznj27BnOnz+v89j6HCsptWvXhhDCYOVU4j9mfbx79w5HjhxBu3btNJ/TgYGBePv2LXx9fXHv3r0kh9C8ffsWAODi4qK1Xf29169fP63vx+7du8PJyUlr35R+L6tVrVoV3t7emvW8efOiZcuWOHDgQIKhL4mpX7++phcFAMqUKQNHR0et92bZsmVx8ODBFP3lzJkzwX3MmDEDf/31F1asWIEqVaogMjJS55nu6udO365qRbsm8+bNq7WufhDxxwB5eHgkOIvn3r17uHXrVqIfbq9fvwYA+Pn54ddff0WvXr0wZswY1KtXD61bt8ZXX32VoPkxuXgeP34MAChatGiC+ytWrBhOnjyZ6GN9/PgxzM3Ntd4wiR0rsdsXKlQowSnOKbl9//79sWnTJjRu3BgeHh5o2LAh2rVrp3XGR1Ju3LiBb7/9FkeOHEFISIjWdfGbe/PkyZMgRhcXF/z777+a9QcPHqBo0aJa46Tiu3fvHoKDg+Hm5qbzevXrm1p16tQBADRu3BgtW7ZEqVKl4ODgoLMmTUxMDNq3b4+bN29i3759mjMr1ezs7HSO2VKfxqxOFNSXie0bN6FI6THTwr179/Dvv/8m+78FALt378Z3332HK1euaMUb9z3wue/95ISFhWH69OlYtWoVnj9/DhFn1ra478/Hjx+jatWqCW5fqFAhg8SRlPz586f6tvfu3QMAdOvWLdF9goODE3yBGlJK/q9dXV1Rr149bNq0CdOmTQMguyUtLS21xjqmVPzn7M2bNwgKCsKyZcuwbNkynbdRvzdHjx6NQ4cOoVKlSihUqBAaNmyIjh07akoy6HOs9PQ575P79+9DCIEJEyZgwoQJOvd5/fo1PDw8kjxO3P8fIPZ7L/6Z2lZWVihQoIDWtpR+L6vpOvu7SJEi+PTpE968eaMzKYov/vc2IN+bcfMIFxcX1K9fP9ljJSbuj7fOnTvjiy++QPfu3ROMh1U/d/qWIlE0EbOwsNC5Pf4bQdeXjkqlQunSpTF37lydx1D3W9vZ2eH48eM4evQo9uzZg/3792Pjxo2oW7cu/vrrL60YUhpPZuPm5oYrV67gwIED2LdvH/bt24dVq1aha9euyZ6mHBQUhFq1asHR0RFTp05FwYIFYWtri0uXLmH06NEJfokb6jlUqVRwc3PDunXrdF6f2tYFXQoWLIjy5ctj3bp1OhOx3r17Y/fu3Vi3bp3ml11cuXLlwsuXLxNsV29TJ265cuXSbI87rkK9Le44n5QeMy2oVCo0aNAAo0aN0nl9kSJFAAAnTpxAixYtULNmTSxZsgS5cuWClZUVVq1alWBQdFoaNGgQVq1ahaFDh6Jq1apwcnKCmZkZ2rdvn+YtRSml6zMssQ/r+C0B6scwa9asRMsnpHWJjJT+X7dv3x49evTAlStXUK5cOWzatAn16tVLcOJLSsR/ztTPQ+fOnRNNSsuUKQNAjm+9c+cOdu/ejf3792Pr1q1YsmQJJk6ciClTpuh1rPRkiPfJiBEj4Ovrq/M2Sf3oUI+nit8Qoo+Ufi8bUkrem5GRkSkeQJ8jR45EjwnI1uAWLVpgxowZCAsLS9ArAEDv97uiidjnKFiwIK5evYp69eolm32am5ujXr16qFevHubOnYsffvgB48ePx9GjR/XKkvPlywdAngUU/wv5zp07musTu61KpdK0BsW9XUrv+/r16xBCaD3elN7e2toazZs3R/PmzaFSqdC/f3/88ssvmDBhgs6WNrVjx47h7du32LZtG2rWrKnZ/ujRoxTdry4FCxbE2bNnERUVpRlwr2ufQ4cOoXr16mna+qMWFhamswVq5MiRWLVqFebPn48OHTrovG25cuVw4sQJqFQqrVbWs2fPwt7eXpO4qL9EL1y4oJV0vXjxAs+ePdPqZk7pMdNCwYIF8fHjx2T/N7Zu3QpbW1scOHBAqxt11apVWvt97ns/OVu2bEG3bt0wZ84czbbw8PAEg5zz5cun8yxoXdvSg7oFK36c6hYINXVLoqOj42f9qk8PrVq1Qt++fTXdk3fv3sXYsWMNcmz1GbcxMTEpeh6yZMkCPz8/+Pn5ITIyEq1bt8b333+PsWPH6nUspQutpvR9om6dsrKyStX7JG/evLCzs0vw2a7+Xrt3757W915UVBQePXqEsmXLarbp872sPmZ8d+/e1ZyZCBjm+T99+rSmFyQ5jx49SraWZlhYGIQQ+PDhg9b3k/q5U5/ollKZdq7Jdu3a4fnz51i+fHmC68LCwjRjfnRlweovRH1LAFSoUAFubm5YunSp1m337duHW7duJXkWmPqMwZ9++klre9wz0JLSpEkTvHjxQqsp9NOnT4k2q8el7vtXMzc31/zaUz+OLFmyAEj4z67+ZRD/10Vqp3IA5HiZwMBAnaezq++nXbt2iImJ0XRxxBUdHa0VZ0pLDURHR+v8tXfu3Dlcu3YtwdmMs2bNwuzZszFu3DgMGTIk0eN+9dVXCAgIwLZt2zTbAgMDsXnzZjRv3lyTpJQsWRLFihXDsmXLtH7N/vzzzzAzM9Ma/5fSY6aFdu3a4cyZMzhw4ECC64KCgjRjIywsLGBmZqb1WPz9/ROcGfW57/3kWFhYJGiZWbhwYYIWA19fX5w5c0arQvq7d+90troaqnxFUtQJVtwxdzExMQn+p729vVGwYEHMnj0bHz9+THCcN2/epFmM+nJ2doavry82bdqEDRs2wNraGq1atTLIsS0sLNCmTRts3boV169fT3B93Och/meetbU1SpQoASEEoqKi9DpWYp+NgGHLVyQmX758sLCw0HqfAEjwGezm5obatWvjl19+0dmantz7xMrKChUqVMCFCxe0tleoUAE5cuTA0qVLERkZqdm+evXqBM9JSr+X1c6cOaM1Fu/p06fYuXMnGjZsqPnuSer5T6nUjhHT1T0dFBSErVu3wtPTM8HQmYsXL8LMzEznEIikZNoWsS5dumDTpk3o168fjh49iurVqyMmJga3b9/Gpk2bcODAAVSoUAFTp07F8ePH0bRpU+TLlw+vX7/GkiVLkCdPHtSoUUOv+7SyssLMmTPRo0cP1KpVCx06dNCUr/Dy8sKwYcMSvW25cuXQoUMHLFmyBMHBwahWrRoOHz6c4l/jvXv3xqJFi9C1a1dcvHgRuXLlwtq1a7XKKCSmV69eePfuHerWrYs8efLg8ePHWLhwIcqVK6fJ3MuVKwcLCwvMnDkTwcHBsLGxQd26dVGtWjW4uLigW7duGDx4MMzMzLB27drP6q7t2rUr1qxZg+HDh+PcuXPw8fFBaGgoDh06hP79+6Nly5aoVasW+vbti+nTp+PKlSto2LAhrKyscO/ePWzevBkLFizQJC4pLTXw8eNHeHp6ws/PDyVLlkSWLFlw7do1rFq1Ck5OTlrjKrZv345Ro0ahcOHCKF68OH7//XetYzVo0ADu7u4AZNJUpUoV9OjRAzdv3tRUwY+JiUlQV2nWrFlo0aIFGjZsiPbt2+P69etYtGgRevXqpfUrSp9jGtrIkSOxa9cuNGvWDN27d4e3tzdCQ0Nx7do1bNmyBf7+/nB1dUXTpk0xd+5cNGrUCB07dsTr16+xePFiFCpUSGvs0Oe+95PTrFkzrF27Fk5OTihRogTOnDmDQ4cOabpa1EaNGoXff/8dDRo0wKBBgzTlK/LmzYt3795p/fI2dPkKXUqWLIkqVapg7NixePfuHbJly4YNGzYkGARsbm6OX3/9FY0bN0bJkiXRo0cPeHh44Pnz5zh69CgcHR3x559/pkmMqeHn54fOnTtjyZIl8PX1NWg19BkzZuDo0aOoXLkyevfujRIlSuDdu3e4dOkSDh06pPnh3bBhQ+TMmRPVq1eHu7s7bt26hUWLFqFp06bImjWrXscqWLAgnJ2dsXTpUmTNmhVZsmRB5cqVkT9/foOXr9DFyckJbdu2xcKFC2FmZoaCBQti9+7dOpOExYsXo0aNGihdujR69+6NAgUKICAgAGfOnMGzZ89w9erVJO+rZcuWGD9+PEJCQuDo6AhAfu9999136Nu3L+rWrQs/Pz88evQIq1atSjBGLKXfy2qlSpWCr6+vVvkKAFqfcerB/OPHj0f79u1hZWWF5s2baxK0lEjtGLHGjRsjT548qFy5Mtzc3PDkyROsWrUKL1680DopRe3gwYOoXr16gs+eZOl1jqUeUlNZX9fpuLVq1Ur0NOTIyEgxc+ZMUbJkSWFjYyNcXFyEt7e3mDJliggODhZCCHH48GHRsmVLkTt3bmFtbS1y584tOnTooHVqvj7xCCGrnpcvX17Y2NiIbNmyiU6dOolnz55p7aOrsn5YWJgYPHiwyJ49u8iSJYto3ry5ePr0aYpPf378+LFo0aKFsLe3F66urmLIkCGacg5Jla/YsmWLaNiwoXBzcxPW1tYib968om/fvuLly5dax1++fLkoUKCAsLCw0DrmqVOnRJUqVYSdnZ3InTu3GDVqlDhw4IDO09x1vVbx4xFCnno/fvx4kT9/fmFlZSVy5swpvvrqK/HgwQOt/ZYtWya8vb2FnZ2dyJo1qyhdurQYNWqUePHihWaflJYaiIiIEEOGDBFlypQRjo6OwsrKSuTLl0/07NkzwSnL6tcvsb/4p5K/e/dO9OzZU2TPnl3Y29uLWrVqifPnz+uMY/v27aJcuXLCxsZG5MmTR3z77bciMjIywX76HDO+z62s/+HDBzF27FhRqFAhYW1tLVxdXUW1atXE7NmztWJdsWKFKFy4sLCxsRHFihUTq1atSpP3flzxb/P+/XvRo0cP4erqKhwcHISvr6+4ffu2zsd1+fJl4ePjo3nup0+fLn766ScBQLx69Uqzn6HLV8yaNUvn/g8ePBD169cXNjY2wt3dXYwbN04cPHhQ53vs8uXLonXr1iJ79uzCxsZG5MuXT7Rr104cPnw42bg+t3xFSv+vhRAiJCRE2NnZCQDi999/T/Y+dUESFdMDAgLEgAEDhKenp+azo169emLZsmWafX755RdRs2ZNzXNVsGBBMXLkSM33gj7HEkKInTt3ihIlSghLS0ut94Why1ck9pjfvHkj2rRpI+zt7YWLi4vo27evuH79us736IMHD0TXrl1Fzpw5hZWVlfDw8BDNmjUTW7ZsSTaugIAAYWlpKdauXZvguiVLloj8+fMLGxsbUaFCBXH8+HGdlfVT8r0c9/H+/vvvms+Q8uXL6yyhNG3aNOHh4SHMzc21PtcSe84MNVvIokWLRI0aNYSrq6uwtLQUOXLkEM2bNxfHjx9PsG9QUJCwtrYWv/76q973YyZEJh+JTkQJHDt2DHXq1EnReAdTN3ToUPzyyy/4+PFjkoN0M7Pu3bvD398/QXV2ovh69uyJu3fvJlo531DMzMwwYMAAvWZcyMjmz5+PH3/8EQ8ePNB7XHOmHSNGRKSv+PXX3r59i7Vr16JGjRpGm4QR6WPSpEk4f/68wafPMmZRUVGYO3cuvv3221SdXJZpx4gRkfGIiYlJdjCxg4PDZ5dpqFq1KmrXro3ixYsjICAAK1asQEhISKJ1l8iwXr16leT1dnZ2CYqEUvrKmzevpl4hpYyVlRWePHmS6tszESMixT19+jTZYpaGGBDdpEkTbNmyBcuWLYOZmRm++OILrFixQqs0C6UddS29xHTr1i3BJNZExk7RMWLHjx/HrFmzcPHiRbx8+RLbt29P9lTnY8eOYfjw4bhx4wY8PT3x7bffptlZTUSUPsLDw5OcmQKQdZLin6VFmcuhQ4eSvD537typnuKHKLNStEUsNDQUZcuWxddff52iKTAePXqEpk2bol+/fli3bh0OHz6MXr16IVeuXIlWEiaijM/W1jbDFyulz8fXmCihDHPWpJmZWbItYqNHj8aePXu0CvC1b98eQUFB2L9/fzpESURERGQ4mWqM2JkzZxL8ovL19cXQoUMTvU1ERIRWFXyVSoV3794he/bsik9dQURERCkj/ptWKHfu3FpTv2V2mSoRe/XqlaaauZq7uztCQkISTL6pNn369DSvRE5ERETp4+nTp8iTJ4/SYRhMpkrEUmPs2LEYPny4Zj04OBh58+bF06dPNVM4EBERKenjRyAiAnj5EggLAx4+BCwsgJgYQKWSlzExwIsXQGQkYGsLLFgAxJu+0SAcHYEPHwAhgKxZgfr1ZSzm5vLSwgJ49AioVk0uW1nJ+D08gGzZ5DGyZpXHAQAzM+0/9TZd18Xfx/HYToRWbQDY2yM0NAT16nlqpqkyFpkqEcuZMycCAgK0tgUEBMDR0THRImo2NjY6J0h2dHRkIkZERGni0yfg0iXg778BOztgxw6ZvAQEANmzy6QqOlpehoQY/v7d3AAbG5nUWVgAXl5AgwZAUBDQsSOQJYt2cqW+9PAArK0NH4/eQkOBAQOA334DevUCli/XPE/GNqwoUyViVatWxd69e7W2HTx4UO+ZzomIiAwhKgp4/ly2ID1+DKxaBWzblvRtkqlrCwAoUgS4dw+oVy+2FUqdML14AeTJA7i6Au7uQJ8+gJMTYGkpW6csLWNblTKl69eBdu2AW7fkA86bVzbPGSlFE7GPHz/i/v37mvVHjx7hypUryJYtG/LmzYuxY8fi+fPnWLNmDQCgX79+WLRoEUaNGoWvv/4aR44cwaZNm7Bnzx6lHgIRERmZ169lS9L9+8DTp7JVy8xMJl1nz8pLMzPZwpUS+fMD1asDzs6yVcrDQ3YtqpMrS0t5nZOTzDtMlhDAypXAoEHyBciVC1i/HqhdW+nI0pSiidiFCxdQp04dzbp6LJe6uvLLly+1pg3Inz8/9uzZg2HDhmHBggXIkycPfv31V9YQIyKiZEVFyTFYT57IFqyoKCA8HDhxQvaEBQYCf/6ZumNnySKP4eICvH8PLF4M9Otn4omVPj5+lE/YunVyvWFDYO1a2cdq5DJMHbH0EhISAicnJwQHB3OMGBFRJqRSyYTq6VPZixUZCZw7JxtQTp0C/v0XyJ1bjr+Kikp5y1V8Tk4ysSpSBPD0BIoXl11/YWFAyZJyDFaRIrKbkHPGf6Znz4By5eQgtu++A0aNSpDFGuv3d6YaI0ZERKYjNBS4cUMOcL95ExgzBrC3lwPhkxMcnPw+lSrJxMrMDHj3TvaA1aghuxHz5v3s8EkfefIAf/whz2yoUUPpaNIVEzEiIlLU48fyb+VKOfj8n39kq9P58wn3jZuE2djIkg8uLrLEQmBgbKNK9eqytUo9gN3aWn7XOzmx9SpDCAmRZxm0bw+oZ9Rp0EDRkJTCRIyIiBTRvj2wcWPy+xUoIBOuggVlMjV7tjxj0Moq7WOkNHDxIuDnBzx4ABw9KseD2dsrHZVimIgREVGaefFCnml4/bpssYqKAlavli1e8eXNKwfSDx8u961dWzaSGFERddMmBLBoETBihBzYly8fsGGDSSdhABMxIiL6DMHBcqD8hg3A9u1yULu6perixZQd4/BhoE6dTF77ipIWFAT07BlbZK1VK9kX7eKiZFQZAhMxIiJKVkgI4O8vyz2cPSv/1JUG4nr/Xvft3d3l2Kz27eV3r4UF0LgxULYsEzCjFxQElC8v30BWVrJvedAgvvD/YSJGRGTihJClHiIjZdfg6dNy/eJFOXfgL7/IswqTU6IEULcu4OsbOyDeyQmoUoX1tEyas7PMug8ckIMCK1RQOqIMhYkYEZGRE0KWgDh4ULZsXb0qW67OnJHT8+gjWzY5V6JKJROsatWAb75h4wbF8/atnEzT3V2uz50rz7hwclI2rgyIiRgRkRHy95eJUkBA6m5fpows//DkiRy/5eYmC5+b+LhqSonTp2UfdKFCMvu3sJBzOtnaKh1ZhsREjIgoE3v7VrZyRUUBly/L77/kdOokB9lXqRJbP7NQodh6WzY2aR83GSGVCpg1Cxg/XvZt29jIKRB42muSmIgREWVQMTGy/MOxY7FT+pw5Azg6yvJLKVG7NrBqlewhsrNLy2jJpL15A3TrBuzbJ9c7dJCDC7NmVTauTICJGBGRwp49k705b94AAwfKbXZ2umttJcbJSbZoBQYCjRoBP/8MeHmlSbhE2k6ckE2xL17I7seffgJ69eLAwRRiIkZElA7Cw4GHD4HXr4HNm4ElS+TE1C9e6N4/fhJmYyMnnS5ZUraI1aghuxGrV5eTXRMpIiYG6N9fvpGLFQM2bQJKl1Y6qkyFiRgRURqJjARmzAAmTdJ9va4krGFD2Rr2ww+ylStnTs6NSBmYhYWcrHvBAmDePMDBQemIMh0mYkREn0kI4P594MMHOZXPgwfA1KmJ71+unBxgP2SIrLmVNatsHSPKFI4cAe7dA/r2leulSgHLlysbUybGRIyI6DO8fSsnoE6Oupi4tXXax0SUJmJi5C+MadNkS5i3N4uzGgATMSIiPQkBPH4MDBgA7N2rfZ2npyyW6u0N1KsHjB7N5IuMwIsXsu7JsWNyvXt3OZUCfTYmYkRESbh7V5aKOH1aDn85dw64cCHhfl27Ar/9lv7xEaW5AweALl3kab0ODrIsRceOSkdlNJiIEZFJEkKeyfj6taxC//EjcPIk8OiRPEPx/n2ZfKXEyZPy7EUiozN5MjBlilwuW1aeFVmkiKIhGRsmYkRk9HbskK1YFy8Cd+7Iul1RUfodo0YNIEsWwMdHlkdq1Yo9M2QCnJ3lZb9+8qxITlNkcEzEiMgohIXJKX7Cw+UwFktL4M8/dXcj6lK6tOx1yZ5dTvfj5SXHJlesKCe2ZgkJMhmhofJXByBP7S1fHqhVS9mYjBgTMSLKVJ4+BZYtkwmWvT2wbRvg4QE8f578bUeOlJNgFykiB9IXLSpLR1jyk5BINhOPGwfs2iX/wbJmlc2/TMLSFD9+iCjD+/QJGDpU1o38+DHh9XGTMHd3maCZmwNNm8p6XV26AHXqcMYVokQ9fiynKfrnH7m+Y4f8x6E0x0SMiDKk58+Bb76RtSNDQ3Xv06sXULWq7E4sXFgWRVUPaSGiFNq5U5ajCAqS0zmsXAm0bq10VCaDiRgRZSghIXJsV+fOuq+fMUNOjK0ewkJEqRQZCYwaJacnAoBKlYANG4D8+ZWNy8QwESMixagnwj58GDh7FjhxAnjyRHsfOztg1Sp51qKHhzJxEhml0aNjk7D//U9OcMrqw+mOiRgRKWL3bqB586T38fUFtm5l6xdRmhgzBjh4EJg+Pfl/RkozTMSIKM0FBQHXrsnJsOfMkRNjx2dhIecQbtlSntHIchFEBhYeDmzfDnToINfd3YF//5VntpBimIgRUZq4dEme5Th7dtL7bdsGfPll+sREZLLu3QPatQOuXJHr6mSMSZjimIgR0WcLDAS++w44fx5wc5NnvutSpoz83C9SBPj5ZyBbtnQNk8g0/fEH0KePrP3i6sp/vAyGiRgRpUpQENCokZwU+/37xPdr3Bho2BAYNIjdjUTpKixMVsZfvlyu16wJrF/Ps14yGCZiRKS327eB4sUTbndxkTUgvb2BXLmA+vVZRJVIEbdvy67Ia9fkP+H48cCkSZxGIgPiK0JEKXLrljzTfdMm7RYwOztgzx6genWe+U6UYTx4IJMwNzdg3Tr5q4gyJCZiRJQklQpo1gzYty/hda1by/ISRJTBNG0quySbNpXN05Rh8XQJIkrUzp1yXFfcJKxpU2DFCjntEJMwogzixg3Ax0fOGanWqxeTsEyALWJEBEDOdvLnn8CZM7LWly4PHgAFCqRvXESUBCHk1BMDB8rB+UOHylphlGkwESMyUULIs9nPnAF27QIWL058359/lsVWOfCeKAP5+BHo10+OAQPk6cm//KJsTKQ3JmJEJuDBA+DRI1nRfv9+4MCBpPcvUUJWtx85EvD0TJ8YiUgPV6/KsyLv3pXjB6ZNk3NHskBrpsNEjMjIhIUBr17JZOubb1J2m5w5gbp1geHDZekJIsrATpwAGjQAIiJkTbANG4AaNZSOilKJiRiREfj0SX4W9+yZ9H7lygHPngHVqslC2z4+gI2N/COiTKJiRaBYMZmE/fabrJZPmRYTMaJM7OJFoEIF3dfZ2wNRUfIM9pYtAWfndA2NiAzp1i05N5iFBWBrCxw6JKcqYldkpsdXkCiTuXkTOHZM/gjWlYR5eMjSEqGh8kzIbt2YhBFlWkIAixbJ5uzvv4/d7urKJMxIsEWMKIPbvl2O9zp/Hrh0Sfc+o0YB06fzc5nIqAQFyfEG27bJ9atXZYVl/qMbFSZiRBnMkyfA7t3A27fAxImJ71esmGzpWrVKLhORETl3DvDzA/z9ASsrYNYsYPBg1pAxQkzEiDKIT5+ALFkSv755cyBvXqB9e54gRWS0hADmz5elKKKigPz5gY0b5QB9MkpMxIgUEhMDhIQADx/qHuuVMydQu7as6TV8eNJJGhEZiUePgHHjZBLWpg3w668c5GnkmIgRpbOnT4Hu3YEjR3Rfnzu3/Cy2tk7XsIgoIyhQQE5zERYG9O/PrkgTwESMKB0IIeffXbky8X1y5ZLDQZiAEZkQlUpO7urjA1SpIrd9/bWyMVG6YiJGlMaePAHy5Uu43dsbWLNGdj0SkQl680bWl9m3T35IXL8OODgoHRWlMyZiRGnk40dZ0yskRHv7hg2ywKqtrTJxEVEGcPw40KED8OKF/DAYP54DQU0UEzEiA7lwQZb8efpUTgH36ZP29blyyemFWAKIyISpVLLo38SJcrloUWDTJqBMGaUjI4UwESP6TC9fAoULy0r2unh6AvfucT5HIpP38SPQujVw8KBc79IFWLKE3ZEmjr/NifQUFAT88Yc8mcnFRZ7lGDcJGzgQ2LlTtpCFhMgxYkzCiAhZsgB2dvJv1So5SJRJmMljixhRMqKigKFD5RmNe/dqXxcUpL3u7697YD4RmaiYGDnpq52d/PW2ahXw6hXP0iENJmJEiYiIADp1ArZuTXyfUaOAAQNk9yPL/RCRlpcvgY4d5Vk7a9fKD4ls2eQf0X+YiBHp8P697s/KyZPlmNpWrZh4EVES/voL6NxZlqjIkkVOoVGwoNJRUQbERIwong4dZIkJNRsb4O5dOc8jEVGSoqOBSZPkmZFCyF9uGzcyCaNEcbA+EeSUQs2ayVauuElYtWpAeDiTMCJKgWfPgLp1gR9+kElY377AP/8AxYopHRllYEzEyKQFB8txXgUKAHv2aF+3ahXw99/KxEVEmYxKBTRuDJw4AWTNKn/RLV0qB+kTJYFdk2RyhJAlJby8El6XK5csTVGrVrqHRUSZmbk5MH8+MGaM/BApVEjpiCiTYIsYmYSYGFlD0cNDfl7qSsLu3pWzjTAJI6IUefJEDspXq1cPOHuWSRjphS1iZNRCQ4EjR4AWLXRfX6YMcOkSYGGRvnERUSa3axfQvbscnH/pUmzyxTnMSE98x5DRefoUaN8ecHKSRavjJ2EdO8qxYUIAV68yCSMiPURGAsOGAS1byjo3xYoBlmzToNRTPBFbvHgxvLy8YGtri8qVK+PcuXNJ7j9//nwULVoUdnZ28PT0xLBhwxAeHp5O0VJGFh0NNG8uz3DcuFFOLxRXqVJAYCCwbh3g6KhMjESUiT16BNSoIceCATIhO3lS91gHohRSNBHbuHEjhg8fjkmTJuHSpUsoW7YsfH198fr1a537r1+/HmPGjMGkSZNw69YtrFixAhs3bsS4cePSOXLKSC5cAJo2BaysgN27Y7dXqgQsWyYTMiGAa9eA7NmVi5OIMrGtW4Hy5YHz5+Ukszt3AnPnAtbWSkdGmZyi7alz585F79690aNHDwDA0qVLsWfPHqxcuRJjxoxJsP/p06dRvXp1dOzYEQDg5eWFDh064OzZs+kaN2UMMTGy7MSTJwmve/FCngFJRGQQp0/LMQ1Vq8rSFCwuSAaiWItYZGQkLl68iPr168cGY26O+vXr48yZMzpvU61aNVy8eFHTffnw4UPs3bsXTZo0SfR+IiIiEBISovVHmdutW4CbmxyWETcJGzhQ1k4UgkkYERmAELHL06cDCxbI4oJMwsiAFGsRCwwMRExMDNzd3bW2u7u74/bt2zpv07FjRwQGBqJGjRoQQiA6Ohr9+vVLsmty+vTpmDJlikFjJ2X4+wPjxwPr1ye87s0bwNU13UMiImO1YQPw22/y7EgrK9kFOXiw0lGREVJ8sL4+jh07hh9++AFLlizBpUuXsG3bNuzZswfTpk1L9DZjx45FcHCw5u/p06fpGDEZQmgo0LYtkD+/dhI2YAAQFCR/tDIJIyKDCAuTUxN16ADs3w8sX650RGTkFGsRc3V1hYWFBQICArS2BwQEIGfOnDpvM2HCBHTp0gW9evUCAJQuXRqhoaHo06cPxo8fD3Md9VtsbGxgY2Nj+AdA6eLsWaBKFe1tZcvKqdyS6JEmItLfnTtAu3bAv//KiWfHjQP69FE6KjJyirWIWVtbw9vbG4cPH9ZsU6lUOHz4MKpWrarzNp8+fUqQbFn8VwRKxO3LJ6MQEZEwCbt0CbhyhUkYERnY778D3t4yCXNzAw4cAL77jjXCKM0p2jU5fPhwLF++HL/99htu3bqFb775BqGhoZqzKLt27YqxY8dq9m/evDl+/vlnbNiwAY8ePcLBgwcxYcIENG/eXJOQkXGIjgZsbWPXJ0+WXZDlyysWEhEZq++/B7p0keMg6tSRv/YaNFA6KjIRiqb6fn5+ePPmDSZOnIhXr16hXLly2L9/v2YA/5MnT7RawL799luYmZnh22+/xfPnz5EjRw40b94c33//vVIPgdKAEECRIrHrefIAkyYpFw8RGbmvvgJ+/BEYPhz49ltOt0HpykyYWJ9eSEgInJycEBwcDEeWV88whAD69weWLtXe7uQkZxExM1MmLiIyQkLILsiyZWO3vX3Lis8ZnLF+f2eqsybJOIWEyHly4ydhZmayLAWTMCIymI8fga5dgS++kDXB1JiEkUKYiJFiIiKANm1kq1dcO3fKAtYxMbJ8DxGRQfz7L1ChghyYDwDXrysbDxEUHiNGpksIwMFBDspXc3EB3r1TLiYiMlJCyHpggwfLX4AeHsAffwA+PkpHRsQWMVJGx47aSdj580zCiCgNhITID5y+fWUS1rixPCuSSRhlEGwRI0Vs2BC7bFqnixBRutq5U37gWFjI+SL/9z85KJUog2AiRuluyJDY5UOHlIuDiExA587A5ctynrREioUTKYk/CyhdrVsH/PRT7HqFCsrFQkRGKCgIGDhQ1r0B5GnXc+cyCaMMiy1ilG7c3YHXr2PXHz1KeMYkEVGqnT8P+PnJD5fAQO0xEEQZFFvEKF20bKmdhG3eDHh5KRYOERkTIYD584Hq1WUSlj+/HAtGlAmwRYzSlBAJx8VycD4RGcy7d0CPHsCuXXK9TRvg118BZ2dFwyJKKbaIUZo5dSphEvbwoTKxEJERunYNKF9eJmHW1sCiRbK5nUkYZSJMxChNfPcdUKOG9rbISNljQERkELlzyyb2ggWBM2eAAQM4JxplOkzEyODOnAEmTIhdnzMHUKk4XRERGcCHD7HjG7JnB/btAy5dknNHEmVCTMTIoO7cAapVi11/8QIYPpw/UonIAE6cAIoXB1avjt1WsiTg6KhYSESfi4kYGUxMDFCsWOz6Dz8AuXIpFw8RGQmVSn6g1KkDPH8OLFwoP3CIjAATMTIIIQDLOOfgDh4MjB2rXDxEZCRevwYaNQLGj5fJV+fOwPHjcsoiIiPA8hVkEDlzaq8vWKBMHERkRI4elRN2v3oF2NnJsyJ79OBYBzIqbBGjVIuMBJYvB1xctIu1RkUpFxMRGYnHj4GGDWUSVqKErJr/9ddMwsjosEWMUuXWLfnZGJ9Kxc9JIjKAfPnk+IZnz+SYsCxZlI6IKE2wRYxSJX4SNnYskzAi+kyHDgH378euT5kCrFzJJIyMGhMx0ktQkPYckU2byoH6P/zAJIyIUik6Gvj2W9kV6ecHRETI7fxQIRPARIxSbNw4OR7s8ePYbX/+qVw8RGQEnj8H6tYFvv9e/qqrWJET0pJJ4RgxSpGJE4Hp07W3vX7NH6xE9Bn27QO6dgUCA4GsWYFly4D27ZWOiihdsUWMkjV7NjBtWuy6v7/8wZojh2IhEVFmFhUFjB4NNGkik7Dy5YGLF5mEkUliIkZJmjEDGDkydn3HDnkyExFRqgkha4QBcqLu06eBwoWVjYlIIeyapEStX69dHX/fPlngmogoVYSQ4xmsrYGNG+Vk3W3aKB0VkaKYiJFOr14BnTrFrv/7L1C6tHLxEFEmFhkJjBkD2NrKU6wBIH9++Udk4piIkU5xJ+vesYNJGBGl0qNHcuzXuXOyNaxrV6BYMaWjIsowOEaMEujbN3b5m2+Ali2Vi4WIMrFt2+RA/HPnAGdnYPt2JmFE8TARIy2HDskzyNWWLFEuFiLKpCIigEGD5Piv4GCgShXgyhX+qiPSgV2TpNGggUzE1M6eVS4WIsqkhJAV8o8fl+ujRgHffQdYWSkbF1EGxUSMAAA7d2onYRMnygLXRER6MTMDevUCbtwA1qyRtcKIKFFmQpjWXBIhISFwcnJCcHAwHB0dlQ4nQ7h0CfD2jl1/+hTIk0e5eIgokwkLk5WeixeP3fbuHZAtm2IhkfEx1u9vjhEjrSTs2DEmYUSkhzt35Biw+vWBN29itzMJI0oRJmIm7tGj2OWhQ4FatRQLhYgym99/l7/k/v1XTlsU9wOFiFKEiZiJ27EjdnnePMXCIKLM5NMnoGdPoEsXIDQUqF1bnhVZqZLSkRFlOkzETNzw4fKybl1l4yCiTOLmTZlwrVwpB+ZPmiTP9MmdW+nIiDIlnjVpwlSq2OXq1ZWLg4gykZkz5RmROXMC69bxVxzRZ2IiZsLiDtIfNEi5OIgoE/npJ8DSUs4Z6e6udDREmR67Jk3U06dySAcA5MjBE5yIKBHXrgEjR8pCrQDg5ASsWMEkjMhA2CJmokaOjF1+8QKwsFAuFiLKgIQAfv0VGDwYCA8HihaVhVqJyKCYiJmgiAhg40a5XLy47GUgItIICQH69gU2bJDrjRtznkiiNMKuSRO0enXs8sKFioVBRBnR5ctyAOmGDbKpfOZMYPduOYaBiAzus9pCwsPDYWtra6hYKB0cOQL06xe7Xq+ecrEQUQazdq3sfoyMBDw9ZTJWrZrSUREZNb1bxFQqFaZNmwYPDw84ODjg4cOHAIAJEyZgxYoVBg+QDCtu4rVli3JxEFEGlD8/EBMDNG8uz+ZhEkaU5vROxL777jusXr0aP/74I6ytrTXbS5UqhV9//dWgwVHaGTMGaNNG6SiISHHBwbHLNWoAZ84AO3fyVGqidKJ3IrZmzRosW7YMnTp1gkWcU+3Kli2L27dvGzQ4MpywMO0zIwcPVi4WIsoAhAAWLAC8vGS1fLWKFWXFfCJKF3onYs+fP0ehQoUSbFepVIiKijJIUGR4a9fGVtK3tARy5VI2HiJS0Lt3wJdfAkOHAkFB2mfwEFG60jsRK1GiBE6cOJFg+5YtW1C+fHmDBEWG17dv7HJkpHJxEJHC/vkHKF9edj9aW8tTp2fOVDoqIpOl91mTEydORLdu3fD8+XOoVCps27YNd+7cwZo1a7B79+60iJE+0x9/xC4PHsxeByKTpFIBc+cCY8cC0dFAwYKyoGDcuc6IKN2ZCaGetyLlTpw4galTp+Lq1av4+PEjvvjiC0ycOBENGzZMixgNKiQkBE5OTggODoajo6PS4aS5mBjtgq0qFRMxIpO0Zg3QrZtcbtcOWLZMTldElEkY6/d3quqI+fj44ODBg4aOhdLAsmWxy3PnMgkjMlkdOwLr1smxYX378sOAKIPQe4xYgQIF8Pbt2wTbg4KCUKBAAYMERYYze3bs8rBhysVBROlMpZJzRUZEyHVLS2D/flnRmUkYUYahdyLm7++PmJiYBNsjIiLw/PlzgwRFhvPihbyMO1ifiIzc69dyfsjevYHRo2O3MwEjynBS3DW5a9cuzfKBAwfgFGdsQUxMDA4fPgwvLy+DBkef5907IDxcLtevr2wsRJROjh2T3ZAvXwJ2dkCZMkpHRERJSPFgfXNz2XhmZmaG+DexsrKCl5cX5syZg2bNmhk+SgMy1sF+8QkBmMdp7wwOBoz44RJRTAzw/ffAlCmyW7J4cWDzZqBkSaUjIzIIY/3+TnGLmOq/aqD58+fH+fPn4erqmmZB0ef77rvY5X79mIQRGbVXr4BOnYAjR+R6jx6yPliWLMrGRUTJSlX5iszMWDPq+OIOBTGtV5jIBD18KIu0RkcDS5cCXbooHRGRwRnr93eqyleEhobi77//xpMnTxAZr0z7YE5iqLjcuWOXf/lFuTiIKA0JEfuLq0ABYNMmIF8+oFgxZeMiIr3o3SJ2+fJlNGnSBJ8+fUJoaCiyZcuGwMBA2Nvbw83NDQ8fPkyrWA3CWDNqtTdvADe32HUWcCUyQs+fA507yyr5maCQNpEhGOv3t97lK4YNG4bmzZvj/fv3sLOzwz///IPHjx/D29sbs+MWrSJFLFoUuxwdzSSMyOjs3w+UKyfPjuzfX/6jE1GmpXciduXKFfzvf/+Dubk5LCwsEBERAU9PT/z4448YN25cWsRIepg6VV5aWMg/IjISUVHAmDGyPlhgoEzG9u7VnsOMiDIdvRMxKysrTSkLNzc3PHnyBADg5OSEp0+f6h3A4sWL4eXlBVtbW1SuXBnnzp1Lcv+goCAMGDAAuXLlgo2NDYoUKYK9e/fqfb/GaMWK2OXNm5WLg4gM7OlToHZtYOZMud6/P3DmDFCkiKJhEdHn0/unVPny5XH+/HkULlwYtWrVwsSJExEYGIi1a9eiVKlSeh1r48aNGD58OJYuXYrKlStj/vz58PX1xZ07d+AWd6DTfyIjI9GgQQO4ublhy5Yt8PDwwOPHj+Hs7KzvwzBKvXrFLvv6KhcHERnQ8+ey9evdO1mHZsUK4KuvlI6KiAxE78H6Fy5cwIcPH1CnTh28fv0aXbt2xenTp1G4cGGsWLEC5cqVS/GxKleujIoVK2LRfwObVCoVPD09MWjQIIwZMybB/kuXLsWsWbNw+/ZtWFlZ6RO2hrEO9gsOBtT56IoVwNdfKxoOERlS9+7AjRvAxo3yDEkiE2Ss39+K1RGLjIyEvb09tmzZglatWmm2d+vWDUFBQdi5c2eC2zRp0gTZsmWDvb09du7ciRw5cqBjx44YPXo0LFI4IMoYX8i3b4G49XWjojhshChT8/cHHBxi/7E/fZKDPm1sFA2LSEnG+P0NpGKMWGIuXbqk1/RGgYGBiImJgbu7u9Z2d3d3vHr1SudtHj58iC1btiAmJgZ79+7FhAkTMGfOHHwXt4x8PBEREQgJCdH6Mzb/+1/sct++TMKIMrXt22VXZLdusv4MANjbMwkjMlJ6JWIHDhzAiBEjMG7cOE29sNu3b6NVq1aoWLGiZhqktKJSqeDm5oZly5bB29sbfn5+GD9+PJYuXZrobaZPnw4nJyfNn6enZ5rGqITffpOXjo6yqDYRZUIREcDgwUDr1nKswdu38pKIjFqKE7EVK1agcePGWL16NWbOnIkqVarg999/R9WqVZEzZ05cv35dr7MXXV1dYWFhgYCAAK3tAQEByJkzp87b5MqVC0WKFNHqhixevDhevXqVoMK/2tixYxEcHKz5S82ZnRnZp0+xy6NGKRcHEX2GBw+A6tXl/JAAMGIEcOIE4OKibFxElOZSnIgtWLAAM2fORGBgIDZt2oTAwEAsWbIE165dw9KlS1G8eHG97tja2hre3t44fPiwZptKpcLhw4dRtWpVnbepXr067t+/r9XydvfuXeTKlQvW1tY6b2NjYwNHR0etP2Ny6lTs8ujRysVBRKm0aZOcJ/LiRSB7dmD3bmDWLCCVJyQRUeaS4kTswYMHaNu2LQCgdevWsLS0xKxZs5AnT55U3/nw4cOxfPly/Pbbb7h16xa++eYbhIaGokePHgCArl27YuzYsZr9v/nmG7x79w5DhgzB3bt3sWfPHvzwww8YMGBAqmPI7DZtil3m2DCiTCY8XE5T9OGDbBG7cgVo2lTpqIgoHaX4qzssLAz29vYAADMzM9jY2CBXrlyfded+fn548+YNJk6ciFevXqFcuXLYv3+/ZgD/kydPNMVjAcDT0xMHDhzAsGHDUKZMGXh4eGDIkCEYbcJNQb/+Ki+LFlU2DiJKBVtbWZJi+3ZgyhT+miIyQSkuX2Fubo7vvvsODg4OAIDRo0dj5MiRcI1bNwHA4MGDDR+lARnT6a9BQbFDSLZtA778UtFwiCgl1q+XgzvjVmAmomQZ0/d3XClOxLy8vGCWzAzSZmZmmrMpMypjeiH//RcoW1Yuq1Sc4JsoQ/v0CRgyRDZjW1vLbkg9x9YSmTJj+v6OK8Xt4P7+/mkYBqVGRETsMpMwogzs1i2gXTvg+nX5zzp2LOeJJCIAqZhrkjIOdcWOwoWVjYOIkvDbb3KS7k+fAHd32TVZt67SURFRBsFELBMLDJSXiVTuICIlCQH07i0nfwWA+vWB33+XyRgR0X8MNsURpa9duwD1FJ1xuyiJKIMwM5MTdJubA9OmAfv3MwkjogTYIpYJhYcDLVvGrvv6KhcLEcUhhJyWyNlZro8ZAzRqBHzxhaJhEVHGxRaxTCgsLHZ5yxZg0SLlYiGi/3z4AHTqBPj4xM49Zm7OJIyIkpSqROzBgwf49ttv0aFDB7x+/RoAsG/fPty4ccOgwZFud+/GLrdooVwcRPSfK1cAb2/gjz/kGZLHjysdERFlEnonYn///TdKly6Ns2fPYtu2bfj48SMA4OrVq5g0aZLBA6SENmyIXWYhbiIFCQH8/DNQpQpw7x7g6SmTsEaNlI6MiDIJvROxMWPG4LvvvsPBgwe1JtquW7cu/vnnH4MGR7qtWSMvq1dn/TAixQQHA35+sjRFRATQvDlw+TJQrZrSkRFRJqJ3Inbt2jV8qWMuHTc3NwSq6ylQmomIAN69k8t16igbC5FJGzgQ2LxZNkvPmQPs3Alkz650VESUyeidiDk7O+Ply5cJtl++fBkeHh4GCYoSN3Nm7PLIkcrFQWTypk+X48JOngSGD2fzNBGlit6JWPv27TF69Gi8evUKZmZmUKlUOHXqFEaMGIGuXbumRYwUh3oYnpUVYERTbRFlfO/fyyr5annyAOfPA5UrKxcTEWV6eidiP/zwA4oVKwZPT098/PgRJUqUQM2aNVGtWjV8++23aREj/Sfu2ZJ8qonS0dmzQPnyQPfusgtSja1gRPSZ9D7nztraGsuXL8eECRNw/fp1fPz4EeXLl0dhTniY5pYujV1mtyRROhACmDtXFmaNjgYKFpQtYUREBqJ3Inby5EnUqFEDefPmRd68edMiJkrE+vXysnRpwM5O2ViIjN7bt7IFbPduud6uHbB8OccEEJFB6d01WbduXeTPnx/jxo3DzZs30yIm0iEmBggIkMudOikbC5HRO3UKKFdOJmE2NrJW2IYNTMKIyOD0TsRevHiB//3vf/j7779RqlQplCtXDrNmzcKzZ8/SIj76z6+/xi7znAiiNPbiBfDsGVC4MPDPP0C/fhwPRkRpQu9EzNXVFQMHDsSpU6fw4MEDtG3bFr/99hu8vLxQt27dtIiRALx6FbucK5dycRAZLSFil9u2BVavBi5elC1jRERpxEyIuJ8++ouJicG+ffswYcIE/Pvvv4iJiTFUbGkiJCQETk5OCA4OhmMm6mZQ/xhv2xbYtEnZWIiMzt9/A8OGAXv28JcOUQaVWb+/k5OqSb8B4NSpU+jfvz9y5cqFjh07olSpUtizZ48hY6P/BAXFLteooVgYRMYnJgaYNg2oW1dOTzRxotIREZGJ0fusybFjx2LDhg148eIFGjRogAULFqBly5awt7dPi/gIwNChscuDBikWBpFxefUK6NwZOHxYrnfvDsyfr2RERGSC9E7Ejh8/jpEjR6Jdu3ZwdXVNi5gonr175WWpUhwvTGQQhw/L048DAgB7e3lWJM+CISIF6J2InTp1Ki3ioCS8fSsvhwxRNg4io7B9O9CmjRycX6qUHHRZvLjSURGRiUpRIrZr1y40btwYVlZW2LVrV5L7tmjRwiCBkRQdDahUcrlKFWVjITIKDRoARYsCPj7AggWsjkxEikrRWZPm5uZ49eoV3NzcYG6e+Ph+MzMznjVpYB8+xNaQDA2VvShEpKfz5wFvb0D9+RUcDDg5KRsTEekls31/p1SKzppUqVRwc3PTLCf2l9GTsMwoMjJ22cZGuTiIMqXoaGDsWKBSJTlnpBqTMCLKIPQuX7FmzRpEREQk2B4ZGYk1a9YYJCiKpX6qzc0BCwtlYyHKVJ4+BWrXBmbMkOuc/YOIMiC9E7EePXogODg4wfYPHz6gR48eBgmKYj15Ii/V48SIKAX27JEV8U+dkn37mzezNAURZUh6J2JCCJjpqKHw7NkzOLG53+BCQ5WOgCgTiYwERowAmjUD3r0DKlSQhVq/+krpyIiIdEpx+Yry5cvDzMwMZmZmqFevHiwtY28aExODR48eoVGjRmkSpClTn4RaqZKycRBlCrduAT/9JJeHDAFmzuTgSiLK0FKciLVq1QoAcOXKFfj6+sLBwUFznbW1Nby8vNCmTRuDB2jK7twBPn2Sy1mzKhsLUaZQtiywaBHg5gb895lFRJSRpTgRmzRpEgDAy8sLfn5+sLW1TbOgSPr999hldXV9IoojIgIYNw7o0kWOCQOAPn0UDYmISB96V9bv1q1bWsRBOqiTrw4dAGtrZWMhynAePAD8/ICLF4Hdu4Hr1wErK6WjIiLSS4oSsWzZsuHu3btwdXWFi4uLzsH6au/evTNYcKYsJga4dEkulymjbCxEGc7mzUCvXkBICJAtm6wRxiSMiDKhFCVi8+bNQ9b/BinNmzcvyUSMDOOff2KXO3VSLg6iDCU8HBg+XE7SDQDVqwN//AF4eiobFxFRKqUoEYvbHdm9e/e0ioXiuHYtdpnfMUQA3rwBGjYErlyR62PHAlOnApZ6j7AgIsow9K4jdunSJVyLkyXs3LkTrVq1wrhx4xAZdz4eSrXHj4FvvpHL+fMrGwtRhpEtG+DqCuTIAezfD/zwA5MwIsr09E7E+vbti7t37wIAHj58CD8/P9jb22Pz5s0YNWqUwQM0RT4+scu9eysXB5HiPn0CwsLksoUFsG6dbBHz9VU0LCIiQ9E7Ebt79y7K/Xea+ObNm1GrVi2sX78eq1evxtatWw0dn0l6+lRe5soFjBmjbCxEirl1C6hcGRg6NHabmxuQO7diIRERGVqqpjhS/Tfx4aFDh9CkSRMAgKenJwIDAw0bnQnq0CF2+fx5gOdFkEn67Tc5PdH168DOnXJ8GBGREdI7EatQoQK+++47rF27Fn///TeaNm0KAHj06BHc3d0NHqApWbMG2LAhdp0//MnkhIYC3bvLv0+fgHr1ZFdkjhwKB0ZElDb0TsTmz5+PS5cuYeDAgRg/fjwKFSoEANiyZQuqVatm8ABNRVQUELdW7tu3bA0jE3P9OlCxomwNMzcHpk0DDhwAcuZUOjIiojRjJoQQhjhQeHg4LCwsYJXBiyqGhITAyckJwcHBcHR0VDocjadPgbx55fLBg0D9+srGQ5SuIiOBggWBZ89kU/D69UCtWkpHRUQZSEb9/v5cqT73++LFi7h16xYAoESJEvjiiy8MFpQpunNHXjo7MwkjE2RtDSxdCixeLFvE2BVJRCZC70Ts9evX8PPzw99//w1nZ2cAQFBQEOrUqYMNGzYgBz9AU2XHDnkZFKRkFETp6OpV4PVroEEDud60KdCkCfvkicik6D1GbNCgQfj48SNu3LiBd+/e4d27d7h+/TpCQkIwePDgtIjRJKxdKy/ZGkZGTwjZ+lW5spy0+8mT2OuYhBGRidG7RWz//v04dOgQihcvrtlWokQJLF68GA0bNjRocKYiOlrOXQywbhgZueBgoE8fYNMmud6gAZAli7IxEREpSO8WMZVKpXNAvpWVlaa+GOnn9evYZY5PJqN18SLwxRcyCbO0BObMAXbtArJnVzoyIiLF6J2I1a1bF0OGDMGLFy80254/f45hw4ahXr16Bg3OVPx3zgOyZuXUeWSkFi4EqlUDHj4E8uUDTp4Ehg9nVyQRmTy9E7FFixYhJCQEXl5eKFiwIAoWLIj8+fMjJCQECxcuTIsYjZq/f+y4sI8fFQ2FKO3cuCFLVLRqBVy+LMeHERGR/mPEPD09cenSJRw+fFhTvqJ48eKoz1HmqXLiROzylCnKxUFkcELEtnjNmydbxLp0YSsYEVEceiViGzduxK5duxAZGYl69eph0KBBaRWXyYiMlJdVqwITJigbC5FBCCETr4MHgd27AQsLwM4O6NpV6ciIiDKcFCdiP//8MwYMGIDChQvDzs4O27Ztw4MHDzBr1qy0jM/oRUXJS87iQkbh7Vs5T+Tu3XJ92zagbVtFQyIiyshSPEZs0aJFmDRpEu7cuYMrV67gt99+w5IlS9IyNpOgTsQy+MxQRMk7fRooX14mYTY2wM8/A199pXRUREQZWooTsYcPH6JbnFmpO3bsiOjoaLx8+TJNAjMV6hq4TMQo01KpgJkzgZo15aSphQsD//wD9OvH8WBERMlIcSIWERGBLHEKL5qbm8Pa2hphYWFpEpgpiFtQPDxcuTiIPsvgwbIScUwM0LGjrBdWrpzSURERZQp6DdafMGEC7O3tNeuRkZH4/vvv4eTkpNk2d+5cw0Vn5JYujV1esUK5OIg+S58+wB9/AD/+CHz9NVvBiIj0YCaEECnZsXbt2jBL5gPWzMwMR44cMUhgaSUkJAROTk4IDg6Go6OjYnF8+qQ9s0vKXgWiDCAmBrhwQbsW2IcPsiIxEVEaySjf34aW4haxY8eOpWEYpqds2djlo0eVi4NILwEBQOfOwLFjsjq+OhljEkZElCp6V9anzxcSAty/L5ddXTm/JGUSR47IXxCHDgHW1sCzZ0pHRESU6TERU8DDh7HL9+5xSA1lcDExwKRJci6ugACgVCnZNdmmjdKRERFlepxiWgHdu8vLQoUAZ2clIyFKxosXQKdOsisSAHr1AhYsAOKctENERKmXIVrEFi9eDC8vL9ja2qJy5co4d+5cim63YcMGmJmZoVWrVmkboIGpy1ZYWCgbB1Gytm2TSZiDA7BuHbB8OZMwIiIDUjwR27hxI4YPH45Jkybh0qVLKFu2LHx9ffH69eskb+fv748RI0bAx8cnnSI1nOBgeblnj7JxECVrwABgxAhZG6xjR6WjISIyOqlKxE6cOIHOnTujatWqeP78OQBg7dq1OHnypN7Hmjt3Lnr37o0ePXqgRIkSWLp0Kezt7bFy5cpEbxMTE4NOnTphypQpKFCgQGoegmJu3ZKFyAHAxUXZWIgSePZM9p1/+CDXzcyAWbOAIkUUDYuIyFjpnYht3boVvr6+sLOzw+XLlxEREQEACA4Oxg8//KDXsSIjI3Hx4kXUr18/NiBzc9SvXx9nzpxJ9HZTp06Fm5sbevbsqW/4ips6NXaZiRhlKHv2yIr4v/0G/O9/SkdDRGQS9E7EvvvuOyxduhTLly+HVZwJEqtXr45Lly7pdazAwEDExMTA3d1da7u7uztevXql8zYnT57EihUrsHz58hTdR0REBEJCQrT+lBITA2zYIJe//JJnS1IGERUFjBwJNGsGvH0LeHsDo0crHRURkUnQOxG7c+cOatasmWC7k5MTgoKCDBFToj58+IAuXbpg+fLlcHV1TdFtpk+fDicnJ82fp6dnmsaYlG3bYpeHDVMsDKJYjx/Lybpnz5brgwcDp04BBQsqGxcRkYnQu3xFzpw5cf/+fXh5eWltP3nypN7jtVxdXWFhYYGAgACt7QEBAciZM2eC/R88eAB/f380b95cs03134ArS0tL3LlzBwXjfYGMHTsWw4cP16yHhIQoloytWRO7nAnPMSBjc+IE0KIFEBQk66isWgVksjOQiYgyO71bxHr37o0hQ4bg7NmzMDMzw4sXL7Bu3TqMGDEC33zzjV7Hsra2hre3Nw4fPqzZplKpcPjwYVStWjXB/sWKFcO1a9dw5coVzV+LFi1Qp04dXLlyRWeCZWNjA0dHR60/pdy5Iy/VdcSIFFW4MGBjI6cpunyZSRgRkQL0bhEbM2YMVCoV6tWrh0+fPqFmzZqwsbHBiBEjMGjQIL0DGD58OLp164YKFSqgUqVKmD9/PkJDQ9GjRw8AQNeuXeHh4YHp06fD1tYWpUqV0rq9838VUeNvz4ju3ZOXTZsqGweZsLdvgezZ5XLOnLJGWIECcsoiIiJKd3onYmZmZhg/fjxGjhyJ+/fv4+PHjyhRogQcHBxSFYCfnx/evHmDiRMn4tWrVyhXrhz279+vGcD/5MkTmJsrXu7ss717F7tcurRycZAJ27IF6NkTWLYM8POT24oVUzYmIiITZyaEEEoHkZ5CQkLg5OSE4ODgdO2mrFQJOH9eLoeFAba26XbXZOrCw2U5iiVL5HrjxrJUBU/bJaJMRKnv77Smd4tYnTp1YJbEB/iRI0c+KyBjJERsElapEpMwSkf37gHt2gFXrsj1MWNkMTsmYUREGYLeiVi5cuW01qOionDlyhVcv34d3bp1M1RcRqV8+djlJCYMIDKsP/4A+vQBPn4EXF2BtWuBRo2UjoqIiOLQOxGbN2+ezu2TJ0/Gx48fPzsgY3T1auxyyZLKxUEm5N9/Y+eGrFkTWL8e8PBQNiYiIkrAYKPgO3funOT8kKbqv6k4AQBxqnQQpa0yZeRk3RMmyDcekzAiogxJ7xaxxJw5cwa2HPyUwKJFscs6JiQgMpx162Sl4Lx55fqPP3IsGBFRBqd3Ita6dWutdSEEXr58iQsXLmDChAkGC8wYhIQAM2bI5QIFAEuDpb1EcYSGAoMGycr41arJ2mBWVkzCiIgyAb1TAycnJ611c3NzFC1aFFOnTkXDhg0NFpgx+Prr2OVvv1UuDjJiN27IsyJv3gTMzQFfX3lJRESZgl51xGJiYnDq1CmULl0aLi4uaRlXmknPOiRxGySCgwEjKntCShNCtoANHCgL0+XKJQfk166tdGRERGnCWOuI6fXT2cLCAg0bNkRQUFAahWM83r6NXT54kEkYGVBoKNC1q6ySHxYmW8GuXGESRkSUCendh1GqVCk8fPgwLWIxKl99Fbtcr55ycZARMjeX5SksLIDp04G9ewE3N6WjIiKiVNB7iqP9+/dj7NixmDZtGry9vZElSxat6zN6c2F6NW2quyWtrYGIiDS7GzIVQsg/9fivO3eAN2+AGjWUjYuIKJ0Ya9dkihOxqVOn4n//+x+yZs0ae+M4g6CEEDAzM0NMTIzhozSg9Hgh378HsmWTyzdvAsWLp8ndkKkIDpYV8kuX5lkfRGSyTD4Rs7CwwMuXL3Hr1q0k96tVq5ZBAksr6fFC/vIL0K+fXI6J4Uls9BkuXgT8/IAHD+QkpQ8fyoH5REQmxlgTsRSXr1Dnaxk90coItm+Xl4ULMwmjVBJCVgMeMQKIjATy5QM2bGASRkRkZPSqI2bGApEpEh0tL1u0UDYOyqSCguQZkdu2yfVWreRs8Zm0ZAwRESVOr0SsSJEiySZj7969+6yAMrvo6Ng5JStWVDYWyoSio2V1/Fu3ZHX82bNl1Xz+CCIiMkp6JWJTpkxJUFmftJ0+HbtcvbpycVAmZWkJDBki54ncuBGoUEHpiIiIKA3plYi1b98ebqxXlKSbN2OX8+RRLg7KRN69A16+BEqWlOt9+gCdOwPxSsMQEZHxSfFQco4PS5kzZ+QlGw4pRU6fBsqVA5o1k2PDANkNySSMiMgkpDgR07Puq8k6cEBeNmumbByUwalUwMyZQM2awNOncjzY69dKR0VEROksxV2TKpUqLeMwGgULAgEBQIkSSkdCGdabN0C3bsC+fXK9QwdZfC5OsWQiIjINeo0Ro+SpS1eUKaNsHJRBHT8uE68XL2SB1oULZakKdv0TEZkkJmIGpk7ELCyUjYMyqLlzZRJWrBiwaZOctoiIiEwWEzEDU0+1aclnlnRZsQIoUACYOhVwcFA6GiIiUhgn4DEwdYsYEzECABw5Avzvf3LKIgDInl22ijEJIyIisEXM4G7ckJfsmjRxMTGy1WvaNJmEVa4MtGundFRERJTBMBEzoPDw2GU7O+XiIIW9eAF06gQcOybXe/ZkPRMiItKJiZgBvX8fu+ztrVwcpKC//pJV8d+8kUVZf/lFJmVEREQ6cIyYAS1eLC8dHABzPrOmZ9YsoFEjmYSVLQtcusQkjIiIksR0wYC+/15efvyobBykkPLl5eU33wD//AMUKaJsPERElOGxa9JA3r6NXd6yRbk4KJ29fg24ucnl+vWBa9diJ+8mIiJKBlvEDMTVNXb5yy+Vi4PSSVQUMHKkbPV68CB2O5MwIiLSAxMxA1DXDgMADw+ODzN6jx8DPj7A7NlAcDDw559KR0RERJkUuyYN4Pz52GV/f8XCoPSwYwfQowcQFAQ4OQErVwKtWysdFRERZVJsuzGAe/fkpZ0dK+obrchIYOhQ2e8cFARUqgRcvswkjIiIPgsTMQM4fFheNmmibByUhhYtAhYskMvDhwMnTgD58ysbExERZXpsvzGAV6/kZUiIsnFQGho4EDh4EOjfH2jeXOloiIjISLBFzAD++kteVq2qbBxkQOHhcnLuqCi5bm0N7NvHJIyIiAyKLWKfafny2OUvvlAuDjKge/cAPz85BuzNG2D6dKUjIiIiI8UWsc+0YkXscsOGysVBBrJhg8yoL1+WxeFq1lQ6IiIiMmJMxD6DSgWcPSuXJ06UZ01SJhUWBvTtC3ToIOeo8vEBrlwBGjdWOjIiIjJiTMQ+w9Chscs1aigWBn2uu3eBypWBZcsAMzPg22+BI0dkdV4iIqI0xDFin2Hv3tjl+vWVi4M+k0oFPHwo54xct44vJhERpRsmYp/B01NOMzhjhmxIoUxEpYqdi6pYMWDbNqB0aSBXLmXjIiIik8Kuyc/w8KG8LFZM2ThITzduAOXKAcePx25r2JBJGBERpTsmYp/hyRN5aWOjbByUQkLI01wrVgSuXQP+9z+5jYiISCFMxFIpbmNK0aLKxUEp9OED0KUL0KuXPEOyYUNgzx72KRMRkaKYiKXSn3/GLnt5KRYGpcTVq0CFCnIgvoUF8MMPskq+m5vSkRERkYnjYP1UUvdo9enDRpUM7dYtWZoiIkKWo9iwgbVGiIgow2AilkqRkfIyRw5l46BkFCsGtGgBhIYCv/0mq+UTERFlEEzEUmnJEnnJgfoZ0OXLQP78gLOzbK787Tf5QpmzJ56IiDIWfjOlghBATIxcdnZWNBSKSwhg0SKgShU5KF/df2xnxySMiIgyJLaIpcLRo7HLfn7KxUFxBAUBPXvKwqwAEB0NhIdzAlAiIsrQ2EyQCgsXxi7zxLsM4Nw5oHx5mYRZWQHz5wPbtzMJIyKiDI+JWCrs2CEvGzZUNAwSApg3T54F6e8vx4WdOgUMGcJTWYmIKFNgIqansLDY5X79lIuDAAQHA3PnAlFRQJs2wKVLsmo+ERFRJsExYno6dix2uWVLxcIgQJ4p8ccfsmBr//5sBSMiokyHiZiePnyQl9bWPBEv3alUwOzZQM6cQNeucluNGizQSkREmRYTMT2NHCkv69ZVNg6T8+YN0K2bnJrI3h6oUwfw9FQ6KiIios/CREwPN24AT57I5ZcvlY3FpJw4AbRvD7x4AdjayrMi8+RROioiIqLPxs41PYwfH7t88KBycZgMlQr4/nugdm2ZhBUtCpw9C/TuzfFgRERkFNgilkJCADt3yuXevTnHZJqLiQGaNgUOHJDrXbrIeaUcHJSNi4iIyIDYIpZCUVGxyyNGKBeHybCwACpUkOPBVq0C1qxhEkZEREYnQyRiixcvhpeXF2xtbVG5cmWcO3cu0X2XL18OHx8fuLi4wMXFBfXr109yf0MJCopdzps3ze/ONMXEyEH5apMnA1euAN27KxQQERFR2lI8Edu4cSOGDx+OSZMm4dKlSyhbtix8fX3x+vVrnfsfO3YMHTp0wNGjR3HmzBl4enqiYcOGeP78eZrGOWhQ7LKNTZrelWl6+RJo0ABo3BiIiJDbLC2BwoWVjYuIiCgNmQkhhJIBVK5cGRUrVsSiRYsAACqVCp6enhg0aBDGjBmT7O1jYmLg4uKCRYsWoau6tlQSQkJC4OTkhODgYDg6OqY4zrhjw5V9xozQX38BnTvL1rAsWYAjR4BKlZSOioiIMpDUfn9ndIq2iEVGRuLixYuoX7++Zpu5uTnq16+PM2fOpOgYnz59QlRUFLJly5ZWYeL06djlOXPS7G5MT3S0PBW1USOZhJUpA1y8yCSMiIhMhqJnTQYGBiImJgbu7u5a293d3XH79u0UHWP06NHInTu3VjIXV0REBCLUXV2QGbW+btyIXe7bV++bky7PngEdO8oaYYB8YufNA+zslI2LiIgoHSk+RuxzzJgxAxs2bMD27dtha2urc5/p06fDyclJ8+eZimrs4eHy0s9P9pyRAfTuLZOwrFmBDRuApUuZhBERkclRNBFzdXWFhYUFAgICtLYHBAQgZ86cSd529uzZmDFjBv766y+UKVMm0f3Gjh2L4OBgzd/Tp0/1jnPcOHnJQfoGtHixnKbo0iWZ4RIREZkgRRMxa2treHt74/Dhw5ptKpUKhw8fRtWqVRO93Y8//ohp06Zh//79qFChQpL3YWNjA0dHR60/fXl5ycs0PjHTuD15Avz6a+x6gQJyUH6hQsrFREREpDDFK+sPHz4c3bp1Q4UKFVCpUiXMnz8foaGh6NGjBwCga9eu8PDwwPTp0wEAM2fOxMSJE7F+/Xp4eXnh1atXAAAHBwc4pFHBT3VLWNwSFqSHXbtkLbCgIFmErWFDpSMiIiLKEBRPxPz8/PDmzRtMnDgRr169Qrly5bB//37NAP4nT57A3Dy24e7nn39GZGQkvvrqK63jTJo0CZMnT06TGCMj5SXHh+kpMhIYPVpO0g0AFSuyLhgREVEcitcRS2+pqUNSqBDw4AFw7BhQq1baxmc0Hj2SY7/On5frw4YBM2YA1tbKxkVERJmSsdYRU7xFLDN48EBeWlkpG0emsWOH7IoMDgZcXIDVq4EWLRQOioiIKONhIpYC5uaASgXEK3dGiQkJkUlY1aqyNAUn5yQiItKJiVgyoqNlEgbIxh1KREwMYGEhl7t2BWxtgS+/ZDMiERFREjJ1Qdf08PFj7HIiNWNpwwagdGkgMDB2W7t2TMKIiIiSwUQsGXv2xC4zEYsnLExOTdShA3DrFjB3rtIRERERZSrsmkxGaGjssjnT1li3b8tWr2vXADMzOf1AGpUPISIiMlZMxJKhLvrfurWycWQoa9cC33wjs1Q3N+D334EGDZSOioiIKNNhIpYM9dSUlnympF9+Afr1k8t16gDr1gG5cikbExERUSbFzrZkRETIy06dlI0jw2jfXla4nTwZOHiQSRgREdFnYDtPMq5dk5dpNI1lxieEnJy7bl05FszJCfj3X8DOTunIiIiIMj22iCXhzRsgKkou29srG4siPn4EunUD6tcHli6N3c4kjIiIyCDYIpaES5dilytUUC4ORfz7rzwr8s4debpo3NNHiYiIyCCYiCXh55/lpbOzCQ3WFwJYtgwYMkQOkPPwAP74A/DxUToyIiIio2Mq6UWqXL4sL7NnVzaOdBMSAvTpA2zcKNcbNwbWrAFcXZWNi4iIyEhxjFgiPn0CnjyRyyNHKhtLurl+Hdi8Wc4Z+eOPwO7dTMKIiIjSEFvEEtG7d+yyyZSuqFYNWLQIKFcOqFpV6WiIiIiMHlvEdFCpgPXr5bKzsxGXrggKArp0kfNEqn3zDZMwIiKidMIWMR3iVmq4f1+5ONLU+fOAnx/w6BFw8yZw4YKsE0ZERETphi1i8ahUwIABsetGN1BfCGD+fKB6dZmEeXnJzJNJGBERUbpji1g8cVvAdu9WLo408e4d0KMHsGuXXG/dGlixQva/EhERUbpjIhZPWJi8NDMDmjZVNhaDevQIqF1bngpqbQ3MnQv078+WMCIiIgUxEYvn7l156eWlaBiG5+kJ5M0LWFkBmzYBX3yhdEREREQmj4lYPBER8vLRI2XjMIi3b4GsWWULmKWlrBFmbw84OiodGREREYGD9RNQV3Jo2VLZOD7biRNA2bLA6NGx23LmZBJGRESUgTARi+eHH+RlZKSycaSaSiUfRJ06wPPnwP79nLCbiIgog2IiFk+RIvKyShVl40iV16+BRo2A8eOBmBigc2dZLyxLFqUjIyIiIh04Riwe9RixRo2UjUNvR48CHTsCr14BdnbA4sVA9+48K5KIiCgDYyIWz+PH8tLGRtk49BISArRpA7x/D5QoIc+KLFlS6aiIiIgoGUzE4ti+PXY5U9U4dXQEfvkF2LcPWLiQXZFERESZhJkQQigdRHoKCQmBk5MTgoOD4RjvDMK4vXgqVQbv1Tt0CDA3B+rWVToSIiKiNJfU93dmxsH6/wkKil0ePz4DJ2HR0cC33wINGwIdOgAvXyodEREREaUSuyb/c/Vq7PLkyYqFkbTnz2XydeKEXG/VKpP1oRIREVFcTMT+s2dP7LJlRnxW9u0DunYFAgMBBwdg+XKgfXuloyIiIqLPwK7J/8yaJS8rVFA2jgRUKlkdv0kTmYSVLw9cusQkjIiIyAgwEYP2vJL16ysXh07m5rI2GAAMGACcPg0ULqxsTERERGQQGbETLt35+8cujxqlWBjaoqNj+0gXLwbatgWaNVM2JiKiNCaEQHR0NGJiYpQOhRRgZWUFCwsLpcNIV0zEAAwZIi+9vQEXF2VjQWQkMGYMcP8+sHOnPH3TwYFJGBEZvcjISLx8+RKfPn1SOhRSiJmZGfLkyQMHBwelQ0k3TMTiyJtX4QAePQL8/OT8kABw7JicvJuIyMipVCo8evQIFhYWyJ07N6ytrWGWYesIUVoQQuDNmzd49uwZChcubDItY0zEAERFycuhQxUMYts24OuvgeBgWZJi9WomYURkMiIjI6FSqeDp6Ql7e3ulwyGF5MiRA/7+/oiKijKZRIyD9SF7AwHAykqBO4+IAAYNknNFBgcDVaoAV64ALVsqEAwRkbLMzfm1ZMpMsRWU73gADx/KS0USsU6dgEWL5PLIkcDx40C+fAoEQkREROnN5BOxuDNtKpKIjR4N5MoF7N4N/PijQkEQERGREkw+EYuOjl329EyHOwwLA/7+O3a9YkXZJNe0aTrcORERpYUzZ87AwsICTXV8lh87dgxmZmYIijup8X+8vLwwf/58rW1Hjx5FkyZNkD17dtjb26NEiRL43//+h+fPn6dR9EB4eDgGDBiA7Nmzw8HBAW3atEFAQECSt/n48SMGDhyIPHnywM7ODiVKlMDSpUt17iuEQOPGjWFmZoYdO3akwSPIvJiIxUnE0rwx6s4dOQbM11eOA1OztU3jOyYiorS0YsUKDBo0CMePH8eLFy9SfZxffvkF9evXR86cObF161bcvHkTS5cuRXBwMObMmWPAiLUNGzYMf/75JzZv3oy///4bL168QOvWrZO8zfDhw7F//378/vvvuHXrFoYOHYqBAwdi165dCfadP3++SY7/SgmTP2sy3RKxdeuAvn2B0FAgRw5Axy8jIiLKfD5+/IiNGzfiwoULePXqFVavXo1x48bpfZxnz55h8ODBGDx4MObNm6fZ7uXlhZo1a+psUTOE4OBgrFixAuvXr0fdunUBAKtWrULx4sXxzz//oEqVKjpvd/r0aXTr1g21a9cGAPTp0we//PILzp07hxYtWmj2u3LlCubMmYMLFy4gV65cafIYMjOTbxFTl64A0miy70+fgF69gM6dZRJWu7ZsDfvvjUtERAkJIT8ylfiLO3Y4JTZt2oRixYqhaNGi6Ny5M1auXAmh70EAbN68GZGRkRiVyBQvzs7Oid62cePGcHBwSPSvZMmSid724sWLiIqKQv04c/wVK1YMefPmxZkzZxK9XbVq1bBr1y48f/4cQggcPXoUd+/eRcOGDTX7fPr0CR07dsTixYuRM2fOJB696TL5FjF16QoAMHjJkps3gXbtgBs3ZIX8iROBCRPS4I6IiIzLp09yUhElfPwIZMmS8v1XrFiBzp07AwAaNWqE4OBg/P3335qWopS6d+8eHB0dU9Vq9OuvvyIsLCzR662S6PJ59eoVrK2tEyR67u7ueKWe61iHhQsXok+fPsiTJw8sLS1hbm6O5cuXo2bNmpp9hg0bhmrVqqElSzIlyuQTsZ075aWZmfwz+MFv3ABy5pRdk/81+RIRkXG4c+cOzp07h+3btwMALC0t4efnhxUrVuidiAkhUj2OysPDI1W3+xwLFy7EP//8g127diFfvnw4fvw4BgwYgNy5c6N+/frYtWsXjhw5gsuXL6d7bJmJySdi338vL21s0uDgo0bJdu5BgwB39zS4AyIi42RvL1umlLrvlFqxYgWio6ORO3duzTYhBGxsbLBo0SI4OTnB0dERgByLFb/VKSgoCE5OTgCAIkWKIDg4GC9fvtS7Vaxx48Y4ceJEotfny5cPN27c0Hldzpw5ERkZiaCgIK34AgICEu1ODAsLw7hx47B9+3bNmaJlypTBlStXMHv2bNSvXx9HjhzBgwcPEjzmNm3awMfHB8eOHdPrMRork0/EnJ2Bp0+BsWMNcLBr14CpU4E1awA7O9kF+d13BjgwEZFpMTPTr3tQCdHR0VizZg3mzJmjNS4KAFq1aoU//vgD/fr1Q+HChWFubo6LFy8iX5yC3Q8fPkRwcDCKFCkCAPjqq68wZswY/Pjjj1qD9dXiJ0pxfU7XpLe3N6ysrHD48GG0adMGgGzpe/LkCapWrarzNlFRUYiKikowE4KFhQVUKhUAYMyYMejVq5fW9aVLl8a8efPQvHnzROMxNSafiIWHy8vP6jUUAvj1V2DwYHnAAgWAmTMNEh8REWVMu3fvxvv379GzZ09Nq5ZamzZtsGLFCvTr1w9Zs2ZFr1698L///Q+WlpYoXbo0nj59itGjR6NKlSqoVq0aAMDT0xPz5s3DwIEDERISgq5du8LLywvPnj3DmjVr4ODgkGgJi8/pmnRyckLPnj0xfPhwZMuWDY6Ojhg0aBCqVq2qdcZksWLFMH36dHz55ZdwdHRErVq1MHLkSNjZ2SFfvnz4+++/sWbNGsydOxeAbGnT1aKWN29e5M+fP9XxGh1hYoKDgwUAERwcLKKjhZBZlBDnz6f6gEK0bx97oEaNhHj92qAxExEZu7CwMHHz5k0RFhamdCgp1qxZM9GkSROd1509e1YAEFevXhVCyMc3adIkUaxYMWFnZyfy588v+vTpI968eZPgtgcPHhS+vr7CxcVF2NraimLFiokRI0aIFy9epNljCQsLE/379xcuLi7C3t5efPnll+Lly5da+wAQq1at0qy/fPlSdO/eXeTOnVvY2tqKokWLijlz5giVSpXo/QAQ27dvTzKOxN4Hcb+/jYmZEKk4xzYTCwkJgZOTE4KDgxEc7Ii8eeX2oCAg3g+a5F2+LM+KvH9fdkP+8AMwYgTASWuJiPQSHh6OR48eIX/+/LBlkWuTldT7IO73t3rcnTEw6a7JDx/kpZ1dKpKw7duB9u1l/QtPT2DDBuC/5mUiIiKilDDpRGzLFnmZqh9fFSrIIjfVqwOrVgHZsxs0NiIiIjJ+Jp2InT8vL1NctuX5c0A9INLTEzh3Tg7M5/xZRERElAomPZhp92556eOTzI5CAAsWyKQr7mSmBQsyCSMiIqJUM+lETN24Fa/8i7Z374AvvwSGDpXjwXTMKk9ERESUGiadiKkbsxKZWB745x+gfHk5VZG1NbBwIbB8ebrFR0RkakzsRH6KxxRff5NOxBKlUgGzZ8s+yydPZBfk6dPAwIHsiiQiSgPqyu+fPn1SOBJSUmRkJABZod9UmOxgfX9/4NmzRK48fhwYOVIut2snW8GMqGYJEVFGY2FhAWdnZ7x+/RoAYG9vn+oJsClzUqlUePPmDezt7WFpaTrpiek80njUk30DOmqI1a4NDBkCFCsG9O3LVjAionSgng5HnYyR6TE3N0fevHlNKgk32UTs7Vt52awZUDC/Cpi3AOjQAVDPizV/vmKxERGZIjMzM+TKlQtubm6IiopSOhxSgLW1dYKJxI1dhkjEFi9ejFmzZuHVq1coW7YsFi5ciEqVKiW6/+bNmzFhwgT4+/ujcOHCmDlzJpo0aaLXfR4+LC97t3wNNO4C/PWXrGdx8CCnKCIiUpCFhYVJjREi06Z4xrFx40YMHz4ckyZNwqVLl1C2bFn4+vom2jR9+vRpdOjQAT179sTly5fRqlUrtGrVCtevX9f7vmvhGBqNLSeTMDs7oFMndkMSERFRulF80u/KlSujYsWKWLRoEQA5WM/T0xODBg3CmDFjEuzv5+eH0NBQ7FZXYwVQpUoVlCtXDkuXLk32/tSTho7CWPyAmbCACiheHNi0CShVynAPjIiIiAzGWCf9VrRFLDIyEhcvXkT9+vU128zNzVG/fn2cOXNG523OnDmjtT8A+Pr6Jrp/YsZjukzCevSQcx0xCSMiIqJ0pugYscDAQMTExMDd3V1ru7u7O27fvq3zNq9evdK5/6tXr3TuHxERgYiICM16cHCwPA5s8WT8AuQd1R6IiQFCQj7noRAREVEaCvnve9rYir5miMH6aWn69OmYMmVKgu1FEQ5831f+ERERUabw9u1bOCWoO5V5KZqIubq6wsLCAgEBAVrbAwICNPVk4suZM6de+48dOxbDhw/XrAcFBSFfvnx48uSJUb2QmVFISAg8PT3x9OlTo+rvz6z4emQcfC0yDr4WGUdwcDDy5s2LbNmyKR2KQSmaiFlbW8Pb2xuHDx9Gq1atAMjB+ocPH8bAgQN13qZq1ao4fPgwhg4dqtl28OBBVK1aVef+NjY2sLGxSbDdycmJ/1QZhKOjI1+LDISvR8bB1yLj4GuRcRhbnTHFuyaHDx+Obt26oUKFCqhUqRLmz5+P0NBQ9OjRAwDQtWtXeHh4YPr06QCAIUOGoFatWpgzZw6aNm2KDRs24MKFC1i2bJmSD4OIiIhIb4onYn5+fnjz5g0mTpyIV69eoVy5cti/f79mQP6TJ0+0st9q1aph/fr1+PbbbzFu3DgULlwYO3bsQCme9UhERESZjOKJGAAMHDgw0a7IY8eOJdjWtm1btG3bNlX3ZWNjg0mTJunsrqT0xdciY+HrkXHwtcg4+FpkHMb6Wihe0JWIiIjIVBnXiDciIiKiTISJGBEREZFCmIgRERERKcQoE7HFixfDy8sLtra2qFy5Ms6dO5fk/ps3b0axYsVga2uL0qVLY+/evekUqfHT57VYvnw5fHx84OLiAhcXF9SvXz/Z1470o+//htqGDRtgZmamqfdHn0/f1yIoKAgDBgxArly5YGNjgyJFivCzykD0fS3mz5+PokWLws7ODp6enhg2bBjCw8PTKVrjdfz4cTRv3hy5c+eGmZkZduzYkextjh07hi+++AI2NjYoVKgQVq9eneZxGpwwMhs2bBDW1tZi5cqV4saNG6J3797C2dlZBAQE6Nz/1KlTwsLCQvz444/i5s2b4ttvvxVWVlbi2rVr6Ry58dH3tejYsaNYvHixuHz5srh165bo3r27cHJyEs+ePUvnyI2Tvq+H2qNHj4SHh4fw8fERLVu2TJ9gjZy+r0VERISoUKGCaNKkiTh58qR49OiROHbsmLhy5Uo6R2589H0t1q1bJ2xsbMS6devEo0ePxIEDB0SuXLnEsGHD0jly47N3714xfvx4sW3bNgFAbN++Pcn9Hz58KOzt7cXw4cPFzZs3xcKFC4WFhYXYv39/+gRsIEaXiFWqVEkMGDBAsx4TEyNy584tpk+frnP/du3aiaZNm2ptq1y5sujbt2+axmkK9H0t4ouOjhZZs2YVv/32W1qFaFJS83pER0eLatWqiV9//VV069aNiZiB6Pta/Pzzz6JAgQIiMjIyvUI0Gfq+FgMGDBB169bV2jZ8+HBRvXr1NI3T1KQkERs1apQoWbKk1jY/Pz/h6+ubhpEZnlF1TUZGRuLixYuoX7++Zpu5uTnq16+PM2fO6LzNmTNntPYHAF9f30T3p5RJzWsR36dPnxAVFWV084opIbWvx9SpU+Hm5oaePXumR5gmITWvxa5du1C1alUMGDAA7u7uKFWqFH744QfExMSkV9hGKTWvRbVq1XDx4kVN9+XDhw+xd+9eNGnSJF1ipljG8v2dIQq6GkpgYCBiYmI0VfnV3N3dcfv2bZ23efXqlc79X716lWZxmoLUvBbxjR49Grlz507wj0b6S83rcfLkSaxYsQJXrlxJhwhNR2pei4cPH+LIkSPo1KkT9u7di/v376N///6IiorCpEmT0iNso5Sa16Jjx44IDAxEjRo1IIRAdHQ0+vXrh3HjxqVHyBRHYt/fISEhCAsLg52dnUKR6ceoWsTIeMyYMQMbNmzA9u3bYWtrq3Q4JufDhw/o0qULli9fDldXV6XDMXkqlQpubm5YtmwZvL294efnh/Hjx2Pp0qVKh2Zyjh07hh9++AFLlizBpUuXsG3bNuzZswfTpk1TOjTKpIyqRczV1RUWFhYICAjQ2h4QEICcOXPqvE3OnDn12p9SJjWvhdrs2bMxY8YMHDp0CGXKlEnLME2Gvq/HgwcP4O/vj+bNm2u2qVQqAIClpSXu3LmDggULpm3QRio1/xu5cuWClZUVLCwsNNuKFy+OV69eITIyEtbW1mkas7FKzWsxYcIEdOnSBb169QIAlC5dGqGhoejTpw/Gjx+vNTcypa3Evr8dHR0zTWsYYGQtYtbW1vD29sbhw4c121QqFQ4fPoyqVavqvE3VqlW19geAgwcPJro/pUxqXgsA+PHHHzFt2jTs378fFSpUSI9QTYK+r0exYsVw7do1XLlyRfPXokUL1KlTB1euXIGnp2d6hm9UUvO/Ub16ddy/f1+TDAPA3bt3kStXLiZhnyE1r8WnT58SJFvqBFlwxsB0ZTTf30qfLWBoGzZsEDY2NmL16tXi5s2bok+fPsLZ2Vm8evVKCCFEly5dxJgxYzT7nzp1SlhaWorZs2eLW7duiUmTJrF8hYHo+1rMmDFDWFtbiy1btoiXL19q/j58+KDUQzAq+r4e8fGsScPR97V48uSJyJo1qxg48P/t3H9MVeUfB/D3vdjlXvGio2Rw44eCcudMwytoao4ki8uybqJCeZcopE5CnKbFmvGjQrMCB86K5gSjO/nRKpgkGEsKrqvQ+LEJXkTBbLJa0CCKGz/u8/3DcdaVH0b29Rq+X9v54zzn8zzn85wzxmfPOffEC4vFIk6cOCHc3d3FG2+84agpTBjjvRfJyclCrVaL48ePi8uXL4tTp04Jf39/ERkZ6agpTBi//fabqK2tFbW1tQKAyMjIELW1teLKlStCCCESExPFc889J8UPfb5iz549oqmpSRw+fJifr7hTHDp0SPj4+AiFQiEWLVokvvnmG+lYSEiIiI6OtosvLCwUAQEBQqFQiLlz54rS0tLbnPHENZ574evrKwAM25KTk29/4hPUeP82/oqF2L9rvPfizJkzYvHixcLZ2Vn4+fmJtLQ0MTAwcJuznpjGcy/6+/tFSkqK8Pf3F0qlUnh7e4u4uDjx66+/3v7EJ5jTp0+P+D9g6PpHR0eLkJCQYX0CAwOFQqEQfn5+Iicn57bnfatkQnAtlYiIiMgRJtQ7YkRERET/JSzEiIiIiByEhRgRERGRg7AQIyIiInIQFmJEREREDsJCjIiIiMhBWIgREREROQgLMSIiIiIHYSFGRHZyc3Mxbdo0R6fxj8lkMnz22WdjxmzcuBFPP/30bcmHiGgsLMSIJqCNGzdCJpMN21paWhydGnJzc6V85HI5vLy8sGnTJvz888//yvjt7e0IDw8HALS1tUEmk6Gurs4uJjMzE7m5uf/K+UaTkpIizdPJyQne3t7YsmULOjs7xzUOi0aiiW2SoxMgov8PvV6PnJwcu7bp06c7KBt7rq6usFgssNlsqK+vx6ZNm3Dt2jWUl5ff8tgeHh43jZk6deotn+fvmDt3LioqKjA4OIimpibExMSgq6sLBQUFt+X8RHTn44oY0QTl7OwMDw8Pu83JyQkZGRmYN28eXFxc4O3tjbi4OPT09Iw6Tn19PVasWAG1Wg1XV1csXLgQZ8+elY5XV1dj+fLlUKlU8Pb2RkJCAn7//fcxc5PJZPDw8IBGo0F4eDgSEhJQUVGB3t5e2Gw2vPbaa/Dy8oKzszMCAwNRVlYm9e3r60N8fDw8PT2hVCrh6+uL/fv324099Ghy5syZAIAFCxZAJpPhkUceAWC/yvTBBx9Ao9HAZrPZ5WgwGBATEyPtFxcXQ6fTQalUws/PD6mpqRgYGBhznpMmTYKHhwfuv/9+rFy5EuvWrcMXX3whHR8cHERsbCxmzpwJlUoFrVaLzMxM6XhKSgqOHTuG4uJiaXWtsrISAHD16lVERkZi2rRpcHNzg8FgQFtb25j5ENGdh4UY0V1GLpcjKysL58+fx7Fjx/Dll1/ipZdeGjXeaDTCy8sLNTU1OHfuHBITE3HPPfcAAC5dugS9Xo81a9agoaEBBQUFqK6uRnx8/LhyUqlUsNlsGBgYQGZmJtLT0/HOO++goaEBYWFheOqpp3Dx4kUAQFZWFkpKSlBYWAiLxQKTyYQZM2aMOO53330HAKioqEB7ezs++eSTYTHr1q1DR0cHTp8+LbV1dnairKwMRqMRAFBVVYUNGzZgx44daGxsRHZ2NnJzc5GWlva359jW1oby8nIoFAqpzWazwcvLC0VFRWhsbERSUhJeeeUVFBYWAgB2796NyMhI6PV6tLe3o729HUuXLkV/fz/CwsKgVqtRVVUFs9mMKVOmQK/Xo6+v72/nRER3AEFEE050dLRwcnISLi4u0rZ27doRY4uKisS9994r7efk5IipU6dK+2q1WuTm5o7YNzY2VmzZssWuraqqSsjlctHb2ztinxvHb25uFgEBASIoKEgIIYRGoxFpaWl2fYKDg0VcXJwQQojt27eL0NBQYbPZRhwfgPj000+FEEK0trYKAKK2ttYuJjo6WhgMBmnfYDCImJgYaT87O1toNBoxODgohBDi0UcfFfv27bMbIy8vT3h6eo6YgxBCJCcnC7lcLlxcXIRSqRQABACRkZExah8hhHjhhRfEmjVrRs116NxardbuGvz5559CpVKJ8vLyMccnojsL3xEjmqBWrFiB9957T9p3cXEBcH11aP/+/bhw4QK6u7sxMDAAq9WKP/74A5MnTx42zq5du/D8888jLy9Perzm7+8P4Ppjy4aGBphMJileCAGbzYbW1lbMmTNnxNy6urowZcoU2Gw2WK1WPPzwwzhy5Ai6u7tx7do1LFu2zC5+2bJlqK+vB3D9seJjjz0GrVYLvV6PVatW4fHHH7+la2U0GrF582a8++67cHZ2hslkwjPPPAO5XC7N02w2262ADQ4OjnndAECr1aKkpARWqxUfffQR6urqsH37druYw4cP4+jRo/jhhx/Q29uLvr4+BAYGjplvfX09WlpaoFar7dqtVisuXbr0D64AETkKCzGiCcrFxQWzZs2ya2tra8OqVauwbds2pKWlwc3NDdXV1YiNjUVfX9+IBUVKSgrWr1+P0tJSnDx5EsnJycjPz8fq1avR09ODrVu3IiEhYVg/Hx+fUXNTq9X4/vvvIZfL4enpCZVKBQDo7u6+6bx0Oh1aW1tx8uRJVFRUIDIyEitXrsTHH398076jefLJJyGEQGlpKYKDg1FVVYWDBw9Kx3t6epCamoqIiIhhfZVK5ajjKhQK6R68+eabeOKJJ5CamorXX38dAJCfn4/du3cjPT0dS5YsgVqtxttvv41vv/12zHx7enqwcOFCuwJ4yJ3ygwwi+ntYiBHdRc6dOwebzYb09HRptWfofaSxBAQEICAgADt37sSzzz6LnJwcrF69GjqdDo2NjcMKvpuRy+Uj9nF1dYVGo4HZbEZISIjUbjabsWjRIru4qKgoREVFYe3atdDr9ejs7ISbm5vdeEPvYw0ODo6Zj1KpREREBEwmE1paWqDVaqHT6aTjOp0OFotl3PO80d69exEaGopt27ZJ81y6dCni4uKkmBtXtBQKxbD8dTodCgoK4O7uDldX11vKiYgciy/rE91FZs2ahf7+fhw6dAiXL19GXl4e3n///VHje3t7ER8fj8rKSly5cgVmsxk1NTXSI8eXX34ZZ86cQXx8POrq6nDx4kUUFxeP+2X9v9qzZw8OHDiAgoICWCwWJCYmoq6uDjt27AAAZGRk4Pjx47hw4QKam5tRVFQEDw+PET9C6+7uDpVKhbKyMvz000/o6uoa9bxGoxGlpaU4evSo9JL+kKSkJHz44YdITU3F+fPn0dTUhPz8fOzdu3dcc1uyZAnmz5+Pffv2AQBmz56Ns2fPory8HM3NzXj11VdRU1Nj12fGjBloaGiAxWLBL7/8gv7+fhiNRtx3330wGAyoqqpCa2srKisrkZCQgB9//HFcORGRY7EQI7qLPPjgg8jIyMCBAwfwwAMPwGQy2X364UZOTk7o6OjAhg0bEBAQgMjISISHhyM1NRUAMH/+fHz11Vdobm7G8uXLsWDBAiQlJUGj0fzjHBMSErBr1y68+OKLmDdvHsrKylBSUoLZs2cDuP5Y86233kJQUBCCg4PR1taGzz//XFrh+6tJkyYhKysL2dnZ0Gg0MBgMo543NDQUbm5usFgsWL9+vd2xsLAwnDhxAqdOnUJwcDAeeughHDx4EL6+vuOe386dO3HkyBFcvXoVW7duRUREBKKiorB48WJ0dHTYrY4BwObNm6HVahEUFITp06fDbDZj8uTJ+Prrr+Hj44OIiAjMmTMHsbGxsFqtXCEj+o+RCSGEo5MgIiIiuhtxRYyIiIjIQViIERERETkICzEiIiIiB2EhRkREROQgLMSIiIiIHISFGBEREZGDsBAjIiIichAWYkREREQOwkKMiIiIyEFYiBERERE5CAsxIiIiIgdhIUZERETkIP8DCmgqSqfn1v8AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -1811,20 +1811,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 328.09489011764526\n", - "lead_lag: True inv_rest: True thres_distance: 32000 auc: 0.8437179\n", + "compute_auc_time: 317.9939298629761\n", + "lead_lag: True inv_rest: True thres_distance: 32000 auc: 0.84355992\n", "Threshold distance: 4000\n", "lead_lag: True\n", "inv_reset: False\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 15.19601583480835\n" + "fit_time: 17.984686136245728\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1836,20 +1836,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 264.1860752105713\n", - "lead_lag: True inv_rest: False thres_distance: 4000 auc: 0.32076046\n", + "compute_auc_time: 182.08021187782288\n", + "lead_lag: True inv_rest: False thres_distance: 4000 auc: 0.8257225199999999\n", "Threshold distance: 8000\n", "lead_lag: True\n", "inv_reset: False\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 15.445886135101318\n" + "fit_time: 17.325438022613525\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1861,20 +1861,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 262.2999367713928\n", - "lead_lag: True inv_rest: False thres_distance: 8000 auc: 0.83433212\n", + "compute_auc_time: 207.74922394752502\n", + "lead_lag: True inv_rest: False thres_distance: 8000 auc: 0.8343324400000001\n", "Threshold distance: 16000\n", "lead_lag: True\n", "inv_reset: False\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 16.100723266601562\n" + "fit_time: 15.623968124389648\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1886,20 +1886,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 269.2015371322632\n", - "lead_lag: True inv_rest: False thres_distance: 16000 auc: 0.53346636\n", + "compute_auc_time: 234.3586070537567\n", + "lead_lag: True inv_rest: False thres_distance: 16000 auc: 0.84074052\n", "Threshold distance: 32000\n", "lead_lag: True\n", "inv_reset: False\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 16.689249992370605\n" + "fit_time: 18.165555000305176\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1911,20 +1911,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 259.4003691673279\n", - "lead_lag: True inv_rest: False thres_distance: 32000 auc: 0.8419117000000002\n", + "compute_auc_time: 252.45590329170227\n", + "lead_lag: True inv_rest: False thres_distance: 32000 auc: 0.8419482599999999\n", "Threshold distance: 4000\n", "lead_lag: False\n", "inv_reset: True\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 12.511054992675781\n" + "fit_time: 12.57522201538086\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1936,20 +1936,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 38.976033210754395\n", - "lead_lag: False inv_rest: True thres_distance: 4000 auc: 0.57581702\n", + "compute_auc_time: 31.587750911712646\n", + "lead_lag: False inv_rest: True thres_distance: 4000 auc: 0.79083568\n", "Threshold distance: 8000\n", "lead_lag: False\n", "inv_reset: True\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 12.427032232284546\n" + "fit_time: 12.51298189163208\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAHcCAYAAABxixZDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACbjklEQVR4nOzdd1hT1xsH8C97yFTAgShu3FrcirturaOKG/fe1bqq1g6t29b507onbq1aW+vWat0bRxXcoqgMkZ3z++M0gQhogoEL4ft5Hh7uvbm5eZNLyJtzzn2PiRBCgIiIiIgyjKnSARARERFlN0zAiIiIiDIYEzAiIiKiDMYEjIiIiCiDMQEjIiIiymBMwIiIiIgyGBMwIiIiogzGBIyIiIgogzEBIyIiIspgTMCIPoGnpyd69OihdBjZTt26dVG3bl2lw/iob7/9FiYmJggJCVE6lEzHxMQE3377rUGOFRQUBBMTE6xevdogxyPKCEzAKNNavXo1TExMND/m5uZwd3dHjx498OTJE6XDy9QiIyPx/fffo1y5crC1tYWjoyN8fHywdu1aZJXZx27evIlvv/0WQUFBSoeSTEJCAlatWoW6desiZ86csLKygqenJ3r27Inz588rHZ5BbNy4EfPnz1c6DC2ZMSaitDJXOgCij/nuu+9QqFAhREdH48yZM1i9ejVOnjyJ69evw9raWtHYbt++DVPTzPU9Jjg4GA0aNEBAQAA6duyIIUOGIDo6Gtu3b4efnx/279+PDRs2wMzMTOlQP+jmzZuYOnUq6tatC09PT63b/vzzT2WCAhAVFYW2bdviwIEDqF27NiZMmICcOXMiKCgIW7ZswZo1a/Dw4UPkz59fsRgNYePGjbh+/TpGjBiRLsePioqCubl+H0GpxVSwYEFERUXBwsLCgBESpS8mYJTpNW3aFJUqVQIA9OnTBy4uLpgxYwb27NmDDh06KBqblZVVhj9mdHQ0LC0tU038/Pz8EBAQgJ07d6JVq1aa7cOGDcOYMWMwe/ZsVKxYEWPHjs2okAHIVrkcOXIY5FiWlpYGOU5ajBkzBgcOHMC8efOSJQJTpkzBvHnzMjQeIQSio6NhY2OToY+bFiqVCrGxsbC2tjbolycTExPFv4wR6U0QZVKrVq0SAMS5c+e0tu/du1cAENOmTdPaHhAQINq1ayecnZ2FlZWV8Pb2Frt370523Ddv3ogRI0aIggULCktLS+Hu7i66desmXr58qdknOjpaTJ48WRQpUkRYWlqK/PnzizFjxojo6GitYxUsWFD4+fkJIYQ4d+6cACBWr16d7DEPHDggAIjffvtNs+3x48eiZ8+ews3NTVhaWopSpUqJFStWaN3vyJEjAoDYtGmTmDhxosiXL58wMTERb968SfE1O336tAAgevXqleLtcXFxolixYsLZ2Vm8e/dOCCFEYGCgACBmzZol5s6dKwoUKCCsra1F7dq1xbVr15IdQ5fXWX3ujh49KgYOHChcXV2Fk5OTEEKIoKAgMXDgQFG8eHFhbW0tcubMKb788ksRGBiY7P7v/xw5ckQIIUSdOnVEnTp1kr1O/v7+4ocffhDu7u7CyspK1K9fX9y9ezfZc1i4cKEoVKiQsLa2FpUrVxbHjx9PdsyUPHr0SJibm4vPP//8g/upTZkyRQAQd+/eFX5+fsLR0VE4ODiIHj16iMjISK19V65cKerVqydcXV2FpaWlKFmypFi8eHGyYxYsWFA0b95cHDhwQHh7ewsrKysxb948vY4hhBD79+8XtWvXFnZ2dsLe3l5UqlRJbNiwQQghX9/3X/uCBQtq7qvr+wOAGDx4sFi/fr0oVaqUMDc3Fzt37tTcNmXKFM2+4eHhYvjw4Zr3paurq2jYsKG4cOHCR2NS/w2vWrVK6/EDAgJE+/bthYuLi7C2thbFixcXEyZM+NApI8owbAGjLEc9JsjZ2Vmz7caNG6hZsybc3d0xbtw45MiRA1u2bEHr1q2xfft2tGnTBgDw9u1b+Pj4ICAgAL169cJnn32GkJAQ7NmzB48fP4aLiwtUKhVatWqFkydPol+/fihZsiSuXbuGefPm4c6dO9i1a1eKcVWqVAmFCxfGli1b4Ofnp3Wbv78/nJ2d0bhxYwCym7BatWowMTHBkCFD4Orqit9//x29e/dGeHh4spaV77//HpaWlhg9ejRiYmJSbQH67bffAADdu3dP8XZzc3N07twZU6dOxalTp9CwYUPNbWvXrkVERAQGDx6M6Oho/Pzzz6hfvz6uXbuG3Llz6/U6qw0aNAiurq6YPHkyIiMjAQDnzp3D33//jY4dOyJ//vwICgrCkiVLULduXdy8eRO2traoXbs2hg0bhl9++QUTJkxAyZIlAUDzOzU//fQTTE1NMXr0aISFhWHmzJno0qUL/vnnH80+S5YswZAhQ+Dj44ORI0ciKCgIrVu3hrOz80e7DX///XfEx8ejW7duH9zvfR06dEChQoUwffp0XLx4Eb/++ivc3NwwY8YMrbhKly6NVq1awdzcHL/99hsGDRoElUqFwYMHax3v9u3b6NSpE/r374++ffuiRIkSeh1j9erV6NWrF0qXLo3x48fDyckJly5dwoEDB9C5c2dMnDgRYWFhePz4saZFz87ODgD0fn8cPnwYW7ZswZAhQ+Di4pKsO1ltwIAB2LZtG4YMGYJSpUrh1atXOHnyJAICAvDZZ599MKaUXL16FT4+PrCwsEC/fv3g6emJe/fu4bfffsOPP/6o24kjSk9KZ4BEqVG3gvz111/i5cuX4tGjR2Lbtm3C1dVVWFlZiUePHmn2bdCggShbtqzWN3CVSiVq1KghihUrptk2efJkAUDs2LEj2eOpVCohhBDr1q0Tpqam4sSJE1q3L126VAAQp06d0mxL2gImhBDjx48XFhYW4vXr15ptMTExwsnJSatVqnfv3iJv3rwiJCRE6zE6duwoHB0dNa1T6padwoULa7Z9SOvWrQWAVFvIhBBix44dAoD45ZdfhBCJrQc2Njbi8ePHmv3++ecfAUCMHDlSs03X11l97mrVqiXi4+O1Hj+l56FuuVu7dq1m29atW7VavZJKrQWsZMmSIiYmRrP9559/FgA0LXkxMTEiV65conLlyiIuLk6z3+rVqwWAj7aAjRw5UgAQly5d+uB+auoWsPdbJNu0aSNy5cqltS2l16Vx48aicOHCWtsKFiwoAIgDBw4k21+XY4SGhgp7e3tRtWpVERUVpbWv+j0ghBDNmzfXavVS0+f9AUCYmpqKGzduJDsO3msBc3R0FIMHD062X1KpxZRSC1jt2rWFvb29ePDgQarPkUhJmWv0MFEKGjZsCFdXV3h4eODLL79Ejhw5sGfPHk1rxevXr3H48GF06NABERERCAkJQUhICF69eoXGjRvj7t27mqsmt2/fjvLlyydrqQHkOBIA2Lp1K0qWLAkvLy/NsUJCQlC/fn0AwJEjR1KN1dfXF3FxcdixY4dm259//onQ0FD4+voCkGN2tm/fjpYtW0IIofUYjRs3RlhYGC5evKh1XD8/P53G+ERERAAA7O3tU91HfVt4eLjW9tatW8Pd3V2zXqVKFVStWhX79+8HoN/rrNa3b99kg/2TPo+4uDi8evUKRYsWhZOTU7Lnra+ePXtqtQ76+PgAAO7fvw8AOH/+PF69eoW+fftqDQDv0qWLVotqatSv2Yde35QMGDBAa93HxwevXr3SOgdJX5ewsDCEhISgTp06uH//PsLCwrTuX6hQIU1ralK6HOPgwYOIiIjAuHHjko2bUr8HPkTf90edOnVQqlSpjx7XyckJ//zzD54+ffrRfT/m5cuXOH78OHr16oUCBQpo3abLcyTKCOyCpExv0aJFKF68OMLCwrBy5UocP35ca/D7v//+CyEEJk2ahEmTJqV4jBcvXsDd3R337t1Du3btPvh4d+/eRUBAAFxdXVM9VmrKly8PLy8v+Pv7o3fv3gBk96OLi4vmA+rly5cIDQ3FsmXLsGzZMp0eo1ChQh+MWU2dGERERMDJySnFfVJL0ooVK5Zs3+LFi2PLli0A9HudPxR3VFQUpk+fjlWrVuHJkydaZTHeTzT09f6HrTqpevPmDQDgwYMHAICiRYtq7Wdubp5q11hSDg4OABJfQ0PEpT7mqVOnMGXKFJw+fRrv3r3T2j8sLAyOjo6a9dT+HnQ5xr179wAAZcqU0es5qOn7/tD1b3fmzJnw8/ODh4cHvL290axZM3Tv3h2FCxfWO0Z1wp3W50iUEZiAUaZXpUoVzVWQrVu3Rq1atdC5c2fcvn0bdnZ2UKlUAIDRo0en2CoAJP/A/RCVSoWyZcti7ty5Kd7u4eHxwfv7+vrixx9/REhICOzt7bFnzx506tRJ0+Kijrdr167JxoqplStXTmtd1yvcSpYsiV27duHq1auoXbt2ivtcvXoVAHRqlUgqLa9zSnEPHToUq1atwogRI1C9enU4OjrCxMQEHTt21DxGWqVWWkMYqPaZl5cXAODatWuoUKGCzvf7WFz37t1DgwYN4OXlhblz58LDwwOWlpbYv38/5s2bl+x1Sel11fcYaaXv+0PXv90OHTrAx8cHO3fuxJ9//olZs2ZhxowZ2LFjB5o2bfrJcRNlNkzAKEsxMzPD9OnTUa9ePSxcuBDjxo3TfEO2sLDQGlSekiJFiuD69esf3efKlSto0KBBmrorfH19MXXqVGzfvh25c+dGeHg4OnbsqLnd1dUV9vb2SEhI+Gi8+mrRogWmT5+OtWvXppiAJSQkYOPGjXB2dkbNmjW1brt7926y/e/cuaNpGdLndf6Qbdu2wc/PD3PmzNFsi46ORmhoqNZ+6dFVVLBgQQCyNa9evXqa7fHx8QgKCkqW+L6vadOmMDMzw/r16/UeiP8hv/32G2JiYrBnzx6t1rIPdXen9RhFihQBAFy/fv2DX0xSe/0/9f3xIXnz5sWgQYMwaNAgvHjxAp999hl+/PFHTQKm6+Op/1Y/9l4nUhLHgFGWU7duXVSpUgXz589HdHQ03NzcULduXfzvf//Ds2fPku3/8uVLzXK7du1w5coV7Ny5M9l+6taIDh064MmTJ1i+fHmyfaKiojRX86WmZMmSKFu2LPz9/eHv74+8efNqJUNmZmZo164dtm/fnuIHRNJ49VWjRg00bNgQq1atwt69e5PdPnHiRNy5cwdff/11spaJXbt2aY3hOnv2LP755x/Nh58+r/OHmJmZJWuRWrBgARISErS2qWuGvZ+YfYpKlSohV65cWL58OeLj4zXbN2zYoOmm/BAPDw/07dsXf/75JxYsWJDsdpVKhTlz5uDx48d6xaVuIXu/O3bVqlUGP0ajRo1gb2+P6dOnIzo6Wuu2pPfNkSNHil3Cn/r+SElCQkKyx3Jzc0O+fPkQExPz0Zje5+rqitq1a2PlypV4+PCh1m2Gag0l+lRsAaMsacyYMWjfvj1Wr16NAQMGYNGiRahVqxbKli2Lvn37onDhwggODsbp06fx+PFjXLlyRXO/bdu2oX379ujVqxe8vb3x+vVr7NmzB0uXLkX58uXRrVs3bNmyBQMGDMCRI0dQs2ZNJCQk4NatW9iyZQv++OMPTZdoanx9fTF58mRYW1ujd+/eyYqm/vTTTzhy5AiqVq2Kvn37olSpUnj9+jUuXryIv/76C69fv07za7N27Vo0aNAAX3zxBTp37gwfHx/ExMRgx44dOHr0KHx9fTFmzJhk9ytatChq1aqFgQMHIiYmBvPnz0euXLnw9ddfa/bR9XX+kBYtWmDdunVwdHREqVKlcPr0afz111/IlSuX1n4VKlSAmZkZZsyYgbCwMFhZWaF+/fpwc3NL82tjaWmJb7/9FkOHDkX9+vXRoUMHBAUFYfXq1ShSpIhOLSxz5szBvXv3MGzYMOzYsQMtWrSAs7MzHj58iK1bt+LWrVtaLZ66aNSoESwtLdGyZUv0798fb9++xfLly+Hm5pZisvspx3BwcMC8efPQp08fVK5cGZ07d4azszOuXLmCd+/eYc2aNQAAb29v+Pv7Y9SoUahcuTLs7OzQsmVLg7w/3hcREYH8+fPjyy+/RPny5WFnZ4e//voL586d02opTS2mlPzyyy+oVasWPvvsM/Tr1w+FChVCUFAQ9u3bh8uXL+sVH1G6UOTaSyIdpFaIVQghEhISRJEiRUSRIkU0ZQ7u3bsnunfvLvLkySMsLCyEu7u7aNGihdi2bZvWfV+9eiWGDBki3N3dNUUk/fz8tEpCxMbGihkzZojSpUsLKysr4ezsLLy9vcXUqVNFWFiYZr/3y1Co3b17V1Ms8uTJkyk+v+DgYDF48GDh4eEhLCwsRJ48eUSDBg3EsmXLNPuoyyts3bpVr9cuIiJCfPvtt6J06dLCxsZG2Nvbi5o1a4rVq1cnuww/aSHWOXPmCA8PD2FlZSV8fHzElStXkh1bl9f5Q+fuzZs3omfPnsLFxUXY2dmJxo0bi1u3bqX4Wi5fvlwULlxYmJmZ6VSI9f3XKbUCnb/88osoWLCgsLKyElWqVBGnTp0S3t7eokmTJjq8ukLEx8eLX3/9Vfj4+AhHR0dhYWEhChYsKHr27KlVokJdhiJpkd+kr0/S4rN79uwR5cqVE9bW1sLT01PMmDFDrFy5Mtl+6kKsKdH1GOp9a9SoIWxsbISDg4OoUqWK2LRpk+b2t2/fis6dOwsnJ6dkhVh1fX/gv0KsKUGSMhQxMTFizJgxonz58sLe3l7kyJFDlC9fPlkR2dRiSu08X79+XbRp00Y4OTkJa2trUaJECTFp0qQU4yHKaCZCsD2WKDsLCgpCoUKFMGvWLIwePVrpcBShUqng6uqKtm3bpti1RkRkaBwDRkTZSnR0dLJxQGvXrsXr169Rt25dZYIiomyHY8CIKFs5c+YMRo4cifbt2yNXrly4ePEiVqxYgTJlyqB9+/ZKh0dE2QQTMCLKVjw9PeHh4YFffvkFr1+/Rs6cOdG9e3f89NNPqc6xSURkaBwDRkRERJTBOAaMiIiIKIMxASMiIiLKYIomYEePHoWJiQm2bdumZBga6RHPt99+q/P0GSYmJvj222/T9Djq2I8eParZ1qNHD50mGKasx8TEBKtXr/7ofkr+DdStW1fvqwrTcp+sYPXq1TAxMUFQUFCGPm5W+DuhzGHmzJnw8vL66JyhQUFBOv9dpQf1e+n8+fOKPH5SBw4cgJ2dXZpnLzF4AmZiYqLTT9JEgTKPmzdv4ttvv83wDwolbNmyBdWqVYOTkxNy5cqFOnXqYN++fcn2U6lUmDlzJgoVKgRra2uUK1cOmzZtSvGYAQEBaNKkCezs7JAzZ05069YtxTenPsck5ai/QKX0s3TpUqXDo3S0f//+NH8hBmRSq8tnYY8ePQwWc1qFh4djxowZGDt2bLJZO5SyePFixZK8adOmoVq1anB1dYW1tTWKFSuGESNGJPtf3qRJExQtWhTTp09P0+MY/CrIdevWaa2vXbsWBw8eTLa9ZMmSCAgIMPTDUxLLly//6LeZ9928eRNTp05F3bp1jfob8YIFCzBs2DA0b94cP/30E6Kjo7F69Wq0aNEC27dvR9u2bTX7Tpw4ET/99BP69u2LypUrY/fu3ejcuTNMTEy0ppx5/PgxateuDUdHR0ybNg1v377F7Nmzce3aNZw9e1brCjtdj0mZw5IlS2BnZ6e1rWrVqgpFY3hp+V9h7Pbv349FixalOQnr37+/1qT1gYGBmDx5Mvr16wcfHx/NdvXk6EpauXIl4uPj0alTJ6VD0Vi8eDFcXFwUSVAvXLiAChUqoGPHjrC3t0dAQACWL1+umcZKPU8tIM/z6NGjMXXqVNjb2+v1OAZPwLp27aq1fubMGRw8eDDZdgCfnIC9e/cOtra2n3QMY2ZhYaF0CJnWggULULlyZfz222+aLuJevXrB3d0da9as0SRgT548wZw5czB48GAsXLgQANCnTx/UqVNHMx+lehLkadOmITIyEhcuXECBAgUAAFWqVMHnn3+O1atXo1+/fnofkzKHL7/8Ei4uLkqHkW4y6/+KyMhIrQ+7rKR69eqoXr26Zv38+fOYPHkyqlevnuLnoZoSz3nVqlVo1aoVrK2tM/RxM6vt27cn21a9enV8+eWX+O2337S+JLdr1w5Dhw7F1q1b0atXL70eJ1O0NapUKvz444/Inz8/rK2t0aBBA/z7779a+9StWxdlypTBhQsXULt2bdja2mLChAkAgJiYGEyZMgVFixaFlZUVPDw88PXXXyMmJkbrGAcPHkStWrXg5OQEOzs7lChRQnMMfeMBgK1bt8Lb2xs2NjZwcXFB165d8eTJk48+35iYGIwcORKurq6wt7dHq1at8PjxY51fr8ePH6N169bIkSMH3NzcMHLkyGTPFUh5XMfmzZvh7e0Ne3t7ODg4oGzZsvj5558ByL51dSHKevXqJesu3r17N5o3b458+fLBysoKRYoUwffff4+EhAStx1Cfq5s3b6JevXqwtbWFu7s7Zs6cmSzG6OhofPvttyhevDisra2RN29etG3bFvfu3dPso1KpMH/+fJQuXRrW1tbInTs3+vfvjzdv3mgdKywsDLdu3UJYWNhHX8Pw8HC4ublpjc9zcHCAnZ0dbGxsNNt2796NuLg4DBo0SLPNxMQEAwcOxOPHj3H69GnN9u3bt6NFixaa5AsAGjZsiOLFi2PLli1pOmZ60PX11PV8A8CyZctQpEgR2NjYoEqVKjhx4oRBYo2NjcXkyZPh7e0NR0dH5MiRAz4+Pjhy5EiyfV+9eoVu3brBwcEBTk5O8PPzw5UrV5KNV4mLi8OtW7d0nuT6Q65evYoePXqgcOHCsLa2Rp48edCrVy+8evXqo/c9f/48GjduDBcXF9jY2KBQoULJ/oHreq4+1fv/K9TjfGbPnq05t1ZWVqhcuTLOnTun2W/27NkwMTHBgwcPkh1z/PjxsLS01DlW9dieY8eOYdCgQXBzc0P+/Pk1t//+++/w8fFBjhw5YG9vj+bNm+PGjRtax3j+/Dl69uyJ/Pnzw8rKCnnz5sUXX3yRbEjFx47Vo0cPLFq0CID2sBq1Z8+e4datW4iLi9PpuaXlOac2Li+1ccXr16/XfB7lzJkTHTt2xKNHjz4aQ2BgIK5evarVWqcWGhqKHj16wNHRUfOeCg0NTfE4t27dwpdffomcOXPC2toalSpVwp49e1J8vsePH0f//v2RK1cuODg4oHv37lp/J56enrhx4waOHTumee3fHxsaExODUaNGwdXVFTly5ECbNm3SPBZLF+pz8f7zd3NzQ7ly5bB79269j5kpCrH+9NNPMDU1xejRoxEWFoaZM2eiS5cu+Oeff7T2e/XqFZo2bYqOHTuia9euyJ07N1QqFVq1aoWTJ0+iX79+KFmyJK5du4Z58+bhzp072LVrFwDgxo0baNGiBcqVK4fvvvsOVlZW+Pfff3Hq1Kk0xbN69Wr07NkTlStXxvTp0xEcHIyff/4Zp06dwqVLl+Dk5JTq8+3Tpw/Wr1+Pzp07o0aNGjh8+DCaN2+u02sVFRWFBg0a4OHDhxg2bBjy5cuHdevW4fDhwx+978GDB9GpUyc0aNAAM2bMACBbIU+dOoXhw4ejdu3aGDZsGH755RdMmDABJUuWBADN79WrV8POzg6jRo2CnZ0dDh8+jMmTJyM8PByzZs3Seqw3b96gSZMmaNu2LTp06IBt27Zh7NixKFu2LJo2bQoASEhIQIsWLXDo0CF07NgRw4cPR0REBA4ePIjr169rmub79++veb2HDRuGwMBALFy4EJcuXcKpU6c039537tyJnj17YtWqVR9ttq5bty62bduGBQsWoGXLloiOjsaCBQsQFhaG4cOHa/a7dOkScuTIoXkN1KpUqaK5vVatWnjy5AlevHiBSpUqJXusKlWqYP/+/XofM73o+nrqer5XrFiB/v37o0aNGhgxYgTu37+PVq1aIWfOnPDw8PikWMPDw/Hrr7+iU6dO6Nu3LyIiIrBixQo0btwYZ8+eRYUKFQDIRKVly5Y4e/YsBg4cCC8vL+zevRt+fn7JjvnkyROULFkSfn5+Oo8xef36tda6mZkZnJ2dcfDgQdy/fx89e/ZEnjx5cOPGDSxbtgw3btzAmTNnUr0A58WLF2jUqBFcXV0xbtw4ODk5ISgoCDt27NDaT9dzlV42btyIiIgI9O/fHyYmJpg5cybatm2L+/fvw8LCAh06dMDXX3+NLVu2YMyYMVr33bJlCxo1agRnZ2e9HnPQoEFwdXXF5MmTERkZCUAObfHz80Pjxo0xY8YMvHv3DkuWLEGtWrVw6dIlzYdju3btcOPGDQwdOhSenp548eIFDh48iIcPH2r20eVY/fv3x9OnT1McPgPI5HLNmjUIDAw0yFCNlJ6zPn788UdMmjQJHTp0QJ8+ffDy5UssWLAAtWvX/ujn0d9//w0A+Oyzz7S2CyHwxRdf4OTJkxgwYABKliyJnTt3pvieunHjBmrWrAl3d3eMGzcOOXLkwJYtW9C6dWts374dbdq00dp/yJAhcHJywrfffovbt29jyZIlePDggeZisvnz52Po0KGws7PDxIkTAQC5c+fWOsbQoUPh7OyMKVOmICgoCPPnz8eQIUPg7++v2eft27eIjo7+6OtnYWEBR0fHZM//1atXiI+Px927dzFu3DiYmZmleJGQt7e3JtfQS3rP9j148GCR2sMcOXJEABAlS5YUMTExmu0///yzACCuXbum2VanTh0BQCxdulTrGOvWrROmpqbixIkTWtuXLl0qAIhTp04JIYSYN2+eACBevnyZaqy6xhMbGyvc3NxEmTJlRFRUlGa/vXv3CgBi8uTJmm1TpkzRev6XL18WAMSgQYO0Hrtz584CgJgyZUqq8QkhxPz58wUAsWXLFs22yMhIUbRoUQFAHDlyRLPdz89PFCxYULM+fPhw4eDgIOLj41M9/tatW5MdR+3du3fJtvXv31/Y2tqK6OhozTb1uVq7dq1mW0xMjMiTJ49o166dZtvKlSsFADF37txkx1WpVEIIIU6cOCEAiA0bNmjdfuDAgWTbV61aJQCIVatWpfr81IKDg0WDBg0EAM2Pi4uL+Pvvv7X2a968uShcuHCy+0dGRgoAYty4cUIIIc6dO5fsOauNGTNGANC8Rroe80N0fZ7v/w3o83rqcr7V74UKFSpovWeWLVsmAIg6dep8NMak6tSpo3Wf+Ph4reMKIcSbN29E7ty5Ra9evTTbtm/fLgCI+fPna7YlJCSI+vXrJ3utAgMDBQDh5+f30XjU79/3f9SvaUqv0aZNmwQAcfz4cc029d9mYGCgEEKInTt3CgDi3LlzqT62PucqNWn9O1G/Rrly5RKvX7/WbN+9e7cAIH777TfNturVqwtvb2+t4509ezbV90Nq1K9RrVq1tP5HRURECCcnJ9G3b1+t/Z8/fy4cHR0129+8eSMAiFmzZqX6GLoeS4gPf3b5+flpnU9dqP9HJD0fqT1n9WMkPSdq73+mBAUFCTMzM/Hjjz9q7Xft2jVhbm6ebPv7vvnmGwFAREREaG3ftWuXACBmzpyp2RYfHy98fHySPY8GDRqIsmXLan0OqFQqUaNGDVGsWLFkz9fb21vExsZqts+cOVMAELt379ZsK126dIr/P9THaNiwoeZzQgghRo4cKczMzERoaKhmm/o8fewnpcd59uyZ1j758+cX/v7+Kb6G06ZNEwBEcHBwirenJlN0Qfbs2VNrgLJ6gOL9+/e19rOyskLPnj21tm3duhUlS5aEl5cXQkJCND/169cHAE1XhfobwO7duz862PRj8Zw/fx4vXrzAoEGDtPrMmzdvDi8vrxSvpFNTt4QMGzZMa/uIESM+GFPS++fNmxdffvmlZputra1mfNGHODk5ITIyEgcPHtTpsd6XtGsuIiICISEh8PHxwbt373Dr1i2tfe3s7LTGOVhaWqJKlSpa53T79u1wcXHB0KFDkz2WuuVg69atcHR0xOeff651fr29vWFnZ6fVFdWjRw8IIXQatGlra4sSJUrAz88PW7duxcqVKzXdn0m7m6OiomBlZZXs/urzHhUVpfVb13112S896PN66nK+1e+FAQMGaL1n1N0Wn8rMzExzXJVKhdevXyM+Ph6VKlXCxYsXNfsdOHAAFhYW6Nu3r2abqakpBg8enOyYnp6eEELodYXV9u3bcfDgQc3Phg0bAGi/RtHR0QgJCUG1atUAQCu+96n/H+3duzfVbix9zlV68fX11WrBSul/s6+vLy5cuKA1bMDf3x9WVlb44osv9H7Mvn37ao2BPHjwIEJDQ9GpUyet18HMzAxVq1bVvA42NjawtLTE0aNHU+321PVYH7N69WoIIQx2odL7z1kfO3bsgEqlQocOHbSeU548eVCsWLGPPqdXr17B3Nw82UUm+/fvh7m5OQYOHKjZZmZmluz/9evXr3H48GF06NBB838iJCQEr169QuPGjXH37t1kQ3P69eun1Xo7cOBAmJuba/UUfEy/fv20Wph9fHyQkJCg1R3+9ddfa71vU/uZM2dOsuPnzJkTBw8exG+//YbvvvsOLi4uePv2bYqxqN8jISEhOscPZJIuyKRjZoDEJ/P+m8jd3T3ZXG13795FQEAAXF1dUzz2ixcvAMh/Er/++iv69OmDcePGoUGDBmjbti2+/PLLZJfdfiwe9QkuUaJEssfz8vLCyZMnU32uDx48gKmpabIrX1I6Vmr3L1q0aLKuDV3uP2jQIGzZsgVNmzaFu7s7GjVqhA4dOqBJkyY6PfaNGzfwzTff4PDhwwgPD9e67f1xV/nz508Wo7OzM65evapZv3fvHkqUKAFz89T/DO/evYuwsDC4ubmleLv6/Oqrffv2MDc3x2+//abZ9sUXX6BYsWKYOHGiphnbxsYmxfF16mZt9Qew+reu++qyX3rQ5/XU5Xyr3wvFihXTut3CwgKFCxc2SMxr1qzBnDlzko25KVSokGb5wYMHyJs3b7KLcooWLWqQGGrXrp3iIPzXr19j6tSp2Lx5c7K/xQ+NRaxTpw7atWuHqVOnYt68eahbty5at26Nzp07a5Lz9Prb14cu/5vbt2+PUaNGwd/fHxMmTIAQAlu3bkXTpk3h4OCg92MmPa+AfB0AaL5Uv0/9GFZWVpgxYwa++uor5M6dG9WqVUOLFi3QvXt35MmTR69jZbT3n7M+7t69CyFEsvegWlq7qdXvqfcTs/c/a/79918IITBp0iRMmjQpxWO9ePEC7u7umvX3Y7Wzs0PevHn1Kn+ky99mqVKlUKpUKZ2PmZSlpaVmXFyLFi3QoEED1KxZE25ubmjRooXWvuK/GR11rfmplikSsNQyf/HeNJUpfTCpVCqULVsWc+fOTfEY6jEoNjY2OH78OI4cOYJ9+/bhwIED8Pf3R/369fHnn39qxaBrPFmNm5sbLl++jD/++AO///47fv/9d6xatQrdu3fHmjVrPnjf0NBQ1KlTBw4ODvjuu+9QpEgRWFtb4+LFixg7dmyyVkVDvYYqlQpubm6aFof3pZZ4f8j9+/dx4MABLFu2TGt7zpw5UatWLa1xgXnz5sWRI0cghEg2CBcA8uXLp9kv6faknj17hpw5c2o+WHU9ZnrQ9fXU93ynl/Xr16NHjx5o3bo1xowZAzc3N5iZmWH69OlaLS5K6dChA/7++2+MGTMGFSpUgJ2dHVQqFZo0afLB10hd8PnMmTP47bff8Mcff6BXr16YM2cOzpw5ozmOof/29aXL+zhfvnzw8fHBli1bMGHCBJw5cwYPHz7UjDPV1/v/59Wv47p16zSJVFJJv8CNGDECLVu2xK5du/DHH39g0qRJmD59Og4fPoyKFSvqdayMlNJnW2of5u9fBKNSqWBiYoLff/89xfP1fgL1vly5ciE+Ph4RERF6l1FQPz4AjB49Go0bN05xH0N9EUpKl7/NsLAwnXoULC0tkTNnzg/uU6NGDeTNmxcbNmxIloCpkz59r5TOFAnYpyhSpAiuXLmCBg0afDT7NDU1RYMGDdCgQQPMnTsX06ZNw8SJE3HkyJEUrwBJTcGCBQEAt2/fTvZN6vbt25rbU7uvSqXStP4kvZ+uj339+vVkH9663t/S0hItW7ZEy5YtoVKpMGjQIPzvf//DpEmTUmxZUzt69ChevXqFHTt2oHbt2prtgYGBOj1uSooUKYJ//vkHcXFxqX5LK1KkCP766y/UrFnTYC1DwcHBAJL/IwPkFXLx8fGa9QoVKuDXX39FQECA1jcp9QUZ6kHg7u7ucHV1TbE6c9LB4vocMz3o+nrqer7Vf+t3797Vei/ExcUhMDAQ5cuX/6R4t23bhsKFC2PHjh1af5tTpkxJFseRI0eSlaZJ6eplQ3nz5g0OHTqEqVOnYvLkyZrt6lYWXVSrVg3VqlXDjz/+iI0bN6JLly7YvHkz+vTpky5/++nF19cXgwYNwu3bt+Hv7w9bW1u0bNnSIMdW9xa4ubnp9H+6SJEi+Oqrr/DVV1/h7t27qFChAubMmYP169frdSx9WzMMzdnZOcUrDt+/4rRIkSIQQqBQoUIoXry43o/j5eUFQL63y5Urp9lesGBBHDp0CG/fvtVK4t7/rFG3dFtYWOj8OXr37l3Uq1dPs/727Vs8e/YMzZo102wzxOs/fPjwjzYuALJFWpfi8NHR0Sm2bAcGBsLFxUXvL0WZYgzYp+jQoQOePHmC5cuXJ7stKipKc0XJ+1cxAYkfdCl1B31IpUqV4ObmhqVLl2rd9/fff0dAQMAHr2hUXwH4yy+/aG2fP3++To/drFkzPH36VGu6pHfv3iVrzUnJ+5fGm5qaat5w6uehrj/z/htf/W0j6beL2NhYLF68WKe4U9KuXTuEhIRoamElpX6cDh06ICEhAd9//32yfeLj47Xi1LUMRdGiRWFqagp/f3+t5/P48WOcOHECFStW1Gz74osvYGFhofU8hRBYunQp3N3dUaNGDa3ns3fvXq1Lvw8dOoQ7d+5oynvoe0xD0/X11PV8V6pUCa6urli6dCliY2M121evXp3q5er6SCmOf/75J1mpjsaNGyMuLk7r/4BKpdKUEkjKUGUoUooN0O29/ObNm2T3e///kT5/+0pr164dzMzMsGnTJmzduhUtWrQwWC2rxo0bw8HBAdOmTUtxvJy69MC7d++SXfFWpEgR2Nvba15TXY8FpP6/EDBcGYoPKVKkCMLCwrSGbTx79gw7d+7U2q9t27YwMzPD1KlTk/1Nif+u5PsQda2y9788NmvWDPHx8ViyZIlmW0JCAhYsWKC1n5ubG+rWrYv//e9/Kb6nUioNsWzZMq3XbsmSJYiPj9d8PgLy9f/Uv/G0jAGLjIzEu3fvkh1r+/btePPmTYpXul+4cEGr5puusnwLWLdu3bBlyxYMGDAAR44cQc2aNZGQkIBbt25hy5Yt+OOPP1CpUiV89913OH78OJo3b46CBQvixYsXWLx4MfLnz6/3Jf8WFhaYMWMGevbsiTp16qBTp06aMhSenp4YOXJkqvetUKECOnXqhMWLFyMsLAw1atTAoUOHdP6m3rdvXyxcuBDdu3fHhQsXkDdvXqxbt06ngrR9+vTB69evUb9+feTPnx8PHjzAggULUKFCBU1JhAoVKsDMzAwzZsxAWFgYrKysUL9+fdSoUQPOzs7w8/PDsGHDYGJignXr1n1St2z37t2xdu1ajBo1CmfPnoWPjw8iIyPx119/YdCgQfjiiy9Qp04d9O/fH9OnT8fly5fRqFEjWFhY4O7du9i6dSt+/vlnzQUJupahcHV1Ra9evfDrr79qxgJGRERg8eLFiIqKwvjx4zX75s+fHyNGjMCsWbMQFxeHypUrY9euXThx4gQ2bNig1Qw+YcIEbN26FfXq1cPw4cPx9u1bzJo1C2XLltW6eESfYxqarq+nrufbwsICP/zwA/r374/69evD19cXgYGBWLVqlUHGgLVo0QI7duxAmzZt0Lx5cwQGBmLp0qUoVaqU1oDY1q1bo0qVKvjqq6/w77//wsvLC3v27NF88Ur6bTotZShS4uDggNq1a2PmzJmIi4uDu7s7/vzzT51ahdesWYPFixejTZs2KFKkCCIiIrB8+XI4ODhoWgH0+dtXmpubG+rVq4e5c+ciIiICvr6+Bju2g4MDlixZgm7duuGzzz5Dx44d4erqiocPH2Lfvn2oWbMmFi5ciDt37qBBgwbo0KEDSpUqBXNzc+zcuRPBwcGawpm6HguQpQUAecFU48aNYWZmpjmOoctQpKRjx44YO3Ys2rRpg2HDhmnKZRQvXlzrAo8iRYrghx9+wPjx4xEUFITWrVvD3t4egYGB2LlzJ/r164fRo0en+jiFCxdGmTJl8Ndff2nVoWvZsiVq1qyJcePGISgoCKVKlcKOHTtS/IK7aNEi1KpVC2XLlkXfvn1RuHBhBAcH4/Tp03j8+DGuXLmitX9sbKzmXN2+fRuLFy9GrVq10KpVK80+3t7eWLJkCX744QcULVoUbm5uqY7dS01axoDdvXsXDRs2hK+vL7y8vGBqaorz589j/fr18PT01CpTBMjxbVevXk3xgp+P0uuayTTQpQzF1q1btbarL4FOeplrnTp1ROnSpVM8TmxsrJgxY4YoXbq0sLKyEs7OzsLb21tMnTpVhIWFCSGEOHTokPjiiy9Evnz5hKWlpciXL5/o1KmTuHPnTpriEUIIf39/UbFiRWFlZSVy5swpunTpIh4/fqy1z/uXDAshRFRUlBg2bJjIlSuXyJEjh2jZsqV49OiRTmUohBDiwYMHolWrVsLW1la4uLiI4cOHay5N/1AZim3btolGjRoJNzc3YWlpKQoUKCD69+8vnj17pnX85cuXi8KFCwszMzOtY546dUpUq1ZN2NjYiHz58omvv/5a/PHHH8keN7VzldJl1e/evRMTJ04UhQoVEhYWFiJPnjziyy+/FPfu3dPab9myZcLb21vY2NgIe3t7UbZsWfH111+Lp0+favbRpwxFXFycWLBggahQoYKws7MTdnZ2ol69euLw4cPJ9k1ISBDTpk0TBQsWFJaWlqJ06dJi/fr1KR73+vXrolGjRsLW1lY4OTmJLl26iOfPn3/SMVOi6/NM7VJ2XV5PXc+3EEIsXrxYFCpUSFhZWYlKlSqJ48ePJyspoYv376NSqTSvk5WVlahYsaLYu3dvis/r5cuXonPnzsLe3l44OjqKHj16iFOnTgkAYvPmzZr90lKGIrXyNY8fPxZt2rQRTk5OwtHRUbRv3148ffo02Xv5/TIUFy9eFJ06dRIFChQQVlZWws3NTbRo0UKcP38+2WPocq5Sk9a/E/VrlFJJh9T+Ty1fvlwAEPb29lrleXSlfo1SK81x5MgR0bhxY+Ho6Cisra1FkSJFRI8ePTSvWUhIiBg8eLDw8vISOXLkEI6OjqJq1apaJXt0PZYQsuTC0KFDhaurqzAxMdH6P27oMhSpPec///xTlClTRlhaWooSJUqI9evXp/iZIoQsxVKrVi2RI0cOkSNHDuHl5SUGDx4sbt++/dHY5s6dK+zs7JKVVXn16pXo1q2bcHBwEI6OjqJbt27i0qVLKf5d3bt3T3Tv3l3kyZNHWFhYCHd3d9GiRQuxbdu2ZM/32LFjol+/fsLZ2VnY2dmJLl26iFevXmkd7/nz56J58+bC3t5eq1REaq+Z+vM7pRJK+nj58qXo16+f5u/I0tJSFCtWTIwYMSLF/wNLliwRtra2Ijw8XO/HMhEii48sJ8qGTExMdCo4m93t2rULbdq0wcmTJ1GzZk2lw8lw/DshXYSFhaFw4cKYOXMmevfunW6Poy4qfO7cuRS78rKiihUrom7dupg3b57e983yY8CIiIDk9dPU41UcHBySVfkmokSOjo74+uuvMWvWLE7KrocDBw7g7t27WsNW9JHlx4ARUeb38uXLFK86VdPlMvCPGTp0KKKiolC9enXExMRgx44d+PvvvzFt2rRMfxWhMYuKivrohTE5c+ZMVuORMtbYsWMxduxYpcPIUpo0aZJqcVZdMAEjonRXuXLlFCdsVtP1MvAPqV+/PubMmYO9e/ciOjoaRYsWxYIFCzBkyJBPOi59Gn9//2QzmLzvyJEjKc6xR2TMFB0Ddvz4ccyaNQsXLlzQXF7bunXrD97n6NGjGDVqFG7cuAEPDw988803HN9AlMmdOnXqgwURnZ2dNVedkXF59uwZbty48cF9vL299Z60myirU7QFLDIyEuXLl0evXr3Qtm3bj+4fGBiI5s2bY8CAAdiwYQMOHTqEPn36IG/evKlW4CUi5WXHAfAk5c2bVzNTBBElyjRXQZqYmHy0BWzs2LHYt28frl+/rtnWsWNHhIaG4sCBAxkQJREREdGny1JjwE6fPp1sqoPGjRtjxIgRqd4nJiZGq1q9SqXC69evkStXLsWnmiAiIiLdCCEQERGBfPnywdQ06xdxyFIJ2PPnz5E7d26tbblz50Z4eDiioqJSvNJp+vTpmDp1akaFSEREROno0aNHyJ8/v9JhfLIslYClxfjx4zFq1CjNelhYGAoUKIBHjx7BwcFBwciIiIgyxsuXwLt3QEJC4k98PHDjBhAZCWzeDDg4AMeOAba2gCGnGs2VC3j1CihZUv6YmQGmpvJ3QgIQFweULi3jK1pUbjcxkb/zX9iNkIqfI9rUFi4u4WjVygP29vaGC05BWSoBy5MnD4KDg7W2BQcHw8HBIdU6P1ZWVrCyskq23cHBgQkYERFlaa9fA48fA6tXA+bmQFgYcOECkD8/EB0N/PGH/seMjU1cdnAAChYELCyAq1eBRo0AKyv5WObmQFAQUK8eEBEhkytnZ6BsWbm/gwOQJ08an1hkJDB4MLBmDdCnD7B8OcLD5U3GMnwoSyVg1atXx/79+7W2HTx4ME2zkBMREWUVr1/L1qrNm4H164ESJYBz51Lf/8KFlLfb2cmWJXNz+TsuDoiJARo0AIKDgZ49ZetUlSpAqVKAIvVxr18HOnQAAgJkMAUKAJnjekGDUjQBe/v2Lf7991/NemBgIC5fvoycOXOiQIECGD9+PJ48eYK1a9cCAAYMGICFCxfi66+/Rq9evXD48GFs2bIF+/btU+opEBER6UylkonOP//I32fOADY2MrlSd8fdvw+EhAD58sn7PH2a/DjvJ18eHsCjR8C4cTKxUqmA4sVlS5StLeDtLfOYTE0IYOVKYOhQICoKyJsX2LgRMNIivYomYOfPn0e9evU06+qxWn5+fli9ejWePXuGhw8fam4vVKgQ9u3bh5EjR+Lnn39G/vz58euvv7IGGBERZSghgNu3gTdv5LipqCiZPL15I7sDy5SRXXlXr8r9bW3l7XFxuj9GSolXoULAgweAnx/QuTPg5ia7/LJ8r9zbt8CAAcCGDXK9USNg3Tr5BI1UpqkDllHCw8Ph6OiIsLAwjgEjIqJkXr2SSc6xY8D27XJc06lT8repKZCk4ybN7OzkGKnatWVrV61assUrd27ZapWQIHMPCwu5v5WVHGOV5ROt1Dx+DFSoIEf///AD8PXX8sVOwtg+v7PUGDAiIiJ9CZHYvffmjRyo/vChbHS5fVt25129Crx4Ibel5s2b5Nty55ZX+T18CPTuLRMmCws5AL5JEzmGytRUDoq3tJS3ubjIbkJKIn9+YNMm2R9bq5bS0WQIJmBERGQ04uKAK1dkT9b8+Z9+vAoVZCtVlSry2IULA9bWskuxSBGZL1AahIcD/foBHTsC6hlwPv9c0ZAyGhMwIiLKlBISZMvSv//Kq/qsrWXtqrg42WqVJ4/8HD91SpZD0IeTk+ztKlBA/lSuDHTpIo/p5ATkyGH450P/uXAB8PUF7t0DjhyR471sbZWOKsMxASMiIkWoi4PGxMghQAkJshvw+HH5e9euTzt+lSpAnTrAV1/Jrj9zczmWKoXSkJQRhAAWLgRGj5ZXKBQsKOtqZMPkC2ACRkREBhQbCxw6JBs5Ll2SA8nj4oBnz2SDx+3bgLs78OSJ7sd0cpID1J8/B1q0kImUhYVM2mrWlMuWlrKaetGicjgRx1hlMqGhcpDcjh1yvXVrWXLC2VnJqBTFBIyIiHSSkCAHoj9+LBOpK1eArVtl95+dne7T1yRNvkxMAHv7xMHvn30muxXt7ID27YF27YBixQz9TChDhYYCFSvKPxQLC2D2bFnry2gv6dQNEzAiIkrRixdA9eoy8Xrw4MP7ppR8Va8uW8CqVJGfu0LI1qyCBWXhUBcXoy7zRGpOTkDTpnJeJH9/oFIlpSPKFJiAERGRxv37QN++wOHDH95PPQC+UCFgxAjZFWhjI8dXubgk1q+ibOrVK3nFRO7ccn3uXDnYz9FR2bgyESZgRETZlBDAnTuyG3Hy5NSn26tfX/YaOTrKlismV/RBf/8ty0sULQocPCgH5Flbyx/SYAJGRGTEVCo5ZuvZM1m64dw54NYt4OzZD9+vc2dg7Fg56TOvGiSdqFTArFnAxImy39rKSv7h5c+vdGSZEhMwIiIjoVLJBGv3bjmNzt9/63f/YcNkyQYPj2w/Ppr09fKlnKDy99/leqdOwP/+J6+woBQxASMiyuKePQOKF//wNDo2NnLCaHd3wNsb8PSUVxy2b59tyzCRoZw4Ibscnz6V3Yy//AL06cMs/iOYgBERZUFCAIMGAUuXpnx7y5YyKatcWZZyMOd/e0oPCQnyD/HpU8DLC9iyBShbVumosgS+JYmIMrngYDkWKywMcHCQxU6jo1Pe98EDObUOUYYwM5OTaP/8MzBvnizgRjoxVToAIiLS9uKFrCTfpo0sFJ4nj0y+AFn64f3k6++/5fgvIZh8UQY4fFiO71IrUwZYvpzJl57YAkZElAkcPgz8+iuwZw8QGZnyPsWLy5IRjo5y6p2cOXmFImWghATgu++A77+XLV/e3iyq+gmYgBERKWT9emDBgg+XhDA1leUgRoxg1XhS0NOnQJcuwNGjcr1HD6BUKSUjyvKYgBERpaN374DTp2Vh8Fu3gIAAOR+xEHKS6vfVqgU0by5LQvDqRMoU/vgD6NZNlpqws5Pdj507Kx1VlscEjIjIwN69A8aMARYv1m3/MWPklYpVq6ZvXER6+/ZbYOpUuVy+vLzKsXhxRUMyFkzAiIgMZPp0YMKElG8zMUmclLp5czl8pkIFwNU1Q0Mk0o+Tk/w9YIC8ypHTCRkMEzAiok909mzKrVfFiwMrVwLVq8uxXERZQmQkkCOHXB4+HKhYEahTR9mYjBD/JRARpUFQkLwAzMQkefI1e7asOn/7NlCzJpMvyiLi4mR/+GefARERcpuJCZOvdMJ/C0REOtq1S7ZqmZgAhQrJWl1JDRsGxMfL+RTZU0NZyoMHQO3a8tvDnTvyj53SFbsgiYg+4tUrwMUl9duvXZO1KImypN27ZVmJ0FBZZG7lSqBtW6WjMnpsASMiSoFKBcyYIYe/vJ98ffedHPelrj7P5IuypNhYWWCudWuZfFWpAly6xOQrg7AFjIgoidevgV69ZKPA+woVAu7elUXAibK8sWPlHI6A7DefNk1OsUAZgi1gREQAbt6UY7ty5UqefE2fDty/L3+YfJHRGDcOKF1azn81ezaTrwzGFjAiytZu3AAaNACCg7W3ly0L7NwJFCmiTFxEBhcdLf+oO3WS67lzA1ev8jJdhfBVJ6Js5/ff5XAXExM5fitp8jVtmhzXdfUqky8yInfvyoJ0nTsDmzYlbmfypRi2gBFRtvHoEVCgQMq39ewJfP894O6esTERpbtNm4B+/YC3b+UVJTlzKh0RgQkYERm5gweBX34BEhJky1dSo0cDvXvLli4LC2XiI0o3UVGykv3y5XK9dm1g40Z+y8gkmIARkdERApg7VyZYKWnQANi/n2OOyYjdugV06CCL1JmYABMnAlOmAOb82M8seCaIyGjcvi27Efftk2WNkurSBahfXzYCFC2qSHhEGefePZl8ubkBGzYADRsqHRG9hwkYEWV5KhVQowbwzz/Jb9u1C/jiiwwPiUhZzZvLrsfmzYG8eZWOhlLAyx+IKMsSQvaqmJlpJ1+tWsm6XkIw+aJs4sYNwMdHzumo1qcPk69MjC1gRJQlHT4sx3K97+XLD8/bSGRUhABWrQKGDJGD7keMkLW+KNNjCxgRZRkqlSzY7eycPPnauFF+FjH5omzj7VugWzd5KW9UFNCoEfC//ykdFemILWBElCWsWCF7VN7366/y84coW7lyRV7leOeO7IP//ns5tyMLq2YZTMCIKFO7cgWoUEF7W/Hichq7zp0BKytFwiJSzokTwOefAzExsqbX5s1ArVpKR0V6YgJGRJmSEEChQtpjigEgIADw8lImJqJMoXJl+SZwdwfWrGG/exbFBIyIMp2YGMDRUf5WK1xY1pZkxXrKlgICZNOvmRlgbQ389ZecUohdjlkWzxwRZRrBwcB338nPl6TJV2SkrCvJ5IuyHSGAhQtlP/yPPyZud3Fh8pXFsQWMiBQXEyOTrvcVLSrreTHxomwpNFReYbJjh1y/ckVeCszEyyjwLBKRYkJDZdHU95MvW1vA3x+4e5fJF2VTZ88CFSvK5MvCApg/H9i2jcmXEWELGBEp4sQJOS/j+xIS+BlD2ZgQMtkaOxaIi5NXovj7y4H3ZFT4b46IMlR0NFCzpnbyVaAAcP++/Oxh8kXZWmAgMGGCTL7atQMuXmTyZaTYAkZEGSIuDliwAPjqK+3tS5YAAwYoExNRplO4MLBokaxsP2gQYGKidESUTpiAEVG6i48HcucG3rzR3v7oEZA/vzIxEWUKKhUwZ46cSLtaNbmtVy9lY6IMwcZ+IkpXW7fKMcRJk6/Dh2V3I5MvytZevgRatAC+/hro2FHO7UjZBlvAiChd3L8vh668fp24LX9+eWVjSiUniLKV48eBTp2Ap0/lG2LiRCBHDqWjogzEFjAiMqj4eFm6qEgR7eRr/XrZ5cjki7I1lUoWVK1XTyZfJUoA//wD9O3L8V7ZDFvAiMhgDh8GGjTQ3ta6tRxonyePIiERZR5v3wJt2wIHD8r1bt2AxYsBOztl4yJFMAEjIoMICkqefO3bBzRrpkg4RJlPjhyAjY38WbwY6NFD6YhIQeyCJKJP8uqVrBlZqFDitl9/lYPsmXxRtpeQIEtKALKLcdUq4Px5Jl/EFjAiSruFC4GhQ7W3zZsnx4ARZXvPngGdOwPu7sC6dTIBy5lT/lC2xwSMiNLE0lIWV1Vzd5ctX02aKBcTUabx559A166y1ESOHPKy4CJFlI6KMhEmYESkN19f7eSLBVWJ/hMfD0yZAkyfLvvhy5WTczky+aL3MAEjIr107Ahs2ZK4HhcHmPM/CRHw+LHscjxxQq737y/75G1slI2LMiX+2yQinQQEyJlSwsMTt4WGMvkiAiDrezVtCly/DtjbA8uXy6ZiolTwKkgiSpUQcpC9iQlQqpR28hUeDjg6KhcbUaZiagrMnw9UqgRcvMjkiz6KCRgRpap3b3mlY1KNG8ur6u3tlYmJKNN4+FAOtldr0EBWtS9aVLmYKMtg5wERpej332XJIrUrV4CyZTlbChEAYM8eWcsrPl62eKmTLlO2a5Bu+JdCRFpu3waqV9cuohoaKi/mYvJF2V5sLDByJPDFF8CbN4CXFwdCUpoonoAtWrQInp6esLa2RtWqVXH27NkP7j9//nyUKFECNjY28PDwwMiRIxEdHZ1B0RIZr+vXZYLl5QWcOZO4/c4djvUiAgAEBgK1asmxXoBMxE6eBDw9lYyKsihFEzB/f3+MGjUKU6ZMwcWLF1G+fHk0btwYL168SHH/jRs3Yty4cZgyZQoCAgKwYsUK+Pv7Y8KECRkcOZFxeftWdi8mVbIkcPcuUKyYMjERZSrbtwMVKwLnzgHOzsDu3cDcubIiMVEaKJqAzZ07F3379kXPnj1RqlQpLF26FLa2tli5cmWK+//999+oWbMmOnfuDE9PTzRq1AidOnX6aKsZESUXFwecOiVbvZIOqG/ZUg5ruXmTY4mJNP7+GwgLk/3zly8DrVopHRFlcYolYLGxsbhw4QIaNmyYGIypKRo2bIjTp0+neJ8aNWrgwoULmoTr/v372L9/P5p9YMbfmJgYhIeHa/0QZTd37gAtWgA+PvLLu4WF/OJeq5b2foMGybHFZmbKxEmUqQiRuDx9OvDzz8CxY0CBAsrFREZDsZGDISEhSEhIQO7cubW2586dG7du3UrxPp07d0ZISAhq1aoFIQTi4+MxYMCAD3ZBTp8+HVOnTjVo7ESZmRByWMrKlfL3v//qdr/Hj+V8jkQEYPNmYM0a+Y1E/Y1l2DCloyIjovggfH0cPXoU06ZNw+LFi3Hx4kXs2LED+/btw/fff5/qfcaPH4+wsDDNz6NHjzIwYqKMoU66TEzkVfC1awOrVydPvsqVA/buBe7dA54+lV2NQsgfJl9EkEXu+vcHOnUCDhyQFe2J0oFiLWAuLi4wMzNDcHCw1vbg4GDkyZMnxftMmjQJ3bp1Q58+fQAAZcuWRWRkJPr164eJEyfCNIX6K1ZWVrCysjL8EyBSWEgIMGMGMHt26vu4uABduwJdusgC3UT0AbdvAx06AFevym8zEyYA/fopHRUZKcUSMEtLS3h7e+PQoUNo3bo1AEClUuHQoUMYMmRIivd59+5dsiTL7L/BKiJpXz2REXv7FvjsM3mFYkoqVACOHmXpCCK9rF8PDBgAREYCbm5y/fPPlY6KjJiiXZCjRo3C8uXLsWbNGgQEBGDgwIGIjIxEz549AQDdu3fH+PHjNfu3bNkSS5YswebNmxEYGIiDBw9i0qRJaNmypSYRIzJW9+4B3bvLKxaTJl/lywOjRwPPn8uuxEuXmHwR6eXHH4Fu3WTyVa+evMqRyRelM0XL9/r6+uLly5eYPHkynj9/jgoVKuDAgQOagfkPHz7UavH65ptvYGJigm+++QZPnjyBq6srWrZsiR9//FGpp0CU7n75BRg+PPl2e3vg5UuAPexEn+jLL4GZM4FRo4BvvuFlwJQhTEQ267sLDw+Ho6MjwsLC4ODgoHQ4RMkIAVy4IOdhXLw4+e0tWsjxwR06cAYUojQRQo7zKl8+cdurV0CuXMrFRB9lbJ/f/PdNlAnExsqiqPPny6veU7J+PdC5M+djJPokb98CAwcCGzcChw8DderI7Uy+KINlqTIURMbmzh051MTKCqhfP3nyZWMDfP01kJAgr2Rk8kX0Ca5elZcDr18v169fVzYeytbYAkakACHk/L0PHya/rVQpWXS7ZUsmXEQGIYSs5zVsGBATI4vebdokp4YgUghbwIgykEoFTJwoi6UmTb7KlQOuXJGfEzduyGnmmHwRGUB4uOy7799fJl9Nm8qrHJl8kcLYAkaUAQID5ZWMv/2W/La4OA6mJ0o3u3fLaYXMzGTT8ldfyW9ARArjv32idHTsGNCggRzDlVSuXPIKxw4dlImLKNvo2lUWx2vfHqheXeloiDT4NYAoHTx9KqcBqltXO/nKmxc4dEhOI8TkiygdhIYCQ4YAb97IdRMTYO5cJl+U6TABIzKQiAiZVJmYyDG+r14l3ubnJ4efPH0qr3YkonRw7pycp2vRIllqgigTYwJG9AlUKsDfH6hWDXBwALZu1b69dm3g3Ttg9WrA0lKREImMnxCyiF7NmnLAZaFCcqwXUSbGMWBEafDypZy1RF1OKKnChYEVK2R9R17JSJTOXr8GevZMLKLXrh3w66+Ak5OiYRF9DBMwIj2cPw+0bQs8epT8tsGDgWnTZEsYEWWAa9fk3FwPH8om5rlzgUGD+M2HsgQmYEQ6evsWqFxZe1vx4sDBg0CBAsrERJSt5csnux+LFAG2bJHjv4iyCI4BI/qIhARgxAjA3j5x2y+/yPpdt28z+SLKUBERMukCZD2X338HLl5k8kVZDhMwolRcvAg0ayaLpP78c+L26tWBoUNZPJUow504AZQsKa9qUStdmv3+lCUxASN6T2wsYGEBeHvLL9dJnTgB/P23MnERZVsqlRxgWa8e8OQJsGBB8urGRFkMEzCi/7x7JwunWlkB8fGJ27t1A3btkr0etWopFR1RNvXiBdCkiZxENSFBVrY/flxOLUSUhbEThbK9S5eAmTPldHFJWVsDkZGcNo5IMUeOyIm0nz8HbGyAhQtlyQle5UhGgAkYZVvBwYCPD3D3bvLb7t2T9byISCEPHgCNGsnm6FKl5FWOpUsrHRWRwfC7PWVLQgB58mgnX926AQEB8jYmX0QKK1gQGD9etnidPcvki4wOW8AoW2rZMnF50iTgu++Ui4WI/vPXX4CnJ1C0qFyfOpXdjWS02AJG2U758sC+fXLZ3JzJF5Hi4uOBb76RXY6+vnLmeoDJFxk1toBRtvLLL8DVq4nrr18rFwsRQZaV6NRJ1ngB5HQT6kKrREaMCRhlC5GRspJ90v/rKhW/YBMp6vffge7dgZAQ+QZdtgzo2FHpqIgyBLsgyej99RdgZ6edfF29yuSLSDFxccDYsXKqiZAQoGJF4MIFJl+UrbAFjIyanZ1s/VKrWVP2dDD5IlKQELLGFwAMHgzMni0L7xFlI0zAyCgJAbi7aydfK1YAvXopFxNRtieE/PZjaQn4+8sJV9u1UzoqIkUwASOj5OgIREQkrnO8F5GCYmOBceNkK9e0aXJboULyhyib4hgwMhoqFbBkiUy0kiZf6i/dRKSAwEA55cS8ecBPPwG3bikdEVGmwBYwMgpCpDw3b9IuSCLKYDt2yH7/sDDAyQlYvRrw8lI6KqJMgS1glOWtW5d8wuw//5RJma2tMjERZWsxMcDQoXJ8V1gYUK0acPky8MUXSkdGlGmwBYyytFGjZM+GmoWFHG5CRAoRQla0P35crn/9NfDDD/LNSUQabAGjLGvTJu3ka9cuJl9EijMxAfr0AXLlknN+zZjB5IsoBWwBoywnPl6WmHjxInHbo0dA/vzKxUSUrUVFAUFBQMmScr1bN6B5cyBnTkXDIsrM2AJGWYoQ8st00uTr8mUmX0SKuX1bjvFq2BB4+TJxO5Mvog9iAkZZSoUK2uuxsUD58oqEQkTr1wPe3nJur7g4WXKCiHTCBIyyjFmz5P95tYQEDi0hUsS7d0Dv3rKrMTISqFtXNkVXqaJ0ZERZBhMwyhIiIuTFVGqxsclLTxBRBrh5UyZaK1fKAfdTpsgZ7/PlUzoyoiyFg/ApS3BwSFw+fpwtX0SKmTEDuHEDyJMH2LABqF9f6YiIsiQmYJSpxcYCOXIkrtvZyVlNiEghv/wCmJvLOR1z51Y6GqIsi504lKl9840sO6EWGqpYKETZ07VrwJgx8hJkQM50v2IFky+iT8QWMMq0hJAD79UiIlKe75GI0oEQwK+/AsOGAdHRQIkSssAqERkEEzDKtAYMSFy+fVt2PxJRBggPB/r3BzZvlutNm3IeRyIDYxckZUq9egHLliWuFy+uXCxE2cqlS7K21+bNssl5xgxg717A1VXpyIiMyie1gEVHR8Pa2tpQsRABAJYuBVatSly/ckW5WIiylXXrZDdjbCzg4SGTsBo1lI6KyCjp3QKmUqnw/fffw93dHXZ2drh//z4AYNKkSVixYoXBA6TsZcgQYODAxPVbt4By5ZSLhyhbKVRIVjhu2VIWVmXyRZRu9E7AfvjhB6xevRozZ86EpaWlZnuZMmXw66+/GjQ4yl7i4oBFixLXr16V436JKB2FhSUu16oFnD4N7N7NuRyJ0pneCdjatWuxbNkydOnSBWZJLkkrX748bt26ZdDgKPt4+xZIks8jIAAoW1a5eIiMnhDAzz8Dnp6yur1a5cqywj0RpSu9E7AnT56gaNGiybarVCrExcUZJCjKXsaMAeztE9fLlWPLF1G6ev0aaNMGGDFCFtdbvVrhgIiyH70TsFKlSuHEiRPJtm/btg0VK1Y0SFCUffz8MzB7duL6qFFy0D2/gBOlkzNngIoVZTejpSWwYIG80pGIMpTeV0FOnjwZfn5+ePLkCVQqFXbs2IHbt29j7dq12Lt3b3rESEbqp5+A8eMT18+fl1e/E1E6UKmAuXPlmy4+HihSBPD355uOSCEmQqjnl9DdiRMn8N133+HKlSt4+/YtPvvsM0yePBmNGjVKjxgNKjw8HI6OjggLC4ND0hmeKcOZm8sLrgAgMFAORSGidLJ2LeDnJ5c7dJCF9hwdlY2JSA/G9vmdpjpgPj4+OHjwoKFjoWxk0KDE5GvOHCZfROmuc2dgwwY59qt/f/bzEylM7zFghQsXxqtXr5JtDw0NReHChQ0SFBm3/v2BJUsS13v1Ui4WIqOlUsm5HGNi5Lq5OXDggJzji8kXkeL0TsCCgoKQoG66SCImJgZPnjwxSFBkvNat055i6NIlwMlJsXCIjNOLF3L+xr59gbFjE7cz8SLKNHTugtyzZ49m+Y8//oBjkrEDCQkJOHToEDzZj0QfcOEC0L174vrNm0DJksrFQ2SUjh6V3Y3PngE2NpxKgiiT0jkBa926NQDAxMQEfuqBnP+xsLCAp6cn5syZY9DgyLgkTb4OHGDyRWRQCQnAjz8CU6fK7seSJYGtW4HSpZWOjIhSoHMCplKpAACFChXCuXPn4OLikm5BkfFZuzax2HaPHkDjxoqGQ2Rcnj8HunQBDh+W6z17yvpeOXIoGxcRpSpNZSiyMmO7jDWrSDr05M0bjvsiMqj792Vx1fh4YOlSoFs3pSMiMjhj+/xOUxmKyMhIHDt2DA8fPkRsbKzWbcOGDTNIYGQc7t+X9R7VNm1i8kVkEEIkfrMpXBjYsgUoWBDw8lI2LiLSid4tYJcuXUKzZs3w7t07REZGImfOnAgJCYGtrS3c3Nxw//799IrVIIwtg87M4uMBC4vE9QIFgAcPlIuHyGg8eQJ07Sqr2meBAthEhmBsn996l6EYOXIkWrZsiTdv3sDGxgZnzpzBgwcP4O3tjdlJJ/WjbG/x4sTlZs2YfBEZxIEDQIUK8mrHQYPkNx0iynL0TsAuX76Mr776CqampjAzM0NMTAw8PDwwc+ZMTJgwIT1ipCwoKgoYPjxxfd8+5WIhMgpxccC4cbK+V0iITML275cFVokoy9E7AbOwsICpqbybm5sbHj58CABwdHTEo0eP9A5g0aJF8PT0hLW1NapWrYqzZ89+cP/Q0FAMHjwYefPmhZWVFYoXL479+/fr/biUfqKjAVvbxHX11Y9ElEaPHgF16wIzZsj1QYOA06eB4sUVDYuI0k7vr04VK1bEuXPnUKxYMdSpUweTJ09GSEgI1q1bhzJlyuh1LH9/f4waNQpLly5F1apVMX/+fDRu3Bi3b9+Gm5tbsv1jY2Px+eefw83NDdu2bYO7uzsePHgAJ47qzlQaNkxc7tGD9b6IPsmTJ7K16/VrwMEBWLEC+PJLpaMiok+k9yD88+fPIyIiAvXq1cOLFy/QvXt3/P333yhWrBhWrFiBChUq6HysqlWronLlyli4cCEAWWvMw8MDQ4cOxbhx45Ltv3TpUsyaNQu3bt2CRdLR3XowtkF8mY0QwH8NpGjcWA5XIaJP1KMHcOMG4O8vr3gkyoaM7fNbsTpgsbGxsLW1xbZt2zRV9gHAz88PoaGh2L17d7L7NGvWDDlz5oStrS12794NV1dXdO7cGWPHjoWZmZlOj2tsJzCz+d//5Fy/ABAeDtjbKxsPUZYUFATY2QHqgtfv3gFmZoCVlaJhESnJ2D6/9R4DlpqLFy+iRYsWOu8fEhKChIQE5M6dW2t77ty58fz58xTvc//+fWzbtg0JCQnYv38/Jk2ahDlz5uCHH35I9XFiYmIQHh6u9UPpZ9q0xGUmX0RpsHOn7HL085NTCgFyUCWTLyKjolcC9scff2D06NGYMGGCpt7XrVu30Lp1a1SuXFkzXVF6UalUcHNzw7Jly+Dt7Q1fX19MnDgRS5cuTfU+06dPh6Ojo+bHw8MjXWPMzi5fBv67JgMjRyoaClHWExMDDBsGtG0LhIUBr17J30RklHROwFasWIGmTZti9erVmDFjBqpVq4b169ejevXqyJMnD65fv67X1YguLi4wMzNDcHCw1vbg4GDkyZMnxfvkzZsXxYsX1+puLFmyJJ4/f56sIr/a+PHjERYWpvlJy5WapJuKFROXx4xRLg6iLOfePaBmTTl/IwCMHg2cOAE4OysbFxGlG50TsJ9//hkzZsxASEgItmzZgpCQECxevBjXrl3D0qVLUVLPS90sLS3h7e2NQ4cOabapVCocOnQI1atXT/E+NWvWxL///qvV0nbnzh3kzZsXlpaWKd7HysoKDg4OWj+UPtzd5e9WrYC8eZWNhSjL2LJFfnu5cAHIlQvYuxeYNUt7GgkiMjo6J2D37t1D+/btAQBt27aFubk5Zs2ahfz586f5wUeNGoXly5djzZo1CAgIwMCBAxEZGYmePXsCALp3747x48dr9h84cCBev36N4cOH486dO9i3bx+mTZuGwYMHpzkGMozr1+XV8gAwc6aysRBlGdHRcjqhiAjZAnb5MtC8udJREVEG0LkOWFRUFGz/q65pYmICKysr5P3EZg5fX1+8fPkSkydPxvPnz1GhQgUcOHBAMzD/4cOHmqKvAODh4YE//vgDI0eORLly5eDu7o7hw4dj7NixnxQHfRohgLJlE9fZ+kWkI2trWVpi505g6lRWtSfKRnQuQ2FqaooffvgBdnZ2AICxY8dizJgxcFFfJv2fYcOGGT5KAzK2y1gzAxOTxOXly4E+fZSLhSjT27hRlpXgG4VIL8b2+a1zAubp6QmTpJ+0KR3MxERzdWRmZWwnUGkREbI4NyATsXS+EJYo63r3Tk6Q+uuvgKWl7G7kNBFEOjO2z2+d27uDgoLSMQzKioRITL4AICFBuViIMrWAAKBDBzlY0sREjvviPI5E2RoHHFCazZmTuNyxo3ZXJBH9Z80aOXn2u3dA7tyyC7J+faWjIiKFKTYVkVKMrQlTKQkJ2uOFs9dfEZEOhAD69pWTZwNylvr162USRkR6M7bPb4NNRUTZy+HDict//aVcHESZlomJnDjb1BT4/ns5Mz2TLyL6D1vAKE3U3Y3FiwO3bysbC1GmIYScPsjJSa6rVHKw/WefKRkVkVEwts9vtoCRXoQAklYe+a82LxFFRABdugA+PnK8FyBbv5h8EVEK0pSA3bt3D9988w06deqEFy9eAAB+//133Lhxw6DBUeYzYICcI1jthx+Ui4Uo07h8GfD2BjZtklc8Hj+udERElMnpnYAdO3YMZcuWxT///IMdO3bg7du3AIArV65gypQpBg+QMo9Xr4BlyxLXWXaCsj0hgCVLgGrVgLt3AQ8PmXw1aaJ0ZESUyemdgI0bNw4//PADDh48qDUBdv369XHmzBmDBkeZS9Kux+ho2btClG2FhQG+vrLEREwM0LIlcOkSUKOG0pERURag90fotWvX0KZNm2Tb3dzcEBISYpCgKPNp3Tpx+dtvASsrpSIhyiSGDAG2bpX1WObMAXbvBnLlUjoqIsoi9E7AnJyc8OzZs2TbL126BHd3d4MERZlLRIT8bFFjTzMRgOnT5bivkyeBUaNYiZiI9KJ3AtaxY0eMHTsWz58/h4mJCVQqFU6dOoXRo0eje/fu6REjKSxp1+OFC8rFQaSoN29kVXu1/PmBc+eAqlWVi4mIsiy9E7Bp06bBy8sLHh4eePv2LUqVKoXatWujRo0a+Oabb9IjRlLQkydAbKxcLlWKV9RTNvXPP0DFikCPHtrNwWz1IqI0SnMh1ocPH+L69et4+/YtKlasiGLFihk6tnRhbIXc0tODB4CnZ+L6u3eAjY1i4RBlPCGAuXOBceOA+HigSBHA3192PRJRhjK2z2+9J+M+efIkatWqhQIFCqBAgQLpERNlAvfvy88atZ9/ZvJF2cyrV7LFa+9eud6hA7B8OWAE//iJSHl6d0HWr18fhQoVwoQJE3Dz5s30iIkUpv6ir/bjj8CwYcrFQ5ThTp0CKlSQyZeVlaz1tXkzky8iMhi9E7CnT5/iq6++wrFjx1CmTBlUqFABs2bNwuPHj9MjPlJA//6Jy+vWARMmKBcLkSKePgUePwaKFQPOnJFTQHC8FxEZ0CdNxh0YGIiNGzdi06ZNuHXrFmrXro3Dhw8bMj6DM7Y+ZEN79AhI2rOcvaZqp2xNCO0ka80aoG1bwN5euZiISMPYPr8/qZZ5oUKFMG7cOPz0008oW7Ysjh07Zqi4SCEVKyYunz6tXBxEGerYMTmwPmmNQz8/Jl9ElG7SnICdOnUKgwYNQt68edG5c2eUKVMG+/btM2RslMEWLUqcaPuLL+T0dkRGLSEB+P57oH59OY3Q5MlKR0RE2YTeXZDjx4/H5s2b8fTpU3z++efo0qULvvjiC9ja2qZXjAZlbE2YhhIXBySZ2hNv3gBOToqFQ5T+nj8HunYFDh2S6z16AAsXAjlyKBoWEaXM2D6/9S5Dcfz4cYwZMwYdOnSAS9IS6ZSlJU2+tmxh8kVG7tAhoEsXIDgYsLWVVzlyJg8iykB6J2CnTp1KjzhIQSpV4nLevED79srFQpTudu4E2rWTg+7LlJHfOEqWVDoqIspmdErA9uzZg6ZNm8LCwgJ79uz54L6tWrUySGCUcXLlSlzmXI9k9D7/HChRAvDxYYVhIlKMTmPATE1N8fz5c7i5ucHUNPVx+yYmJkhISDBogIZmbH3In+rdO+0hLyw7QUbp3Dl5laP6/1dYGODoqGxMRKQXY/v81ukqSJVKBTc3N81yaj+ZPfmi5Lp1S1xWXwFJZDTi44Hx44EqVeScjmpMvohIYXqXoVi7di1iYmKSbY+NjcXatWsNEhRljCdPgB075HKNGkDOnMrGQ2RQjx4BdesCP/0k1zlbBxFlInqXoTAzM8OzZ880LWJqr169gpubW6ZvBTO2Jsy0OndONgqo3b0LFC2qXDxEBrVvn7yq8fVrOX/jihXAl18qHRURfQJj+/zWuwVMCAGTFOZEe/z4MRzZrJ9lJE2+xoxh8kVGIjYWGD0aaNFCJl+VKskCq0y+iCiT0bkMRcWKFWFiYgITExM0aNAA5uaJd01ISEBgYCCaNGmSLkGSYTVtmrjcrh0wc6ZysRAZVEAA8Msvcnn4cGDGDMDKStmYiIhSoHMC1rp1awDA5cuX0bhxY9jZ2Wlus7S0hKenJ9q1a2fwAMmwYmOBAwcS1zlsj4xK+fKymr2bG/Df/ywiosxI5wRsypQpAABPT0/4+vrC2to63YKi9LNqVeLyy5eyCDhRlhUTA0yYIC/nrVBBbuvXT9GQiIh0ofcg/KzO2Abx6SPpfI9mZvIKfaIs6949wNdXVg8uXhy4fh2wsFA6KiJKJ8b2+a1TC1jOnDlx584duLi4wNnZOcVB+GqvX782WHBkOCqV9nyPw4crFwvRJ9u6FejTBwgPl/VT5s5l8kVEWYpOCdi8efNgb2+vWf5QAkaZU+XK2utz5igTB9EniY4GRo2Sk2cDQM2awKZNgIeHsnEREemJXZDZwM6dQNu2ievZ64yT0Xj5EmjUCLh8Wa6PHw989x1grvNQViLKwozt81vvOmAXL17EtWvXNOu7d+9G69atMWHCBMTGxho0ODKMpMlXUJBiYRB9mpw5ARcXwNVVXso7bRqTLyLKsvROwPr37487d+4AAO7fvw9fX1/Y2tpi69at+Prrrw0eIH2aK1cSlxctAgoWVC4WIr29ewdERcllMzNgwwbZAta4saJhERF9Kr0TsDt37qDCf5d7b926FXXq1MHGjRuxevVqbN++3dDx0Sfq2TNxeeBA5eIg0ltAAFC1KjBiROI2NzcgXz7FQiIiMpQ0TUWkUqkAAH/99ReaNWsGAPDw8EBISIhho6NP8r//yVlYAKBzZ4DXTlCWsWaNnEbo+nVg9245/ouIyIjonYBVqlQJP/zwA9atW4djx46hefPmAIDAwEDkzp3b4AFS2qhUwIABievq2VmIMrXISKBHD/nz7h3QoIHscnR1VTgwIiLD0jsBmz9/Pi5evIghQ4Zg4sSJKPrfLM7btm1DjRo1DB4gpU2LFonLp08DuXIpFwuRTq5fl/VS1qwBTE2B778H/vgDyJNH6ciIiAzOYGUooqOjYWZmBotMXgzR2C5jTcnbt8B/Zdtgbi4r4BNlarGxQJEiwOPHcozXxo1AnTpKR0VEmYixfX6n+RruCxcuICAgAABQqlQpfPbZZwYLitLu9Wvt1q4nT5SLhUhnlpbA0qXyUt01a9jlSERGT+8E7MWLF/D19cWxY8fg5OQEAAgNDUW9evWwefNmuPIfp6KSJl/du8uLxogypStXgBcvgM8/l+vNmwPNmvFqESLKFvQeAzZ06FC8ffsWN27cwOvXr/H69Wtcv34d4eHhGDZsWHrESDp6/DhxuW9f2ZBAlOkIIVu7qlaVk2k/fJh4G5MvIsom9G4BO3DgAP766y+ULFlSs61UqVJYtGgRGjVqZNDgSD9XryYuL1umXBxEqQoLA/r1A7Zskeuffw7kyKFsTERECtC7BUylUqU40N7CwkJTH4yU8V9FEDg6KhsHUYouXAA++0wmX+bmckb4PXt4iS4RZUt6J2D169fH8OHD8fTpU822J0+eYOTIkWjQoIFBg6O06dVL6QiI3rNgAVCjBnD/vpwP6+RJYNQodjkSUbaldwK2cOFChIeHw9PTE0WKFEGRIkVQqFAhhIeHY8GCBekRI+mgfPnE5W++US4OohTduCFLTbRuLadnqFpV6YiIiBSVpjpgQggcOnRIU4aiZMmSaNiwocGDSw/GVkcEAEJDAWfnxHXDVHYj+kRCJLZwRUUBW7cC3bqx1YuI0sTYPr/1GoTv7++PPXv2IDY2Fg0aNMDQoUPTKy7SkUqlnXy9eaNcLEQAZOI1bx5w8CCwdy9gZgbY2Mi6KEREBECPBGzJkiUYPHgwihUrBhsbG+zYsQP37t3DrFmz0jM++oCEBDmWWW3YMOC/0mxEynj1Ss7juHevXN+xA2jfXtGQiIgyI53HgC1cuBBTpkzB7du3cfnyZaxZswaLFy9Oz9joI9q0SVy2tATmz1csFCLg77+BihVl8mVlBSxZAnz5pdJRERFlSjqPAbOxsUFAQAA8PT0ByHIUNjY2CAoKQt68edMzRoMypj7kpENpOO6LFKNSAbNmARMnymbZYsVkqYkKFZSOjIiMiDF9fgN6tIDFxMQgR5KCiaamprC0tERUVFS6BEYfFhSUuLx/v2JhEMm+73HjZPLVubOs98Xki4jog/QahD9p0iTY2tpq1mNjY/Hjjz/CMUnlz7lz5xouOkpVoUKJy02aKBcHEfr1AzZtAmbOlEXoeJUjEdFH6ZyA1a5dG7dv39baVqNGDdy/f1+zbsJ/vBli27bE5UaN+HlHGSwhATh/PrGWV7lysknW3l7RsIiIspI01QHLyoyhDzlXLuD1a7kcGwukMDMUUfoIDga6dgWOHpXV7FlQlYgyiDF8fieldyV8UtbIkYnJ19q1TL4oAx0+LKdc+Osvednt48dKR0RElGUxActChNAuNdGxo2KhUHaSkABMmQI0bChbwMqUkV2Q7dopHRkRUZal1yB8Uo4QsrSS2vXrbP2iDPD0KdCli+xyBIA+fYCffwaSXIxDRET6yxQtYIsWLYKnpyesra1RtWpVnD17Vqf7bd68GSYmJmjdunX6BpgJtG0LxMUlrpcurVwslI3s2CGTLzs7YMMGYPlyJl9ERAageALm7++PUaNGYcqUKbh48SLKly+Pxo0b48WLFx+8X1BQEEaPHg0fH58MilRZu3YlLkdGKhYGZTeDBwOjR8vaXp07Kx0NEZHRSFMCduLECXTt2hXVq1fHkydPAADr1q3DyZMn9T7W3Llz0bdvX/Ts2ROlSpXC0qVLYWtri5UrV6Z6n4SEBHTp0gVTp05F4cKF0/IUspSxYxOXb99mAwSlo8eP5VyOERFy3cREVrkvXlzRsIiIjI3eCdj27dvRuHFj2NjY4NKlS4iJiQEAhIWFYdq0aXodKzY2FhcuXEDDhg0TAzI1RcOGDXH69OlU7/fdd9/Bzc0NvXv31jf8LGn79sRlfg5Sutm3T1awX7MG+OorpaMhIjJqeidgP/zwA5YuXYrly5fDIsko8Jo1a+LixYt6HSskJAQJCQnInTu31vbcuXPj+fPnKd7n5MmTWLFiBZYvX67TY8TExCA8PFzrJysZOBC4d08u6/iUifQTFweMGQO0aAG8egV4e2s3uxIRkcHpnYDdvn0btWvXTrbd0dERoaGhhogpVREREejWrRuWL18OFxcXne4zffp0ODo6an48PDzSNUZDunkTWLo0cf3LL5WLhYzUgwdA7drA7Nlyfdgw4NQpoEgRZeMiIjJyepehyJMnD/799194enpqbT958qTe47FcXFxgZmaG4OBgre3BwcHIkydPsv3v3buHoKAgtGzZUrNNpVIBAMzNzXH79m0Uee+DY/z48Rg1apRmPTw8PMskYUl6ZhEaCiSZcpPo0504AbRqJf+4nJyAVauAbHBFMRFRZqB3C1jfvn0xfPhw/PPPPzAxMcHTp0+xYcMGjB49GgMHDtTrWJaWlvD29sahQ4c021QqFQ4dOoTq1asn29/LywvXrl3D5cuXNT+tWrVCvXr1cPny5RQTKysrKzg4OGj9ZAVv3wLPnsnlpk2ZfFE6KFZMFperWhW4dInJFxFRBtK7BWzcuHFQqVRo0KAB3r17h9q1a8PKygqjR4/G0KFD9Q5g1KhR8PPzQ6VKlVClShXMnz8fkZGR6NmzJwCge/fucHd3x/Tp02FtbY0yZcpo3d/JyQkAkm3P6pJ2PW7cqFwcZGRevZKTiQJAnjyyxlfhwnJqISIiyjB6J2AmJiaYOHEixowZg3///Rdv375FqVKlYGdnl6YAfH198fLlS0yePBnPnz9HhQoVcODAAc3A/IcPH8LUVPFyZRlOfUFprlyyd4jok23bBvTuDSxbBvj6ym1eXsrGRESUTZkIIYTSQWSkrDCbup+fnGgbACZPBqZOVTYeyuKio2VZicWL5XrTprLkhImJsnEREekhK3x+60PvBKxevXow+cA/7sOHD39yUOkps59AIYCkDX4REXIWGKI0uXsX6NABuHxZro8bB3z3HScSJaIsJ7N/futL7y7IChUqaK3HxcXh8uXLuH79Ovz8/AwVV7bl7Z24HBzM5Is+waZNQL9+8ooOFxdg3TqgSROloyIiIqQhAZs3b16K27/99lu8ffv2kwPKznbvlhejqbm5KRcLZXFXrybO3Vi7trySw91d2ZiIiEjDYKPbu3bt+sH5G+njks6+xFyWPkm5cnIS7UmTgEOHmHwREWUyereApeb06dOwtrY21OGypTNn5O9evYAcOZSNhbKgDRsAHx+gQAG5PnMmB9oTEWVSeidgbdu21VoXQuDZs2c4f/48Jk2aZLDAspudO4Fjx+Ry0aLKxkJZTGQkMHSorGRfo4as7WVhweSLiCgT0zsBc3yvJLupqSlKlCiB7777Do0aNTJYYNnNN98kLg8bplwclMXcuCGvcrx5U14+27ix9mW0RESUKemVgCUkJKBnz54oW7YsnJ2d0yumbGf5cvn5CcheJHY/0kcJIVu8hgwBoqKAvHnlQPu6dZWOjIiIdKDXV2UzMzM0atQIoaGh6RRO9hMbKysFqLERkT4qMhLo3l1WtY+Kkq1ely8z+SIiykL07qsoU6YM7t+/nx6xZEs3biQuBwTIck1EH2RqKstMmJkB06cD+/ezZgkRURaj9xiwH374AaNHj8b3338Pb29v5Hivv8wYqtNmJB8f+dvTk9Py0QcIkThNgo0NsGUL8PIlUKuW0pEREVEa6JyAfffdd/jqq6/QrFkzAECrVq20piQSQsDExAQJCQmGj9JI3bwpe5MA4PPPlY2FMrGwMNlPXbZs4tUaJUrIHyIiypJ0ngvSzMwMz549Q0BAwAf3q1OnjkECSy+ZaS6pL74A9uyRywkJvHiNUnDhAuDrC9y7B1hbA/fvywH3RETZTGb6/DYEnVvA1HlaZk+wsoorVxKTry5dmHzRe4QAFi6U1exjY4GCBYHNm5l8EREZCb3GgJmwsKPBJJ3T/JdfFAuDMqPQUHmF444dcr11a2DlSoClX4iIjIZeCVjx4sU/moS9fv36kwLKDpIO3enSBciZU7lYKJOJj5fV7AMCZDX72bNllXt++SEiMip6JWBTp05NVgmf9BMdDdy5k7i+dq1ysVAmZG4ODB8u53H09wcqVVI6IiIiSgd6JWAdO3aEG+sNfRJ//8RllYoNGwTg9Wvg2TOgdGm53q8f0LUrp0QgIjJiOg/95vivTycE0KOHXM6Vi8kXAfj7bzkgsEULOfYLkH8YTL6IiIyazgmYjtUq6AN2705cZtdjNqdSATNmALVrA48eyfFeL14oHRUREWUQnbsgVSpVesaRLXTunLj8Xz1byo5evgT8/IDff5frnToB//sfYG+vbFxERJRh9J6KiNLm1Ck5bzIAzJ+vaCikpOPHZcL19KksrLpggSw5wf5oIqJshQlYBvj3X+0p+4YNUy4WUtjcuTL58vKS8zmWLat0REREpAAmYBmgWLHE5e++Y2NHtrZiBVC4sPxDsLNTOhoiIlIIJ8BJZ+fOJS5Pnw5MmqRcLKSAw4eBr76Sl8AC8vLXuXOZfBERZXNsAUtHcXFAlSqJ6+PGKRcLZbCEBNnK9f33MvmqWhXo0EHpqIiIKJNgApaONm1KXN6+Xbk4KIM9fSrnmDp6VK737i3rfBEREf2HCVg6+vln+dvWFmjbVtlYKIP8+aesYv/ypSym+r//yWSMiIgoCY4BSydv3wIXL8rloUOVjYUyyKxZQJMmMvkqX17+ATD5IiKiFDABSyeDBycut2qlXByUgSpWlL8HDgTOnAGKF1c2HiIiyrTYBZkOnjxJnGrI1RWoXl3ZeCgdvXgBqCeob9gQuHYtcVJtIiKiVLAFLB2MGZO4fOkS634Zpbg4eaKLFwfu3UvczuSLiIh0wAQsHaivfmzUCHB3VzYWSgcPHgA+PsDs2UBYGPDbb0pHREREWQy7IA0sPj5xuXdv5eKgdLJrF9CzJxAaCjg6AitX8hJXIiLSG1vADOzHHxOXW7ZULg4ysNhYYMQIoE0bmXxVqSL7l5l8ERFRGjABM7BlyxKXbWyUi4MMbOHCxMJuo0YBJ04AhQopGxMREWVZ7II0oDdvZBF0AFi1StlYyMCGDAEOHgQGDWLTJhERfTK2gBlQ+/YpL1MWFB0tJ82Oi5PrlpbA778z+SIiIoNgC5iBCAEcOiSXq1SRs9BQFnX3LuDrK8d4vXwJTJ+udERERGRk2AJmIP7+ictLlyoXB32izZuBzz6TyZeLC1C7ttIRERGREWICZiDbtycuq2ekoSwkKgro3x/o1ElO5OnjA1y+DDRtqnRkRERkhJiAGYgQ8vcXXygbB6XBnTtA1aryElYTE+Cbb4DDh1lFl4iI0g3HgBnAb78ltoDVratoKJQWKhVw/76c03HDBjmnIxERUTpiAvaJbt4EWrVKXG/USLlYSA8qFWD6XwOwlxewYwdQtiyQN6+ycRERUbbALshPlLTy/W+/AaVKKRcL6ejGDaBCBeD48cRtjRox+SIiogzDBOwTHTwof9epA7RooWws9BFCACtWAJUrA9euAV99lTh4j4iIKAMxAfsEQsgyUQDQt6+ysdBHREQA3boBffrIKx4bNQL27ZOD7omIiDIYE7BPoJ4aEADq11cuDvqIK1eASpXkAHszM2DaNFnV3s1N6ciIiCib4iD8T7BuXeIyhw9lUgEBssRETIwsK7F5M1CrltJRERFRNscE7BNcvCh/r12rbBz0AV5e8jLVyEhgzRpZ3Z6IiEhhTMDS6Ny5xOVmzZSLg1Jw6RJQqBDg5CTHeK1ZA1hZJZadICIiUhg/kdLon38Sl3PlUi4OSkIIYOFCoFo1OdhefYWjjQ2TLyIiylTYApZGf/0lf3fpomwc9J/QUKB3b1lQFQDi44HoaJl8ERERZTJsFkij3buVjoA0zp6VM6Dv2AFYWADz5wM7dzL5IiKiTIsJWBrcu5e43K6dcnFke0IA8+bJqxqDguS4r1OngOHDWd+LiIgyNSZgaXDgQOJy69aKhUFhYcDcuUBcnMyEL16UVe6JiIgyOY4BSwN1AdZmzdjQoignJ2DTJlloddAgngwiIsoymIClwd278nehQsrGke2oVMDs2UCePED37nJbrVosrEpERFkOEzA9nTyZuDx8uHJxZDsvXwJ+fnIKIVtboF49wMND6aiIiIjShAmYngYNSlwuVky5OLKVEyeAjh2Bp08Ba2t5lWP+/EpHRURElGYchK+nmzflbx8fZePIFlQq4Mcfgbp1ZfJVooSsgNu3L8d7ERFRlsYWMD3ExwMJCXL5m2+UjcXoJSQAzZsDf/wh17t1AxYvBuzslI2LiIjIANgCpoeePROXWe0gnZmZAZUqyfFeq1bJGc+ZfBERkZHIFAnYokWL4OnpCWtra1StWhVnz55Ndd/ly5fDx8cHzs7OcHZ2RsOGDT+4v6HExgLr18tlKyvA2TndHzL7SUiQg+3Vvv0WuHwZ6NFDoYCIiIjSh+IJmL+/P0aNGoUpU6bg4sWLKF++PBo3bowXL16kuP/Ro0fRqVMnHDlyBKdPn4aHhwcaNWqEJ0+epGucFy4kLt+6la4PlT09ewZ8/jnQtCkQEyO3mZvzSgciIjJKJkIIoWQAVatWReXKlbFw4UIAgEqlgoeHB4YOHYpx48Z99P4JCQlwdnbGwoUL0V1dG+oDwsPD4ejoiLCwMDg4OOgc56BBwJIlgKsrkEpuSGn1559A166y9StHDuDwYaBKFaWjIiKiTCStn9+ZlaItYLGxsbhw4QIaNmyo2WZqaoqGDRvi9OnTOh3j3bt3iIuLQ86cOdMrTAghky9AzvlMBhIfD0ycCDRpIpOvcuVkUyOTLyIiMnKKXgUZEhKChIQE5M6dW2t77ty5cUvHfr6xY8ciX758WklcUjExMYhRd2lBZtD6EAIoUCBxXYdGOdLF48dA586yxhcA9O8vJ9a2sVE2LiIiogyg+BiwT/HTTz9h8+bN2LlzJ6ytrVPcZ/r06XB0dNT8eOhZPf3sWZkrqNWr9ykRk0bfvjL5srcHNm8Gli5l8kVERNmGogmYi4sLzMzMEBwcrLU9ODgYefLk+eB9Z8+ejZ9++gl//vknypUrl+p+48ePR1hYmObn0aNHesX4+nXicny8XnelD1m0SGazFy8Cvr5KR0NERJShFE3ALC0t4e3tjUOHDmm2qVQqHDp0CNWrV0/1fjNnzsT333+PAwcOoFKlSh98DCsrKzg4OGj96CM6Wv6uUUOWpqI0evgQ+PXXxPXCheVg+6JFlYuJiIhIIYpXwh81ahT8/PxQqVIlVKlSBfPnz0dkZCR6/lf1tHv37nB3d8f06dMBADNmzMDkyZOxceNGeHp64vnz5wAAOzs72KVDoU71UDQrK4MfOvvYs0fW8goNlQPqGjVSOiIiIiJFKZ6A+fr64uXLl5g8eTKeP3+OChUq4MCBA5qB+Q8fPoSpaWJD3ZIlSxAbG4svv/xS6zhTpkzBt99+a/D4AgPl7/d6SUkXsbHA2LFy8mxATh/Aul5ERETK1wHLaPrWEVHP+Tx4MPBfqTLSRWCgHNt17pxcHzkS+OknwNJS2biIiChLMrY6YIq3gGVmp04lLletqlwcWc6uXbLLMSxMztm0ejXQqpXCQREREWUeTMA+YPHixOWuXZWLI8sJD5fJV/XqssRE0kJqRERExATsQzZulL/btEnsiqRUJCQkXibavTtgbS1fOAsLZeMiIiLKhLJ0Idb0pC4/AcjeNPqAzZuBsmWBkJDEbR06MPkiIiJKBROwVMTGJi5//rlycWRqUVFyCqFOnYCAAGDuXKUjIiIiyhLYBZmK69cTl835KiV365Zs5bp2TfbPTpgApEMZECIiImPE1CIVSRtz2JP2nnXrgIEDgchIwM0NWL+ezYRERER6YAKWgidPgO3b5TKnH3rP//4HDBggl+vVAzZsAPLmVTYmIiKiLIZjwFKQtODq4cPKxZEpdewo52/89lvg4EEmX0RERGnAFrAUnDwpf5cqBdSurWwsihNCZqH168uxXo6OwNWrgI2N0pERERFlWWwBS4E6AWvYUNk4FPf2LeDnJ1+IpUsTtzP5IiIi+iRsAXvPixeJy4MGKReH4q5elVc53r4NmJrKAfdERERkEEzA3hMQkLhcooRycShGCGDZMmD4cCAmBnB3BzZtAnx8lI6MiIjIaDABe09UlPydJ4+ycSgiPBzo1w/w95frTZsCa9cCLi7KxkVERGRkOAbsPVeuyN+FCysbhyKuXwe2bpW1N2bOBPbuZfJFRESUDtgC9p4LF+TvpGPBso0aNWQNjgoVgOrVlY6GiIjIaLEF7D0PHsjf1aopG0eGCA0FunXTHvg2cCCTLyIionTGFrAkhADOnpXLjRsrG0u6O3cO8PUFAgOBmzeB8+dlnS8iIiJKd2wBS2LXrsTlZs0UCyN9CQHMnw/UrCmTL09PWeOLyRcREVGGYQtYEqdOJS7nzKlcHOnm9WugZ09gzx653rYtsGIF4OSkaFhERETZDROw/6hUwJw5crluXUVDSR+BgfKJPXwIWFoCc+fKSrNs+SIiIspwTMD+888/ictffaVcHOnGwwMoUACwsAC2bAE++0zpiIiIiLItJmD/Uc//CAAtWigXh0G9egXY28sWL3NzWePL1hZwcFA6MiIiomyNg/D/Exwsf3t5KRuHwZw4AZQvD4wdm7gtTx4mX0RERJkAE7D/GM34L5UKmDYNqFcPePIEOHCAE2kTERFlMkzAANy6lbhctqxycXyyFy+AJk2AiROBhASga1dZ7ytHDqUjIyIioiQ4BgzAmDGJywMGKBfHJzlyBOjcGXj+HLCxARYtAnr04FWOREREmRATMMg5pwGgZUvANCu2CYaHA+3aAW/eAKVKyascS5dWOioiIiJKRbZPwNSD7wE5DWKW5OAA/O9/wO+/AwsWsMuRiIgok8v2CdiOHYnLn3+uXBx6++sv2VxXv75cb99e/hAREVGmlxU73Azqzz/l76JFZamsTC8+HvjmG6BRI6BTJ+DZM6UjIiIiIj1lhZQjXakn4K5VS9EwdPPkiUy6TpyQ661bcx5HIiKiLChbJ2APHyYut22rXBw6+f13oHt3ICQEsLMDli8HOnZUOioiIiJKg2zdBXnxYuJypp1+SKWS1eybNZPJV8WKMnAmX0RERFlWtk7ALl+Wvxs2zMTlskxNZW0vABg8GPj7b6BYMWVjIiIiok+Srbsgly+Xv9+8UTaOFMXHJ14VsGiRvMIx0zbTERFlnISEBMTFxSkdBqUDCwsLmJmZKR1GhsjWCdjTp/J3tWrKxqElNhYYNw74919g927ZNGdnx+SLiAjA27dv8fjxYwghlA6F0oGJiQny588POzs7pUNJd9k2AUv63u3USbk4tAQGAr6+cv5GADh6VE6qTURESEhIwOPHj2FrawtXV1eYZNqxI5QWQgi8fPkSjx8/RrFixYy+JSzbJmDR0YnL5copF4fGjh1Ar15AWJgsLbF6NZMvIqIk4uLiIISAq6srbGxslA6H0oGrqyuCgoIQFxdn9AlYth2EHxSUuKzo+zgmBhg6VM7lGBYm+0MvXwa++ELBoIiIMi+2fBmv7HRus20Ctnu3/G1qqnAF/C5dgIUL5fKYMcDx40DBggoGREREROkt2yZg6gtoSpVSNg6MHQvkzQvs3QvMnAlYWCgcEBEREaW3bJuALVsmf7dsmcEPHBUFHDuWuF65MnD/PtC8eQYHQkREGen06dMwMzND8xT+3x89ehQmJiYIDQ1Ndpunpyfmz5+vte3IkSNo1qwZcuXKBVtbW5QqVQpfffUVnjx5kk7RA9HR0Rg8eDBy5coFOzs7tGvXDsHBwR+8z9u3bzFkyBDkz58fNjY2KFWqFJYuXZpuMWYl2TYBU4/ty9AGp9u35Rivxo0Tq8ACgLV1BgZBRERKWLFiBYYOHYrjx4/jqboOUhr873//Q8OGDZEnTx5s374dN2/exNKlSxEWFoY5c+YYMGJtI0eOxG+//YatW7fi2LFjePr0Kdp+ZB6/UaNG4cCBA1i/fj0CAgIwYsQIDBkyBHv27Em3OLOKbHsVpDrxyrCGpw0bgP79gchIwNUVSOFbDhERGae3b9/C398f58+fx/Pnz7F69WpMmDBB7+M8fvwYw4YNw7BhwzBv3jzNdk9PT9SuXTvFFjRDCAsLw4oVK7Bx40bUr18fALBq1SqULFkSZ86cQbVUCmr+/fff8PPzQ926dQEA/fr1w//+9z+cPXsWrVq1SpdYs4ps2wKmHgOW7rXe3r0D+vQBunaVyVfdurL1678/RiIiShsh5L9VJX70rQO7ZcsWeHl5oUSJEujatStWrlyZpmKyW7duRWxsLL7++usUb3dyckr1vk2bNoWdnV2qP6VLl071vhcuXEBcXBwaNmyo2ebl5YUCBQrg9OnTqd6vRo0a2LNnD548eQIhBI4cOYI7d+6gUaNGH3+yRi7btoDFx8vf6doFefMm0KEDcOOGrGg/eTIwaVJi/ycREaXZu3cZ8CU6FW/fAjly6L7/ihUr0LVrVwBAkyZNEBYWhmPHjmlahnR19+5dODg4IG/evHrdDwB+/fVXREVFpXq7xQc+EJ8/fw5LS8tkCV7u3LnxXD1fcQoWLFiAfv36IX/+/DA3N4epqSmWL1+O2rVr6x2/scm2CVhEhPydrgnY7t0y+cqTR3ZB/tdsS0RE2cft27dx9uxZ7Ny5EwBgbm4OX19frFixQu8ETAiR5lpZ7u7uabrfp1iwYAHOnDmDPXv2oGDBgjh+/DgGDx6MfPnyabWmZUfZNgFT+0Br7af7+mvZVj10KJA7dzo+EBFR9mNrK1uilHpsXa1YsQLx8fHIly+fZpsQAlZWVli4cCEcHR3h4OAAQI61er+VKTQ0FI6OjgCA4sWLIywsDM+ePdO7Faxp06Y4ceJEqrcXLFgQN27cSPG2PHnyIDY2FqGhoVrxBQcHI0+ePCneJyoqChMmTMDOnTs1V36WK1cOly9fxuzZs5mAKR2A0gyagF27Bnz3HbB2rSyvb2YG/PCDAR+AiIjUTEz06wZUQnx8PNauXYs5c+YkG/fUunVrbNq0CQMGDECxYsVgamqKCxcuoGCSYtz3799HWFgYihcvDgD48ssvMW7cOMycOVNrEL7a+wlSUp/SBent7Q0LCwscOnQI7dq1AyBb9h4+fIjq1auneJ+4uDjExcXB1FR7uLmZmRlUKlWqj5VdZOsEzNRQlyAIAfz6KzBsmJxksnBhYMYMAx2ciIiyqr179+LNmzfo3bu3phVLrV27dlixYgUGDBgAe3t79OnTB1999RXMzc1RtmxZPHr0CGPHjkW1atVQo0YNAICHhwfmzZuHIUOGIDw8HN27d4enpyceP36MtWvXws7OLtVSFJ/SBeno6IjevXtj1KhRyJkzJxwcHDB06FBUr15d6wpILy8vTJ8+HW3atIGDgwPq1KmDMWPGwMbGBgULFsSxY8ewdu1azJ07N82xGA2RzYSFhQkAAggTX35pkAMK0bGjEDINE6JJEyFevDDAgYmIKKmoqChx8+ZNERUVpXQoOmvRooVo1qxZirf9888/AoC4cuWKEEI+vylTpggvLy9hY2MjChUqJPr16ydevnyZ7L4HDx4UjRs3Fs7OzsLa2lp4eXmJ0aNHi6dPn6bbc4mKihKDBg0Szs7OwtbWVrRp00Y8e/ZMax8AYtWqVZr1Z8+eiR49eoh8+fIJa2trUaJECTFnzhyhUqlSfYzUzrH68zssLMygz0spJkKk4TrYLCw8PPy/byFhmDPHAaNGfcLBLl2SVzn++6/sbpw2DRg92oBNa0REpBYdHY3AwEAUKlQI1ixgbZQ+dI7Vn99hYWGaMXNZWbbugvTx+YQ779wJdOwIxMYCHh7A5s3Af03ERERERB+SrROwT6ofU6mSPEDNmsCqVUCuXAaLi4iIiIxbtk7ALC31vMOTJ4B6EKOHB3D2rBxwn8aaLERERJQ9ZevBSvb2Ou4oBPDzzzLZSjqBaJEiTL6IiIhIb9k6AXNz02Gn16+BNm2AESPkeC/O4E5ERESfKNsmYDolX2fOABUryimFLC2BBQuA5cvTPTYiIkpdNrt4P1vJTuc22yZgJUt+4EaVCpg9W14m+fCh7Gr8+29gyBB2ORIRKcTMzAwAEBsbq3AklF7U51Z9ro1Zth2E/+rVB248fhwYM0Yud+ggW72MoOYIEVFWZm5uDltbW7x8+RIWFhbJprihrE2lUuHly5ewtbWFubnxpyfG/wxTUb78B26sWxcYPhzw8gL692erFxFRJmBiYoK8efMiMDAQDx48UDocSgempqYoUKAATLLB5262TcDKlk2yolLJqxw7dQLUs7rPn69EWERE9AGWlpYoVqwYuyGNlKWlZbZp2cwUCdiiRYswa9YsPH/+HOXLl8eCBQtQpUqVVPffunUrJk2ahKCgIBQrVgwzZsxAs2bN9HpMTRHWFy+Abt2AP/8E9u4FDh7kVEJERJmYqakppyKiLE/xTMPf3x+jRo3ClClTcPHiRZQvXx6NGzfGixcvUtz/77//RqdOndC7d29cunQJrVu3RuvWrXH9+nW9HtfcHMDRo0CFCjL5srEBunRhdyMRERGlO8Un465atSoqV66MhQsXApCD8Dw8PDB06FCMGzcu2f6+vr6IjIzE3r17NduqVauGChUqYOnSpR99PPVknqdajUeNvTNk92PJksCWLUCZMoZ7YkRERGQwxjYZt6ItYLGxsbhw4QIaNmyo2WZqaoqGDRvi9OnTKd7n9OnTWvsDQOPGjVPdPzVl9kyXyVfPnsC5c0y+iIiIKMMoOgYsJCQECQkJyJ07t9b23Llz49atWyne5/nz5ynu//z58xT3j4mJQUxMjGY9LCwMAPDawhpY+DPQsSOQkACEh3/KUyEiIqJ0FP7f57SxFGvNFIPw09P06dMxderUZNsLxUXLEhP9+ysQFREREaXFq1ev4OjoqHQYn0zRBMzFxQVmZmYIDg7W2h4cHIw86nIQ78mTJ49e+48fPx6jRo3SrIeGhqJgwYJ4+PChUZzArCw8PBweHh549OiRUfTnZ3U8H5kHz0XmwXOReYSFhaFAgQLImTOn0qEYhKIJmKWlJby9vXHo0CG0bt0agByEf+jQIQwZMiTF+1SvXh2HDh3CiBEjNNsOHjyI6tWrp7i/lZUVrKyskm13dHTkmymTcHBw4LnIRHg+Mg+ei8yD5yLzMJY6YYp3QY4aNQp+fn6oVKkSqlSpgvnz5yMyMhI9e/YEAHTv3h3u7u6YPn06AGD48OGoU6cO5syZg+bNm2Pz5s04f/48li1bpuTTICIiItKZ4gmYr68vXr58icmTJ+P58+eoUKECDhw4oBlo//DhQ61st0aNGti4cSO++eYbTJgwAcWKFcOuXbtQhlcxEhERURaheAIGAEOGDEm1y/Ho0aPJtrVv3x7t27dP02NZWVlhypQpKXZLUsbiuchceD4yD56LzIPnIvMwtnOheCFWIiIiouzGOEayEREREWUhTMCIiIiIMhgTMCIiIqIMZpQJ2KJFi+Dp6Qlra2tUrVoVZ8+e/eD+W7duhZeXF6ytrVG2bFns378/gyI1fvqci+XLl8PHxwfOzs5wdnZGw4YNP3ruSD/6vjfUNm/eDBMTE029Pvp0+p6L0NBQDB48GHnz5oWVlRWKFy/O/1UGou+5mD9/PkqUKAEbGxt4eHhg5MiRiI6OzqBojdfx48fRsmVL5MuXDyYmJti1a9dH73P06FF89tlnsLKyQtGiRbF69ep0j9NghJHZvHmzsLS0FCtXrhQ3btwQffv2FU5OTiI4ODjF/U+dOiXMzMzEzJkzxc2bN8U333wjLCwsxLVr1zI4cuOj77no3LmzWLRokbh06ZIICAgQPXr0EI6OjuLx48cZHLlx0vd8qAUGBgp3d3fh4+Mjvvjii4wJ1sjpey5iYmJEpUqVRLNmzcTJkydFYGCgOHr0qLh8+XIGR2589D0XGzZsEFZWVmLDhg0iMDBQ/PHHHyJv3rxi5MiRGRy58dm/f7+YOHGi2LFjhwAgdu7c+cH979+/L2xtbcWoUaPEzZs3xYIFC4SZmZk4cOBAxgT8iYwuAatSpYoYPHiwZj0hIUHky5dPTJ8+PcX9O3ToIJo3b661rWrVqqJ///7pGmd2oO+5eF98fLywt7cXa9asSa8Qs5W0nI/4+HhRo0YN8euvvwo/Pz8mYAai77lYsmSJKFy4sIiNjc2oELMNfc/F4MGDRf369bW2jRo1StSsWTNd48xudEnAvv76a1G6dGmtbb6+vqJx48bpGJnhGFUXZGxsLC5cuICGDRtqtpmamqJhw4Y4ffp0ivc5ffq01v4A0Lhx41T3J92k5Vy87927d4iLizOaeb+UlNbz8d1338HNzQ29e/fOiDCzhbSciz179qB69eoYPHgwcufOjTJlymDatGlISEjIqLCNUlrORY0aNXDhwgVNN+X9+/exf/9+NGvWLENipkRZ/fM7UxRiNZSQkBAkJCRoquir5c6dG7du3UrxPs+fP09x/+fPn6dbnNlBWs7F+8aOHYt8+fIle4OR/tJyPk6ePIkVK1bg8uXLGRBh9pGWc3H//n0cPnwYXbp0wf79+/Hvv/9i0KBBiIuLw5QpUzIibKOUlnPRuXNnhISEoFatWhBCID4+HgMGDMCECRMyImRKIrXP7/DwcERFRcHGxkahyHRjVC1gZDx++uknbN68GTt37oS1tbXS4WQ7ERER6NatG5YvXw4XFxelw8n2VCoV3NzcsGzZMnh7e8PX1xcTJ07E0qVLlQ4t2zl69CimTZuGxYsX4+LFi9ixYwf27duH77//XunQKIsxqhYwFxcXmJmZITg4WGt7cHAw8uTJk+J98uTJo9f+pJu0nAu12bNn46effsJff/2FcuXKpWeY2Ya+5+PevXsICgpCy5YtNdtUKhUAwNzcHLdv30aRIkXSN2gjlZb3Rt68eWFhYQEzMzPNtpIlS+L58+eIjY2FpaVlusZsrNJyLiZNmoRu3bqhT58+AICyZcsiMjIS/fr1w8SJE7XmLqb0ldrnt4ODQ6Zv/QKMrAXM0tIS3t7eOHTokGabSqXCoUOHUL169RTvU716da39AeDgwYOp7k+6Scu5AICZM2fi+++/x4EDB1CpUqWMCDVb0Pd8eHl54dq1a7h8+bLmp1WrVqhXrx4uX74MDw+PjAzfqKTlvVGzZk38+++/miQYAO7cuYO8efMy+foEaTkX7969S5ZkqRNjwZn9MlSW//xW+ioAQ9u8ebOwsrISq1evFjdv3hT9+vUTTk5O4vnz50IIIbp16ybGjRun2f/UqVPC3NxczJ49WwQEBIgpU6awDIWB6HsufvrpJ2FpaSm2bdsmnj17pvmJiIhQ6ikYFX3Px/t4FaTh6HsuHj58KOzt7cWQIUPE7du3xd69e4Wbm5v44YcflHoKRkPfczFlyhRhb28vNm3aJO7fvy/+/PNPUaRIEdGhQwelnoLRiIiIEJcuXRKXLl0SAMTcuXPFpUuXxIMHD4QQQowbN0506/b/du4+psqyjwP49xz0vHQ4B0bm4MjxBQ3WXErHpIk18i2OyyLf0GKPIKQNQlxNizUTqKG1gobOSmqCEpOXVuHGgMWCDXAlasAmCEKQNVmucDCKI3DO7/mjcc8jL0X5HHzw+9nuP+7r7f5d1z3nb9d9cf6jtB/5GYr9+/dLS0uLHDt2jD9DMdWOHj0qc+fOFY1GIyEhIfLtt98qdWFhYRIdHe3SvqioSAIDA0Wj0cjixYultLTUzRFPX5N5F/PmzRMAo66UlBT3Bz5NTfbfxq2YgN1Zk30XZ8+elccee0y0Wq0EBARIenq6DA8Puznq6Wky72JoaEhSU1Nl4cKFotPpxGKxSEJCgty4ccP9gU8zVVVVY/4fMLL+0dHREhYWNqpPcHCwaDQaCQgIkJycHLfH/U+pRLhnSkRERORO0+oMGBEREdH/AyZgRERERG7GBIyIiIjIzZiAEREREbkZEzAiIiIiN2MCRkRERORmTMCIiIiI3IwJGBEREZGbMQEjIhe5ubnw9vae6jD+MZVKha+++mrCNjExMXjuuefcEg8R0ViYgBFNQzExMVCpVKOu9vb2qQ4Nubm5SjxqtRr+/v7YuXMnrl+/fkfG7+7uxvr16wEAXV1dUKlUaGhocGmTlZWF3NzcO/K88aSmpirz9PDwgMViwe7du9HT0zOpcZgsEk1PM6Y6ACL637DZbMjJyXEpe+CBB6YoGlcmkwmtra1wOp1obGzEzp07ce3aNVRUVPzrsX19ff+yjZeX179+zt+xePFiVFZWwuFwoKWlBbGxsejt7UVhYaFbnk9Edy/ugBFNU1qtFr6+vi6Xh4cHMjMz8fDDD8NgMMBisSAhIQH9/f3jjtPY2IhVq1bBaDTCZDJh2bJlOH/+vFJfW1uLJ554Anq9HhaLBUlJSfj9998njE2lUsHX1xdmsxnr169HUlISKisrMTAwAKfTibfeegv+/v7QarUIDg5GeXm50ndwcBCJiYnw8/ODTqfDvHnzcPjwYZexRz5BLliwAADwyCOPQKVS4cknnwTguquUnZ0Ns9kMp9PpEmNERARiY2OV+5KSElitVuh0OgQEBCAtLQ3Dw8MTznPGjBnw9fXFnDlzsHbtWmzduhVff/21Uu9wOBAXF4cFCxZAr9cjKCgIWVlZSn1qaipOnjyJkpISZTeturoaAPDTTz8hMjIS3t7e8PHxQUREBLq6uiaMh4juHkzAiO4xarUaR44cwaVLl3Dy5El88803eO2118ZtHxUVBX9/f9TX1+PChQtITk7GzJkzAQAdHR2w2WzYvHkzmpqaUFhYiNraWiQmJk4qJr1eD6fTieHhYWRlZSEjIwPvv/8+mpqaEB4ejmeffRZXrlwBABw5cgRnzpxBUVERWltbkZ+fj/nz54857rlz5wAAlZWV6O7uxhdffDGqzdatW/Hbb7+hqqpKKevp6UF5eTmioqIAADU1NdixYwf27t2L5uZmHD9+HLm5uUhPT//bc+zq6kJFRQU0Go1S5nQ64e/vj+LiYjQ3N+PgwYN44403UFRUBADYt28fIiMjYbPZ0N3dje7uboSGhmJoaAjh4eEwGo2oqalBXV0dPD09YbPZMDg4+LdjIqIpJEQ07URHR4uHh4cYDAbl2rJly5hti4uL5f7771fuc3JyxMvLS7k3Go2Sm5s7Zt+4uDjZvXu3S1lNTY2o1WoZGBgYs8/t47e1tUlgYKA8+uijIiJiNpslPT3dpc/y5cslISFBRET27Nkjq1evFqfTOeb4AOTLL78UEZHOzk4BIN9//71Lm+joaImIiFDuIyIiJDY2Vrk/fvy4mM1mcTgcIiKyZs0aOXTokMsYeXl54ufnN2YMIiIpKSmiVqvFYDCITqcTAAJAMjMzx+0jIvLyyy/L5s2bx4115NlBQUEua3Dz5k3R6/VSUVEx4fhEdHfgGTCiaWrVqlX46KOPlHuDwQDgz92gw4cP4/Lly+jr68Pw8DDsdjv++OMP3HfffaPGefXVV/Hiiy8iLy9P+Yy2cOFCAH9+nmxqakJ+fr7SXkTgdDrR2dmJhx56aMzYent74enpCafTCbvdjscffxyffvop+vr6cO3aNaxcudKl/cqVK9HY2Ajgz8+H69atQ1BQEGw2GzZs2ICnnnrqX61VVFQUdu3ahQ8//BBarRb5+fnYvn071Gq1Ms+6ujqXHS+HwzHhugFAUFAQzpw5A7vdjs8++wwNDQ3Ys2ePS5tjx47hxIkTuHr1KgYGBjA4OIjg4OAJ421sbER7ezuMRqNLud1uR0dHxz9YASJyNyZgRNOUwWDAokWLXMq6urqwYcMGxMfHIz09HT4+PqitrUVcXBwGBwfHTCRSU1PxwgsvoLS0FGVlZUhJSUFBQQE2btyI/v5+vPTSS0hKShrVb+7cuePGZjQacfHiRajVavj5+UGv1wMA+vr6/nJeVqsVnZ2dKCsrQ2VlJSIjI7F27Vp8/vnnf9l3PM888wxEBKWlpVi+fDlqamrwwQcfKPX9/f1IS0vDpk2bRvXV6XTjjqvRaJR38M477+Dpp59GWloa3n77bQBAQUEB9u3bh4yMDKxYsQJGoxHvvfcevvvuuwnj7e/vx7Jly1wS3xF3yx9aENHEmIAR3UMuXLgAp9OJjIwMZXdn5LzRRAIDAxEYGIhXXnkFzz//PHJycrBx40ZYrVY0NzePSvT+ilqtHrOPyWSC2WxGXV0dwsLClPK6ujqEhIS4tNu2bRu2bduGLVu2wGazoaenBz4+Pi7jjZy3cjgcE8aj0+mwadMm5Ofno729HUFBQbBarUq91WpFa2vrpOd5uwMHDmD16tWIj49X5hkaGoqEhASlze07WBqNZlT8VqsVhYWFmD17Nkwm07+KiYimBg/hE91DFi1ahKGhIRw9ehQ//PAD8vLy8PHHH4/bfmBgAImJiaiursaPP/6Iuro61NfXK58WX3/9dZw9exaJiYloaGjAlStXUFJSMulD+Lfav38/3n33XRQWFqK1tRXJycloaGjA3r17AQCZmZk4ffo0Ll++jLa2NhQXF8PX13fMH4+dPXs29Ho9ysvL8csvv6C3t3fc50ZFRaG0tBQnTpxQDt+POHjwIE6dOoW0tDRcunQJLS0tKCgowIEDByY1txUrVmDJkiU4dOgQAODBBx/E+fPnUVFRgba2Nrz55puor6936TN//nw0NTWhtbUVv/76K4aGhhAVFYVZs2YhIiICNTU16OzsRHV1NZKSkvDzzz9PKiYimiJTfQiNiO68sQ5uj8jMzBQ/Pz/R6/USHh4up06dEgBy48YNEXE9JH/z5k3Zvn27WCwW0Wg0YjabJTEx0eWA/blz52TdunXi6ekpBoNBlixZMuoQ/a1uP4R/O4fDIampqTJnzhyZOXOmLF26VMrKypT67OxsCQ4OFoPBICaTSdasWSMXL15U6nHLIXwRkU8++UQsFouo1WoJCwsbd30cDof4+fkJAOno6BgVV3l5uYSGhoperxeTySQhISGSnZ097jxSUlJk6dKlo8pPnz4tWq1Wrl69Kna7XWJiYsTLy0u8vb0lPj5ekpOTXfpdv35dWV8AUlVVJSIi3d3dsmPHDpk1a5ZotVoJCAiQXbt2SW9v77gxEdHdQyUiMrUpIBEREdG9hZ8giYiIiNyMCRgRERGRmzEBIyIiInIzJmBEREREbsYEjIiIiMjNmIARERERuRkTMCIiIiI3YwJGRERE5GZMwIiIiIjcjAkYERERkZsxASMiIiJyMyZgRERERG72X18aPkRyQUeDAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1961,20 +1961,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 39.384063959121704\n", - "lead_lag: False inv_rest: True thres_distance: 8000 auc: 0.48937509999999995\n", + "compute_auc_time: 33.34321594238281\n", + "lead_lag: False inv_rest: True thres_distance: 8000 auc: 0.7972313600000001\n", "Threshold distance: 16000\n", "lead_lag: False\n", "inv_reset: True\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 12.668967962265015\n" + "fit_time: 12.596282005310059\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1986,15 +1986,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 32.15404915809631\n", - "lead_lag: False inv_rest: True thres_distance: 16000 auc: 0.78722396\n", + "compute_auc_time: 32.92912983894348\n", + "lead_lag: False inv_rest: True thres_distance: 16000 auc: 0.7872241999999998\n", "Threshold distance: 32000\n", "lead_lag: False\n", "inv_reset: True\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 12.898165941238403\n" + "fit_time: 13.208525896072388\n" ] }, { @@ -2011,15 +2011,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 32.97649002075195\n", - "lead_lag: False inv_rest: True thres_distance: 32000 auc: 0.78283068\n", + "compute_auc_time: 33.75607681274414\n", + "lead_lag: False inv_rest: True thres_distance: 32000 auc: 0.78283072\n", "Threshold distance: 4000\n", "lead_lag: False\n", "inv_reset: False\n", "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 8.701767206192017\n" + "fit_time: 8.927592039108276\n" ] }, { @@ -2036,7 +2036,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 17.6672580242157\n", + "compute_auc_time: 17.88940119743347\n", "lead_lag: False inv_rest: False thres_distance: 4000 auc: 0.80501948\n", "Threshold distance: 8000\n", "lead_lag: False\n", @@ -2044,7 +2044,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 8.961244106292725\n" + "fit_time: 9.03955888748169\n" ] }, { @@ -2061,7 +2061,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 18.04946804046631\n", + "compute_auc_time: 18.115923166275024\n", "lead_lag: False inv_rest: False thres_distance: 8000 auc: 0.80946924\n", "Threshold distance: 16000\n", "lead_lag: False\n", @@ -2069,7 +2069,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 9.036370038986206\n" + "fit_time: 8.920457124710083\n" ] }, { @@ -2086,7 +2086,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 18.47234296798706\n", + "compute_auc_time: 18.476377248764038\n", "lead_lag: False inv_rest: False thres_distance: 16000 auc: 0.79710896\n", "Threshold distance: 32000\n", "lead_lag: False\n", @@ -2094,7 +2094,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 9.334766149520874\n" + "fit_time: 9.18234395980835\n" ] }, { @@ -2111,10 +2111,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 19.540114879608154\n", + "compute_auc_time: 19.352643966674805\n", "lead_lag: False inv_rest: False thres_distance: 32000 auc: 0.78804452\n", - "CPU times: user 5h 20min 27s, sys: 8min 49s, total: 5h 29min 16s\n", - "Wall time: 50min 31s\n" + "CPU times: user 4h 43min 7s, sys: 10min 21s, total: 4h 53min 28s\n", + "Wall time: 47min 7s\n" ] } ], @@ -2204,7 +2204,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 37, "id": "303b9c84", "metadata": {}, "outputs": [], @@ -2245,7 +2245,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -2254,7 +2254,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 39, "id": "a22e802a-c924-4ead-9c8d-0fb3c262e84d", "metadata": {}, "outputs": [ @@ -2364,8 +2364,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1h 53min 41s, sys: 45min 25s, total: 2h 39min 7s\n", - "Wall time: 34min 37s\n" + "CPU times: user 4h 43min 46s, sys: 1h 8min 20s, total: 5h 52min 6s\n", + "Wall time: 59min 55s\n" ] } ], @@ -2402,13 +2402,13 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 40, "id": "e6043a4d-1ba9-4e77-acbb-5a758d9c1693", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2431,7 +2431,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 41, "id": "4c52ba35-77cf-45e4-bc24-b8084a0a6583", "metadata": {}, "outputs": [ @@ -2475,8 +2475,8 @@ " \n", " 1\n", " ArrowHead\n", - " 0.730769\n", - " 0.050233\n", + " 0.758741\n", + " 0.06979\n", " 0.65\n", " 0.03\n", " \n", @@ -2571,8 +2571,8 @@ " \n", " 13\n", " Herring\n", - " 0.514583\n", - " 0.049669\n", + " 0.539583\n", + " 0.06667\n", " 0.52\n", " 0.02\n", " \n", @@ -2675,16 +2675,16 @@ " \n", " 26\n", " Wafer\n", - " 0.516456\n", - " 0.038697\n", + " 0.834789\n", + " 0.022035\n", " 0.56\n", " 0.02\n", " \n", " \n", " 27\n", " Wine\n", - " 0.558566\n", - " 0.155328\n", + " 0.774476\n", + " 0.086879\n", " 0.53\n", " 0.02\n", " \n", @@ -2695,7 +2695,7 @@ "text/plain": [ " 0 1 2 3 4\n", "0 Adiac 0.998026 0.064889 0.99 0.1\n", - "1 ArrowHead 0.730769 0.050233 0.65 0.03\n", + "1 ArrowHead 0.758741 0.06979 0.65 0.03\n", "2 Beef 1.0 0.0 0.57 0.15\n", "3 BeetleFly 0.894737 0.160296 0.9 0.08\n", "4 BirdChicken 0.921053 0.143551 0.85 0.15\n", @@ -2707,7 +2707,7 @@ "10 FaceFour 0.843496 0.060361 0.94 0.1\n", "11 GunPoint 0.768229 0.062154 0.75 0.03\n", "12 Ham 0.509346 0.014708 0.5 0.02\n", - "13 Herring 0.514583 0.049669 0.52 0.02\n", + "13 Herring 0.539583 0.06667 0.52 0.02\n", "14 Lightning2 0.780435 0.044914 0.63 0.07\n", "15 Lightning7 0.955285 0.091263 0.73 0.11\n", "16 Meat 0.967949 0.073 1.0 0.04\n", @@ -2720,11 +2720,11 @@ "23 ToeSegmentation2 0.764865 0.039496 0.88 0.02\n", "24 Trace 1.0 0.01688 1.0 0.04\n", "25 TwoLeadECG 0.783216 0.017189 0.89 0.01\n", - "26 Wafer 0.516456 0.038697 0.56 0.02\n", - "27 Wine 0.558566 0.155328 0.53 0.02" + "26 Wafer 0.834789 0.022035 0.56 0.02\n", + "27 Wine 0.774476 0.086879 0.53 0.02" ] }, - "execution_count": 48, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -2735,7 +2735,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 42, "id": "168f43f7-d6a7-49de-b95a-336ac6b2cb1c", "metadata": {}, "outputs": [ @@ -2779,8 +2779,8 @@ " \n", " 1\n", " ArrowHead\n", - " 0.730769\n", - " 0.050233\n", + " 0.758741\n", + " 0.06979\n", " 0.65\n", " 0.03\n", " \n", @@ -2875,8 +2875,8 @@ " \n", " 13\n", " Herring\n", - " 0.514583\n", - " 0.049669\n", + " 0.539583\n", + " 0.06667\n", " 0.52\n", " 0.02\n", " \n", @@ -2979,16 +2979,16 @@ " \n", " 26\n", " Wafer\n", - " 0.516456\n", - " 0.038697\n", + " 0.834789\n", + " 0.022035\n", " 0.56\n", " 0.02\n", " \n", " \n", " 27\n", " Wine\n", - " 0.558566\n", - " 0.155328\n", + " 0.774476\n", + " 0.086879\n", " 0.53\n", " 0.02\n", " \n", @@ -2999,7 +2999,7 @@ "text/plain": [ " 0 1 2 3 4\n", "0 Adiac 0.998026 0.064889 0.99 0.1\n", - "1 ArrowHead 0.730769 0.050233 0.65 0.03\n", + "1 ArrowHead 0.758741 0.06979 0.65 0.03\n", "2 Beef 1.0 0.0 0.57 0.15\n", "3 BeetleFly 0.894737 0.160296 0.9 0.08\n", "4 BirdChicken 0.921053 0.143551 0.85 0.15\n", @@ -3011,7 +3011,7 @@ "10 FaceFour 0.843496 0.060361 0.94 0.1\n", "11 GunPoint 0.768229 0.062154 0.75 0.03\n", "12 Ham 0.509346 0.014708 0.5 0.02\n", - "13 Herring 0.514583 0.049669 0.52 0.02\n", + "13 Herring 0.539583 0.06667 0.52 0.02\n", "14 Lightning2 0.780435 0.044914 0.63 0.07\n", "15 Lightning7 0.955285 0.091263 0.73 0.11\n", "16 Meat 0.967949 0.073 1.0 0.04\n", @@ -3024,11 +3024,11 @@ "23 ToeSegmentation2 0.764865 0.039496 0.88 0.02\n", "24 Trace 1.0 0.01688 1.0 0.04\n", "25 TwoLeadECG 0.783216 0.017189 0.89 0.01\n", - "26 Wafer 0.516456 0.038697 0.56 0.02\n", - "27 Wine 0.558566 0.155328 0.53 0.02" + "26 Wafer 0.834789 0.022035 0.56 0.02\n", + "27 Wine 0.774476 0.086879 0.53 0.02" ] }, - "execution_count": 49, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -3123,6 +3123,7 @@ " signature_kwargs={\n", " \"augmentation_list\": None,\n", " \"depth\": depth,\n", + " \"backend\": \"iisignature\",\n", " },\n", ")\n", "fit_time = time.time() - start_time\n", diff --git a/src/signature_mahalanobis_knn/mahal_distance.py b/src/signature_mahalanobis_knn/mahal_distance.py index f4923ef..53c7146 100644 --- a/src/signature_mahalanobis_knn/mahal_distance.py +++ b/src/signature_mahalanobis_knn/mahal_distance.py @@ -10,6 +10,7 @@ def __init__( subspace_thres: float = 1e-3, svd_thres: float = 1e-12, zero_thres: float = 1e-15, + default_dtype: np.dtype = np.float64, ): """ After fit is called, becomes callable and intended to be used @@ -40,7 +41,7 @@ def __init__( self.S: np.ndarray | None = None # numerical rank of the corpus self.numerical_rank: int | None = None - self.default_dtype = np.float32 + self.default_dtype = default_dtype def fit(self, X: np.ndarray, y: None = None, **kwargs) -> None: # noqa: ARG002 """ diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index 6fdb4ba..a402d21 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -81,13 +81,15 @@ def fit( (Active only if `window_name in ['sliding, 'expanding']. - window_step: int, The step of the sliding/expanding window. (Active only if `window_name in ['sliding, 'expanding']. - - rescaling: "pre" or "post", + - rescaling: str, "pre" or "post", - "pre": rescale the path last signature term should be roughly O(1) - "post": Rescals the output signature by multiplying the depth-d term by d!. Aim is that every term become ~O(1). - - sig_tfm: One of: ['signature', 'logsignature']). + - sig_tfm: str, One of: ['signature', 'logsignature']). - depth: int, Signature truncation depth. + - backend: str, one of: `'esig'` (default), or `'iisignature'`. + The backend to use for signature computation. By default, the following arguments are used: - augmentation_list: ("addtime",) - window_name: "global" @@ -120,6 +122,7 @@ def fit( "rescaling": None, "sig_tfm": "signature", "depth": 2, + "backend": "esig", } if signature_kwargs is None: From 3f43f7ef948195af38bb3ab3b1f758a25ceac719 Mon Sep 17 00:00:00 2001 From: rchan Date: Fri, 24 Nov 2023 14:41:29 +0000 Subject: [PATCH 20/22] add esig opt dependency and cdf plotting --- paper-examples/examples.ipynb | 665 +++++++++++++------------ pyproject.toml | 3 + src/signature_mahalanobis_knn/utils.py | 88 +++- 3 files changed, 447 insertions(+), 309 deletions(-) diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index fb07e98..03bec6c 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -7,40 +7,24 @@ "metadata": {}, "outputs": [], "source": [ - "import sys\n", - "import os\n", - "\n", - "sys.path.insert(0, os.path.join(\"..\", \"..\"))\n", "import random\n", "import time\n", "\n", - "import sklearn\n", "import numpy as np\n", - "import matplotlib.lines as mlines\n", "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", "\n", "import Data\n", "from signature_mahalanobis_knn import SignatureMahalanobisKNN\n", - "from signature_mahalanobis_knn.utils import compute_auc_given_dists\n", + "from signature_mahalanobis_knn.utils import (\n", + " compute_auc_given_dists,\n", + " plot_cdf_given_dists,\n", + ")\n", "import UCR_data_support" ] }, { "cell_type": "code", "execution_count": 2, - "id": "34fc097e-0eb5-4c0d-9973-4dc8810ec398", - "metadata": {}, - "outputs": [], - "source": [ - "DATA_DIR = \"/Users/zoos/PycharmProjects/Anomaly_detection/data/\"\n", - "# importlib.reload(Data)\n", - "# importlib.reload(SigMahaKNN)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "b7a56abc", "metadata": {}, "outputs": [], @@ -67,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9", "metadata": {}, "outputs": [], @@ -82,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "a9b82cb0-4754-409c-891b-b19ec7e9b1a3", "metadata": {}, "outputs": [ @@ -94,21 +78,21 @@ "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 10.063539028167725\n", - "compute_auc_time: 9.991588115692139\n", + "fit_time: 9.688912153244019\n", + "compute_auc_time: 10.269761800765991\n", "depth: 1 , Auc of digit: 0 is 0.9236207222288126\n", "doing digit 1 doing signature level 1\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3015568256378174\n" + "fit_time: 1.2819938659667969\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n" ] }, @@ -116,20 +100,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 6.059915065765381\n", + "compute_auc_time: 6.245326042175293\n", "depth: 1 , Auc of digit: 1 is 0.8300113256239612\n", "doing digit 2 doing signature level 1\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3631317615509033\n" + "fit_time: 1.3130040168762207\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n" ] }, @@ -137,27 +121,27 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 6.2524518966674805\n", + "compute_auc_time: 6.352444171905518\n", "depth: 1 , Auc of digit: 2 is 0.9320072476980582\n", "doing digit 3 doing signature level 1\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.3106367588043213\n", - "compute_auc_time: 5.999101161956787\n", + "fit_time: 1.315458059310913\n", + "compute_auc_time: 6.223802804946899\n", "depth: 1 , Auc of digit: 3 is 0.922022303545074\n", "doing digit 4 doing signature level 1\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.4209661483764648\n" + "fit_time: 1.4521958827972412\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n" ] }, @@ -165,20 +149,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 5.9232141971588135\n", + "compute_auc_time: 6.100835084915161\n", "depth: 1 , Auc of digit: 4 is 0.9830396151391684\n", "doing digit 5 doing signature level 1\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.2171669006347656\n" + "fit_time: 1.3075149059295654\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n" ] }, @@ -186,20 +170,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 5.923392057418823\n", + "compute_auc_time: 6.035906076431274\n", "depth: 1 , Auc of digit: 5 is 0.9057290216637331\n", "doing digit 6 doing signature level 1\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.161789894104004\n" + "fit_time: 1.3131701946258545\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n" ] }, @@ -207,34 +191,44 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 5.955906867980957\n", + "compute_auc_time: 6.04359769821167\n", "depth: 1 , Auc of digit: 6 is 0.8962102986355833\n", "doing digit 7 doing signature level 1\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.4109997749328613\n", - "compute_auc_time: 5.941327095031738\n", + "fit_time: 1.364300012588501\n", + "compute_auc_time: 6.059554100036621\n", "depth: 1 , Auc of digit: 7 is 0.8957924255068479\n", "doing digit 8 doing signature level 1\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.2382440567016602\n", - "compute_auc_time: 5.920679092407227\n", + "fit_time: 1.1893792152404785\n", + "compute_auc_time: 6.056625843048096\n", "depth: 1 , Auc of digit: 8 is 0.9399820412035783\n", "doing digit 9 doing signature level 1\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.2690927982330322\n", - "compute_auc_time: 5.920597791671753\n", + "fit_time: 1.2779922485351562\n", + "compute_auc_time: 6.125757932662964\n", "depth: 1 , Auc of digit: 9 is 0.8178161049365983\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -251,77 +245,87 @@ "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 1.308121681213379\n", - "compute_auc_time: 6.258044958114624\n", + "fit_time: 1.3745968341827393\n", + "compute_auc_time: 6.313787221908569\n", "depth: 2 , Auc of digit: 0 is 0.9994156440437432\n", "doing digit 1 doing signature level 2\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3163371086120605\n", - "compute_auc_time: 6.049156904220581\n", + "fit_time: 1.3893768787384033\n", + "compute_auc_time: 6.167309761047363\n", "depth: 2 , Auc of digit: 1 is 0.882206498032918\n", "doing digit 2 doing signature level 2\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.311708927154541\n", - "compute_auc_time: 6.092707872390747\n", + "fit_time: 1.3798871040344238\n", + "compute_auc_time: 6.319882392883301\n", "depth: 2 , Auc of digit: 2 is 0.9511227445177669\n", "doing digit 3 doing signature level 2\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.1984961032867432\n", - "compute_auc_time: 6.022700786590576\n", + "fit_time: 1.27274489402771\n", + "compute_auc_time: 6.294939994812012\n", "depth: 2 , Auc of digit: 3 is 0.9886656275413391\n", "doing digit 4 doing signature level 2\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3563220500946045\n", - "compute_auc_time: 6.444512128829956\n", + "fit_time: 1.3157386779785156\n", + "compute_auc_time: 6.4051289558410645\n", "depth: 2 , Auc of digit: 4 is 0.9971212578104729\n", "doing digit 5 doing signature level 2\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.2241871356964111\n", - "compute_auc_time: 6.081561088562012\n", + "fit_time: 1.2873790264129639\n", + "compute_auc_time: 6.221255779266357\n", "depth: 2 , Auc of digit: 5 is 0.9647887656249261\n", "doing digit 6 doing signature level 2\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.226757287979126\n", - "compute_auc_time: 6.031784296035767\n", + "fit_time: 1.2547879219055176\n", + "compute_auc_time: 6.341688871383667\n", "depth: 2 , Auc of digit: 6 is 0.9924061022258366\n", "doing digit 7 doing signature level 2\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.324833869934082\n", - "compute_auc_time: 6.246238946914673\n", + "fit_time: 1.333056926727295\n", + "compute_auc_time: 6.299951076507568\n", "depth: 2 , Auc of digit: 7 is 0.9607328695554606\n", "doing digit 8 doing signature level 2\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.1929960250854492\n", - "compute_auc_time: 6.09051513671875\n", + "fit_time: 1.288444995880127\n", + "compute_auc_time: 6.317756175994873\n", "depth: 2 , Auc of digit: 8 is 0.9951771030993043\n", "doing digit 9 doing signature level 2\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.4631941318511963\n", - "compute_auc_time: 6.044775009155273\n", + "fit_time: 1.2493579387664795\n", + "compute_auc_time: 6.216753244400024\n", "depth: 2 , Auc of digit: 9 is 0.8993403813138158\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB6pUlEQVR4nO3dd3hTZRsG8DvduwXa0lIKZe9ZhuxVKYgouwyhIIKyBUE2BZElW0ERBCqITEEQFAQEGaLMsjctu2WndLfJ+/3xfkkJHTRdp23u33Xlas6bc06ejCZP3qkSQggQERERmSAzpQMgIiIiUgoTISIiIjJZTISIiIjIZDERIiIiIpPFRIiIiIhMFhMhIiIiMllMhIiIiMhkMREiIiIik8VEiIiIiEwWEyET5OPjg759+yodhslp3rw5mjdvrnQYbzR16lSoVCo8efJE6VDyHJVKhalTp2bLucLCwqBSqRAcHJwt58vvsvL/0bdvX/j4+GQ5hk2bNqFw4cKIiop6477Z+V4w1sGDB6FSqbBlyxZF7v9Vly5dgoWFBS5cuKB0KJnGRCibBQcHQ6VS6S8WFhbw8vJC3759cf/+faXDy9Oio6Mxffp0VK9eHXZ2dnB2dkaTJk2wZs0a5JeVYC5duoSpU6ciLCxM6VBS0Gg0WL16NZo3b47ChQvD2toaPj4+6NevH06ePKl0eNni559/xqJFi5QOw0BuxKRLqnQXc3NzlChRAh07dkRISEiO3ndq+vbtaxCPg4MDSpcujS5duuCXX36BVqvN0fuPiYnB1KlTcfDgwQwfo9FoEBQUhGHDhsHBwSHngjOCUu9nrVaL4OBgvPfee/D29oa9vT2qVq2KL7/8EnFxcQb7Vq5cGe3atcOUKVNyPc5sIyhbrV69WgAQX3zxhVi7dq1YsWKF6N+/vzA3NxdlypQRsbGxSoco4uLiREJCgtJhGAgPDxdVqlQRZmZmomfPnuL7778XixcvFk2bNhUAREBAgEhKSlI6zDfavHmzACAOHDiQ4rb4+HgRHx+f+0EJIWJiYkSbNm0EANG0aVMxd+5csXLlSjF58mRRoUIFoVKpxN27d4UQQgQFBQkA4vHjx4rEmhXt2rUTJUuWzLHzx8bGisTERKOOSSsmrVYrYmNjs+V9HRoaKgCIHj16iLVr14rg4GAxduxY4eTkJKytrcWZM2eyfB/GCAwMFNbW1mLt2rVi7dq1Yvny5WLixImievXqAoBo3ry5UKvVBsdk5f8jISFBxMXF6bcfP34sAIigoKAMn2Pbtm1CpVKJe/fuZWh/Y8+fGWm9dw4cOCAAiM2bN+fI/b58+VIAEG+99Zb48ssvxfLly0W/fv2EmZmZaN68udBqtQb7//777wKAuHHjRo7Ek9OYCGUzXSJ04sQJg/KxY8cKAGLjxo0KRaas2NhYodFo0rzd399fmJmZie3bt6e4bfTo0QKAmD17dk6GmKqoqCij9k8vEVLSkCFDBACxcOHCFLclJSWJuXPn5moipNVqRUxMTLafNycSIY1Gk6UfMDmdnAmRnAjNnTvXoHzHjh0CgBg4cGCO3v/rAgMDhb29faq3zZo1SwAQ3bp1y7H7z0wi9N5774nGjRtneP+CnAjFx8eLo0ePpiifNm2aACD27t1rUJ6QkCAKFSokJk+enCPx5DQmQtksrURo586dAoCYOXOmQfnly5dF586dRaFChYS1tbXw9fVNNRl4/vy5+PTTT0XJkiWFlZWV8PLyEr179zb4soqLixNTpkwRZcqUEVZWVqJ48eJizJgxBr+UhBCiZMmSIjAwUAghxIkTJwQAERwcnOI+d+/eLQCI3377TV9279490a9fP+Hu7i6srKxE5cqVxcqVKw2O0/2Trl+/XkycOFEUK1ZMqFQq8fz581Sfs2PHjgkA4sMPP0z19sTERFGuXDlRqFAh/Zfnqx/8CxYsECVKlBA2NjaiadOm4vz58ynOkZHnWffaHTx4UAwaNEi4ubkJFxcXIYQQYWFhYtCgQaJ8+fLCxsZGFC5cWHTp0kWEhoamOP71iy4patasmWjWrFmK52njxo3iyy+/FF5eXsLa2lq0bNlSXL9+PcVjWLJkiShVqpSwsbERdevWFYcOHUpxztTcvXtXWFhYiLfffjvd/XR0idD169dFYGCgcHZ2Fk5OTqJv374iOjraYN9Vq1aJFi1aCDc3N2FlZSUqVaokvv322xTnLFmypGjXrp3YvXu38PX1FdbW1vqkLKPnEEL+8mzatKlwcHAQjo6Ook6dOmLdunVCCPn8vv7cv/olktH/DwBiyJAh4qeffhKVK1cWFhYWYtu2bfrbXv3yi4yMFCNGjND/X7q5uQk/Pz9x6tSpN8akew+vXr3a4P4vX74sunbtKlxdXYWNjY0oX768mDBhQnovWZqJUFRUlABg8Nr/+++/wt/fXzg5OQlbW1vRtGlTceTIEYPjjHkPpCa9REgIIVq3bi1UKpW4evWqviy193JYWJho3769sLOzE25ubuLTTz/Vfy69+mMjMDAwxfP6+iW9pCU2NlZYWVmJqVOnprgtLi5OfPrpp8LV1VU4ODiI9u3bi7t376Z6TmM+Hzds2CDGjx8vihYtKuzs7ET79u3FnTt3DJ6PtN47xn52ZJdz584JAOLrr79OcVvHjh1F9erVc+y+c5JF1hrWKKN0fUYKFSqkL7t48SIaNWoELy8vjBs3Dvb29ti0aRM6dOiAX375BR07dgQAREVFoUmTJrh8+TI+/PBD1K5dG0+ePMGOHTtw7949uLq6QqvV4r333sORI0cwcOBAVKpUCefPn8fChQtx7do1/Prrr6nGVadOHZQuXRqbNm1CYGCgwW0bN25EoUKF4O/vDwCIiIjAW2+9BZVKhaFDh8LNzQ1//PEH+vfvj8jISHz66acGx0+fPh1WVlYYPXo04uPjYWVllWoMv/32GwCgT58+qd5uYWGBnj17Ytq0aTh69Cj8/Pz0t61ZswYvX77EkCFDEBcXh8WLF6Nly5Y4f/48ihYtatTzrDN48GC4ublhypQpiI6OBgCcOHEC//zzD7p3747ixYsjLCwM3333HZo3b45Lly7Bzs4OTZs2xfDhw/H1119jwoQJqFSpEgDo/6Zl9uzZMDMzw+jRo6FWq/HVV1+hV69e+O+///T7fPfddxg6dCiaNGmCkSNHIiwsDB06dEChQoVQvHjxdM//xx9/ICkpCb179053v9d169YNpUqVwqxZs3D69Gn88MMPcHd3x5w5cwziqlKlCt577z1YWFjgt99+w+DBg6HVajFkyBCD8129ehU9evTAxx9/jAEDBqBChQpGnSM4OBgffvghqlSpgvHjx8PFxQVnzpzB7t270bNnT0ycOBFqtRr37t3DwoULAUDf18PY/4+//voLmzZtwtChQ+Hq6ppmR9xPPvkEW7ZswdChQ1G5cmU8ffoUR44cweXLl1G7du10Y0rNuXPn0KRJE1haWmLgwIHw8fHBzZs38dtvv2HGjBkZe+FecfPmTQBAkSJF9I+rbdu28PX1RVBQEMzMzLB69Wq0bNkShw8fRr169QyOz8h7IDN69+6NP//8E3v37kX58uVT3Sc6OhotW7bEw4cPMWLECHh4eODnn3/GgQMH0j23m5sbvvvuOwwaNAgdO3ZEp06dAADVq1dP85hTp04hISEBtWvXTnHbRx99hJ9++gk9e/ZEw4YN8ddff6Fdu3Yp9jP283HGjBlQqVQYO3YsHj16hEWLFsHPzw8hISGwtbXN0HsnI58dMTExiImJSfc5AwBzc3OD76fUhIeHAwBcXV1T3Obr64vt27cjMjISTk5Ob7y/PEXpTKyg0dUK7Nu3Tzx+/FjcvXtXbNmyRbi5uQlra2t984MQQrRq1UpUq1bN4BepVqsVDRs2FOXKldOXTZkyRQAQW7duTXF/urbatWvXCjMzM3H48GGD25ctWyYAGFRzvlojJIQQ48ePF5aWluLZs2f6svj4eOHi4mJQS9O/f3/h6ekpnjx5YnAf3bt3F87OzvraGt2vldKlS2eo+aNDhw4CQJo1RkIIsXXrVoNfIrpffba2tgZt+v/9958AIEaOHKkvy+jzrHvtGjdunKLfRmqPQ1eTtWbNGn1Zek1jadUIVapUyaBvxOLFiwUAfc1WfHy8KFKkiKhbt65B/5Tg4GAB4I01QiNHjhQAMtxPRFcb8HoNXceOHUWRIkUMylJ7Xvz9/UXp0qUNykqWLCkAiN27d6fYPyPnePHihXB0dBT169dP0Uz1an+FtJoSjPn/ACDMzMzExYsXU5wHr9UCODs7iyFDhqTY71VpxZRajVDTpk2Fo6OjuH37dpqPMTW6c02bNk08fvxYhIeHi4MHD4patWoJAOKXX34RWq1WlCtXTvj7+xucLyYmRpQqVcqg1siY90Bq3lQjdObMmRT/p6//f8yfP18AEL/++qu+LDY2VlSsWDHdGiEhjG8a++GHHwz+53RCQkIEADF48GCD8p49e6Y4v7Gfj15eXiIyMlK/36ZNmwQAsXjxYn3Zm5rG3vTZIUTya/mmS0aab/38/ISTk1Oqn9U///yzACD++++/N54nr+GosRzi5+cHNzc3eHt7o0uXLrC3t8eOHTv0v96fPXuGv/76C926dcPLly/x5MkTPHnyBE+fPoW/vz+uX7+uH2X2yy+/oEaNGilqLgA5hBMANm/ejEqVKqFixYr6cz158gQtW7YEgHR/RQUEBCAxMRFbt27Vl/3555948eIFAgICAABCCPzyyy9o3749hBAG9+Hv7w+1Wo3Tp08bnDcwMBC2trZvfK5evnwJAHB0dExzH91tkZGRBuUdOnSAl5eXfrtevXqoX78+fv/9dwDGPc86AwYMgLm5uUHZq48jMTERT58+RdmyZeHi4pLicRurX79+BrVlTZo0AQDcunULAHDy5Ek8ffoUAwYMgIVFciVur1693vgLDkh+ztJ7flPzySefGGw3adIET58+NXgNXn1e1Go1njx5gmbNmuHWrVtQq9UGx5cqVUpfu/iqjJxj7969ePnyJcaNGwcbGxuD43X/A+kx9v+jWbNmqFy58hvP6+Ligv/++w8PHjx4475v8vjxYxw6dAgffvghSpQoYXBbRh4jAAQFBcHNzQ0eHh5o3rw5bt68iTlz5qBTp04ICQnB9evX0bNnTzx9+lT/HERHR6NVq1Y4dOhQitFcGXkPZIauZkP3v5+a3bt3w8vLC++9956+zMbGBgMGDMjSfafm6dOnAJDi/0n3OTJ8+HCD8tdrdzLz+dinTx+D/8kuXbrA09NTf58Z8abPDt397N27942XdevWpXtfM2fOxL59+zB79my4uLikuF333OXHaTfYNJZDli5divLly0OtVmPVqlU4dOgQrK2t9bffuHEDQghMnjwZkydPTvUcjx49gpeXF27evInOnTune3/Xr1/H5cuX4ebmlua50lKjRg1UrFgRGzduRP/+/QHIZjFXV1f9F8Xjx4/x4sULLF++HMuXL8/QfZQqVSrdmHV0HwYvX75M9R9Md9ur++qUK1cuxb7ly5fHpk2bABj3PKcXd2xsLGbNmoXVq1fj/v37BsP5X//CN9brX3q6D5Tnz58DAG7fvg0AKFu2rMF+FhYWGZo7RVdNnd6XjrFx6c559OhRBAUF4dixYymq39VqNZydnfXbab0fMnIOXRNP1apVjXoMOsb+f2T0vfvVV18hMDAQ3t7e8PX1xTvvvIM+ffqgdOnSRseo+/LK7GMEgIEDB6Jr164wMzODi4sLqlSpov/cuX79OgCkaAJ/lVqtNkgGMvIeyAzdPD3pJee3b99GmTJlUiSBr/8fZKdX/691MZiZmaFMmTIG5bpmXZ3MfD6+/tmlUqlQtmxZo6beeNNnBwCULl06U+/HV23cuBGTJk1C//79MWjQoFT30T13GU3a8xImQjmkXr16qFOnDgBZa9G4cWP07NkTV69ehYODg/6X1+jRo1P9lQwY9w+v1WpRrVo1LFiwINXbvb290z0+ICAAM2bMwJMnT+Do6IgdO3agR48e+hoIXbwffPBBmh+kr7fBZ6Q2CJB9aH799VecO3cOTZs2TXWfc+fOAUCGfqW/KjPPc2pxDxs2DKtXr8ann36KBg0awNnZGSqVCt27d8/ynCiv1z7pvP6hnFkVK1YEAJw/fx41a9bM8HFviuvmzZto1aoVKlasiAULFsDb2xtWVlb4/fffsXDhwhTPS2rPq7HnyCxj/z8y+t7t1q0bmjRpgm3btuHPP//E3LlzMWfOHGzduhVt27bNctzGKleunEEfulfpnsu5c+em+T54vQ9KTr03dZPv5WRSYwxdH6rnz5+/sc9dajLz+ZgdMvL6REVFZWiCSHNz81R/KOzduxd9+vRBu3btsGzZsjSP1yVfqfUfyuuYCOUCc3NzzJo1Cy1atMCSJUswbtw4fYZuaWmZ5geXTpkyZd44a2eZMmVw9uxZtGrVKlMZeUBAAKZNm4ZffvkFRYsWRWRkJLp3766/3c3NDY6OjtBoNG+M11jvvvsuZs2ahTVr1qSaCGk0Gvz8888oVKgQGjVqZHCb7lfuq65du6avKTHmeU7Pli1bEBgYiPnz5+vL4uLi8OLFC4P9cuLXUMmSJQHI2q0WLVroy5OSkhAWFvbGD9i2bdvC3NwcP/30k9EdptPz22+/IT4+Hjt27DD4ZfqmzqyZOYfuF/mFCxfS/fJM6/nP6v9Hejw9PTF48GAMHjwYjx49Qu3atTFjxgx9IpTR+9O9V3Nqhl7dc+jk5JTt/8PGWrt2LVQqFd5+++009ylZsiQuXboEIYTBc3jjxo03nt/Y11j3YyE0NBTVqlUziEGr1eLmzZsGtUBXr141OD4zn4+vf3YJIXDjxg2D/+fseK/OmzcP06ZNe+N+JUuWTFEb9d9//6Fjx46oU6cONm3aZNA0/7rQ0FCYmZml2fk9L2MfoVzSvHlz1KtXD4sWLUJcXBzc3d3RvHlzfP/993j48GGK/R8/fqy/3rlzZ5w9exbbtm1LsZ8u8+/WrRvu37+PFStWpNgnNjZWP/opLZUqVUK1atWwceNGbNy4EZ6engZJibm5OTp37oxffvkl1Q/qV+M1VsOGDeHn54fVq1dj586dKW6fOHEirl27hs8//zzFL/Vff/3VoI/P8ePH8d9//+m/hIx5ntNjbm6e4lfwN998A41GY1Bmb28PACkSpKyoU6cOihQpghUrViApKUlfvm7dOoMq8LR4e3tjwIAB+PPPP/HNN9+kuF2r1WL+/Pm4d++eUXHpfo2+3ky4evXqbD9H69at4ejoiFmzZqWY2fbVY+3t7VNtqszq/0dqNBpNivtyd3dHsWLFEB8f/8aYXufm5oamTZti1apVuHPnjsFt2VE76OvrizJlymDevHmp1hBk5X/YGLNnz8aff/6JgICAVJu2dfz9/XH//n3s2LFDXxYXF5fqa/g6Ozs7ABn/P/T19YWVlVWKGdZ1nyNff/21Qfnrsz1n5vNRN+JVZ8uWLXj48KFBTWJG3zvpyWwfocuXL6Ndu3bw8fHBzp0731hLeurUKVSpUsWgOTy/YI1QLhozZgy6du2K4OBgfPLJJ1i6dCkaN26MatWqYcCAAShdujQiIiJw7Ngx3Lt3D2fPntUft2XLFnTt2hUffvghfH198ezZM+zYsQPLli1DjRo10Lt3b2zatAmffPIJDhw4gEaNGkGj0eDKlSvYtGkT9uzZo2+qS0tAQACmTJkCGxsb9O/fH2Zmhnny7NmzceDAAdSvXx8DBgxA5cqV8ezZM5w+fRr79u3Ds2fPMv3crFmzBq1atcL777+Pnj17okmTJoiPj8fWrVtx8OBBBAQEYMyYMSmOK1u2LBo3boxBgwYhPj4eixYtQpEiRfD555/r98no85yed999F2vXroWzszMqV66MY8eOYd++ffoqdZ2aNWvC3Nwcc+bMgVqthrW1NVq2bAl3d/dMPzdWVlaYOnUqhg0bhpYtW6Jbt24ICwtDcHBwqn0oUjN//nzcvHkTw4cPx9atW/Huu++iUKFCuHPnDjZv3owrV64Y1ABmROvWrWFlZYX27dvj448/RlRUFFasWAF3d/dUk86snMPJyQkLFy7ERx99hLp166Jnz54oVKgQzp49i5iYGPz4448A5Bfaxo0bMWrUKNStWxcODg5o3759tvx/vO7ly5coXrw4unTpgho1asDBwQH79u3DiRMnDGoO04opNV9//TUaN26M2rVrY+DAgShVqhTCwsKwa9euLC+VYWZmhh9++AFt27ZFlSpV0K9fP3h5eeH+/fs4cOAAnJyc9FNZZIekpCT89NNPAGQCc/v2bezYsQPnzp1DixYt0uxLo/Pxxx9jyZIl6NGjB0aMGAFPT0+sW7dO31k+vfe9ra0tKleujI0bN6J8+fIoXLgwqlatmmb/KxsbG7Ru3Rr79u3DF198oS+vWbMmevTogW+//RZqtRoNGzbE/v37U62VMvbzsXDhwmjcuDH69euHiIgILFq0CGXLljXoDG7Meyctmekj9PLlS/j7++P58+cYM2YMdu3aZXB7mTJl0KBBA/12YmIi/v77bwwePNio+8kzcnWMmglIa0JFIeQMtWXKlBFlypTRD8++efOm6NOnj/Dw8BCWlpbCy8tLvPvuu2LLli0Gxz59+lQMHTpUeHl56SeDCwwMNBiqmZCQIObMmSOqVKkirK2tRaFChYSvr6+YNm2awXT2rw+f17l+/bp+KOXrE6zpREREiCFDhghvb29haWkpPDw8RKtWrcTy5cv1+2R21tOXL1+KqVOniipVqghbW1vh6OgoGjVqJIKDg1MMH351Arn58+cLb29vYW1tLZo0aSLOnj2b4twZeZ7Te+2eP38u+vXrp59Uzd/fX1y5ciXV53LFihWidOnSwtzcPEMTKr7+PKU10d7XX38tSpYsKaytrUW9evXE0aNHha+vr2jTpk0Gnl05g/QPP/wgmjRpIpydnYWlpaUoWbKk6Nevn8HQ+rRmltY9P69OIrljxw5RvXp1YWNjI3x8fMScOXPEqlWrUuynm1AxNRk9h27fhg0bCltbW+Hk5CTq1asn1q9fr789KipK9OzZU7i4uKQYEpzR/w/8f0LF1OCVIdPx8fFizJgxokaNGsLR0VHY29uLGjVqpJgMMq2Y0nqdL1y4IDp27ChcXFyEjY2NqFChwhtn7E1rQsXUnDlzRnTq1EkUKVJEWFtbi5IlS4pu3bqJ/fv36/cx5j2QmsDAQIOh2XZ2dsLHx0d07txZbNmyJdVZ5lObUPHWrVuiXbt2wtbWVri5uYnPPvtM/PLLLwKA+Pfffw3u7/Xh3//884/w9fUVVlZWGRpKv3XrVqFSqQwmNRRCDtkfPny4KFKkiLC3t093QkVjPh/Xr18vxo8fL9zd3YWtra1o165dimkT0nrvGPvZYay0JqXUXV7/zPvjjz8E/j8BZ36kEiKfrGZJ9IqwsDCUKlUKc+fOxejRo5UORxFarRZubm7o1KlThpoLiAqCRYsWYeTIkbh3757BaM+s0mg0qFy5Mrp164bp06dn23lfd/DgQbRo0QKbN29Gly5dcux+clOHDh2gUqlS7b6RH7CPEFE+EBcXl6KfyJo1a/Ds2TM0b95cmaCIclhsbKzBdlxcHL7//nuUK1cuW5MgQPbz+eKLL7B06dIMjbIi6fLly9i5c2eOJo85jX2EiPKBf//9FyNHjkTXrl1RpEgRnD59GitXrkTVqlXRtWtXpcMjyhGdOnVCiRIlULNmTajVavz000+4cuXKGyf/y6yAgAD9JLKUMZUqVTIYxJEfMREiygd8fHzg7e2Nr7/+Gs+ePUPhwoXRp08fzJ49O8013IjyO39/f/zwww9Yt26dvulqw4YNTFYoWynaR+jQoUOYO3cuTp06hYcPH2Lbtm3o0KFDusccPHgQo0aNwsWLF+Ht7Y1Jkyahb9++uRIvERERFSyK9hGKjo5GjRo1sHTp0gztHxoainbt2qFFixYICQnBp59+io8++gh79uzJ4UiJiIioIMozo8Z0Pc7TqxEaO3Ysdu3aZTBhVffu3fHixQvs3r07F6IkIiKigiRf9RE6duxYiunL/f39U6wE/Kr4+HiDWV61Wi2ePXuGIkWK5MvF4YiIiEyREAIvX75EsWLFUkz4mxX5KhEKDw9H0aJFDcp062LFxsamOgX4rFmzMrTOChEREeV9d+/ezdTiuGnJV4lQZowfPx6jRo3Sb6vVapQoUQJ3796Fk5OTgpEREVFeptUCCQlAXByQmCivR0fL7YQEWRYVBbx8Ka/fuQM4OADx8cCVK4CrK6DRJB975gxQqhRw44bcdnICkpLk9WvXAGtrwNlZliUlyWOTkoCYGKWfCeMVLgyYmQFPngCVKgGWlvLy7Bng4gKUKCG3LSzkPp6eQJEi8jl4+hSoWBGwsQGKndwOvP02rJztEBcXiS5dvOHo6JitsearRMjDwwMREREGZREREXByckpzQThra2tYW1unKHdycmIiRESUxwkhEwldchAbK5OPiAiZKOgSkgcP5Jfo1auAo2Ny8pGQAJw9K794IyKA27fll258vExgzp4FypWTyc316/JY3XlzYnqcc+fSvi0mJmtJT7FigJWVfM5u3wbq1ZPPiUolE5C6dWWyVquW3M/aWj5vFSokJypWVvK5sbeXiZqFhSzXaoGiReXtun0dHJJv1/01M5P3l2XR0cCQIcCPPwIWHwErViAyUt6U3d1a8lUi1KBBA/z+++8GZXv37jVY/I2IiHKWEPLLMipKfnHHxQEvXsi/t2/LL8ObN+Vtly7JX/qRkcCpU7JGRJe8nDsnawfs7GTSkZgoL0+fyi9TlUp+Aee08+eTr7+yIHwKVlbyEhUlkw57e5lMPHsmEyhvb1m7Ub26LL99WyYd1taGNSIVK8rH5eQkj9PdpivTJRbm5vKvhYV8Tm1tk7dfLS9w3V0vXAC6dQMuX5YPsEQJ+abLIYomQlFRUQar+IaGhiIkJASFCxdGiRIlMH78eNy/fx9r1qwBAHzyySdYsmQJPv/8c3z44Yf466+/sGnTphQr4xIRmSpdDUpcnLxERspalEeP5O3x8TIRuXNHJiDXrsm/usTE3V0mJZcvy5oRB4fkGplz5+TxZmaZT1Bu3zbcfq2S3+BxpPfdZ20tY6lSJTlBuX4daNoUuHULqFNH7qOrwYiIAKpVk7EnJQHFi8vbzc1lIuHmJptiLCxk89SrNR+2tnK7wCUceY0QwKpVwLBh8k3r6Qn8/DOQw8sIKZoInTx5Ei1atNBv6/ryBAYGIjg4GA8fPsSdO3f0t5cqVQq7du3CyJEjsXjxYhQvXhw//PAD/P39cz12IqKMECK5H0hCgqw5iY6WNQ/Pn8uE4tYt+WWbkCCvW/z/kzk+Hjh9GvDxkd8LR4/KZpxXm33On5c/mHXJz/PnOf+YXk+CXFxkEhEeDtSoIZOdZs3k4yxRQiYQVavKfRITZRKiS14SE2V/klebV3S1IXZ2yTUfr95ubp7zj5FyWVQU8MkngG75lNatgbVrZWaew/LMPEK5JTIyEs7OzlCr1ewjRER6Go1MJHR9Rx48AO7elYmFRgOEhcnaBEA29zg6yiTnyBGgZMnkpp1Tp+QXvVqdfjNLbitaVNaK1K6dXFNy8ybQqJFMYCpVkjUhERGy6cbOTj4f7u6y/NVkxMdHdgS2s5NlRFl27x5Qs6b8pfDll8Dnnyf/w/1fTn1/56s+QkREQsjkJD4+uZ9KYmLydni4TGIsLGSNxLlzssbhxAlZ7uUlv+DPnpXluvNlxd27htv37r35mBIlZLJkby9rea5eBRo3lklKeDhQurRMNqytZbNW5cqyRiUqSiYiuo6tlpbyMTg7JzflFC4sEzUrqxTfJUR5U/HiwPr1smq0ceNcvWsmQkSUo3R9VqKi5Bd/eLjcDguTTSaXL8sv8fh44J9/AA8P2eSzYwdQvrwccmxhIT8fdf1bsuLVJOXZszfvX7GiTCxKl5Y/Vt3cZNeFFy9k51gXF/nYypVLTkzMzWUNjI2NrDWxsUlOXCws2NeECJGRwMCBQPfugG5FibffViQUJkJElCaNRtaWxMXJEUAPHgD378tmoDt3kmtVEhKAw4fliKD9+2XS8PixbBpSqTI/4OPMGfk3KSn1ZiZdJ1a1WtaSWFvLy/37QKFCstnH1laOQqpdWz4eDw+ZwNjYyNhcXeV1GxtZi6LrMEtEOeTUKSAgQLbNHjgg+wPZ2SkWDv/diQqoiAiZqMTEJHesvXFD1mA8eCBrQxISZM2Mm5usbTl8WM4pEhUla2qMdeuW4V8gZRLk4CDPX706EBoKtGol/zZoIJOYiAigfv3kUTqVKyfXsOgSHRcX+ZeI8hEhgCVLgNGj5YdPyZLAhg2KJkEAEyGiPE8I2Ufk7l1ZK3LrlmxmefFCJjahobK5x94eOH5c1mbExmb+/k6cSFmmG8Hz8qW879KlZedalUr2w2nVSiYu0dEywTEzk4mLpaVMsnTNQzY2mY+LiPKxFy+A/v2BrVvldocOcqh8oUJKRgWAiRBRrhNCNjWFh8saG13tS2KiTHZsbWVfmZcv5eRsxvaJSUxMWdasWfJw5Zs3gYYNZXOTpaXsoyiE/HFmbS1j8/GRcRQrJjsXc2QQEWXaixdyZsmwMPlhMm+enCsoj3SWYyJElE2SkmQi8+iRTHCio4GTJ2VfGq1W9lt5fTK5zKhXT9YCNWkiP1NiYmQyU7KkrKWxtpbJS4kScpZaIiJFubgAbdsCe/YAGzfK2S7zECZCRK/RamVH39u3ZTITGyuboxISgM2b5WAH3cy6uuUDnj7N/P1ZWwP+/vI+q1WTTVsVKsj7K1UKKFtWjp5KYzk9IqK85+lT+euwaFG5vWCB7Ijo7KxsXKlgIkQFmlYra2ju3UueZ+b2bTlo4elTWXNjYSGn5nd1zdj8L69LLQmqVk0mT61aySbw4sVlMuPiIieoK1NG3l8eqRkmIso+//wjh8WXLQvs3Ss7GebhToJMhChf0mplAhIWJvu8hIbKIdT37sn1+s6eNf6caSVBtWvLzr537sh1jBIT5XQXJUsmT1qnWzjS1ZXT/xORidJqgblzgYkT5VwV1tbAw4fyl2AexkSI8iRdzc2jR3JRyAsXZIdi3SgpjSZz561cOXkF6BIl5DwzxYrJpMbVVTZzOTrKkU4cnk1ElEGPHwOBgcAff8jtHj2A77+XH6h5HBMhUkRcnFws8r//5Jw2R4/K/jghIcYnOba2svnJzU0uVePiIpula9eWK1O7u8taGyIiygGHD8umsAcPZPPX118DH32Ub9r+mQhRthNC1rg8eSKbio8fl81Whw/L8pgY485XsaIcSl6qlJyjxtdX1uxUr674PFxERKZNowEGD5ZJUMWKwKZNspNkPsJEiDJNowF+/x1YvFg2DR85kvocNm/i6ir73BQuLGcXLllS9rErWjTf/KAgIjJN5uZysdTFi4GFC+XU8fkMEyFKlxByLqzjx2XH5OBgOSLy5MmMn8PSUiY69evLZqy33pI/HDhqiogoH/rrLznU9uOP5XbVqsCKFcrGlAVMhAiA7Nh/+rRsytq7V466MmZG4/ffB957T07kV7687IDMzsZERAWIRgN88QUwfbqsCfL1zXOTI2YGEyETpdUCu3YBQ4bI2ZAzqmVLmSD17JncXyePTg1BRETZ5cEDoFcv4OBBud23r+ysWQAwETIRL18C27YB48bJpq3Hj1Pfz8lJrjNVsybQrp3s86Zbd4qIiEzQnj1A797yi8PBQQ6L79lT6aiyDROhAiopCfj3X2DtWmDdOjk0PS1dugBz5sgVxYmIiPSmTgWmTZPXa9SQo8LKl1c0pOzGRKiAePEC+PNP4KefgN9+S3s/d3e5WOeYMfI9zWYtIiJKk4uL/PvJJ3JUWAH80mAilI+tXw9s3Qps2ZL+fpUqyebcIUMAe/tcCY2IiPKr6OjkL4sRI4BatYBmzZSNKQcxEcpHEhNlP7XAQDnKKzUuLnLk1rRpwLvvcuQWERFlUGIiMGECsGOHnCPF0VHOcVKAkyCAiVCeFxUlR2qdOJH2PoGBQOvWcoZzM7Pci42IiAqI27fll8i//8rtX3+VHaRNABOhPEijAebNkyO80tKsmWwSc3XNvbiIiKgA2r5d9p948QJwdgZWrQI6dVI6qlzDRCiPiIkBdu6US7Y8fZrydktL2SxWv76cx4qIiChLEhKAzz+Xy2MAQL16wIYNcmFHE8JESGGPHsk1tdIydKisHWJfHyIiylZjxyYnQZ99BsycCVhZKRuTAtijREF//pl6ElSpkuwMLQTwzTdMgoiIKAeMGwdUqSI7R8+bZ5JJEMAaIUVoNED79sAffySXubjIJjF2diYiohwRFyeXGOjRQ24XLQqcO2fyXzym/ehzmVYra3ssLAyToEGDgOfPTf69SEREOeX6daBBA7k0xvr1yeX84mGNUG5ISpIzkoeGprzt1Cmgdu3cj4mIiEzE+vXAwIFyPhZXV6BwYaUjylOYCOWw8+flKu2vu34dKFs29+MhIiITERsrZ4ZesUJuN20K/PyznHWX9FgnloPWrUuZBN2+LTtBMwkiIqIcc+WKnG9lxQo5O/SkScD+/UyCUsFEKId8+CHwwQfJ25MmyQSoRAnlYiIiIhNx86ZsknB3l0OUp0+XHVQpBT4r2UytTl6sV+e77+TCvURERLmiXTtZG9SuHeDpqXQ0eRprhLJJTAzQuHHKJOjWLSZBRESUwy5eBJo0kf0vdD76iElQBjARygaHDwP29sDRo8llHh6yKczEZionIqLcJIRcG6xuXeDIEeDTT5WOKN9hIpRF33wjO+LrmJnJZTMePlQuJiIiMgFRUXKF+P795Qix1q2B779XOqp8h32EskClMtxetEiOVCQiIspRZ88C3boB167JlbinT5drh3GCRKMxEcqExMSUS7Js2gR07apMPEREZEIOHwbefhuIj5fD4TdskJ1UKVOYCGXC60nQs2dAoULKxEJERCambl2gYkWZBP34o5wtmjKNiZCRXm8OE0KZOIiIyIRcvizXajI3B2xsgH375FIZbArLMj6DRng9CdJolImDiIhMhBDAkiVAzZrAjBnJ5a6uTIKyCWuEMujqVcPtxES+B4mIKAe9eCFHhG3dKrfPngW0Wn75ZDM+mxlUq1by9bg4zlROREQ56Phx+cWzdStgaSmHJW/ZwiQoB/AZzYDr1+UUDTrW1srFQkREBZgQwMKFchRYWJiclffoUTk3y+v9MyhbMBHKgPLlk6/fvatcHEREVMCFhgITJsj+F507A6dPy1FilGPYwPMGK1cmX7e3B4oXVy4WIiIq4EqXBpYulc0QgwezFigXqIQwrQHgkZGRcHZ2hlqthpOTU7r7CmHYHBsdDdjZ5XCARERkOrRaYP58uWDqW28pHU2eZsz3tzFYI5SG+Hg5VYPOsGFMgoiIKBs9fgwEBgJ//AGULAlcuAA4OCgdlclhIpSGtWsNtxcuVCYOIiIqgA4dAnr0AB48kL+6J06U/S8o17GzdBoGDEi+rtXKyTyJiIiyRKuVEyO2aCGToAoVgP/+k1867A+kCNYIpSIhIfl61ap8bxIRUTaIigI6dQL27pXbvXsD337L5jCFMRFKxavzBB08qFgYRERUkNjbA7a28vLtt0DfvkpHRGAilMKOHcnXbWyAIkWUi4WIiPI5jUY2M9jayuaF1auB8HCgcmWlI6P/Yx+h17z/fvL1mBjl4iAionzu4UPAz0/2/9HNVFO4MJOgPIY1Qq+4dCn5eo8e7BtERESZ9OefwAcfyCHy9vbArVtAmTJKR0WpYI3QK6pUSb6+Zo1ycRARUT6VlCSHwrdpI5Og6tWBkyeZBOVhrBH6v6Sk5OsNG3J1eSIiMtK9e0DPnsDhw3L744/lJHS2tsrGReni1/3/eXklX9+1S7k4iIgoH9JqgbZt5ezQjo7AihVAQIDSUVEGsGns/x49Sr7u4qJYGERElB+ZmQGLFgF16sgV45kE5RtMhABcv558/Z9/lIuDiIjykTt3ZKdonVat5CzRZcsqFxMZjYkQDN/HDRooFwcREeUTO3YANWsCXboAN24kl5vxazW/4SsG4Px5+dfTU9k4iIgoj0tIAEaOlJPOPX8OVKzI0TX5nOKJ0NKlS+Hj4wMbGxvUr18fx48fT3f/RYsWoUKFCrC1tYW3tzdGjhyJuLi4LMWwfbv8y75BRESUptBQoHFj2RcIkAnRkSOAj4+SUVEWKZoIbdy4EaNGjUJQUBBOnz6NGjVqwN/fH49e7bn8ip9//hnjxo1DUFAQLl++jJUrV2Ljxo2YMGFCluLQ1QT5+WXpNEREVFD98gtQqxZw4gRQqJD8Bb1gAWBlpXRklEWKJkILFizAgAED0K9fP1SuXBnLli2DnZ0dVq1aler+//zzDxo1aoSePXvCx8cHrVu3Ro8ePd5Yi/Qmz57Jv++8k6XTEBFRQfXPP4BaLTuShoQA772ndESUTRRLhBISEnDq1Cn4vVINY2ZmBj8/Pxw7dizVYxo2bIhTp07pE59bt27h999/xzvpZDDx8fGIjIw0uLzu9m3599VJFYmIyMTp1gcDgFmzgMWLgb//BkqUUC4mynaKJUJPnjyBRqNB0aJFDcqLFi2K8PDwVI/p2bMnvvjiCzRu3BiWlpYoU6YMmjdvnm7T2KxZs+Ds7Ky/eHt7G9z+avLD9zYREQEANmyQzQSJiXLbygoYPhywtFQ2Lsp2ineWNsbBgwcxc+ZMfPvttzh9+jS2bt2KXbt2Yfr06WkeM378eKjVav3l7t27Brf/9VfydS4ITERk4mJj5dIYPXoAu3fLGaKpQFNszJ+rqyvMzc0RERFhUB4REQEPD49Uj5k8eTJ69+6Njz76CABQrVo1REdHY+DAgZg4cSLMUpm/wdraGtbW1mnGcfNm8nWOgCQiMmFXrwLdugHnzgEqFTBhAjBwoNJRUQ5TrEbIysoKvr6+2L9/v75Mq9Vi//79aJDGrIYxMTEpkh1zc3MAgHi1LdcIISHyb61amTqciIgKgp9+Anx9ZRLk7g7s2QN8+SV/IZsARV/hUaNGITAwEHXq1EG9evWwaNEiREdHo1+/fgCAPn36wMvLC7NmzQIAtG/fHgsWLECtWrVQv3593LhxA5MnT0b79u31CZGxzp2Tf9nsS0RkombMACZNktdbtADWreMMuyZE0UQoICAAjx8/xpQpUxAeHo6aNWti9+7d+g7Ud+7cMagBmjRpElQqFSZNmoT79+/Dzc0N7du3x4wZMzIdg25WaXaUJiIyUV26AF99BYwaJROiTP6wpvxJJTLbppRPRUZGwtnZGWq1Gk5OTrC2ljOmz54NjB2rdHRERJTjhJDNATVqJJc9fQoUKaJcTPRGr39/Z5d8NWosuwkhkyAAqFRJ2ViIiCgXREUBffoAtWvLOYF0mASZLJNOhC5eTL5es6ZiYRARUW44dw6oU0d2jAaACxeUjYfyBJNOhE6eTL7OPkJERAWUEMDy5UC9enKIvJcXcPAgMGSI0pFRHmDS4wI1GqUjICKiHBUZKSdI3LBBbrdtC6xZA7i6KhsX5RmsEQLQpImycRARUQ7Zvl0mQebmcmTYzp1MgsiASdcIubvLv3FxysZBREQ55IMPgDNngK5d5crxRK8x6RqhuXPlX19fZeMgIqJs8uIFMHQo8Py53FapgAULmARRmky6Rig2Vv599kzZOIiIKBucOAEEBAChocCTJ8n9gojSYbI1Qmp18vWFC5WLg4iIskgIYNEioFEjmQSVKgV89pnSUVE+YbI1Qq+OGPv/ih5ERJTfPHsG9OsH7Nghtzt3Bn74AXBxUTQsyj9MNhGKilI6AiIiypLz54F33wXu3AGsrGRfoMGDZb8gogwy2URo1Kjk62Ym20BIRJSPFSsmm8XKlAE2bZLLZhAZyWQToUKF5F8zM/54ICLKN16+BBwc5Ad3kSLAH38A3t5ANi7CSabFZOtCDh2Sf3VD6ImIKI87fFiukB0cnFxWpQqTIMoSk02EwsPl36dPlY2DiIjeQKsFZs4EWrQA7t8HvvmGayRRtjHZREjXNNa6tbJxEBFROh49Atq0ASZOlMnPBx/IKn1zc6UjowLCZPsI6SYddXNTNg4iIkrDgQNAz56yCt/WFliyRA6VZ8dOykYmmwjpcO09IqI86PZtWWWflARUrixHhVWponRUVACZfCKkayIjIqI8pGRJYPx44N492SfI3l7piKiAMvlEyMLknwEiojxi3z7AxwcoW1ZuT5vGZjDKcSbbWRqQc2/xf4yISGFJScCkSbIpLCAAiI+X5fyAplxg0vUhxYopHQERkYm7fx/o0UPOEQQAdevK2aKJcolJJ0LNmikdARGRCfvjD6BPH+DJE8DREVi+HOjeXemoyMSYdNMYEREpIDERGDsWeOcdmQTVqgWcOsUkiBTBRIiIiHKXEHKOIAAYMgT45x+gXDllYyKTZdJNY7pJFYmIKBcIITtAW1kBGzcCp08DnTsrHRWZOJNOhBo0UDoCIiITkJAAjBsH2NjINcMAoFQpeSFSmEknQj4+SkdARFTAhYbKvj/Hj8vaoD59gIoVlY6KSI99hIiIKGds3So7Qh8/Dri4ANu2MQmiPIeJEBERZa/4eGDYMNn/R60G3noLCAkB3n9f6ciIUjDpprHChZWOgIiogBFCzhB96JDc/vxz4MsvAUtLZeMiSoNJJ0JFiigdARFRAaNSAR99BFy8CKxZI+cKIsrD2DRGRERZExsLXL6cvN27N3DtGpMgyheYCBERUeZdvSr7APn5AY8fJ5ez7wHlEyadCFlbKx0BEVE+9tNPgK8vcO6cXDYjNFTpiIiMZrKJEFeeJyLKpJgYoH9/2QQWHQ00by5HhdWrp3RkREYz2USIiIgy4dIlmfCsWiU7RgcFAfv28dcl5VsmPWqMiIiMNGeOHBHm4QGsWwe0bKl0RERZYrKJ0IMHSkdARJQPff01YGEh1wwrWlTpaIiyzGSbxurXVzoCIqJ84Px5YMwYOVEiADg7AytXMgmiAsNka4Q4ySkRUTqEAH74ARg+HIiLAypUkBMlEhUwJpsIERFRGiIjgY8/BjZskNtt23KdMCqwTLZpjIiIUnHmjJwbaMMGwNxcdo7euRNwc1M6MqIckaUaobi4ONjY2GRXLEREpKS1a2XzV0IC4O0tk6GGDZWOiihHGV0jpNVqMX36dHh5ecHBwQG3bt0CAEyePBkrV67M9gCJiCiXlCoFaDRA+/ZygkQmQWQCjE6EvvzySwQHB+Orr76ClZWVvrxq1ar44YcfsjU4IiLKYWp18vXGjYFjx4Dt27lWGJkMoxOhNWvWYPny5ejVqxfMzc315TVq1MCVK1eyNTgiIsohQgCLFwM+PnK2aJ26deWM0UQmwuhE6P79+yhbtmyKcq1Wi8TExGwJioiIctCzZ0DHjsCnnwIvXgDBwQoHRKQcoxOhypUr4/DhwynKt2zZglq1amVLUERElEP+/ReoVUs2f1lZAd98I0eGEZkoo0eNTZkyBYGBgbh//z60Wi22bt2Kq1evYs2aNdi5c2dOxEhERFml1QILFgDjxwNJSUCZMsDGjXKoPJEJM7pG6P3338dvv/2Gffv2wd7eHlOmTMHly5fx22+/4e23386JGImIKKt++kkulZGUBHTrBpw6xSSICIBKCN0CMqYhMjISzs7OaNxYjcOHnZQOh4godyQlAe3ayb5BH3/MDtGU7+i+v9VqNZycsu/72+gaodKlS+Pp06cpyl+8eIHSpUtnS1BERJRFWq1cKyw+Xm5bWAC7dwOffMIkiOgVRidCYWFh0Gg0Kcrj4+Nx//79bAmKiIiy4NEjuT7YgAHA2LHJ5UyAiFLIcGfpHTt26K/v2bMHzs7O+m2NRoP9+/fDx8cnW4MjIiIjHTwI9OwJPHwI2NoC1asrHRFRnpbhRKhDhw4AAJVKhcDAQIPbLC0t4ePjg/nz52drcERElEEaDTBjBjBtmmwWq1QJ2LwZqFJF6ciI8rQMJ0JarRYAUKpUKZw4cQKurq45FhQRERkhPBzo1Qv46y+53a+fnB/I3l7ZuIjyAaPnEQoNDc2JOHJdXJzSERARZZOYGODkScDODli2DOjdW+mIiPINoxMhAIiOjsbff/+NO3fuICEhweC24cOHZ0tgOS0mRukIiIiyQIjkzs+lSwObNgElSwIVKyobF1E+Y3QidObMGbzzzjuIiYlBdHQ0ChcujCdPnsDOzg7u7u75JhGqW1fpCIiIMun+feCDD+Qs0a1byzJ/f2VjIsqnjB4+P3LkSLRv3x7Pnz+Hra0t/v33X9y+fRu+vr6YN29eTsRIREQ6u3cDNWvK0WGDB8uJEoko04xOhEJCQvDZZ5/BzMwM5ubmiI+Ph7e3N7766itMmDAhJ2IkIqLERGDcODk/0JMnMhn6/Xc5USIRZZrRiZClpSXMzORh7u7uuHPnDgDA2dkZd+/ezd7oiIgIuHsXaN48eZX4wYOBY8eA8uUVDYuoIDA6EapVqxZOnDgBAGjWrBmmTJmCdevW4dNPP0XVqlWNDmDp0qXw8fGBjY0N6tevj+PHj6e7/4sXLzBkyBB4enrC2toa5cuXx++//270/RIR5Qv378van3/+AZyc5NxAS5cCNjZKR0ZUIBidCM2cOROenp4AgBkzZqBQoUIYNGgQHj9+jO+//96oc23cuBGjRo1CUFAQTp8+jRo1asDf3x+PHj1Kdf+EhAS8/fbbCAsLw5YtW3D16lWsWLECXl5exj4MIqL8wcsLaN8eqFMHOHMG6NJF6YiIChRFV5+vX78+6tatiyVLlgCQkzZ6e3tj2LBhGDduXIr9ly1bhrlz5+LKlSuwtLTM1H3qVq8NDFQjOJirzxNRHhQWBjg4ALqJa2NiAHNzwNpa0bCIlJRnVp9Py+nTp/Huu+9meP+EhAScOnUKfn5+ycGYmcHPzw/Hjh1L9ZgdO3agQYMGGDJkCIoWLYqqVati5syZqS4CqxMfH4/IyEiDCxFRnrVtm2wKCwyUS2UAcqJEJkFEOcKoRGjPnj0YPXo0JkyYgFu3bgEArly5gg4dOqBu3br6ZTgy4smTJ9BoNChatKhBedGiRREeHp7qMbdu3cKWLVug0Wjw+++/Y/LkyZg/fz6+/PLLNO9n1qxZcHZ21l+8vb0zHCMRUa6JjweGDwc6dQLUauDpU/mXiHJUhhOhlStXom3btggODsacOXPw1ltv4aeffkKDBg3g4eGBCxcu5HinZa1WC3d3dyxfvhy+vr4ICAjAxIkTsWzZsjSPGT9+PNRqtf7CkW1ElOfcvAk0aiTXBwOA0aOBw4eBQoWUjYvIBGR4AorFixdjzpw5GDNmDH755Rd07doV3377Lc6fP4/ixYsbfceurq4wNzdHRESEQXlERAQ8PDxSPcbT0xOWlpYwNzfXl1WqVAnh4eFISEiAlZVVimOsra1hzSplIsqrNm0CPvoIePkSKFIE+PFHoF07paMiMhkZrhG6efMmunbtCgDo1KkTLCwsMHfu3EwlQQBgZWUFX19f7N+/X1+m1Wqxf/9+NGjQINVjGjVqhBs3bhg0wV27dg2enp6pJkFERHlaXJxcJuPlS1kjFBLCJIgol2U4EYqNjYWdnR0AQKVSwdraWj+MPrNGjRqFFStW4Mcff8Tly5cxaNAgREdHo1+/fgCAPn36YPz48fr9Bw0ahGfPnmHEiBG4du0adu3ahZkzZ2LIkCFZioOISBE2NsDGjcCECXLJjEz+sCSizDNqbvYffvgBDg4OAICkpCQEBwfDVTe88/+MWXQ1ICAAjx8/xpQpUxAeHo6aNWti9+7d+g7Ud+7c0c9iDQDe3t7Ys2cPRo4cierVq8PLywsjRozA2LFjjXkYRETK+flnORz+o4/kdp068kJEisjwPEI+Pj5QqVTpn0yl0o8my6s4jxARKSImBhgxAvjhB8DKSjaDVaqkdFRE+UZOzSOU4RqhsLCwbLvTvIALNhNRrrl8GejWDbhwAVCpZL8grhNGlCeY7LLF0dFKR0BEJuHHH+UiqTExQNGismmsZUuloyKi/zPZRKhWLaUjIKICTQhgwABg5Uq57ecH/PSTTIaIKM/ItiU2iIjoFSoVULo0YGYGTJ8O7N7NJIgoDzLZGiEiomwnhFwWw8VFbo8bB7RpA9SurWhYRJQ21ggREWWHly+BXr2AJk1kfyBA1gYxCSLK0zKVCN28eROTJk1Cjx498OjRIwDAH3/8gYsXL2ZrcERE+UJICODrC6xfL0eIHTqkdERElEFGJ0J///03qlWrhv/++w9bt25FVFQUAODs2bMICgrK9gCJiPIsIYDvvgPeegu4fh3w9pZJUJs2SkdGRBlkdCI0btw4fPnll9i7d6/B+l4tW7bEv//+m63BERHlWWo1EBAgh8bHxwPt2wNnzgANGyodGREZwehE6Pz58+jYsWOKcnd3dzx58iRbgiIiyvOGDgU2bwYsLID584Ht2+Xq8USUrxidCLm4uODhw4cpys+cOQMvL69sCYqIKM+bNUv2CzpyBBg1Sg6XJ6J8x+hEqHv37hg7dizCw8OhUqmg1Wpx9OhRjB49Gn369MmJGImIlPf8uZwlWqd4ceDECaB+feViIqIsMzoRmjlzJipWrAhvb29ERUWhcuXKaNq0KRo2bIhJkyblRIxERMr67z85HX3fvrIJTIe1QET5ntETKlpZWWHFihWYPHkyLly4gKioKNSqVQvlypXLifiIiJQjBLBggZwYMSkJKFNG1gQRUYFhdCJ05MgRNG7cGCVKlECJEiVyIiYiIuU9fSprgHbulNvdugErVgBOToqGRUTZy+imsZYtW6JUqVKYMGECLl26lBMxEREp6+hRoGZNmQRZW8u5gjZsYBJEVAAZnQg9ePAAn332Gf7++29UrVoVNWvWxNy5c3Hv3r2ciI+IKPc9eADcuweUKwf8+y/wySfsD0RUQBmdCLm6umLo0KE4evQobt68ia5du+LHH3+Ej48PWrZsmRMxEhHlPCGSr3ftCgQHA6dOyZohIiqwsrToaqlSpTBu3DjMnj0b1apVw99//51dcRER5Z6//5ZzAr06R1pgIODoqFxMRJQrMp0IHT16FIMHD4anpyd69uyJqlWrYteuXdkZGxFRztJogOnTgZYt5fIYU6YoHRER5TKjR42NHz8eGzZswIMHD/D2229j8eLFeP/992FnZ5cT8RER5YzwcOCDD4D9++V2377AokVKRkRECjA6ETp06BDGjBmDbt26wdXVNSdiIiLKWfv3A716ARERgJ2dHBXGmfGJTJLRidDRo0dzIg4iotyxbRvQubPsHF21KrBpE1CpktJREZFCMpQI7dixA23btoWlpSV27NiR7r7vvfdetgRGRJQj3n4bqFABaNIEWLwYsLVVOiIiUlCGEqEOHTogPDwc7u7u6NChQ5r7qVQqaDSa7IqNiCh7nDghR4WZmQEODnJuIGdnpaMiojwgQ6PGtFot3N3d9dfTujAJIqI8JSkJGD8eqFdPrhmmwySIiP7P6OHza9asQXx8fIryhIQErFmzJluCIiLKsrt3gebNgdmz5TZnvyeiVBidCPXr1w9qtTpF+cuXL9GvX79sCYqIKEt27ZIzQh89KtcH27yZQ+OJKFVGJ0JCCKhSWXPn3r17cGZ1MxEpKSEBGD0aePdd4NkzoE4dOVFily5KR0ZEeVSGh8/XqlULKpUKKpUKrVq1goVF8qEajQahoaFo06ZNjgRJRJQhly8DX38tr48YAcyZI1ePJyJKQ4YTId1osZCQEPj7+8PBwUF/m5WVFXx8fNC5c+dsD5CIKMNq1ACWLAHc3YF0RrgSEelkOBEKCgoCAPj4+CAgIAA2NjY5FhQRUYbExwMTJgC9eyevEj9woKIhEVH+YvTM0oGBgTkRBxGRcW7eBAICgFOngJ07gQsXAEtLpaMionwmQ4lQ4cKFce3aNbi6uqJQoUKpdpbWefbsWbYFR0SUqs2bgY8+AiIjgcKF5RxBTIKIKBMylAgtXLgQjo6O+uvpJUJERDkmLg4YNUoukgoAjRoB69cD3t7KxkVE+VaGEqFXm8P69u2bU7EQEaXt8WOgdWsgJERujx8PfPEFYGF0Cz8RkZ7R8widPn0a58+f129v374dHTp0wIQJE5CQkJCtwRER6RUuDLi6Am5uwO7dwMyZTIKIKMuMToQ+/vhjXLt2DQBw69YtBAQEwM7ODps3b8bnn3+e7QESkQmLiQFiY+V1c3Ng3TpZI+Tvr2hYRFRwGJ0IXbt2DTX/P0x18+bNaNasGX7++WcEBwfjl19+ye74iMhUXb4M1K8PfPppcpm7O1CsmGIhEVHBk6klNrRaLQBg3759eOeddwAA3t7eePLkSfZGR0Sm6ccf5fIYFy4A27fL/kFERDnA6ESoTp06+PLLL7F27Vr8/fffaNeuHQAgNDQURYsWzfYAiciEREcDffvKS0wM0KqVbApzc1M4MCIqqIxOhBYtWoTTp09j6NChmDhxIsqWLQsA2LJlCxo2bJjtARKRibhwAahbV9YGmZkB06cDe/YAHh5KR0ZEBZjRQy6qV69uMGpMZ+7cuTA3N8+WoIjIxCQkAG3bAvfuyT5AP/8MNGumdFREZAIyPfb01KlTuHz5MgCgcuXKqF27drYFRUQmxsoKWLYMWLpU1gixKYyIconRidCjR48QEBCAv//+Gy4uLgCAFy9eoEWLFtiwYQPc+AFGRBlx9izw6BHw9ttyu1074J13AM5cT0S5yOg+QsOGDUNUVBQuXryIZ8+e4dmzZ7hw4QIiIyMxfPjwnIiRiAoSIWTtT/36ctHUO3eSb2MSRES5zOgaod27d2Pfvn2oVKmSvqxy5cpYunQpWrduna3BEVEBo1YDAwcCmzbJ7bffBuztlY2JiEya0TVCWq0Wlqms8mxpaamfX4iIKIVTp4DatWUSZGEBzJ8P7NgBFCmidGREZMKMToRatmyJESNG4MGDB/qy+/fvY+TIkWjVqlW2BkdEBcQ33wANGwK3bgElSwJHjshV5NkURkQKMzoRWrJkCSIjI+Hj44MyZcqgTJkyKFWqFCIjI/HNN9/kRIxElN9dvCiHyHfoAJw5I/sHERHlAUb3EfL29sbp06exf/9+/fD5SpUqwc/PL9uDI6J8TIjkGp+FC2WNUO/erAUiojzFqERo48aN2LFjBxISEtCqVSsMGzYsp+IiovxKCJn47N0L7NwpV423tQX69FE6MiKiFDKcCH333XcYMmQIypUrB1tbW2zduhU3b97E3LlzczI+IspPnj6V64Tt3Cm3t24FunZVNCQiovRkuI/QkiVLEBQUhKtXryIkJAQ//vgjvv3225yMjYjyk3/+AWrVkkmQtTXw3XdAly5KR0VElK4MJ0K3bt1CYGCgfrtnz55ISkrCw4cPcyQwIsontFpgzhygaVPg7l2gXDng33+BTz5hfyAiyvMynAjFx8fD/pWJz8zMzGBlZYXY2NgcCYyI8onhw4Fx4wCNBujZU84XVLOm0lEREWWIUZ2lJ0+eDDs7O/12QkICZsyYAWdnZ33ZggULsi86Isr7Bg4E1q8HvvoK+PBD1gIRUb6S4USoadOmuHr1qkFZw4YNcevWLf22ih+ARAWfRgOcPJk8F1D16kBYGODoqGhYRESZkeFE6ODBgzkYBhHlCxERwAcfAAcPytmhdckQkyAiyqeMnlmaiEzUX38BNWoA+/YBVlbAvXtKR0RElGVMhIgofRoNEBQE+PnJGqGqVWXTWOfOSkdGRJRlRi+xQUQm5MEDoFcv2RQGAB99BCxeDLwyaIKIKD9jIkREadu6VSZBDg7A99/L4fFERAVInmgaW7p0KXx8fGBjY4P69evj+PHjGTpuw4YNUKlU6NChQ84GSGSqhgwBRo+WcwMxCSKiAihTidDhw4fxwQcfoEGDBrh//z4AYO3atThy5IjR59q4cSNGjRqFoKAgnD59GjVq1IC/vz8ePXqU7nFhYWEYPXo0mjRpkpmHQESpuXdPrhX28qXcVqmAuXOB8uUVDYuIKKcYnQj98ssv8Pf3h62tLc6cOYP4+HgAgFqtxsyZM40OYMGCBRgwYAD69euHypUrY9myZbCzs8OqVavSPEaj0aBXr16YNm0aSpcubfR9ElEqdu2SM0L/+CPw2WdKR0NElCuMToS+/PJLLFu2DCtWrIClpaW+vFGjRjh9+rRR50pISMCpU6fg5+eXHJCZGfz8/HDs2LE0j/viiy/g7u6O/v37v/E+4uPjERkZaXAholckJgJjxgDvvitXj/f1BcaOVToqIqJcYXQidPXqVTRt2jRFubOzM168eGHUuZ48eQKNRoOiRYsalBctWhTh4eGpHnPkyBGsXLkSK1asyNB9zJo1C87OzvqLt7e3UTESFWi3b8vFUufNk9vDhwNHjwJlyigbFxFRLjE6EfLw8MCNGzdSlB85ciTHm6levnyJ3r17Y8WKFXB1dc3QMePHj4dardZf7t69m6MxEuUbhw/LprB//wVcXIBt2+TQeGtrpSMjIso1Rg+fHzBgAEaMGIFVq1ZBpVLhwYMHOHbsGEaPHo3JkycbdS5XV1eYm5sjIiLCoDwiIgIeHh4p9r958ybCwsLQvn17fZlWq5UPxMICV69eRZnXfslaW1vDmh/sRCmVKyeTnvr1gQ0bAB8fpSMiIsp1RidC48aNg1arRatWrRATE4OmTZvC2toao0ePxrBhw4w6l5WVFXx9fbF//379EHitVov9+/dj6NChKfavWLEizp8/b1A2adIkvHz5EosXL2azF9GbPH0KFCkir3t4yDmCSpeWS2YQEZkgoxMhlUqFiRMnYsyYMbhx4waioqJQuXJlODg4ZCqAUaNGITAwEHXq1EG9evWwaNEiREdHo1+/fgCAPn36wMvLC7NmzYKNjQ2qVq1qcLyLiwsApCgnotds2QL07w8sXw4EBMiyihWVjYmISGGZnlnaysoKlStXznIAAQEBePz4MaZMmYLw8HDUrFkTu3fv1negvnPnDszM8sS8j0T5U1ycHA7/7bdy+8cfgW7d5BxBREQmTiWEEMYc0KJFC6jS+QD966+/shxUToqMjISzszOmTVNjyhQnpcMhylnXr8ukJyREbo8bB3zxBfDK1BdERPmB7vtbrVbDySn7vr+NrhGqWbOmwXZiYiJCQkJw4cIFBAYGZldcRJRV69cDAwcCUVGAqyuwdi3Qpo3SURER5SlGJ0ILFy5MtXzq1KmIiorKckBElA3OnUteG6xpU+DnnwEvL2VjIiLKg7Kt880HH3yQ7rIYRJSLqleXi6VOngzs388kiIgoDZnuLP26Y8eOwcbGJrtOR0TGWrcOaNIEKFFCbn/1FTtEExG9gdGJUKdOnQy2hRB4+PAhTp48afSEikSUDaKjgWHDgNWrgYYN5dxAlpZMgoiIMsDoRMjZ2dlg28zMDBUqVMAXX3yB1q1bZ1tgRJQBFy/KUWGXLgFmZoC/v/xLREQZYlQipNFo0K9fP1SrVg2FChXKqZiI6E2EkDVAQ4cCsbGAp6fsEN28udKRERHlK0b9dDQ3N0fr1q2NXmWeiLJRdDTQp4+cJTo2VtYChYQwCSIiygSj69CrVq2KW7du5UQsRJQRZmZyeLy5OTBrFvD774C7u9JRERHlS0b3Efryyy8xevRoTJ8+Hb6+vrC3tze4PTtneySi/xNCXszMAFtbYNMm4PFjoHFjpSMjIsrXMpwIffHFF/jss8/wzjvvAADee+89g6U2hBBQqVTQaDTZHyWRKVOr5QzR1aoBkybJsgoV5IWIiLIkw4nQtGnT8Mknn+DAgQM5GQ8RverUKblS/M2bwI4dsl+Qp6fSURERFRgZToR0a7M2a9Ysx4Ihov8TAliyRM4OnZAAlCwJbNjAJIiIKJsZ1UcovVXniSibvHgha362bpXbHToAq1YBnLKCiCjbGZUIlS9f/o3J0LNnz7IUEJFJS0qSs0Nfvixnh543T84azR8hREQ5wqhEaNq0aSlmliaibGRhAYwYIdcJ27gRqFNH6YiIiAo0oxKh7t27w53zlRBlr2fPgIcPgSpV5PbAgcAHHwCvTU1BRETZL8MTKrJ/EFEO+OcfoGZN4N13Zd8gQDaDMQkiIsoVGU6EdKPGiCgbaLXAnDlA06bA3buyP9CjR0pHRURkcjLcNKbVanMyDiLT8fgxEBgI/PGH3O7RA/j+e8DRUdm4iIhMkNFLbBBRFhw6JBOfBw8AGxvgm2/kUHk2PRMRKYKJEFFuWrBAJkEVK8r1wqpVUzoiIiKTxkSIKDetXAmULg188QXg4KB0NEREJi/DnaWJKBP++gv47DO5ZAYAFCkia4WYBBER5QmsESLKCRqNrPWZPl0mQfXrA926KR0VERG9hokQUXZ78ADo1Qs4eFBu9+8v5wkiIqI8h4kQUXb68085K/Tjx3JSxO+/l0kRERHlSewjRJRd5s4F2rSRSVCNGsDp00yCiIjyOCZCRNmlVi35d9Ag4N9/gfLllY2HiIjeiE1jRFnx6BGgW4jYzw84fz558VQiIsrzWCNElBmJicCYMbLW5+bN5HImQURE+QoTISJj3b4NNGkCzJsHqNXAb78pHREREWUSm8aIjPHrr0C/fsCLF4CzM7BqFdCpk9JRERFRJrFGiCgjEhKATz8FOnaUSVC9esCZM0yCiIjyOSZCRBmxZAmweLG8PmoUcPgwUKqUsjEREVGWsWmMKCOGDgX27gUGDwbat1c6GiIiyiasESJKTVycXBw1MVFuW1kBf/zBJIiIqIBhjRDR665fBwICZB+gx4+BWbOUjoiIiHIIa4SIXrVhA1C7tkyCXF2Bpk2VjoiIiHIQEyEiAIiNBT7+GOjRA4iKkvMEhYQAbdsqHRkREeUgJkJE164B9esDy5cDKhUwaRLw11+Al5fSkRERUQ4z2T5CMTFKR0B5hlYL3Lol1wxbt06uGUZERCbBZBOhqlWVjoAUpdUCZv+vEK1YEdi6FahWDfD0VDYuIiLKVWwaI9Nz8SJQsyZw6FByWevWTIKIiEwQEyEyHUIAK1cCdesC588Dn30my4iIyGQxESLT8PIl0Ls38NFHcoRY69bArl2yczQREZksJkJU8J09C9SpIztCm5sDM2fKWaLd3ZWOjIiIFGaynaXJRFy+LIfGx8fL4fAbNgCNGysdFRER5RFMhKhgq1gReO89IDoa+PFHOVs0ERHR/zERooLnzBmgVCnAxUX2AfrxR8DaOnm4PBER0f/xm4EKDiGAJUuAt96SnaJ1I8JsbZkEERFRqlgjRAXDixdA//5yYkQASEoC4uJkEkRERJQG/kym/O/4caBWLZkEWVoCixYB27YxCSIiojdiIkT5lxDAwoVyFFhYmOwXdPQoMGIE5wciIqIMYSJE+ZdaDSxYACQmAp07A6dPy1mjiYiIMoh9hCj/cnEB1q+XEyYOHsxaICIiMhoTIco/tFpg3jzAwwPo00eWNW7MCRKJiCjTmAhR/vD4MRAYKJfGsLMDWrQAvL2VjoqIiPI5JkKU9x0+DHTvDjx4ANjYyFFhxYsrHRURERUA7CxNeZdWC8yYATRvLpOgChWA//4DBgxgfyAiIsoWrBGivEmjAdq1A/bskdu9ewPffgs4OCgbFxERFSisEaK8ydwcqFNH9gdavRpYs4ZJEBERZTsmQpR3aDSyU7TO1KlASAjQt69CARERUUGXJxKhpUuXwsfHBzY2Nqhfvz6OHz+e5r4rVqxAkyZNUKhQIRQqVAh+fn7p7k/5xMOHwNtvA23bAvHxsszCAihXTtm4iIioQFM8Edq4cSNGjRqFoKAgnD59GjVq1IC/vz8ePXqU6v4HDx5Ejx49cODAARw7dgze3t5o3bo17t+/n8uRU7b580+gRg3gwAHgyhU5QSIREVEuUAkhhJIB1K9fH3Xr1sWSJUsAAFqtFt7e3hg2bBjGjRv3xuM1Gg0KFSqEJUuWoI9ukr10REZGwtnZGWvXqvHBB05Zjp+yICkJCAoCZs2S64ZVrw5s2iRHhxEREb1C9/2tVqvh5JR939+K1gglJCTg1KlT8PPz05eZmZnBz88Px44dy9A5YmJikJiYiMKFC6d6e3x8PCIjIw0ulAfcuwe0bAnMnCmToI8/Bv79l0kQERHlKkUToSdPnkCj0aBo0aIG5UWLFkV4eHiGzjF27FgUK1bMIJl61axZs+Ds7Ky/eHM24rxhwAA5UaKjI7BhA7BsGWBrq3RURERkYhTvI5QVs2fPxoYNG7Bt2zbY2Nikus/48eOhVqv1l7t37+ZylJSqpUvlMhmnTwMBAUpHQ0REJkrRCRVdXV1hbm6OiIgIg/KIiAh4eHike+y8efMwe/Zs7Nu3D9WrV09zP2tra1hbW2dLvJQFd+7ITtEffSS3S5cG/vpL2ZiIiMjkKVojZGVlBV9fX+zfv19fptVqsX//fjRo0CDN47766itMnz4du3fvRp06dXIjVMqKHTuAmjWBgQNlMkRERJRHKL7ExqhRoxAYGIg6deqgXr16WLRoEaKjo9GvXz8AQJ8+feDl5YVZs2YBAObMmYMpU6bg559/ho+Pj74vkYODAxw483DekpAAjB0rF0kFgLp1OS8QERHlKYonQgEBAXj8+DGmTJmC8PBw1KxZE7t379Z3oL5z5w7MzJIrrr777jskJCSgS5cuBucJCgrC1KlTczN0Sk9oqOz7c+KE3B45Epg9G7CyUjYuIiKiVyg+j1Bu4zxCueDXX+WyGGo1UKgQEBwMvPeewkEREVF+llPzCCleI0QFUGSkTIIaNJBD40uUUDoiIiKiVDERouyh0cgV4wGgTx/Axgbo2BGwtFQ2LiIionTk63mEKI/YsAGoVg148iS5rFs3JkFERJTnMRGizIuNlUtj9OgBXL4MLFigdERERERGYdMYZc6VK7LW5/x5QKUCJkwAOGqPiIjyGSZCZLy1a4FBg4DoaMDdHfjpJ+Dtt5WOioiIyGhMhMg4338PfPKJvN6iBbBuHeDpqWxMREREmcQ+QmSc7t2BsmVlM9jevUyCiIgoX2ONEKVPCLk4asuWsi+QszNw7hxga6t0ZERERFnGGiFKW1QUEBgI+PkBy5YllzMJIiKiAoI1QpS6c+fkqLCrVwEzM9kxmoiIqIBhIkSGhACWLwdGjADi4wEvL2D9eqBJE6UjIyIiynZMhChZZCQwcCCwcaPcbtsWWLMGcHVVNi4iIqIcwj5ClOzCBWDzZrlm2FdfATt3MgkiIqICjTVClKxhQ2DJEqBmTblyPBERUQHHGiFT9uIF0Lu3XCdMZ9AgJkFERGQyWCNkqk6cAAICgNBQ4NIl4ORJOU8QERGRCWGNkKkRAli0CGjUSCZBPj5yjiAmQUREZIJYI2RKnj0D+vUDduyQ2506AStXAi4uioZFRESkFCZCpiI0FGjeHLhzB7CyAhYsAAYPZk0QERGZNCZCpsLbGyhRArC0BDZtAmrXVjoiIiIixTERKsiePgUcHWUNkIWFnCPIzg5wclI6MiIiojyBnaULqsOHgRo1gLFjk8s8PJgEERERvYKJUEGj1QIzZwItWgD37wO7d3PBVCIiojQwESpIHj0C2rQBJk4ENBrggw/kfEH29kpHRkRElCexj1BBceAA0LMnEB4O2NoCS5cCfftyVBgREVE6mAgVBJGRQOfOwPPnQOXKclRYlSpKR0VERJTnMREqCJycgO+/B/74A/jmGzaFERERZRATofxq3z7AzAxo2VJud+0qL0RERJRh7Cyd3yQlAZMmAa1bAz16AA8fKh0RERFRvsUaofzk/n2Z/Bw+LLc7dOA6YURERFnARCi/+OMPoE8f4MkTwMEBWLEC6N5d6aiIiIjyNTaN5XVarZwd+p13ZBJUqxZw+jSTICIiomzARCivMzOTcwMBwJAhwD//AOXKKRsTERFRAcGmsbwqKUkulArIyRG7dgXefVfZmIiIcphGo0FiYqLSYZBCLC0tYW5unqv3yUQor0lIAMaNA27cALZvlzNDOzgwCSKiAi8qKgr37t2DEELpUEghKpUKxYsXh4ODQ67dJxOhvCQ0FAgIkOuDAcDBg3LxVCKiAk6j0eDevXuws7ODm5sbVFweyOQIIfD48WPcu3cP5cqVy7WaISZCecXWrcCHHwJqtRwSHxzMJIiITEZiYiKEEHBzc4Otra3S4ZBC3NzcEBYWhsTExFxLhNhZWmnx8cCwYXKtMLUaeOstICQEeP99pSMjIsp1rAkybUq8/kyElNarF7Bkibw+Zgxw6BBQsqSyMREREZkIJkJKGzsW8PQEdu4EvvoKsLRUOiIiIiKTwUQot8XGAn//nbxdty5w6xbQrp1yMRERUZYcO3YM5ubmaJfKZ/nBgwehUqnw4sWLFLf5+Phg0aJFBmUHDhzAO++8gyJFisDOzg6VK1fGZ599hvv37+dQ9EBcXByGDBmCIkWKwMHBAZ07d0ZERES6x0RERKBv374oVqwY7Ozs0KZNG1y/fj3FfseOHUPLli1hb28PJycnNG3aFLGxsTn1UIzGRCg3Xb0q+wD5+8t+QDo2NoqFREREWbdy5UoMGzYMhw4dwoMHDzJ9nu+//x5+fn7w8PDAL7/8gkuXLmHZsmVQq9WYP39+NkZsaOTIkfjtt9+wefNm/P3333jw4AE6deqU5v5CCHTo0AG3bt3C9u3bcebMGZQsWRJ+fn6Ijo7W73fs2DG0adMGrVu3xvHjx3HixAkMHToUZmZ5KP0QJkatVgsAYu1ade7e8U8/CWFvLwQghJubEAcO5O79ExHlYbGxseLSpUsiNjZW6VCM9vLlS+Hg4CCuXLkiAgICxIwZMwxuP3DggAAgnj9/nuLYkiVLioULFwohhLh7966wsrISn376aar3k9rx2eHFixfC0tJSbN68WV92+fJlAUAcO3Ys1WOuXr0qAIgLFy7oyzQajXBzcxMrVqzQl9WvX19MmjQpw7Gk9z7QfX+r1dn7/Z2HUrICKiYG+Ogj4IMPgOhooHlzWRvUvLnCgRER5V1CyI9MJS7Gzue4adMmVKxYERUqVMAHH3yAVatWZWpSyM2bNyMhIQGff/55qre7uLikeWzbtm3h4OCQ5qVKlSppHnvq1CkkJibCz89PX1axYkWUKFECx44dS/WY+Ph4AIDNKy0aZmZmsLa2xpEjRwAAjx49wn///Qd3d3c0bNgQRYsWRbNmzfS35xWcRygnXboEdOsGXLwoZ4ieMgWYPBnI5enDiYjym5gYOam+EqKiAHv7jO+/cuVKfPDBBwCANm3aQK1W4++//0ZzI3/wXr9+HU5OTvD09DTqOAD44Ycf0u13Y5nOQJzw8HBYWVmlSLSKFi2KcN1al6/RJUrjx4/H999/D3t7eyxcuBD37t3Dw4cPAQC3bt0CAEydOhXz5s1DzZo1sWbNGrRq1QoXLlxAuTyybiYToZy0fbtMgjw8gHXrgJYtlY6IiIiy0dWrV3H8+HFs27YNAGBhYYGAgACsXLnS6ERICJHpeXS8vLwydVxmWVpaYuvWrejfvz8KFy4Mc3Nz+Pn5oW3btvraMK1WCwD4+OOP0a9fPwBArVq1sH//fqxatQqzZs3K1ZjTwkQoJ33+uaxnHTYMKFpU6WiIiPINOztZM6PUfWfUypUrkZSUhGLFiunLhBCwtrbGkiVL4OzsDCcnJwCAWq1OUevy4sULODs7AwDKly8PtVqNhw8fGl0r1LZtWxw+fDjN20uWLImLFy+mepuHhwcSEhLw4sULg/giIiLg4eGR5jl9fX0REhICtVqNhIQEuLm5oX79+qhTpw4A6B9D5cqVDY6rVKkS7ty5k9GHluOYCGWn8+eBL74A1qwBbG1lE9iXXyodFRFRvqNSGdc8pYSkpCSsWbMG8+fPR+vWrQ1u69ChA9avX49PPvkE5cqVg5mZGU6dOoWSr0yYe+vWLajVapQvXx4A0KVLF4wbNw5fffUVFi5cmOL+Xk9UXpWVpjFfX19YWlpi//796Ny5MwBZ03Xnzh00aNAgzeN0dInc9evXcfLkSUyfPh2AnBqgWLFiuHr1qsH+165dQ9u2bd943lyTrV2v84EcGTWm1QqxfLkQNjZyVNjnn2ffuYmITEB+HDW2bds2YWVlJV68eJHits8//1zUqVNHvz1w4EDh4+Mjtm/fLm7duiX+/vtv8dZbb4m33npLaLVa/X5Lly4VKpVKfPjhh+LgwYMiLCxMHDlyRAwcOFCMGjUqxx7LJ598IkqUKCH++usvcfLkSdGgQQPRoEEDg30qVKggtm7dqt/etGmTOHDggLh586b49ddfRcmSJUWnTp0Mjlm4cKFwcnISmzdvFtevXxeTJk0SNjY24saNG6nGocSoMSZCWT+hEN27ywQIEKJNGyEePcqecxMRmYj8mAi9++674p133kn1tv/++08AEGfPnhVCyMcXFBQkKlasKGxtbUWpUqXEwIEDxePHj1Mcu3fvXuHv7y8KFSokbGxsRMWKFcXo0aPFgwcPcuyxxMbGisGDB4tChQoJOzs70bFjR/Hw4UODfQCI1atX67cXL14sihcvLiwtLUWJEiXEpEmTRHx8fIpzz5o1SxQvXlzY2dmJBg0aiMOHD6cbR24nQiohMjHGLx+LjIyEs7Mz1q5V44MPnLJ2sjNn5KiwGzdkM9jMmcDo0UBemiiKiCgfiIuLQ2hoKEqVKmUwJJtMS3rvA933t1qt1ve7yg7sI5RZ27YB3bsDCQmAtzewYQPQsKHSUREREZERmAhlVp06cpKLRo2A1auBIkWUjoiIiIiMxETIGPfvA7q5Gry9gePHgdKl5fAGIiIiynfYmSUjhAAWL5ZJz44dyeVlyjAJIiIiyseYCL3Js2dAx47Ap5/K/kCvJkJERESUrzERSs+//wK1asmlMqysgG++AVasUDoqIqICy8QGMtNrlHj9mQilRqsF5s0DmjQB7tyRTWD//AMMHcqmMCKiHGD+/8WoExISFI6ElKR7/c1zcXFydpZOzaFDwJgx8nq3brIWKBvnLCAiIkMWFhaws7PD48ePYWlpCTPOx2ZytFotHj9+DDs7O1hY5F56wkQoNc2bAyNGABUrAh9/zFogIqIcplKp4OnpidDQUNy+fVvpcEghZmZmKFGiBFS5+L3LRAiQTWGLFwM9egC6lXYXLVI0JCIiU2NlZYVy5cqxecyEWVlZ5XptYJ5IhJYuXYq5c+ciPDwcNWrUwDfffIN69eqluf/mzZsxefJkhIWFoVy5cpgzZw7eeeedzN35o0dA797An38CO3cCe/dyiQwiIoWYmZlxiQ3KVYp/42/cuBGjRo1CUFAQTp8+jRo1asDf3x+PHj1Kdf9//vkHPXr0QP/+/XHmzBl06NABHTp0wIULF4y/84MHgZo1ZRJkawv06sVmMCIiIhOi+KKr9evXR926dbFkyRIAsrOUt7c3hg0bhnHjxqXYPyAgANHR0di5c6e+7K233kLNmjWxbNmyN96fbtG2/zqNR71f58hmsUqVgE2bgKpVs++BERERUbbJqUVXFa0RSkhIwKlTp+Dn56cvMzMzg5+fH44dO5bqMceOHTPYHwD8/f3T3D8tFbfOkklQv37AiRNMgoiIiEyQon2Enjx5Ao1Gg6JFixqUFy1aFFeuXEn1mPDw8FT3Dw8PT3X/+Ph4xMfH67fVajUA4JmlDbBksVxBXqMBIiOz8lCIiIgoB0X+/3s6uxuy8kRn6Zw0a9YsTJs2LUV5qcQ4OTT+448ViIqIiIgy4+nTp3B2ds628ymaCLm6usLc3BwREREG5REREfDQDWN/jYeHh1H7jx8/HqNGjdJvv3jxAiVLlsSdO3ey9Ykk40VGRsLb2xt3797N1vZeyhy+HnkHX4u8g69F3qFWq1GiRAkULlw4W8+raCJkZWUFX19f7N+/Hx06dAAgO0vv378fQ4cOTfWYBg0aYP/+/fj000/1ZXv37kWDBg1S3d/a2hrW1tYpyp2dnfmmziOcnJz4WuQhfD3yDr4WeQdfi7wju+cZUrxpbNSoUQgMDESdOnVQr149LFq0CNHR0ejXrx8AoE+fPvDy8sKsWbMAACNGjECzZs0wf/58tGvXDhs2bMDJkyexfPlyJR8GERER5UOKJ0IBAQF4/PgxpkyZgvDwcNSsWRO7d+/Wd4i+c+eOQfbXsGFD/Pzzz5g0aRImTJiAcuXK4ddff0VVjvoiIiIiIymeCAHA0KFD02wKO3jwYIqyrl27omvXrpm6L2trawQFBaXaXEa5i69F3sLXI+/ga5F38LXIO3LqtVB8QkUiIiIipSi+xAYRERGRUpgIERERkcliIkREREQmi4kQERERmawCmQgtXboUPj4+sLGxQf369XH8+PF099+8eTMqVqwIGxsbVKtWDb///nsuRVrwGfNarFixAk2aNEGhQoVQqFAh+Pn5vfG1I+MY+7+hs2HDBqhUKv3Ep5R1xr4WL168wJAhQ+Dp6Qlra2uUL1+en1XZxNjXYtGiRahQoQJsbW3h7e2NkSNHIi4uLpeiLbgOHTqE9u3bo1ixYlCpVPj111/feMzBgwdRu3ZtWFtbo2zZsggODjb+jkUBs2HDBmFlZSVWrVolLl68KAYMGCBcXFxEREREqvsfPXpUmJubi6+++kpcunRJTJo0SVhaWorz58/ncuQFj7GvRc+ePcXSpUvFmTNnxOXLl0Xfvn2Fs7OzuHfvXi5HXjAZ+3rohIaGCi8vL9GkSRPx/vvv506wBZyxr0V8fLyoU6eOeOedd8SRI0dEaGioOHjwoAgJCcnlyAseY1+LdevWCWtra7Fu3ToRGhoq9uzZIzw9PcXIkSNzOfKC5/fffxcTJ04UW7duFQDEtm3b0t3/1q1bws7OTowaNUpcunRJfPPNN8Lc3Fzs3r3bqPstcIlQvXr1xJAhQ/TbGo1GFCtWTMyaNSvV/bt16ybatWtnUFa/fn3x8ccf52icpsDY1+J1SUlJwtHRUfz44485FaJJyczrkZSUJBo2bCh++OEHERgYyEQomxj7Wnz33XeidOnSIiEhIbdCNBnGvhZDhgwRLVu2NCgbNWqUaNSoUY7GaWoykgh9/vnnokqVKgZlAQEBwt/f36j7KlBNYwkJCTh16hT8/Pz0ZWZmZvDz88OxY8dSPebYsWMG+wOAv79/mvtTxmTmtXhdTEwMEhMTs32BPVOU2dfjiy++gLu7O/r3758bYZqEzLwWO3bsQIMGDTBkyBAULVoUVatWxcyZM6HRaHIr7AIpM69Fw4YNcerUKX3z2a1bt/D777/jnXfeyZWYKVl2fX/niZmls8uTJ0+g0Wj0y3PoFC1aFFeuXEn1mPDw8FT3Dw8Pz7E4TUFmXovXjR07FsWKFUvxRifjZeb1OHLkCFauXImQkJBciNB0ZOa1uHXrFv766y/06tULv//+O27cuIHBgwcjMTERQUFBuRF2gZSZ16Jnz5548uQJGjduDCEEkpKS8Mknn2DChAm5ETK9Iq3v78jISMTGxsLW1jZD5ylQNUJUcMyePRsbNmzAtm3bYGNjo3Q4Jufly5fo3bs3VqxYAVdXV6XDMXlarRbu7u5Yvnw5fH19ERAQgIkTJ2LZsmVKh2ZyDh48iJkzZ+Lbb7/F6dOnsXXrVuzatQvTp09XOjTKpAJVI+Tq6gpzc3NEREQYlEdERMDDwyPVYzw8PIzanzImM6+Fzrx58zB79mzs27cP1atXz8kwTYaxr8fNmzcRFhaG9u3b68u0Wi0AwMLCAlevXkWZMmVyNugCKjP/G56enrC0tIS5ubm+rFKlSggPD0dCQgKsrKxyNOaCKjOvxeTJk9G7d2989NFHAIBq1aohOjoaAwcOxMSJEw0WCaecldb3t5OTU4Zrg4ACViNkZWUFX19f7N+/X1+m1Wqxf/9+NGjQINVjGjRoYLA/AOzduzfN/SljMvNaAMBXX32F6dOnY/fu3ahTp05uhGoSjH09KlasiPPnzyMkJER/ee+999CiRQuEhITA29s7N8MvUDLzv9GoUSPcuHFDn4wCwLVr1+Dp6ckkKAsy81rExMSkSHZ0Carg0p25Ktu+v43rx533bdiwQVhbW4vg4GBx6dIlMXDgQOHi4iLCw8OFEEL07t1bjBs3Tr//0aNHhYWFhZg3b564fPmyCAoK4vD5bGLsazF79mxhZWUltmzZIh4+fKi/vHz5UqmHUKAY+3q8jqPGso+xr8WdO3eEo6OjGDp0qLh69arYuXOncHd3F19++aVSD6HAMPa1CAoKEo6OjmL9+vXi1q1b4s8//xRlypQR3bp1U+ohFBgvX74UZ86cEWfOnBEAxIIFC8SZM2fE7du3hRBCjBs3TvTu3Vu/v274/JgxY8Tly5fF0qVLOXxe55tvvhElSpQQVlZWol69euLff//V39asWTMRGBhosP+mTZtE+fLlhZWVlahSpYrYtWtXLkdccBnzWpQsWVIASHEJCgrK/cALKGP/N17FRCh7Gfta/PPPP6J+/frC2tpalC5dWsyYMUMkJSXlctQFkzGvRWJiopg6daooU6aMsLGxEd7e3mLw4MHi+fPnuR94AXPgwIFUvwN0z39gYKBo1qxZimNq1qwprKysROnSpcXq1auNvl+VEKzLIyIiItNUoPoIERERERmDiRARERGZLCZCREREZLKYCBEREZHJYiJEREREJouJEBEREZksJkJERERkspgIEZGB4OBguLi4KB1GpqlUKvz666/p7tO3b1906NAhV+IhoryNiRBRAdS3b1+oVKoUlxs3bigdGoKDg/XxmJmZoXjx4ujXrx8ePXqULed/+PAh2rZtCwAICwuDSqVCSEiIwT6LFy9GcHBwttxfWqZOnap/nObm5vD29sbAgQPx7Nkzo87DpI0oZxWo1eeJKFmbNm2wevVqgzI3NzeFojHk5OSEq1evQqvV4uzZs+jXrx8ePHiAPXv2ZPncaa0a/ipnZ+cs309GVKlSBfv27YNGo8Hly5fx4YcfQq1WY+PGjbly/0T0ZqwRIiqgrK2t4eHhYXAxNzfHggULUK1aNdjb28Pb2xuDBw9GVFRUmuc5e/YsWrRoAUdHRzg5OcHX1xcnT57U337kyBE0adIEtra28Pb2xvDhwxEdHZ1ubCqVCh4eHihWrBjatm2L4cOHY9++fYiNjYVWq8UXX3yB4sWLw9raGjVr1sTu3bv1xyYkJGDo0KHw9PSEjY0NSpYsiVmzZhmcW9c0VqpUKQBArVq1oFKp0Lx5cwCGtSzLly9HsWLFDFZ2B4D3338fH374oX57+/btqF27NmxsbFC6dGlMmzYNSUlJ6T5OCwsLeHh4wMvLC35+fujatSv27t2rv12j0aB///4oVaoUbG1tUaFCBSxevFh/+9SpU/Hjjz9i+/bt+tqlgwcPAgDu3r2Lbt26wcXFBYULF8b777+PsLCwdOMhopSYCBGZGDMzM3z99de4ePEifvzxR/z111/4/PPP09y/V69eKF68OE6cOIFTp05h3LhxsLS0BADcvHkTbdq0QefOnXHu3Dls3LgRR44cwdChQ42KydbWFlqtFklJSVi8eDHmz5+PefPm4dy5c/D398d7772H69evAwC+/vpr7NixA5s2bcLVq1exbt06+Pj4pHre48ePAwD27duHhw8fYuvWrSn26dq1K54+fYoDBw7oy549e4bdu3ejV69eAIDDhw+jT58+GDFiBC5duoTvv/8ewcHBmDFjRoYfY1hYGPbs2QMrKyt9mVarRfHixbF582ZcunQJU6ZMwYQJE7Bp0yYAwOjRo9GtWze0adMGDx8+xMOHD9GwYUMkJibC398fjo6OOHz4MI4ePQoHBwe0adMGCQkJGY6JiIACufo8kakLDAwU5ubmwt7eXn/p0qVLqvtu3rxZFClSRL+9evVq4ezsrN92dHQUwcHBqR7bv39/MXDgQIOyw4cPCzMzMxEbG5vqMa+f/9q1a6J8+fKiTp06QgghihUrJmbMmGFwTN26dcXgwYOFEEIMGzZMtGzZUmi12lTPD0Bs27ZNCCFEaGioACDOnDljsE9gYKB4//339dvvv/+++PDDD/Xb33//vShWrJjQaDRCCCFatWolZs6caXCOtWvXCk9Pz1RjEEKIoKAgYWZmJuzt7YWNjY1+Je0FCxakeYwQQgwZMkR07tw5zVh1912hQgWD5yA+Pl7Y2tqKPXv2pHt+IjLEPkJEBVSLFi3w3Xff6bft7e0ByNqRWbNm4cqVK4iMjERSUhLi4uIQExMDOzu7FOcZNWoUPvroI6xdu1bfvFOmTBkAstns3LlzWLdunX5/IQS0Wi1CQ0NRqVKlVGNTq9VwcHCAVqtFXFwcGjdujB9++AGRkZF48OABGjVqZLB/o0aNcPbsWQCyWevtt99GhQoV0KZNG7z77rto3bp1lp6rXr16YcCAAfj2229hbW2NdevWoXv37jAzM9M/zqNHjxrUAGk0mnSfNwCoUKECduzYgbi4OPz0008ICQnBsGHDDPZZunQpVq1ahTt37iA2NhYJCQmoWbNmuvGePXsWN27cgKOjo0F5XFwcbt68mYlngMh0MREiKqDs7e1RtmxZg7KwsDC8++67GDRoEGbMmIHChQvjyJEj6N+/PxISElL9Qp86dSp69uyJXbt24Y8//kBQUBA2bNiAjh07IioqCh9//DGGDx+e4rgSJUqkGZujoyNOnz4NMzMzeHp6wtbWFgAQGRn5xsdVu3ZthIaG4o8//sC+ffvQrVs3+Pn5YcuWLW88Ni3t27eHEAK7du1C3bp1cfjwYSxcuFB/e1RUFKZNm4ZOnTqlONbGxibN81pZWelfg9mzZ6Ndu3aYNm0apk+fDgDYsGEDRo8ejfnz56NBgwZwdHTE3Llz8d9//6Ubb1RUFHx9fQ0SUJ280iGeKL9gIkRkQk6dOgWtVov58+frazt0/VHSU758eZQvXx4jR45Ejx49sHr1anTs2BG1a9fGpUuXUiRcb2JmZpbqMU5OTihWrBiOHj2KZs2a6cuPHj2KevXqGewXEBCAgIAAdOnSBW3atMGzZ89QuHBhg/Pp+uNoNJp047GxsUGnTp2wbt063LhxAxUqVEDt2rX1t9euXRtXr141+nG+btKkSWjZsiUGDRqkf5wNGzbE4MGD9fu8XqNjZWWVIv7atWtj48aNcHd3h5OTU5ZiIjJ17CxNZELKli2LxMREfPPNN7h16xbWrl2LZcuWpbl/bGwshg4dioMHD+L27ds4evQoTpw4oW/yGjt2LP755x8MHToUISEhuH79OrZv3250Z+lXjRkzBnPmzMHGjRtx9epVjBs3DiEhIRgxYgQAYMGCBVi/fj2uXLmCa9euYfPmzfDw8Eh1Ekh3d3fY2tpi9+7diIiIgFqtTvN+e/XqhV27dmHVqlX6TtI6U6ZMwZo1azBt2jRcvHgRly9fxoYNGzBp0iSjHluDBg1QvXp1zJw5EwBQrlw5nDx5Env27MG1a9cwefJknDhxwuAYHx8fnDt3DlevXsWTJ0+QmJiIXr16wdXVFe+//z4OHz6M0NBQHDx4EMOHD8e9e/eMionI5CndSYmIsl9qHWx1FixYIDw9PYWtra3w9/cXa9asEQDE8+fPhRCGnZnj4+NF9+7dhbe3t7CyshLFihUTQ4cONegIffz4cfH2228LBwcHYW9vL6pXr56is/OrXu8s/TqNRiOmTp0qvLy8hKWlpahRo4b4448/9LcvX75c1KxZU9jb2wsnJyfRqlUrcfr0af3teKWztBBCrFixQnh7ewszMzPRrFmzNJ8fjUYjPD09BQBx8+bNFHHt3r1bNGzYUNja2gonJydRr149sXz58jQfR1BQkKhRo0aK8vXr1wtra2tx584dERcXJ/r27SucnZ2Fi4uLGDRokBg3bpzBcY8ePdI/vwDEgQMHhBBCPHz4UPTp00e4uroKa2trUbp0aTFgwAChVqvTjImIUlIJIYSyqRgRERGRMtg0RkRERCaLiRARERGZLCZCREREZLKYCBEREZHJYiJEREREJouJEBEREZksJkJERERkspgIERERkcliIkREREQmi4kQERERmSwmQkRERGSymAgRERGRyfof3rD6AospDsoAAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB7PUlEQVR4nO3dd1hTZxsG8DvsPVQQRBS17kXFUfeiorW2tlVxVHFU665abd1oHWitq62tW+uoe9RWa+vede+9cIMbBNl5vz/eL4HIkEDCAXL/risXOW/OOXmSkOTJO1VCCAEiIiIiE2SmdABERERESmEiRERERCaLiRARERGZLCZCREREZLKYCBEREZHJYiJEREREJouJEBEREZksJkJERERkspgIERERkcliImSCfHx80LVrV6XDMDmNGjVCo0aNlA7jrcaNGweVSoWnT58qHUquo1KpMG7cOIOcKzQ0FCqVCkuXLjXI+fK67Lw/unbtCh8fn2zHsHbtWhQoUABRUVFv3deQ/wv62rt3L1QqFdavX6/I/ad06dIlWFhY4MKFC0qHkmVMhAxs6dKlUKlU2ouFhQW8vLzQtWtXPHjwQOnwcrXo6GhMmDABVapUgZ2dHZydnVG/fn0sW7YMeWUlmEuXLmHcuHEIDQ1VOpRUkpKSsGTJEjRq1AgFChSAtbU1fHx80K1bN5w4cULp8Azi999/x6xZs5QOQ0dOxKRJqjQXc3NzFCtWDJ988gnOnDlj1PtOS9euXXXicXBwQMmSJdGmTRts2LABarXaqPf/+vVrjBs3Dnv37s30MUlJSQgODsaAAQPg4OBgvOD0oNT/s1qtxtKlS/HRRx/B29sb9vb2qFSpEiZOnIjY2FidfStUqICWLVti7NixOR6nwQgyqCVLlggA4rvvvhPLly8XCxYsED169BDm5uaiVKlSIiYmRukQRWxsrIiPj1c6DB1hYWGiYsWKwszMTHTs2FHMmzdPzJ49WzRo0EAAEIGBgSIxMVHpMN9q3bp1AoDYs2dPqtvi4uJEXFxczgclhHj9+rVo3ry5ACAaNGggpk2bJhYtWiTGjBkjypYtK1Qqlbh3754QQojg4GABQDx58kSRWLOjZcuWonjx4kY7f0xMjEhISNDrmPRiUqvVIiYmxiD/17dv3xYARIcOHcTy5cvF0qVLxbfffiucnJyEtbW1OH36dLbvQx9BQUHC2tpaLF++XCxfvlzMnz9fjBo1SlSpUkUAEI0aNRIRERE6x2Tn/REfHy9iY2O120+ePBEARHBwcKbPsWnTJqFSqcT9+/cztb++58+K9P539uzZIwCIdevWGeV+X716JQCI9957T0ycOFHMnz9fdOvWTZiZmYlGjRoJtVqts/+2bdsEAHHjxg2jxGNsTIQMTJMIHT9+XKf822+/FQDEmjVrFIpMWTExMSIpKSnd2wMCAoSZmZn4448/Ut02dOhQAUBMmTLFmCGmKSoqSq/9M0qElNSvXz8BQMycOTPVbYmJiWLatGk5mgip1Wrx+vVrg5/XGIlQUlJStn7AGDs5EyI5EZo2bZpO+ZYtWwQA0atXL6Pe/5uCgoKEvb19mreFhIQIAKJdu3ZGu/+sJEIfffSRqFevXqb3z8+JUFxcnDh06FCq8vHjxwsAYseOHTrl8fHxwtXVVYwZM8Yo8RgbEyEDSy8R+uuvvwQAMXnyZJ3yy5cvi88++0y4uroKa2tr4efnl2Yy8OLFCzFo0CBRvHhxYWVlJby8vETnzp11vqxiY2PF2LFjRalSpYSVlZUoWrSoGDZsmM4vJSGEKF68uAgKChJCCHH8+HEBQCxdujTVfW7fvl0AEH/++ae27P79+6Jbt27C3d1dWFlZiQoVKohFixbpHKd5k65atUqMGjVKFClSRKhUKvHixYs0n7MjR44IAKJ79+5p3p6QkCBKly4tXF1dtV+eKT/4Z8yYIYoVKyZsbGxEgwYNxPnz51OdIzPPs+a127t3r+jTp49wc3MTLi4uQgghQkNDRZ8+fUSZMmWEjY2NKFCggGjTpo24fft2quPfvGiSooYNG4qGDRumep7WrFkjJk6cKLy8vIS1tbVo0qSJuH79eqrH8PPPP4sSJUoIGxsbUaNGDbF///5U50zLvXv3hIWFhXj//fcz3E9Dkwhdv35dBAUFCWdnZ+Hk5CS6du0qoqOjdfZdvHixaNy4sXBzcxNWVlaifPny4pdffkl1zuLFi4uWLVuK7du3Cz8/P2Ftba1NyjJ7DiHkL88GDRoIBwcH4ejoKKpXry5WrlwphJDP75vPfcovkcy+PwCIfv36iRUrVogKFSoICwsLsWnTJu1tKb/8IiMjxVdffaV9X7q5uQl/f39x8uTJt8ak+R9esmSJzv1fvnxZtG3bVhQqVEjY2NiIMmXKiJEjR2b0kqWbCEVFRQkAOq/9f//9JwICAoSTk5OwtbUVDRo0EAcPHtQ5Tp//gbRklAgJIUSzZs2ESqUSV69e1Zal9b8cGhoqWrVqJezs7ISbm5sYNGiQ9nMp5Y+NoKCgVM/rm5eMkpaYmBhhZWUlxo0bl+q22NhYMWjQIFGoUCHh4OAgWrVqJe7du5fmOfX5fFy9erUYMWKEKFy4sLCzsxOtWrUSd+/e1Xk+0vvf0fezw1DOnTsnAIgff/wx1W2ffPKJqFKlitHu25gsstewRpml6TPi6uqqLbt48SLq1q0LLy8vDB8+HPb29li7di1at26NDRs24JNPPgEAREVFoX79+rh8+TK6d++OatWq4enTp9iyZQvu37+PQoUKQa1W46OPPsLBgwfRq1cvlC9fHufPn8fMmTNx7do1bN68Oc24qlevjpIlS2Lt2rUICgrSuW3NmjVwdXVFQEAAACA8PBzvvfceVCoV+vfvDzc3N/z999/o0aMHIiMjMWjQIJ3jJ0yYACsrKwwdOhRxcXGwsrJKM4Y///wTANClS5c0b7ewsEDHjh0xfvx4HDp0CP7+/trbli1bhlevXqFfv36IjY3F7Nmz0aRJE5w/fx6FCxfW63nW6Nu3L9zc3DB27FhER0cDAI4fP47Dhw+jffv2KFq0KEJDQ/Hrr7+iUaNGuHTpEuzs7NCgQQMMHDgQP/74I0aOHIny5csDgPZveqZMmQIzMzMMHToUERER+P7779GpUyccPXpUu8+vv/6K/v37o379+hg8eDBCQ0PRunVruLq6omjRohme/++//0ZiYiI6d+6c4X5vateuHUqUKIGQkBCcOnUKCxcuhLu7O6ZOnaoTV8WKFfHRRx/BwsICf/75J/r27Qu1Wo1+/frpnO/q1avo0KEDvvzyS/Ts2RNly5bV6xxLly5F9+7dUbFiRYwYMQIuLi44ffo0tm/fjo4dO2LUqFGIiIjA/fv3MXPmTADQ9vXQ9/2xe/durF27Fv3790ehQoXS7Yjbu3dvrF+/Hv3790eFChXw7NkzHDx4EJcvX0a1atUyjCkt586dQ/369WFpaYlevXrBx8cHN2/exJ9//olJkyZl7oVL4ebNmwCAggULah9XixYt4Ofnh+DgYJiZmWHJkiVo0qQJDhw4gJo1a+ocn5n/gazo3Lkz/v33X+zYsQNlypRJc5/o6Gg0adIEjx49wldffQUPDw/8/vvv2LNnT4bndnNzw6+//oo+ffrgk08+waeffgoAqFKlSrrHnDx5EvHx8ahWrVqq27744gusWLECHTt2RJ06dbB79260bNky1X76fj5OmjQJKpUK3377LR4/foxZs2bB398fZ86cga2tbab+dzLz2fH69Wu8fv06w+cMAMzNzXW+n9ISFhYGAChUqFCq2/z8/PDHH38gMjISTk5Ob72/XEXpTCy/0dQK7Ny5Uzx58kTcu3dPrF+/Xri5uQlra2tt84MQQjRt2lRUrlxZ5xepWq0WderUEaVLl9aWjR07VgAQGzduTHV/mrba5cuXCzMzM3HgwAGd2+fOnSsA6FRzpqwREkKIESNGCEtLS/H8+XNtWVxcnHBxcdGppenRo4fw9PQUT58+1bmP9u3bC2dnZ21tjebXSsmSJTPV/NG6dWsBIN0aIyGE2Lhxo84vEc2vPltbW502/aNHjwoAYvDgwdqyzD7PmteuXr16qfptpPU4NDVZy5Yt05Zl1DSWXo1Q+fLldfpGzJ49WwDQ1mzFxcWJggULiho1auj0T1m6dKkA8NYaocGDBwsAme4noqkNeLOG7pNPPhEFCxbUKUvreQkICBAlS5bUKStevLgAILZv355q/8yc4+XLl8LR0VHUqlUrVTNVyv4K6TUl6PP+ACDMzMzExYsXU50Hb9QCODs7i379+qXaL6X0YkqrRqhBgwbC0dFR3LlzJ93HmBbNucaPHy+ePHkiwsLCxN69e8W7774rAIgNGzYItVotSpcuLQICAnTO9/r1a1GiRAmdWiN9/gfS8rYaodOnT6d6n775/pg+fboAIDZv3qwti4mJEeXKlcuwRkgI/ZvGFi5cqPOe0zhz5owAIPr27atT3rFjx1Tn1/fz0cvLS0RGRmr3W7t2rQAgZs+erS17W9PY2z47hEh+Ld92yUzzrb+/v3Byckrzs/r3338XAMTRo0ffep7chqPGjMTf3x9ubm7w9vZGmzZtYG9vjy1btmh/vT9//hy7d+9Gu3bt8OrVKzx9+hRPnz7Fs2fPEBAQgOvXr2tHmW3YsAFVq1ZNVXMByCGcALBu3TqUL18e5cqV057r6dOnaNKkCQBk+CsqMDAQCQkJ2Lhxo7bs33//xcuXLxEYGAgAEEJgw4YNaNWqFYQQOvcREBCAiIgInDp1Sue8QUFBsLW1fetz9erVKwCAo6NjuvtobouMjNQpb926Nby8vLTbNWvWRK1atbBt2zYA+j3PGj179oS5ublOWcrHkZCQgGfPnuGdd96Bi4tLqsetr27duunUltWvXx8AcOvWLQDAiRMn8OzZM/Ts2RMWFsmVuJ06dXrrLzgg+TnL6PlNS+/evXW269evj2fPnum8Bimfl4iICDx9+hQNGzbErVu3EBERoXN8iRIltLWLKWXmHDt27MCrV68wfPhw2NjY6ByveQ9kRN/3R8OGDVGhQoW3ntfFxQVHjx7Fw4cP37rv2zx58gT79+9H9+7dUaxYMZ3bMvMYASA4OBhubm7w8PBAo0aNcPPmTUydOhWffvopzpw5g+vXr6Njx4549uyZ9jmIjo5G06ZNsX///lSjuTLzP5AVmpoNzXs/Ldu3b4eXlxc++ugjbZmNjQ169uyZrftOy7NnzwAg1ftJ8zkycOBAnfI3a3ey8vnYpUsXnfdkmzZt4Onpqb3PzHjbZ4fmfnbs2PHWy8qVKzO8r8mTJ2Pnzp2YMmUKXFxcUt2uee7y4rQbbBozkjlz5qBMmTKIiIjA4sWLsX//flhbW2tvv3HjBoQQGDNmDMaMGZPmOR4/fgwvLy/cvHkTn332WYb3d/36dVy+fBlubm7pnis9VatWRbly5bBmzRr06NEDgGwWK1SokPaL4smTJ3j58iXmz5+P+fPnZ+o+SpQokWHMGpoPg1evXqX5BtPclnJfjdKlS6fat0yZMli7di0A/Z7njOKOiYlBSEgIlixZggcPHugM53/zC19fb37paT5QXrx4AQC4c+cOAOCdd97R2c/CwiJTc6doqqkz+tLRNy7NOQ8dOoTg4GAcOXIkVfV7REQEnJ2dtdvp/T9k5hyaJp5KlSrp9Rg09H1/ZPZ/9/vvv0dQUBC8vb3h5+eHDz74AF26dEHJkiX1jlHz5ZXVxwgAvXr1Qtu2bWFmZgYXFxdUrFhR+7lz/fp1AEjVBJ5SRESETjKQmf+BrNDM05NRcn7nzh2UKlUqVRL45vvAkFK+rzUxmJmZoVSpUjrlmmZdjax8Pr752aVSqfDOO+/oNfXG2z47AKBkyZJZ+n9Mac2aNRg9ejR69OiBPn36pLmP5rnLbNKemzARMpKaNWuievXqAGStRb169dCxY0dcvXoVDg4O2l9eQ4cOTfNXMqDfG16tVqNy5cqYMWNGmrd7e3tneHxgYCAmTZqEp0+fwtHREVu2bEGHDh20NRCaeD///PN0P0jfbIPPTG0QIPvQbN68GefOnUODBg3S3OfcuXMAkKlf6Sll5XlOK+4BAwZgyZIlGDRoEGrXrg1nZ2eoVCq0b98+23OivFn7pPHmh3JWlStXDgBw/vx5+Pr6Zvq4t8V18+ZNNG3aFOXKlcOMGTPg7e0NKysrbNu2DTNnzkz1vKT1vOp7jqzS9/2R2f/ddu3aoX79+ti0aRP+/fdfTJs2DVOnTsXGjRvRokWLbMetr9KlS+v0oUtJ81xOmzYt3f+DN/ugGOt/UzP5njGTGn1o+lC9ePHirX3u0pKVz0dDyMzrExUVlakJIs3NzdP8obBjxw506dIFLVu2xNy5c9M9XpN8pdV/KLdjIpQDzM3NERISgsaNG+Pnn3/G8OHDtRm6paVluh9cGqVKlXrrrJ2lSpXC2bNn0bRp0yxl5IGBgRg/fjw2bNiAwoULIzIyEu3bt9fe7ubmBkdHRyQlJb01Xn19+OGHCAkJwbJly9JMhJKSkvD777/D1dUVdevW1blN8ys3pWvXrmlrSvR5njOyfv16BAUFYfr06dqy2NhYvHz5Umc/Y/waKl68OABZu9W4cWNteWJiIkJDQ9/6AduiRQuYm5tjxYoVeneYzsiff/6JuLg4bNmyReeX6ds6s2blHJpf5BcuXMjwyzO95z+774+MeHp6om/fvujbty8eP36MatWqYdKkSdpEKLP3p/lfNdYMvZrn0MnJyeDvYX0tX74cKpUK77//frr7FC9eHJcuXYIQQuc5vHHjxlvPr+9rrPmxcPv2bVSuXFknBrVajZs3b+rUAl29elXn+Kx8Pr752SWEwI0bN3Tez4b4X/3hhx8wfvz4t+5XvHjxVLVRR48exSeffILq1atj7dq1Ok3zb7p9+zbMzMzS7fyem7GPUA5p1KgRatasiVmzZiE2Nhbu7u5o1KgR5s2bh0ePHqXa/8mTJ9rrn332Gc6ePYtNmzal2k+T+bdr1w4PHjzAggULUu0TExOjHf2UnvLly6Ny5cpYs2YN1qxZA09PT52kxNzcHJ999hk2bNiQ5gd1ynj1VadOHfj7+2PJkiX466+/Ut0+atQoXLt2Dd98802qX+qbN2/W6eNz7NgxHD16VPslpM/znBFzc/NUv4J/+uknJCUl6ZTZ29sDQKoEKTuqV6+OggULYsGCBUhMTNSWr1y5UqcKPD3e3t7o2bMn/v33X/z000+pbler1Zg+fTru37+vV1yaX6NvNhMuWbLE4Odo1qwZHB0dERISkmpm25TH2tvbp9lUmd33R1qSkpJS3Ze7uzuKFCmCuLi4t8b0Jjc3NzRo0ACLFy/G3bt3dW4zRO2gn58fSpUqhR9++CHNGoLsvIf1MWXKFPz7778IDAxMs2lbIyAgAA8ePMCWLVu0ZbGxsWm+hm+ys7MDkPn3oZ+fH6ysrFLNsK75HPnxxx91yt+c7Tkrn4+aEa8a69evx6NHj3RqEjP7v5ORrPYRunz5Mlq2bAkfHx/89ddfb60lPXnyJCpWrKjTHJ5XsEYoBw0bNgxt27bF0qVL0bt3b8yZMwf16tVD5cqV0bNnT5QsWRLh4eE4cuQI7t+/j7Nnz2qPW79+Pdq2bYvu3bvDz88Pz58/x5YtWzB37lxUrVoVnTt3xtq1a9G7d2/s2bMHdevWRVJSEq5cuYK1a9fin3/+0TbVpScwMBBjx46FjY0NevToATMz3Tx5ypQp2LNnD2rVqoWePXuiQoUKeP78OU6dOoWdO3fi+fPnWX5uli1bhqZNm+Ljjz9Gx44dUb9+fcTFxWHjxo3Yu3cvAgMDMWzYsFTHvfPOO6hXrx769OmDuLg4zJo1CwULFsQ333yj3Sezz3NGPvzwQyxfvhzOzs6oUKECjhw5gp07d2qr1DV8fX1hbm6OqVOnIiIiAtbW1mjSpAnc3d2z/NxYWVlh3LhxGDBgAJo0aYJ27dohNDQUS5cuTbMPRVqmT5+OmzdvYuDAgdi4cSM+/PBDuLq64u7du1i3bh2uXLmiUwOYGc2aNYOVlRVatWqFL7/8ElFRUViwYAHc3d3TTDqzcw4nJyfMnDkTX3zxBWrUqIGOHTvC1dUVZ8+exevXr/Hbb78BkF9oa9aswZAhQ1CjRg04ODigVatWBnl/vOnVq1coWrQo2rRpg6pVq8LBwQE7d+7E8ePHdWoO04spLT/++CPq1auHatWqoVevXihRogRCQ0OxdevWbC+VYWZmhoULF6JFixaoWLEiunXrBi8vLzx48AB79uyBk5OTdioLQ0hMTMSKFSsAyATmzp072LJlC86dO4fGjRun25dG48svv8TPP/+MDh064KuvvoKnpydWrlyp7Syf0f+9ra0tKlSogDVr1qBMmTIoUKAAKlWqlG7/KxsbGzRr1gw7d+7Ed999py339fVFhw4d8MsvvyAiIgJ16tTBrl270qyV0vfzsUCBAqhXrx66deuG8PBwzJo1C++8845OZ3B9/nfSk5U+Qq9evUJAQABevHiBYcOGYevWrTq3lypVCrVr19ZuJyQkYN++fejbt69e95Nr5OgYNROQ3oSKQsgZakuVKiVKlSqlHZ598+ZN0aVLF+Hh4SEsLS2Fl5eX+PDDD8X69et1jn327Jno37+/8PLy0k4GFxQUpDNUMz4+XkydOlVUrFhRWFtbC1dXV+Hn5yfGjx+vM539m8PnNa5fv64dSvnmBGsa4eHhol+/fsLb21tYWloKDw8P0bRpUzF//nztPlmd9fTVq1di3LhxomLFisLW1lY4OjqKunXriqVLl6YaPpxyArnp06cLb29vYW1tLerXry/Onj2b6tyZeZ4zeu1evHghunXrpp1ULSAgQFy5ciXN53LBggWiZMmSwtzcPFMTKr75PKU30d6PP/4oihcvLqytrUXNmjXFoUOHhJ+fn2jevHkmnl05g/TChQtF/fr1hbOzs7C0tBTFixcX3bp10xlan97M0prnJ+Ukklu2bBFVqlQRNjY2wsfHR0ydOlUsXrw41X6aCRXTktlzaPatU6eOsLW1FU5OTqJmzZpi1apV2tujoqJEx44dhYuLS6ohwZl9f+D/EyqmBSmGTMfFxYlhw4aJqlWrCkdHR2Fvby+qVq2aajLI9GJK73W+cOGC+OSTT4SLi4uwsbERZcuWfeuMvelNqJiW06dPi08//VQULFhQWFtbi+LFi4t27dqJXbt2affR538gLUFBQTpDs+3s7ISPj4/47LPPxPr169OcZT6tCRVv3bolWrZsKWxtbYWbm5v4+uuvxYYNGwQA8d9//+nc35vDvw8fPiz8/PyElZVVpobSb9y4UahUKp1JDYWQQ/YHDhwoChYsKOzt7TOcUFGfz8dVq1aJESNGCHd3d2FraytatmyZatqE9P539P3s0Fd6k1JqLm9+5v39998C/5+AMy9SCZFHVrMkSiE0NBQlSpTAtGnTMHToUKXDUYRarYabmxs+/fTTTDUXEOUHs2bNwuDBg3H//n2d0Z7ZlZSUhAoVKqBdu3aYMGGCwc77pr1796Jx48ZYt24d2rRpY7T7yUmtW7eGSqVKs/tGXsA+QkR5QGxsbKp+IsuWLcPz58/RqFEjZYIiMrKYmBid7djYWMybNw+lS5c2aBIEyH4+3333HebMmZOpUVYkXb58GX/99ZdRk0djYx8hojzgv//+w+DBg9G2bVsULFgQp06dwqJFi1CpUiW0bdtW6fCIjOLTTz9FsWLF4Ovri4iICKxYsQJXrlx56+R/WRUYGKidRJYyp3z58jqDOPIiJkJEeYCPjw+8vb3x448/4vnz5yhQoAC6dOmCKVOmpLuGG1FeFxAQgIULF2LlypXapqvVq1czWSGDUrSP0P79+zFt2jScPHkSjx49wqZNm9C6desMj9m7dy+GDBmCixcvwtvbG6NHj0bXrl1zJF4iIiLKXxTtIxQdHY2qVatizpw5mdr/9u3baNmyJRo3bowzZ85g0KBB+OKLL/DPP/8YOVIiIiLKj3LNqDFNj/OMaoS+/fZbbN26VWfCqvbt2+Ply5fYvn17DkRJRERE+Ume6iN05MiRVNOXBwQEpFoJOKW4uDidWV7VajWeP3+OggUL5snF4YiIiEyREAKvXr1CkSJFUk34mx15KhEKCwtD4cKFdco062LFxMSkOQV4SEhIptZZISIiotzv3r17WVocNz15KhHKihEjRmDIkCHa7YiICBQrVgz37t2Dk5OTgpEREVFOS0wEYmKA+Hh5iY4GEhKA2Fjg+XMgKUnuEx8PxMUBd+8Crq5yn7g44MwZoFgxeXtCAnDiBFCkCHDlCqBSAS4u8rbz52V5YqLcLxPLApokCwv5HAFA0aKAlRVw6xZQqxbgYhWNo+ft0bw5YGMDREREYtMmbzg6Oho2BoOezcg8PDwQHh6uUxYeHg4nJ6d0F4SztraGtbV1qnInJycmQkREOUStBqKigNevk5OIuDhAs+6oJmFISABevgSEkImFpjwxUSYqkZGAZhk6K6vkhGXnTqBaNWDrVuDdd+Ux8fHAtWtyX2dnIJvrl6YrvWXgHj40zv1llY2NTPjc3ABHR/n8XbkCVKggkz1LS3mJjQVu3wbq1pWJiqUl8PSpPKZkSbkdHQ1YWwOennJbs9/r18nnNzcH7OzkxcpKXmxtAScned3cXL7Gadq8GejZE9iyEahfH4B87TdtyniduazIU4lQ7dq1sW3bNp2yHTt26Cz+RkRE2adWyy+e16+TE5GEBODmTVn26hVw+TJQqJD84jx8WNaU7NsHlCkjE5JixWSNirW1TFaMTbM26OnTqW8zVhKUFktL+Zg1E1S/84784re0BM6eBfz9Zc3TvXtAnTrJCYjmeS1XTiYW5ubyr4WFTOpiYuRzqinTXF6/Bry95X1aWcnkwslJJj7W1vKvs7M8X64XFwd88w3w449yu0MHmWkWKmS0u1Q0EYqKitJZxff27ds4c+YMChQogGLFimHEiBF48OABli1bBgDo3bs3fv75Z3zzzTfo3r07du/ejbVr16ZaGZeIKL9JTJRfeFFRybUd8fHyi1OI5NqU27fll2FsrKwNsbMD7tyRX6KOjvKYx4+BixflF+6uXTJxiY8HQkPlL3ZN0pNV16/Lv3fvyr85kQSlJWUtx4MHgK+vTAbOnAGaN09OTi5cABo3lgnDvXtA2bLJtRaWlrJZq0SJ5EQjMREoXDi5lsPSUt6Xvb28cBxOFt28CQQGAidPJpfVri2fYCNSNBE6ceIEGjdurN3W9OUJCgrC0qVL8ejRI9zVvJMAlChRAlu3bsXgwYMxe/ZsFC1aFAsXLkRAQECOx05EJIT8kn/+PDkxiYiQZTExwP37MrHQ3PboEfDsmfyyPHZMfpmq1cCffwI1ash9Dh2Sv+4Bue/r17r9KAzpwQP5V9N8BMi4Dc3cXPadqVRJfse1aJGcREREyMddtmxy84qFhXyuvL1l8qap+bC0lPsWKAA4OADu7snJiabZxdlZljEZyWPWrQO++EJWQwLyRZw5E+jd2+gvZq6ZRyinREZGwtnZGREREewjRGRChJB9TyIiZG1JVJTcVqvlL/6XL+WXbUSE/GF65Yrs4+HpKWtHDh4EiheX57l7V34257dPT01Tlp0dUKWKTIoeP5ZdNDSJiJmZfF6aNUtuFvP2lkmIhQXg4SGTFCcnWcaEhDIUGwsMGQL8+mtyWenSwNq1sgovBWN9f+epPkJEZBqEkInKgweyRkTTOTYuTtZeODrK63FxsoahZEl5/dkzOVrnzh3ZAfTixeQfmFl15Ury9Tt3dGM0hpQJlo+P/GF89ar8TihYUPbLqVxZdkjVNMtcvJjcgmBpCTx5ImuYrK1lEle0aHLzTcoaFAcHWTtlwClZiDLv+nWgXTvd3uYdOwJz58o3eQ5hIkREBiGETESePpX9VjRDjy0sZFJz/bocaaKphTlxAvDyAnbvBqpWlbfduJE8Eii7jhzJ/jlSMjOTcQOyv8jz5zLmOnVk3GXKyJoRS0v5WOvVk0nGo0dAxYqyPGX/Ek3/lQIFZA2Mg0NyrQqRSYiPl1k+IDto/fQT0KNHjlcj8i1HZOI0HW3j4pI748bEyI6z16/LL+bYWPmjLTRUfnEnJACaJf4cHZOHQOtL8xl49mxymSGSoJRcXGTyVaWKrE0pUED2UbGxkTUnhQvLGpPoaJmcuLvLBMXWVjYVeXvLZh5LSzbzEBlUxYrAzz8D06bJprDKlRUJg32EiPIBIWRNzMuXsk/HhQvycvKk/CKPj5dNRLt3AzVryo669vbyyz83cXeX8RctKpuFTp+WNeVxcbLDbdmysmnn5UvZ9KVp5klKkv1VrK3lxdVVbht5sAkR6eP6dfnrIuXcfpoRBzY2bz2cfYSITEhSkuzAe+cO8N9/ssnpyBHZL+TgQdkM899/mZsb5c0momPH5F9DJkGFC8uOxFeuyEnYnjwB3ntPJltPnwJ+fsnzm3h6ysdhZyf7vHCUD5EJWLYM6NNHjgybPTu5XKXKVBJkTEyEiIxMCNm09PQpEB4ukwVN7czjx7Kviea2zI5Eun07+3Fp+uKULSubqPz9ZUJy8aLs9+LqKuMsV07uY2Mjj/H2liODbG2TkxsiojRFRwP9+wNLl8rtH3+Ukzi1aKFoWCkxESLSk2YUU3S0rPlISpJlly/LPjQREcDGjbJvypMn+p07Ow3VZcrI/jpFisgmJmdnOey5TBmZ1GhGCnGUEBHliAsX5Kiwy5eTy774AmjYULmY0sBEiExafLxsgnr0SHYSfvRI9j+5fl0Ow/b2lrU1hw/L/fTpyKtvEgTITrmRkbJZ6coVoHp1mcR4egJNmsh+L15eMuFxdGQHXiLKhYQAFi+WNUGxsbLMwQGYN092+stlmAhRvqNZw+f8ebmK8f37MrmxsZHDuY8dA8LCcj4uf395v6VLy9qi99+Xic+778qRTAo3kxMRZd+rV7Iv0MqVyWVVq8pRYWXKKBdXBpgIUZ4SEyPnbDlxQg65vntX1tQcPGicJQjS4+4uE5rq1WVzWPXqsvOvSiX70/j4yJFPHJhIRCbj3j35iy/lmi29e8ulMnLxLz0mQpRrvHolk4qbN+X76OJF2YH49GnZqdhY7OyADz+UywY0bizjKFVKNkdpRjjZ2iZPfEdERGnw8JDt95rp3xculH2EcjkmQpRjEhPlcPCLF4Hjx+WEfHfuGCfJUamAatVkTU358nLqCk9P2VHYykp2KM7BGdyJiPI/S0tg9WrZIfqXX+QvyjyAiRAZRFycXBdKs1hlYiLw119ysIBmnShDcXaW6yr5+srJAUuVkp2anZ05GoqIKMecPClnOk25OKq3d/K083kEEyHSW2ys7KezcKEcGJDV5RXS4u0NvPOO7EBctqxMcry8ZH8bBwfD3Q8REWWREHJpjKFD5Yf2qVN5ukMkEyFKRQg59PvKFXm5fBnYswc4dy5789zY2Mg1qurVAypVksvK1Koll0qwsjJc/EREZCQvXsiFUTdtkts3b8q1wiZMUDaubGAiZOLUamD7duDAAWDvXrlsQ1Z5eckfB2XLylqdihVln5zGjbnmExFRnnfsGBAYKEe1aAwZAowZo1hIhsBEyMSo1TKBX7Mme/+7VlayZqd6dfk+KFzYcDESEVEuIoQcAv/tt8nzlLi6Ar/9BrRqpWxsBsBEyAQkJABTp+qf+BQvLpOdokVlwuPnJ0dfmZsbJ04iIsplnj0DunaVo1806tQBVq2SXwj5ABOhfCgiQi7uu2SJbg1mRho2BAYNkslOkSJMdoiITF5cnOzIefNmctm338r+QPmovwMToXzg/n1g8mTg118zf4yvr0x+BgzIM1M9EBFRTrK2luuFDR4sJ0pcvlyuHJ/PMBHKg5KSgEWLgC+/1O+4Nm3kcXl4lCMREeWkr76SizX27ClHxORDTITyiGPHgD//BCZOzNz+7u7ABx8Aw4fLde64QjkREWVo/365kOOQIcllKhUwbpxiIeUEJkK5WGys7KR88WLm9p86FejWTa6NRURElClJSUBICBAcLEeIVa4MvP++0lHlGC5IkMsIAYwfL5NwW9uMk6AqVYBLl+QxQgDffMMkiIiI9BAeLvv9jBkj51cRQvahMCFMhHKBJ0+AESNk8mNmlnEt5LRpsgO/EMDZs3JBUSIiIr3t3g1UrQrs3Cm3zczkL/GVK5WNK4exaUxhTZvK/8WMvP++nP2ZC4oSEVG2JSUB330nh8Fr1k3y9AR+/x1o1EjR0JTAREghanXGc/U4Ock5gFxdcywkIiLK7x4+BDp1kmsqaTRrJofGu7srFpaSWMeggN69006Cvv8euHtXJugREUyCiIjIwLp3T06CzM3lJHR//22ySRDAGqEcIwTQty8wd27at588CVSrlrMxERGRifnpJ/ll4+wMrF4t11EycUyEcsCPP8o5qdLi7Q1cuMBJDomIyAiE0J1IrnRpOSldpUpytmhiImRsGU1kGBMD2NjkXCxERGRCtm2TQ423bgXs7JLLTbBDdEbYR8hIoqLST4JevZJJOpMgIiIyuIQEObFcy5ayP1B6TRIEgImQUezbBzg6pi5/+FAmQA4OOR8TERGZgDt3gAYNZE2QxpMnQHy8cjHlcmwaM7D0aoESEgALPttERGQsf/wh11l68UJuW1rKhGjgQC44mQHWCBnIoEFp/585O8taICZBRERkFPHx8kuodevkJKhECeDQIdksxiQoQ/x6NoD0/seOH5eLphIRERnFrVtAYKBcNV7js8+AhQsBFxfFwspLWCOUDRERaSdBlSrJmaOZBBERkVGtXZucBFlZAXPmAOvWMQnSA2uEsujkybQTneho3VGKRERERjNsmFw09c4dmRS9+67SEeU5TISyICQEGDkydXliYsbrhxEREWXLq1e6w5LNzYFVqwBra87Mm0VsGtPTkSOpkyArK9khmkkQEREZzerVQPHiwOHDuuVubkyCsoGJkB6OHQPq1NEtW78eiItTJh4iIjIBMTHAl18CHTrIUWHt2wPPnikdVb7BprFMiooCatXSLRszRnbOJyIiMoorV4B27YDz55PLGjWSTWFkEKwRyqQ3Z4oeNw747jtFQiEiIlOwfLkclaNJgmxtgcWLgd9+4xIFBsQaoUyIjdXddnYGgoOViYWIiPK56GhgwABgyZLksgoV5LD4ChWUiyufYo1QJtja6m6/fKlIGERElN9dugTUrKmbBHXvLmfoZRJkFKwReovwcN3tN5MiIiIig0lKkrNFA4C9PTB3LvD558rGlM+xRugtPDx0t1+/ViYOIiIyAZUrAz/+CFSpImfuZRJkdEyEMrB7t+72oEGKhEFERPnVpUty0dSUvvhCztdStqwyMZkYJkLpWL8eaNpUt2zmTGViISKifEYIYN48oFo1YMQI3dtUKg6Pz0FMhNLRtq3u9l9/KRMHERHlM5GRclLE3r3ljLwzZsj1wkgR7CydhoQE3e3du4HGjZWJhYiI8pFTp+QEiTdvJpcNGADUr69cTCaONUJpKFBAd5tJEBERZYsQwM8/A7VrJydBzs7Ahg2yczSbwhTDGqE3PHokl9PQqFxZuViIiCgfePkS6NED2LgxuaxGDWDNGqBECcXCIok1Qm8oUkR3+8QJZeIgIqJ84PZt2SE6ZRI0eDBw8CCToFyCiVAKERG62xMnAlZWysRCRET5QNGiQOHC8rqrK/DHH7JzNL9ccg0mQim4uOhujxqlSBhERJRfWFoCq1cDH3wAnD4NfPSR0hHRG9hH6P/enDG6WTNl4iAiojzs8GG5NEbVqsllxYsDW7cqFxNliDVC//dm4rN9uzJxEBFRHqRWA99/DzRoICeie/VK6Ygok5gI/d+hQ8nXmzSRE3sSERG91ZMnwIcfAt9+KxdNvX4dmD1b6agok9g0BuCff3S3t2xRJg4iIspjDhyQs0Q/fCi3VSrZwXT4cGXjokxjIgSgZUvdbXt7ZeIgIqI8Qq0GQkKAsWPldQBwdwdWrADef1/Z2EgvTIQAeHkBd+/K6/PnKxsLERHlcuHhQOfOwI4dyWWNGwMrVwKensrFRVnCRAjJSRAABAYqFwcREeVyMTFAzZrJXxxmZkBwsGwOMzdXNjbKEsU7S8+ZMwc+Pj6wsbFBrVq1cOzYsQz3nzVrFsqWLQtbW1t4e3tj8ODBiI2NzfL9x8frbjs6ZvlURESU39naAgMHyuseHsCuXbJ5jElQnqVojdCaNWswZMgQzJ07F7Vq1cKsWbMQEBCAq1evwt3dPdX+v//+O4YPH47FixejTp06uHbtGrp27QqVSoUZM2ZkKYbQUN1tjhYjIqIMDR4MREcDvXvLfkGUpylaIzRjxgz07NkT3bp1Q4UKFTB37lzY2dlh8eLFae5/+PBh1K1bFx07doSPjw+aNWuGDh06vLUWKbM44ScREenYsQOYOVO3zMxM1gIxCcoXFEuE4uPjcfLkSfj7+ycHY2YGf39/HDlyJM1j6tSpg5MnT2oTn1u3bmHbtm344IMP0r2fuLg4REZG6lxSun07+TpHixEREQAgMVH2+wkIAL7+Gti9W+mIyEgUaxp7+vQpkpKSUFizGN3/FS5cGFeuXEnzmI4dO+Lp06eoV68ehBBITExE7969MXLkyHTvJyQkBOPHj0/39m3bkq9rpoEgIiITdv8+0LGjnCNIY8UKOdsu5TuKd5bWx969ezF58mT88ssvOHXqFDZu3IitW7diwoQJ6R4zYsQIREREaC/37t3Tuf2XX5KvV6xorMiJiChP2LYN8PVNToLMzeXSGQsXKhoWGY9iNUKFChWCubk5wsPDdcrDw8Ph4eGR5jFjxoxB586d8cUXXwAAKleujOjoaPTq1QujRo2CmVnqvM7a2hrW1tbpxuHgALx8Ka/36JG1x0JERHlcQoJsCps2LbmsWDG5cnzt2srFRUanWI2QlZUV/Pz8sGvXLm2ZWq3Grl27UDudf7rXr1+nSnbM/z9kUQiRpTg0SRAAlCmTpVMQEVFedueOXCw1ZRL00UfA6dNMgkyAosPnhwwZgqCgIFSvXh01a9bErFmzEB0djW7dugEAunTpAi8vL4SEhAAAWrVqhRkzZuDdd99FrVq1cOPGDYwZMwatWrXSJkTZ4eCQ7VMQEVFe07Ur8N9/8rqlpWwK++orzqdiIhRNhAIDA/HkyROMHTsWYWFh8PX1xfbt27UdqO/evatTAzR69GioVCqMHj0aDx48gJubG1q1aoVJkyZl6f4TEgzyMIiIKC+bOxfw85PD4desAWrUUDoiykEqkdU2pTwqMjISzs7OiIiIQHi4k05zmGk9E0REJkqI1LU9e/fKTtIuLgoERJmR8vvbycnJYOfNU6PGDG3nzuTrjRsrFwcREeWQDRuARo3kmmEpNWrEJMhEmXQitGdP8nU7O+XiICIiI4uNBfr3B9q0AfbvB4YMUToiyiVMevX5lCtz9OypXBxERGREN24A7drJUWAaL1/K2aMtTPprkGDiNUKvXydfr1VLuTiIiMhIVq8GqlVLToKsrYF584Dff2cSRABMvEboxYvk62waIyLKR2JigEGDgPnzk8vKlgXWrgWqVFEsLMp9TDoRUquTrxuwAzoRESnpyhXZFHb+fHLZ558Dv/7KCeMoFZNtGouLS06EnJ2VjYWIiAxo3brkJMjWFli8GFi2jEkQpclka4T++CP5ekSEcnEQEZGBjRwJ7N4NPH4sm8K4ojZlwGQToSdPkq9Xr65cHERElE0REbpV++bmMgGyswPs7ZWLi/IEk20as7RMvv7/xeyJiCgvEQJYsgQoXhw4elT3Njc3JkGUKSabCH3zTfJ1vleIiPKYqCggKAjo3l3WCAUG6g4FJsokk20aS7muGBcYJiLKQ86dk6PCrl5NLgsIAGxslIuJ8iyTrRFKsag9OnRQLg4iIsokIeS8QDVrJidBDg7AqlVykkRbW2XjozzJZGuENEPnK1fWTYqIiCgXiowEvvxSzhSt8e67wJo1QOnSysVFeZ7JpwB37igdARERZejsWcDPTzcJ6tcPOHyYSRBlm8nWCGnExSkdARERZUgI4N49ed3ZGVi0CPjsM2VjonzD5GuEhg1TOgIiIsqQry8wcyZQowZw6hSTIDIok0+EwsKUjoCIiHScOwckJOiW9e4NHDoElCypTEyUb5l8IsRZpYmIcgkhgFmz5AfzqFG6t6lUujPhEhmIySdChQopHQEREeH5c6B1a2DwYFkbNG0asG+f0lGRCTD5ztKffqp0BEREJu7IEaB9e+Du3eSyYcOAOnWUi4lMhsnXCHFWaSIihajVsuanQYPkJKhgQeCvv4Dvv2dTGOUIk64RKlFC6QiIiEzU06dyrbBt25LL6tWTs0QXLapcXGRyTLpGyNVV6QiIiEzQtWtySLwmCVKpgJEjgT17mARRjjPpGiEiIlKAjw9QpAjw4AHg5gasWAE0a6Z0VGSiTLpG6Px5pSMgIjJBVlZyjbDWreXyGUyCSEEmXSPk4KB0BEREJmDvXtkJunLl5LISJYBNmxQLiUjDpGuEOndWOgIionwsKQkYPx5o2hRo2xaIilI6IqJUTDoRcnRUOgIionzq0SPZ5DVunBwmf/Uq8OuvSkdFlIpJJ0JERGQEO3bIUWG7d8ttMzNg4kRgyBBFwyJKi0n3EeKCq0REBpSYKGuAJk+W64YBcnTYqlVy0kSiXMikE6Fq1ZSOgIgon3jwAOjQAThwILmseXNg2TI5RJ4olzLpRMjOTukIiIjygagouWK8pprd3FzWCg0dKpvFiHIxk/4P1dTcEhFRNjg4AIMGyeve3sD+/cA33zAJojzBpGuEzM2VjoCIKJ8YNkz2EerTByhQQOloiDLNpNP1kiWVjoCIKA/6809g5kzdMjMzYNQoJkGU55h0jRAREekhPh4YMQKYMUMmPtWqAQ0bKh0VUbaYdI0QERFl0u3bQP36MgkC5CSJa9YoGxORAZh0IuTsrHQERER5wMaNwLvvAseOyW0rK+Cnn4A5c5SNi8gATLppjFNbEBFlIC5ODoH/+efkslKlZE2Qn59ycREZkEknQkRElI4bN4DAQODUqeSydu2A+fNZnU75ikk3jRERURqEALp2TU6CrK2BuXOB1auZBFG+w0SIiIh0qVTAggVy+v0yZYCjR4Evv5TlRPlMtprGYmNjYWNjY6hYiIhIKULoJjrlywN//y07STs6KhcXkZHpXSOkVqsxYcIEeHl5wcHBAbdu3QIAjBkzBosWLTJ4gEREZGQrV8r5gGJjdcsbNGASRPme3onQxIkTsXTpUnz//fewsrLSlleqVAkLFy40aHBERGREr18DX3wBfP65XDV+6FClIyLKcXonQsuWLcP8+fPRqVMnmKdYrKtq1aq4cuWKQYMjIiIjuXQJqFkTSFmT//q1nCiRyITonQg9ePAA77zzTqpytVqNhIQEgwRFRERGtHQpUKMGcPGi3LazA5YtAxYv5orxZHL0/o+vUKECDhw4kKp8/fr1ePfddw0SFBERGUFUFBAUBHTrJmt/AKByZeDkSaBzZ2VjI1KI3qPGxo4di6CgIDx48ABqtRobN27E1atXsWzZMvz111/GiJGIiLLr/Hk5IWLKLgw9ewKzZwO2tsrFRaQwvWuEPv74Y/z555/YuXMn7O3tMXbsWFy+fBl//vkn3n//fWPESERE2bV+fXIS5OAA/P67nCWaSRCZOJUQQigdRE6KjIyEs7MzgAg8euQEDw+lIyIiygGJiUCTJsCrV8DatUDp0kpHRKQXzfd3REQEnJycDHZevWuESpYsiWfPnqUqf/nyJUqWLGmQoIiIKJtevNDdtrAANmwAjhxhEkSUgt6JUGhoKJKSklKVx8XF4cGDBwYJioiIskgI4JdfgOLFgRMndG9zcwO4GgCRjkx3lt6yZYv2+j///PP/5iUpKSkJu3btgo+Pj0GDIyIiPUREyAkS16+X2+3aAadPc6FUogxkOhFq3bo1AEClUiEoKEjnNktLS/j4+GD69OkGDY6IiDLpxAmZ+Ny+nVz28cesASJ6i0wnQur/zzZaokQJHD9+HIUKFTJaUERElElCAD/+CAwbBmgmtXVxkZMmfvyxkpER5Ql6zyN0O+WvjTzO0lLpCIiIsuHFC6B7d2Dz5uSy994DVq+WfYSI6K30ToQAIDo6Gvv27cPdu3cRHx+vc9vAgQMNElhOKFhQ6QiIiLLo+HGgbVvgzp3ksqFDgcmT+SuPSA96J0KnT5/GBx98gNevXyM6OhoFChTA06dPYWdnB3d39zyTCNnbKx0BEVE2mJsDjx7J6wUKyLXCWrZUNiaiPEjv4fODBw9Gq1at8OLFC9ja2uK///7DnTt34Ofnhx9++MEYMRIR0ZuqVQOmTwfq1gXOnGESRJRFes8s7eLigqNHj6Js2bJwcXHBkSNHUL58eRw9ehRBQUG4knIdm1xIMzOlvX0EoqIMNzMlEZFRnTwJVK0qJ0bUEAJIStItI8qncs3M0paWljAzk4e5u7vj7t27AABnZ2fcu3fPYIEREREAtRoICQFq1QLGjtW9TaViEkSUTXonQu+++y6OHz8OAGjYsCHGjh2LlStXYtCgQahUqZLeAcyZMwc+Pj6wsbFBrVq1cOzYsQz3f/nyJfr16wdPT09YW1ujTJky2LZtm973S0SU6z1+DLRoAYwcKWt+QkKAw4eVjoooX9E7EZo8eTI8PT0BAJMmTYKrqyv69OmDJ0+eYN68eXqda82aNRgyZAiCg4Nx6tQpVK1aFQEBAXj8+HGa+8fHx+P9999HaGgo1q9fj6tXr2LBggXw8vLS92EQEeVue/cCvr7Av//KbZVK1gjVqqVkVET5jqKrz9eqVQs1atTAzz//DEBO2ujt7Y0BAwZg+PDhqfafO3cupk2bhitXrsAyi8ND2UeIiHK1pCRg0iRg/HjZLAYAhQsDv/8uV48nMlG5po9Qek6dOoUPP/ww0/vHx8fj5MmT8Pf3Tw7GzAz+/v44cuRImsds2bIFtWvXRr9+/VC4cGFUqlQJkydPTnMRWI24uDhERkbqXIiIcqWwMKBZMyA4ODkJ8vcHzp5lEkRkJHolQv/88w+GDh2KkSNH4tatWwCAK1euoHXr1qhRo4Z2GY7MePr0KZKSklC4cGGd8sKFCyMsLCzNY27duoX169cjKSkJ27Ztw5gxYzB9+nRMnDgx3fsJCQmBs7Oz9uLt7Z3pGImIcsylS7IpbPduuW1mBkyYAGzfLmuEiMgoMp0ILVq0CC1atMDSpUsxdepUvPfee1ixYgVq164NDw8PXLhwweidltVqNdzd3TF//nz4+fkhMDAQo0aNwty5c9M9ZsSIEYiIiNBeOLKNiHKlUqWAokXl9SJFZEI0erScOJGIjCbTidDs2bMxdepUPH36FGvXrsXTp0/xyy+/4Pz585g7dy7Kly+v1x0XKlQI5ubmCA8P1ykPDw+Hh4dHmsd4enqiTJkyME/xwVC+fHmEhYWlWupDw9raGk5OTjoXIqJcx9oaWLNGLptx5gzQsKHSERGZhEwnQjdv3kTbtm0BAJ9++iksLCwwbdo0FNX8gtGTlZUV/Pz8sGvXLm2ZWq3Grl27ULt27TSPqVu3Lm7cuKHTBHft2jV4enrCysoqS3EQESli+3bg4kXdslKlgLVrATc3ZWIiMkGZToRiYmJgZ2cHAFCpVLC2ttYOo8+qIUOGYMGCBfjtt99w+fJl9OnTB9HR0ejWrRsAoEuXLhgxYoR2/z59+uD58+f46quvcO3aNWzduhWTJ09Gv379shUHEVGOSUgAhg+X8wO1awdERysdEZFJ02tK0oULF8LBwQEAkJiYiKVLl6JQoUI6++iz6GpgYCCePHmCsWPHIiwsDL6+vti+fbu2A/Xdu3e1s1gDgLe3N/755x8MHjwYVapUgZeXF7766it8++23+jwMIiJl3LsHtG+fPCnipUvAokVAHlmsmig/yvQ8Qj4+PlCpVBmfTKXSjibLrTiPEBEp4s8/ga5dgefP5baFBTB1KjB4sJwskYgyZKx5hDJdIxQaGmqwO80NEhOVjoCITEJ8PDBiBDBjRnJZ8eKyYzRniSZSnMmu1hcXp3QERJTv3b4tm8JSrqH4ySeyOczVVbm4iEjLZBOhypWVjoCI8rWICKBGDeDZM7ltZQX88APQvz+bwohyEYMtsUFERCk4O8v+PwBQsqTsID1gAJMgolzGZGuEiIiMbsQIuVRG374yMSKiXIc1QkREhrB2LTBrlm6ZmZlMhpgEEeVaWUqEbt68idGjR6NDhw54/PgxAODvv//GxTdnSSUiyu9iYoDevYHAQGDoUODgQaUjIiI96J0I7du3D5UrV8bRo0exceNGREVFAQDOnj2L4OBggwdIRJRrXb0KvPceMG+e3E5KAjZtUjYmItKL3onQ8OHDMXHiROzYsUNnfa8mTZrgv//+M2hwRES51sqVgJ8fcO6c3LaxARYulCPDiCjP0Luz9Pnz5/H777+nKnd3d8fTp08NEhQRUa71+rVcEmPRouSy8uVlH6FKlZSLi4iyRO8aIRcXFzx69ChV+enTp+Hl5WWQoIiIcqVLl4CaNXWToKAg4PhxJkFEeZTeiVD79u3x7bffIiwsDCqVCmq1GocOHcLQoUPRpUsXY8RIRKQ8IWTSoxkUYmcHLF0qL/b2SkZGRNmgdyI0efJklCtXDt7e3oiKikKFChXQoEED1KlTB6NHjzZGjEREylOpgCVLAFtbWftz4oRMjIgoT8v06vNvunv3Li5cuICoqCi8++67KF26tKFjMwrN6rWVK0fg3DmuPk9EGVCr5VxAKR04IDtJ29kpExORiVJ89XmNgwcPol69eihWrBiKFStmsECIiHINIeQIsOXLgR07AGvr5Nvq11cuLiIyOL2bxpo0aYISJUpg5MiRuHTpkjFiIiJSzqtXQKdOQK9esvbn22+VjoiIjEjvROjhw4f4+uuvsW/fPlSqVAm+vr6YNm0a7t+/b4z4iIhyzunTQLVqwKpVyWUJCbKGiIjyJb0ToUKFCqF///44dOgQbt68ibZt2+K3336Dj48PmjRpYowYiYiMSwjgl1+A2rWBGzdkmZMTsGYNMGcOV4wnyseytfp8iRIlMHz4cFStWhVjxozBvn37DBUXEVHOiIgAvvgCWL8+uczPTyZBpUopFxcR5Ygsrz5/6NAh9O3bF56enujYsSMqVaqErVu3GjI2IiLjOnFCNoWlTIIGDgQOHWISRGQi9K4RGjFiBFavXo2HDx/i/fffx+zZs/Hxxx/DjkNJiSiv2bgRuHVLXndxkfMEtW6tZERElMP0ToT279+PYcOGoV27dihUqJAxYiIiyhnjxwP79slV41evBnx8lI6IiHKY3onQoUOHjBEHEZHxPXsGFCyYvG1pCWzeDDg7A1ZWioVFRMrJVCK0ZcsWtGjRApaWltiyZUuG+3700UcGCYyIyGDUamDGDGDcOGD/ftkvSMPNTbGwiEh5mVpiw8zMDGFhYXB3d4fZm9PNpzyZSoWkpCSDBmhoXGKDyMQ8eybXBNMM5ihVCjh1Sg6PJ6I8Q9ElNtRqdZrXiYhytYMHgQ4dgJQTvrZtKxdOJSJCFobPL1u2DHFxcanK4+PjsWzZMoMERUSULWo1MGUK0KhRchJUqBDw999ASIjsG0REhCwkQt26dUNERESq8levXqFbt24GCYqIKMsePwY++AAYMUKOBgOABg2AM2eA5s0VDY2Ich+9EyEhBFRpTDd///59ODs7GyQoIqIsOXQI8PUF/vlHbqtUwJgxwK5dgJeXoqERUe6U6eHz7777LlQqFVQqFZo2bQoLi+RDk5KScPv2bTTnry0iUpKVFfD0qbxeuDCwYgXg769sTESUq2U6EWr9/9lWz5w5g4CAADg4OGhvs7Kygo+PDz777DODB0hElGk1agBTp8oRYitWAB4eSkdERLlcpobPp/Tbb78hMDAQNjY2xorJqDh8nigf+e8/oHp1IEUNNYSQnaXNzZWLi4gMzljD5/XuIxQUFJRnkyAiyicSE4GxY4E6deQyGSmpVEyCiCjTMtU0VqBAAVy7dg2FChWCq6trmp2lNZ4/f26w4IiIUnn4UM4NtH+/3J40CfjoI9ksRkSkp0wlQjNnzoSjo6P2ekaJEBGR0WzfDnTunNwh2twcmDgR8PNTNi4iyrP07iOU17GPEFEelJgoh8FPmZJcVrQosGoVUK+ecnERUY7JNX2ETp06hfPnz2u3//jjD7Ru3RojR45EfHy8wQIjIgIA3LsnZ4hOmQS1bCknSGQSRETZpHci9OWXX+LatWsAgFu3biEwMBB2dnZYt24dvvnmG4MHSEQm7OxZOUHioUNy28IC+OEHYMsWoGBBRUMjovxB70To2rVr8PX1BQCsW7cODRs2xO+//46lS5diw4YNho6PiExZ2bJAsWLyevHiwIEDwNdfA2Z6f3QREaUpS0tsaFag37lzJz744AMAgLe3N55qOjASERmCjQ2wdi3QqRNw+jTw3ntKR0RE+YzeiVD16tUxceJELF++HPv27UPLli0BALdv30bhwoUNHiARmZDNm4FLl3TLSpeWs0S7uioSEhHlb3onQrNmzcKpU6fQv39/jBo1Cu+88w4AYP369ahTp47BAyQiExAXB3z1FfDJJ0BgIPD6tdIREZGJMNjw+djYWJibm8PS0tIQpzMaDp8nymVu3pTJz8mTyWVz5wJffqlcTESU6xhr+HymF11908mTJ3H58mUAQIUKFVCtWjWDBUVEJmLdOuCLL4DISLltbQ3MnAn06qVsXERkMvROhB4/fozAwEDs27cPLi4uAICXL1+icePGWL16Ndzc3AwdIxHlN7GxwJAhwK+/JpeVLi07Rv9/VCoRUU7Qu4/QgAEDEBUVhYsXL+L58+d4/vw5Lly4gMjISAwcONAYMRJRfnLtmhz9lTIJ6tBBNo0xCSKiHKZ3jdD27duxc+dOlC9fXltWoUIFzJkzB82aNTNocESUzzx/DtSsCUREyG0bG+Cnn4AePeSq8UREOUzvGiG1Wp1mh2hLS0vt/EJERGkqUEBOiAgA5coBx47JPkJMgohIIXonQk2aNMFXX32Fhw8fassePHiAwYMHo2nTpgYNjojyoZEjge+/B44fBypXVjoaIjJxeidCP//8MyIjI+Hj44NSpUqhVKlSKFGiBCIjI/HTTz8ZI0Yiyqt++w2YPVu3zNwcGDYMcHBQJiYiohT07iPk7e2NU6dOYdeuXdrh8+XLl4e/v7/BgyOiPCo6GujXTyZC5uZAjRoAJ1wlolxIr0RozZo12LJlC+Lj49G0aVMMGDDAWHERUV514QLQti1w5YrcTkoCtm1jIkREuVKmE6Fff/0V/fr1Q+nSpWFra4uNGzfi5s2bmDZtmjHjI6K8Qghg0SJgwAA5TxAgm7/mzQM6dlQ2NiKidGS6j9DPP/+M4OBgXL16FWfOnMFvv/2GX375xZixEVFe8eoV8PnnQM+eyUlQ1apybiAmQUSUi2U6Ebp16xaCgoK02x07dkRiYiIePXpklMCIKI84cwbw8wN+/z25rHdv4L//gDJlFAuLiCgzMt00FhcXB3t7e+22mZkZrKysEBMTY5TAiCgPEALo1g24fl1uOzoCCxcC7dopGxcRUSbp1Vl6zJgxsLOz027Hx8dj0qRJcHZ21pbNmDHDcNERUe6mUsmRYbVqARUqyLXCSpVSOioiokzLdCLUoEEDXL16VaesTp06uHXrlnZbxdlhifI/tRowS9GqXqUKsHMnUL26XD2eiCgPyXQitHfvXiOGQUS5nhByXbD162XiY2WVfFvdusrFRUSUDXrPLE1EJujFC+DTT4GvvgIOHABGjFA6IiIig9B7ZmkiMjFHjwKBgcCdO8llZmayhojN4USUx7FGiIjSJgQwfTpQr15yElSgAPDnn8C0aUyCiChfYI0QEaX27BnQtSvw11/JZXXqAKtXA97eioVFRGRouaJGaM6cOfDx8YGNjQ1q1aqFY8eOZeq41atXQ6VSoXXr1sYNkMiUHDoE+PrqJkHffgvs3cskiIjynSwlQgcOHMDnn3+O2rVr48GDBwCA5cuX4+DBg3qfa82aNRgyZAiCg4Nx6tQpVK1aFQEBAXj8+HGGx4WGhmLo0KGoX79+Vh4CEaVnyxbg/n15vVAh4O+/gSlTAEtLZeMiIjICvROhDRs2ICAgALa2tjh9+jTi4uIAABEREZg8ebLeAcyYMQM9e/ZEt27dUKFCBcydOxd2dnZYvHhxusckJSWhU6dOGD9+PEqWLKn3fRJRBiZOBN57D2jQQC6f0by50hERERmN3onQxIkTMXfuXCxYsACWKX4h1q1bF6dOndLrXPHx8Th58iT8/f2TAzIzg7+/P44cOZLucd999x3c3d3Ro0ePt95HXFwcIiMjdS5ElMKbta+WlrJD9K5dgJeXMjEREeUQvROhq1evokGDBqnKnZ2d8fLlS73O9fTpUyQlJaFw4cI65YULF0ZYWFiaxxw8eBCLFi3CggULMnUfISEhcHZ21l682ceBSEpKAiZMAEqUkDU/KRUqBFhwLAUR5X96J0IeHh64ceNGqvKDBw8avZnq1atX6Ny5MxYsWIBChQpl6pgRI0YgIiJCe7l3755RYyTKE8LCgIAAYOxY4PVruUhqVJTSURER5Ti9f/L17NkTX331FRYvXgyVSoWHDx/iyJEjGDp0KMaMGaPXuQoVKgRzc3OEh4frlIeHh8PDwyPV/jdv3kRoaChatWqlLVOr1fKBWFjg6tWrKPXGgo/W1taw5vpHRMl27QI6dQI07zszM6BzZ8DWVtm4iIgUoHciNHz4cKjVajRt2hSvX79GgwYNYG1tjaFDh2LAgAF6ncvKygp+fn7YtWuXdgi8Wq3Grl270L9//1T7lytXDufPn9cpGz16NF69eoXZs2ez2YsoI0lJwHffyeYwIWSZpyewahXQsKGysRERKUTvREilUmHUqFEYNmwYbty4gaioKFSoUAEODg5ZCmDIkCEICgpC9erVUbNmTcyaNQvR0dHo1q0bAKBLly7w8vJCSEgIbGxsUKlSJZ3jXVxcACBVORGl8PAh0LEjsG9fclmzZsDy5YC7u3JxEREpLMu9Ia2srFChQoVsBxAYGIgnT55g7NixCAsLg6+vL7Zv367tQH337l2YmeWKeR+J8qY9e+RaYU+eyG1zczlE/ptvZLMYEZEJUwmhqSPPnMaNG0OVwRpDu3fvznZQxhQZGQlnZ2dUrhyBc+eclA6HyPj++w+oXx9ITASKFpVNYfXqKR0VEZFeNN/fERERcHIy3Pe33jVCvr6+OtsJCQk4c+YMLly4gKCgIEPFRUSG8t57QEiIXCJj6VI5NJ6IiABkIRGaOXNmmuXjxo1DFIffEinvwAG5QKq5eXLZkCHywqYwIiIdBvtU/PzzzzNcFoOIjCw+Hhg6VC6NMWGC7m1mZkyCiIjSYLBPxiNHjsDGxsZQpyMifYSGygRo+nS5/d13qWeLJiKiVPRuGvv00091toUQePToEU6cOKH3hIpEZACbNwPdugGaJW4sLYEffgCqVlUyKiKiPEHvRMjZ2Vln28zMDGXLlsV3332HZs2aGSwwInqLuDg5BP7HH5PLSpYE1qwBqldXLi4iojxEr0QoKSkJ3bp1Q+XKleHq6mqsmIjobW7elHMDnTyZXNamDbBwIfDGjxUiIkqfXn2EzM3N0axZM71XmSciAzp+HKhWLTkJsrYGfvkFWLuWSRARkZ707ixdqVIl3Lp1yxixEFFmVKoE+PjI66VLywkT+/QBMpjolIiI0qZ3IjRx4kQMHToUf/31Fx49eoTIyEidCxEZma2trP3p1k3WCr0xySkREWVeppfY+O677/D111/D0dEx+eAUv0CFEFCpVEhKSjJ8lAbEJTYoz1m1SjaFlS2rdCRERIox1hIbmU6EzM3N8ejRI1y+fDnD/Ro2bGiQwIyFiRDlGTExwMCBsgN0lSqyCczWVumoiIgUofhaY5p8KbcnOkT5wuXLQLt2wIULcvvcOdkcxvX8iIgMSq8+QhmtOk9EBvLbb3IeIE0SZGcHLFnCJIiIyAj0mkeoTJkyb02Gnj9/nq2AiExWdDTQr59MhDQqVpQ1QRUqKBcXEVE+plciNH78+FQzSxORAVy4IJvCUvbB69FDzhptZ6dcXERE+ZxeiVD79u3h7u5urFiITNPjx8B778kaIQCwtwfmzQM6dVI2LiIiE5DpPkLsH0RkJO7uwNdfy+tVqsi5gZgEERHlCL1HjRGREYwdK5fH6NOHQ+SJiHJQphMhtVptzDiITIMQstkrPl7OEaRhbg4MGaJcXEREJkqvPkJElA0REUCvXnIUmIUFUKuWvBARkWL0XmuMiLLg5EnAz08mQQCQmAjs3KlsTERExESIyKiEAH76CahTB7h5U5Y5OwMbNgCjRikbGxERsWmMyGhevJBzAW3alFxWsyawejVQooRycRERkRZrhIiM4ehRuWJ8yiTo66+BAweYBBER5SKsESIyNLVa1gSFhsrtAgWApUuBVq2UjIqIiNLAGiEiQzMzA1asAKytZd+g06eZBBER5VKsESIyhKQkOReQhq8vsGePXEXe0lKxsIiIKGOsESLKDrUamDoVaNwYSEjQva12bSZBRES5HBMhoqx68gT48ENg+HDZCZrD4YmI8hw2jRFlxf79QIcOwMOHclulAmxs5LxBXKCYiCjPYCJEpI+kJCAkBAgOls1igFw9fsUK4P33lY2NiIj0xkSIKLPCw4HPP9ddGqNJE5kEeXoqFxcREWUZ+wgRZcbu3UDVqslJkJkZMH488O+/TIKIiPIw1ggRZcZff8kaIUAmPr//DjRqpGhIRESUfUyEiDJjyhTg4EHA1RVYvlz2CyIiojyPiRBRWsLCAA+P5G0rK+Dvv2UiZMYWZSKi/IKf6EQpJSYCI0cCpUoB587p3lawIJMgIqJ8hp/qRBr378sZokNCgNevgXbtgOhopaMiIiIjYiJEBADbtsn1wQ4elNsWFsAXXwC2toqGRURExsU+QmTaEhLk0hjTpiWXFSsGrF4t1wojIqJ8zWQTofPnlY6AFHfnDtC+PfDff8llH30ELFkCFCigXFxERJRjTLZprHlzpSMgRf39t2wK0yRBlpbArFnA5s1MgoiITIjJ1ghZWysdASnK2Rl49UpeL1ECWLMGqFFD2ZiIiCjHmWwiRCauTh1g0iTg+HFg4ULAxUXpiIiISAFMhMg07NkDNGgAmJsnlw0bBqhU8kJERCbJZPsIkYmIjQX695erxIeE6N5mZsYkiIjIxDERovzr+nXZBDZnjtwODgYuXlQ2JiIiylWYCFH+tHo1UK0acPq03LaxAebOBSpUUDYuIiLKVdhHiPKXmBhg0CBg/vzksrJlgbVrgSpVFAuLiIhyJyZClH9cuSLXB0s5W2bnzsAvvwAODsrFRUREuRYTIcofDh8GmjVLXiTV1lYmQF27KhoWERHlbuwjRPmDr6+cGBEAKlYETpxgEkRERG/FRIjyBzs72Q+oTx/g2DF2iiYiokxhIkR5jxByYdTr13XLy5eXzWF2dsrERUREeQ4TIcpboqJkB+ju3YHAQDlhIhERURYxEaK84+xZwM8PWLlSbp8+Dfzxh7IxERFRnsZEiHI/IYB584BatYBr12SZo6OcNDEwUNnYiIgoT+PwecrdIiOBXr2ANWuSy6pVk9vvvKNcXERElC+wRohyr1OnkpMejQED5JxBTIKIiMgAWCNEudOjR0DdusmdoZ2dgcWLgU8/VTYuIiLKV1gjRLmTpyfw9dfyeo0asmM0kyAiIjIw1ghR7jVuHFC4MPDll4CVldLREBFRPpQraoTmzJkDHx8f2NjYoFatWjh27Fi6+y5YsAD169eHq6srXF1d4e/vn+H+lAcIAcycCcyZo1tuYSH7BDEJIiIiI1E8EVqzZg2GDBmC4OBgnDp1ClWrVkVAQAAeP36c5v579+5Fhw4dsGfPHhw5cgTe3t5o1qwZHjx4kMORk0E8fw58/DEwZAgweLBcI4yIiCiHqIQQQskAatWqhRo1auDnn38GAKjVanh7e2PAgAEYPnz4W49PSkqCq6srfv75Z3Tp0uWt+0dGRsLZ2RkffxyBzZudsh0/ZcPhw0D79sC9e8ll06fLpIiIiCgFzfd3REQEnJwM9/2taI1QfHw8Tp48CX9/f22ZmZkZ/P39ceTIkUyd4/Xr10hISECBAgXSvD0uLg6RkZE6F1KYWg18/z3QoEFyElSoELBtG5MgIiLKUYomQk+fPkVSUhIKFy6sU164cGGEhYVl6hzffvstihQpopNMpRQSEgJnZ2ftxdvbO9txUzY8eQJ8+CHw7bdAUpIsq18fOHMGaNFC0dCIiMj0KN5HKDumTJmC1atXY9OmTbCxsUlznxEjRiAiIkJ7uZeyGYZy1oEDgK8v8PffclulAkaPBnbvBry8FA2NiIhMk6LD5wsVKgRzc3OEh4frlIeHh8PDwyPDY3/44QdMmTIFO3fuRJUqVdLdz9raGtbW1gaJl7IhMRHo2RN4+FBuu7sDK1YA77+vbFxERGTSFK0RsrKygp+fH3bt2qUtU6vV2LVrF2rXrp3ucd9//z0mTJiA7du3o3r16jkRKmWXhYVcNd7KCmjcWDaFMQkiIiKFKT6h4pAhQxAUFITq1aujZs2amDVrFqKjo9GtWzcAQJcuXeDl5YWQkBAAwNSpUzF27Fj8/vvv8PHx0fYlcnBwgIODg2KPg9KQmCgTIA0/P2D/fqB6dcDcXLm4iIiI/k/xRCgwMBBPnjzB2LFjERYWBl9fX2zfvl3bgfru3bswM0uuuPr1118RHx+PNm3a6JwnODgY48aNy8nQKT1JScCECcDevcDOnbrJUK1aioVFRET0JsXnEcppnEfIyB49Ajp2lEkQAIwYAUyerGhIRESU9+XLeYQon/n3X6Bq1eQkyMwMcHRUNCQiIqKMKN40RvlAYiIQHAyEhMh1wwA5HH7VKjlHEBERUS7FRIiy5/59oEMH4ODB5LIWLYBly+Rs0URERLkYm8Yo67ZtkxMkapIgCwu5dMZffzEJIiKiPIE1QpR127cDz57J68WKAatXAxnM/0RERJTbMBGirJs2DTh0CChaFFiyBEhn4VsiIqLciokQZd6DB7prgllbAzt2AK6uct0wIiKiPIZ9hOjt4uOBwYOBMmWAixd1bytQgEkQERHlWUyEKGO3bwP16gGzZgGvXwPt2gExMUpHRUREZBBMhCh9GzYA774LHD8ut62sgL59ARsbZeMiIiIyEPYRotRiY4GhQ4E5c5LLSpUC1q4FqlVTLi4iIiIDYyJEum7ckM1fp08nlwUGAvPnAwZc24WIiCg3YNMYJdu8Wdb4aJIga2tg3jy5VAaTICIiyodYI0TJChQAoqPl9bJlZVNYlSrKxkRERGRETIQoWYMGwHffAVevAr/8Ajg4KB0RERGRUTERMmX//gv4+wNmKVpIR46Ufzk3EBERmQD2ETJFr18D3bsDAQHA1Km6t6lUTIKIiMhkMBEyNRcvAjVqyLXBAGDMGODaNWVjIiIiUggTIVMhhEx+atQALl2SZfb2sqxMGWVjIyIiUgj7CJmCqCigTx9gxYrkssqV5aiwcuWUi4uIiEhhrBHK786dA6pX102CvvwSOHqUSRAREZk81gjlZ3v3Ai1ayCUzAMDRUc4Q3b69omERERHlFqwRys9q1ABKlJDX330XOHmSSRAREVEKTITyM3t72Q9o0CDg8GGgdGmlIyIiIspVmAjlF0IAc+cCN2/qlleqBMycCdjYKBMXERFRLsZEKD94+VKuGN+nj1wpPi5O6YiIiIjyBCZCed3x43LF+PXr5fbJk8C2bcrGRERElEcwEcqrhABmzQLq1gVu35ZlLi7A5s3AJ58oGBgREVHeweHzedHz50C3bsCWLcll770HrF4NFC+uXFxERER5DGuE8pojR+RQ+JRJ0LBhwP79TIKIiIj0xBqhvOTuXaBhQyAhQW4XLAj89hvQsqWycREREeVRrBHKS4oVA4YMkdfr1QPOnGESRERElA2sEcprJkyQTWA9ewIWfPmIiIiygzVCuZVaDYSEAL/+qltuaSnnC2ISRERElG38Ns2NHj8GOncG/v0XsLICatWScwUREeVzSUlJSND0gySTY2lpCXNz8xy9TyZCuc3evUDHjsCjR3I7IUGOFGMiRET5XFRUFO7fvw8hhNKhkEJUKhWKFi0KBweHHLtPJkK5RVISMHEi8N13slkMADw8gJUrgSZNlI2NiMjIkpKScP/+fdjZ2cHNzQ0qlUrpkCiHCSHw5MkT3L9/H6VLl86xmiEmQrnBo0fA558Du3cnl/n7AytWAIULKxcXEVEOSUhIgBACbm5usLW1VTocUoibmxtCQ0ORkJCQY4kQO0srbccOwNc3OQkyM5M1Q//8wySIiEwOa4JMmxKvP2uElJSQIEeAPX4st4sUAVatAho0UDYuIiIiE8EaISVZWsrEx9ISaN5cTpDIJIiIiCjHMBHKaW8OC61RAzh8GNi6FXBzUyYmIiLKliNHjsDc3Bwt05jtf+/evVCpVHj58mWq23x8fDBr1iydsj179uCDDz5AwYIFYWdnhwoVKuDrr7/GgwcPjBQ9EBsbi379+qFgwYJwcHDAZ599hvDw8AyPCQ8PR9euXVGkSBHY2dmhefPmuH79eqr9jhw5giZNmsDe3h5OTk5o0KABYmJijPVQ9MZEKKckJADDhwPNmgGJibq3Va8u+wYREVGetGjRIgwYMAD79+/Hw4cPs3yeefPmwd/fHx4eHtiwYQMuXbqEuXPnIiIiAtOnTzdgxLoGDx6MP//8E+vWrcO+ffvw8OFDfPrpp+nuL4RA69atcevWLfzxxx84ffo0ihcvDn9/f0RHR2v3O3LkCJo3b45mzZrh2LFjOH78OPr37w+z3PSdJ0xMRESEACA+/jgi5+70zh0h6tQRApCX0aNz7r6JiPKAmJgYcenSJRETE6N0KHp79eqVcHBwEFeuXBGBgYFi0qRJOrfv2bNHABAvXrxIdWzx4sXFzJkzhRBC3Lt3T1hZWYlBgwaleT9pHW8IL1++FJaWlmLdunXassuXLwsA4siRI2kec/XqVQFAXLhwQVuWlJQk3NzcxIIFC7RltWrVEqP1+M7L6P9A8/0dEWHY7+9clJLlU3/+KUeFHT4sty0s5KrxRESUL6xduxblypVD2bJl8fnnn2Px4sVZmhRy3bp1iI+PxzfffJPm7S4uLuke26JFCzg4OKR7qVixYrrHnjx5EgkJCfD399eWlStXDsWKFcORI0fSPCYuLg4AYGNjoy0zMzODtbU1Dh48CAB4/Pgxjh49Cnd3d9SpUweFCxdGw4YNtbfnFhw1Zizx8cCIEcCMGcllPj7AmjVAzZqKhUVElFdUrw6EheX8/Xp4ACdOZH7/RYsW4fPPPwcANG/eHBEREdi3bx8aNWqk1/1ev34dTk5O8PT01Os4AFi4cGGG/W4sLS3TvS0sLAxWVlapEq3ChQsjLJ0XQJMojRgxAvPmzYO9vT1mzpyJ+/fv49H/V0a4desWAGDcuHH44Ycf4Ovri2XLlqFp06a4cOECSpcureejNA4mQsZw+zbQvj1w7Fhy2SefAIsXAxlk9ERElCwsDDBi/2CDuHr1Ko4dO4ZNmzYBACwsLBAYGIhFixbpnQgJIbI8j46Xl1eWjssqS0tLbNy4ET169ECBAgVgbm4Of39/tGjRQlsbpv7/KglffvklunXrBgB49913sWvXLixevBghISE5GnN6mAgZ2saNQPfuQESE3LayAqZPB/r1AzhRGBFRpnl45P77XbRoERITE1GkSBFtmRAC1tbW+Pnnn+Hs7AwnJycAQERERKpal5cvX8LZ2RkAUKZMGURERODRo0d61wq1aNECBw4cSPf24sWL4+LFi2ne5uHhgfj4eLx8+VInvvDwcHhk8GT4+fnhzJkziIiIQHx8PNzc3FCrVi1Ur14dALSPoUKFCjrHlS9fHnfv3s3sQzM6JkKGtmtXchJUqpRsCvPzUzYmIqI8SJ/mKSUkJiZi2bJlmD59Opo1a6ZzW+vWrbFq1Sr07t0bpUuXhpmZGU6ePInixYtr97l16xYiIiJQpkwZAECbNm0wfPhwfP/995g5c2aq+3szUUkpO01jfn5+sLS0xK5du/DZZ58BkDVdd+/eRe3atdM9TkOTyF2/fh0nTpzAhAkTAMipAYoUKYKrV6/q7H/t2jW0aNHirefNMQbtep0HGH3UWEyMEL6+QrRrJ4SBe7YTEeVXeXHU2KZNm4SVlZV4+fJlqtu++eYbUb16de12r169hI+Pj/jjjz/ErVu3xL59+8R7770n3nvvPaFWq7X7zZkzR6hUKtG9e3exd+9eERoaKg4ePCh69eolhgwZYrTH0rt3b1GsWDGxe/duceLECVG7dm1Ru3ZtnX3Kli0rNm7cqN1eu3at2LNnj7h586bYvHmzKF68uPj00091jpk5c6ZwcnIS69atE9evXxejR48WNjY24saNG2nGocSoMSZC2XX3buqyFy+ESPGPTUREGcuLidCHH34oPvjggzRvO3r0qAAgzp49K4SQjy84OFiUK1dO2NraihIlSohevXqJJ0+epDp2x44dIiAgQLi6ugobGxtRrlw5MXToUPHw4UOjPZaYmBjRt29f4erqKuzs7MQnn3wiHj16pLMPALFkyRLt9uzZs0XRokWFpaWlKFasmBg9erSIi4tLde6QkBBRtGhRYWdnJ2rXri0OHDiQYRw5nQiphMjCGL88LDIyEs7Ozvj44whs3uyU9RPFxABDhgDLl8v623LlDBckEZGJiY2Nxe3bt1GiRAmdIdlkWjL6P9B8f0dERGj7XRkC5xHKiqtXgffeA+bOBaKjgbZtgf/PqUBERER5BxMhfa1cKTs/nzsnt21tgcGD5egwIiIiylM4aiyzXr8GBg4EFi1KLitfHli3Dshgxk4iIiLKvVgjlBmXLsnZoFMmQd26AcePMwkiIiLKw5gIvc3atUCNGoBmIio7O2DZMjlLtL29srERERFRtrBp7G3c3YHYWHm9cmWZGHGEGBGRUZjYQGZ6gxKvPxOht2nUCAgOBu7fB2bPlp2jiYjIoMzNzQEA8fHxsOXnrMmKj48HkPz/kBOYCKUkBLBtG9CiBWCWotVwzBiuE0ZEZEQWFhaws7PDkydPYGlpCTMz9twwNWq1Gk+ePIGdnR0sLHIuPWEipBEZCXz5JbB6NfD998CwYcm3MQkiIjIqlUoFT09P3L59G3fu3FE6HFKImZkZihUrBlUOfu8yEQKA06eBdu2AGzfk9siRQJs2QIkSysZFRGRCrKysULp0aW3zCJkeKyurHK8NzBWJ0Jw5czBt2jSEhYWhatWq+Omnn1CzZs1091+3bh3GjBmD0NBQlC5dGlOnTsUHH3yg/x0LAfz6q5wQUfPGc3KSw+SZBBER5TgzMzMusUE5SvFG2DVr1mDIkCEIDg7GqVOnULVqVQQEBODx48dp7n/48GF06NABPXr0wOnTp9G6dWu0bt0aFy5c0Ot+beNfylqgfv2Sk6Dq1WXtUJs22XxURERElBcovuhqrVq1UKNGDfz8888AZGcpb29vDBgwAMOHD0+1f2BgIKKjo/HXX39py9577z34+vpi7ty5b70/zaJt1+2K453XKdqhBw0CpkwBrK2z/ZiIiIjIsPLloqvx8fE4efIk/P39tWVmZmbw9/fHkSNH0jzmyJEjOvsDQEBAQLr7p8ddkwS5uACbNwMzZzIJIiIiMjGK9hF6+vQpkpKSULhwYZ3ywoUL48qVK2keExYWlub+YWFhae4fFxeHuBQrw0dERAAAIgG5eOrSpUCxYnLUGBEREeVKkf//njZ0Q1au6CxtTCEhIRg/fnyqcm8AOHlSzhZNREREecKzZ8/g7OxssPMpmggVKlQI5ubmCA8P1ykPDw+Hh4dHmsd4eHjotf+IESMwZMgQ7fbLly9RvHhx3L1716BPJOkvMjIS3t7euHfvnkHbeylr+HrkHnwtcg++FrlHREQEihUrhgIFChj0vIomQlZWVvDz88OuXbvQunVrALKz9K5du9C/f/80j6lduzZ27dqFQYMGact27NiB2rVrp7m/tbU1rNPo++Ps7Mx/6lzCycmJr0Uuwtcj9+BrkXvwtcg9DD3PkOJNY0OGDEFQUBCqV6+OmjVrYtasWYiOjka3bt0AAF26dIGXlxdCQkIAAF999RUaNmyI6dOno2XLlli9ejVOnDiB+fPnK/kwiIiIKA9SPBEKDAzEkydPMHbsWISFhcHX1xfbt2/Xdoi+e/euTvZXp04d/P777xg9ejRGjhyJ0qVLY/PmzahUqZJSD4GIiIjyKMUTIQDo379/uk1he/fuTVXWtm1btG3bNkv3ZW1tjeDg4DSbyyhn8bXIXfh65B58LXIPvha5h7FeC8UnVCQiIiJSiuJLbBAREREphYkQERERmSwmQkRERGSymAgRERGRycqXidCcOXPg4+MDGxsb1KpVC8eOHctw/3Xr1qFcuXKwsbFB5cqVsW3bthyKNP/T57VYsGAB6tevD1dXV7i6usLf3/+trx3pR9/3hsbq1auhUqm0E59S9un7Wrx8+RL9+vWDp6cnrK2tUaZMGX5WGYi+r8WsWbNQtmxZ2NrawtvbG4MHD0ZsbGwORZt/7d+/H61atUKRIkWgUqmwefPmtx6zd+9eVKtWDdbW1njnnXewdOlS/e9Y5DOrV68WVlZWYvHixeLixYuiZ8+ewsXFRYSHh6e5/6FDh4S5ubn4/vvvxaVLl8To0aOFpaWlOH/+fA5Hnv/o+1p07NhRzJkzR5w+fVpcvnxZdO3aVTg7O4v79+/ncOT5k76vh8bt27eFl5eXqF+/vvj4449zJth8Tt/XIi4uTlSvXl188MEH4uDBg+L27dti79694syZMzkcef6j72uxcuVKYW1tLVauXClu374t/vnnH+Hp6SkGDx6cw5HnP9u2bROjRo0SGzduFADEpk2bMtz/1q1bws7OTgwZMkRcunRJ/PTTT8Lc3Fxs375dr/vNd4lQzZo1Rb9+/bTbSUlJokiRIiIkJCTN/du1aydatmypU1arVi3x5ZdfGjVOU6Dva/GmxMRE4ejoKH777TdjhWhSsvJ6JCYmijp16oiFCxeKoKAgJkIGou9r8euvv4qSJUuK+Pj4nArRZOj7WvTr1080adJEp2zIkCGibt26Ro3T1GQmEfrmm29ExYoVdcoCAwNFQECAXveVr5rG4uPjcfLkSfj7+2vLzMzM4O/vjyNHjqR5zJEjR3T2B4CAgIB096fMycpr8abXr18jISHB4AvsmaKsvh7fffcd3N3d0aNHj5wI0yRk5bXYsmULateujX79+qFw4cKoVKkSJk+ejKSkpJwKO1/KymtRp04dnDx5Utt8duvWLWzbtg0ffPBBjsRMyQz1/Z0rZpY2lKdPnyIpKUm7PIdG4cKFceXKlTSPCQsLS3P/sLAwo8VpCrLyWrzp22+/RZEiRVL9o5P+svJ6HDx4EIsWLcKZM2dyIELTkZXX4tatW9i9ezc6deqEbdu24caNG+jbty8SEhIQHBycE2HnS1l5LTp27IinT5+iXr16EEIgMTERvXv3xsiRI3MiZEohve/vyMhIxMTEwNbWNlPnyVc1QpR/TJkyBatXr8amTZtgY2OjdDgm59WrV+jcuTMWLFiAQoUKKR2OyVOr1XB3d8f8+fPh5+eHwMBAjBo1CnPnzlU6NJOzd+9eTJ48Gb/88gtOnTqFjRs3YuvWrZgwYYLSoVEW5asaoUKFCsHc3Bzh4eE65eHh4fDw8EjzGA8PD732p8zJymuh8cMPP2DKlCnYuXMnqlSpYswwTYa+r8fNmzcRGhqKVq1aacvUajUAwMLCAlevXkWpUqWMG3Q+lZX3hqenJywtLWFubq4tK1++PMLCwhAfHw8rKyujxpxfZeW1GDNmDDp37owvvvgCAFC5cmVER0ejV69eGDVqlM4i4WRc6X1/Ozk5Zbo2CMhnNUJWVlbw8/PDrl27tGVqtRq7du1C7dq10zymdu3aOvsDwI4dO9LdnzInK68FAHz//feYMGECtm/fjurVq+dEqCZB39ejXLlyOH/+PM6cOaO9fPTRR2jcuDHOnDkDb2/vnAw/X8nKe6Nu3bq4ceOGNhkFgGvXrsHT05NJUDZk5bV4/fp1qmRHk6AKLt2Zowz2/a1fP+7cb/Xq1cLa2losXbpUXLp0SfTq1Uu4uLiIsLAwIYQQnTt3FsOHD9fuf+jQIWFhYSF++OEHcfnyZREcHMzh8wai72sxZcoUYWVlJdavXy8ePXqkvbx69Uqph5Cv6Pt6vImjxgxH39fi7t27wtHRUfTv319cvXpV/PXXX8Ld3V1MnDhRqYeQb+j7WgQHBwtHR0exatUqcevWLfHvv/+KUqVKiXbt2in1EPKNV69eidOnT4vTp08LAGLGjBni9OnT4s6dO0IIIYYPHy46d+6s3V8zfH7YsGHi8uXLYs6cORw+r/HTTz+JYsWKCSsrK1GzZk3x33//aW9r2LChCAoK0tl/7dq1okyZMsLKykpUrFhRbN26NYcjzr/0eS2KFy8uAKS6BAcH53zg+ZS+742UmAgZlr6vxeHDh0WtWrWEtbW1KFmypJg0aZJITEzM4ajzJ31ei4SEBDFu3DhRqlQpYWNjI7y9vUXfvn3Fixcvcj7wfGbPnj1pfgdonv+goCDRsGHDVMf4+voKKysrUbJkSbFkyRK971clBOvyiIiIyDTlqz5CRERERPpgIkREREQmi4kQERERmSwmQkRERGSymAgRERGRyWIiRERERCaLiRARERGZLCZCRKRj6dKlcHFxUTqMLFOpVNi8eXOG+3Tt2hWtW7fOkXiIKHdjIkSUD3Xt2hUqlSrV5caNG0qHhqVLl2rjMTMzQ9GiRdGtWzc8fvzYIOd/9OgRWrRoAQAIDQ2FSqXCmTNndPaZPXs2li5dapD7S8+4ceO0j9Pc3Bze3t7o1asXnj9/rtd5mLQRGVe+Wn2eiJI1b94cS5Ys0Slzc3NTKBpdTk5OuHr1KtRqNc6ePYtu3brh4cOH+Oeff7J97vRWDU/J2dk52/eTGRUrVsTOnTuRlJSEy5cvo3v37oiIiMCaNWty5P6J6O1YI0SUT1lbW8PDw0PnYm5ujhkzZqBy5cqwt7eHt7c3+vbti6ioqHTPc/bsWTRu3BiOjo5wcnKCn58fTpw4ob394MGDqF+/PmxtbeHt7Y2BAwciOjo6w9hUKhU8PDxQpEgRtGjRAgMHDsTOnTsRExMDtVqN7777DkWLFoW1tTV8fX2xfft27bHx8fHo378/PD09YWNjg+LFiyMkJETn3JqmsRIlSgAA3n33XahUKjRq1AiAbi3L/PnzUaRIEZ2V3QHg448/Rvfu3bXbf/zxB6pVqwYbGxuULFkS48ePR2JiYoaP08LCAh4eHvDy8oK/vz/atm2LHTt2aG9PSkpCjx49UKJECdja2qJs2bKYPXu29vZx48bht99+wx9//KGtXdq7dy8A4N69e2jXrh1cXFxQoEABfPzxxwgNDc0wHiJKjYkQkYkxMzPDjz/+iIsXL+K3337D7t278c0336S7f6dOnVC0aFEcP34cJ0+exPDhw2FpaQkAuHnzJpo3b47PPvsM586dw5o1a3Dw4EH0799fr5hsbW2hVquRmJiI2bNnY/r06fjhhx9w7tw5BAQE4KOPPsL169cBAD/++CO2bNmCtWvX4urVq1i5ciV8fHzSPO+xY8cAADt37sSjR4+wcePGVPu0bdsWz549w549e7Rlz58/x/bt29GpUycAwIEDB9ClSxd89dVXuHTpEubNm4elS5di0qRJmX6MoaGh+Oeff2BlZaUtU6vVKFq0KNatW4dLly5h7NixGDlyJNauXQsAGDp0KNq1a4fmzZvj0aNHePToEerUqYOEhAQEBATA0dERBw4cwKFDh+Dg4IDmzZsjPj4+0zEREZAvV58nMnVBQUHC3Nxc2Nvbay9t2rRJc99169aJggULareXLFkinJ2dtduOjo5i6dKlaR7bo0cP0atXL52yAwcOCDMzMxETE5PmMW+e/9q1a6JMmTKievXqQgghihQpIiZNmqRzTI0aNUTfvn2FEEIMGDBANGnSRKjV6jTPD0Bs2rRJCCHE7du3BQBx+vRpnX2CgoLExx9/rN3++OOPRffu3bXb8+bNE0WKFBFJSUlCCCGaNm0qJk+erHOO5cuXC09PzzRjEEKI4OBgYWZmJuzt7YWNjY12Je0ZM2ake4wQQvTr10989tln6caque+yZcvqPAdxcXHC1tZW/PPPPxmen4h0sY8QUT7VuHFj/Prrr9pte3t7ALJ2JCQkBFeuXEFkZCQSExMRGxuL169fw87OLtV5hgwZgi+++ALLly/XNu+UKlUKgGw2O3fuHFauXKndXwgBtVqN27dvo3z58mnGFhERAQcHB6jVasTGxqJevXpYuHAhIiMj8fDhQ9StW1dn/7p16+Ls2bMAZLPW+++/j7Jly6J58+b48MMP0axZs2w9V506dULPnj3xyy+/wNraGitXrkT79u1hZmamfZyHDh3SqQFKSkrK8HkDgLJly2LLli2IjY3FihUrcObMGQwYMEBnnzlz5mDx4sW4e/cuYmJiEB8fD19f3wzjPXv2LG7cuAFHR0ed8tjYWNy8eTMLzwCR6WIiRJRP2dvb45133tEpCw0NxYcffog+ffpg0qRJKFCgAA4ePIgePXogPj4+zS/0cePGoWPHjti6dSv+/vtvBAcHY/Xq1fjkk08QFRWFL7/8EgMHDkx1XLFixdKNzdHREadOnYKZmRk8PT1ha2sLAIiMjHzr46pWrRpu376Nv//+Gzt37kS7du3g7++P9evXv/XY9LRq1QpCCGzduhU1atTAgQMHMHPmTO3tUVFRGD9+PD799NNUx9rY2KR7XisrK+1rMGXKFLRs2RLjx4/HhAkTAACrV6/G0KFDMX36dNSuXRuOjo6YNm0ajh49mmG8UVFR8PPz00lANXJLh3iivIKJEJEJOXnyJNRqNaZPn66t7dD0R8lImTJlUKZMGQwePBgdOnTAkiVL8Mknn6BatWq4dOlSqoTrbczMzNI8xsnJCUWKFMGhQ4fQsGFDbfmhQ4dQs2ZNnf0CAwMRGBiINm3aoHnz5nj+/DkKFCigcz5Nf5ykpKQM47GxscGnn36KlStX4saNGyhbtiyqVaumvb1atWq4evWq3o/zTaNHj0aTJk3Qp08f7eOsU6cO+vbtq93nzRodKyurVPFXq1YNa9asgbu7O5ycnLIVE5GpY2dpIhPyzjvvICEhAT/99BNu3bqF5cuXY+7cuenuHxMTg/79+2Pv3r24c+cODh06hOPHj2ubvL799lscPnwY/fv3x5kzZ3D9+nX88ccfeneWTmnYsGGYOnUq1qxZg6tXr2L48OE4c+YMvvrqKwDAjBkzsGrVKly5cgXXrl3DunXr4OHhkeYkkO7u7rC1tcX27dsRHh6OiIiIdO+3U6dO2Lp1KxYvXqztJK0xduxYLFu2DOPHj8fFixdx+fJlrF69GqNHj9brsdWuXRtVqlTB5MmTAQClS5fGiRMn8M8//+DatWsYM2YMjh8/rnOMj48Pzp07h6tXr+Lp06dISEhAp06dUKhQIXz88cc4cOAAbt++jb1792LgwIG4f/++XjERmTylOykRkeGl1cFWY8aMGcLT01PY2tqKgIAAsWzZMgFAvHjxQgih25k5Li5OtG/fXnh7ewsrKytRpEgR0b9/f52O0MeOHRPvv/++cHBwEPb29qJKlSqpOjun9GZn6TclJSWJcePGCS8vL2FpaSmqVq0q/v77b+3t8+fPF76+vsLe3l44OTmJpk2bilOnTmlvR4rO0kIIsWDBAuHt7S3MzMxEw4YN031+kpKShKenpwAgbt68mSqu7du3izp16ghbW1vh5OQkatasKebPn5/u4wgODhZVq1ZNVb5q1SphbW0t7t69K2JjY0XXrl2Fs7OzcHFxEX369BHDhw/XOe7x48fa5xeA2LNnjxBCiEePHokuXbqIQoUKCWtra1GyZEnRs2dPERERkW5MRJSaSgghlE3FiIiIiJTBpjEiIiIyWUyEiIiIyGQxESIiIiKTxUSIiIiITBYTISIiIjJZTISIiIjIZDERIiIiIpPFRIiIiIhMFhMhIiIiMllMhIiIiMhkMREiIiIik8VEiIiIiEzW/wCMlyBx3fSzrgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -338,77 +342,87 @@ "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 1.342965841293335\n", - "compute_auc_time: 6.445879936218262\n", + "fit_time: 1.4438748359680176\n", + "compute_auc_time: 6.563769817352295\n", "depth: 3 , Auc of digit: 0 is 0.9978321712119015\n", "doing digit 1 doing signature level 3\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.4032697677612305\n", - "compute_auc_time: 6.378614664077759\n", + "fit_time: 1.415640115737915\n", + "compute_auc_time: 6.474632024765015\n", "depth: 3 , Auc of digit: 1 is 0.970122092330133\n", "doing digit 2 doing signature level 3\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.4213371276855469\n", - "compute_auc_time: 6.583529949188232\n", + "fit_time: 1.3865909576416016\n", + "compute_auc_time: 6.617231845855713\n", "depth: 3 , Auc of digit: 2 is 0.9907229815494015\n", "doing digit 3 doing signature level 3\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.3599779605865479\n", - "compute_auc_time: 6.415704965591431\n", + "fit_time: 1.4027378559112549\n", + "compute_auc_time: 6.600866794586182\n", "depth: 3 , Auc of digit: 3 is 0.9952787566639559\n", "doing digit 4 doing signature level 3\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3847181797027588\n", - "compute_auc_time: 6.45753288269043\n", + "fit_time: 1.4259991645812988\n", + "compute_auc_time: 6.604549884796143\n", "depth: 3 , Auc of digit: 4 is 0.9998316935138888\n", "doing digit 5 doing signature level 3\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.3755779266357422\n", - "compute_auc_time: 6.4378650188446045\n", + "fit_time: 1.4912703037261963\n", + "compute_auc_time: 6.5209479331970215\n", "depth: 3 , Auc of digit: 5 is 0.9819583712798636\n", "doing digit 6 doing signature level 3\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.259742021560669\n", - "compute_auc_time: 6.417846918106079\n", + "fit_time: 1.4395511150360107\n", + "compute_auc_time: 6.649335145950317\n", "depth: 3 , Auc of digit: 6 is 0.9945587105810065\n", "doing digit 7 doing signature level 3\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.3221640586853027\n", - "compute_auc_time: 6.397592067718506\n", + "fit_time: 1.3501660823822021\n", + "compute_auc_time: 6.567941904067993\n", "depth: 3 , Auc of digit: 7 is 0.9778264970511301\n", "doing digit 8 doing signature level 3\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.28696608543396\n", - "compute_auc_time: 6.392870903015137\n", + "fit_time: 1.467175006866455\n", + "compute_auc_time: 6.605494022369385\n", "depth: 3 , Auc of digit: 8 is 0.9984290759314479\n", "doing digit 9 doing signature level 3\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.286924123764038\n", - "compute_auc_time: 6.4979729652404785\n", + "fit_time: 1.4061648845672607\n", + "compute_auc_time: 6.380589962005615\n", "depth: 3 , Auc of digit: 9 is 0.9264809418391013\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB4RUlEQVR4nO3dd1hTZxsG8DsgeysiiAjuPXHUvag4auvGjbvWWa3WURWtddW6Wm2tW1tbt9U6q9ZdrRP3FupEcYEoM3m/P94vwciQQOAAuX/XlQvOyRlPcjKevFMlhBAgIiIiMkFmSgdAREREpBQmQkRERGSymAgRERGRyWIiRERERCaLiRARERGZLCZCREREZLKYCBEREZHJYiJEREREJouJEBEREZksJkImyMfHBz179lQ6DJPTsGFDNGzYUOkw3mvSpElQqVR4+vSp0qFkOyqVCpMmTTLKsUJDQ6FSqbBy5UqjHC+ny8j7o2fPnvDx8clwDOvXr0fevHkRFRX13m2N+Vow1MGDB6FSqbBx40ZFzv+2K1euIE+ePLh06ZLSoaQbEyEjW7lyJVQqle6WJ08eeHp6omfPnnjw4IHS4WVrr1+/xpQpU1CxYkXY2trCyckJ9erVw+rVq5FTZoK5cuUKJk2ahNDQUKVDSUKtVmPFihVo2LAh8ubNCysrK/j4+KBXr144ffq00uEZxW+//YZ58+YpHYaerIhJm1Rpb+bm5ihcuDDatGmD4ODgTD13cnr27KkXj729PYoWLYr27dtj06ZN0Gg0mXr+N2/eYNKkSTh48GCa91Gr1QgKCsKQIUNgb2+fecEZQMnX85IlS9CgQQMUKFAAVlZWKFKkCHr16pXks61s2bJo2bIlJk6cqEicxpBH6QByq6+//hpFihRBTEwMTpw4gZUrV+Lo0aO4dOkSrK2tFY3t+vXrMDPLXjnw48eP0aRJE1y9ehWdOnXC4MGDERMTg02bNiEwMBA7d+7EmjVrYG5urnSoqbpy5QomT56Mhg0bJvmF+tdffykTFIDo6Gi0bdsWu3fvRv369TFu3DjkzZsXoaGhWL9+PVatWoW7d++iUKFCisVoDL/99hsuXbqEzz//PFOOHx0djTx5DPvYTCkmb29vREdHw8LCwmjxde7cGS1atIBarcbVq1fx008/YdeuXThx4gQqV65stPOkhZWVFZYuXQpAPm///fcf/vzzT7Rv3x4NGzbE1q1b4ejoqNs+I++PJUuW6CVXb968weTJkwEgzaVMf/75J65fv47+/funOw5jy+zXc2rOnTuHIkWK4OOPP4aLiwtCQkKwZMkSbN++HefPn0fBggV12w4YMAAtWrTA7du3UaxYsSyPNcMEGdWKFSsEAHHq1Cm99aNHjxYAxLp16xSKTFnR0dFCrVaneL+/v78wMzMTW7duTXLfyJEjBQAxY8aMzAwxWVFRUQZtv2HDBgFAHDhwIHMCSqdBgwYJAGLu3LlJ7ktISBCzZs0S9+7dE0IIERQUJACI8PDwTItHo9GIN2/eGP24LVu2FN7e3kY9plqtFtHR0enePzNieldISIgAIGbNmqW3ftu2bQKA6N+/f6ae/12BgYHCzs4u2fumT58uAIiOHTtm2vnDw8MFABEUFJTmfT7++GNRt27dNG9v6PHTI6XXzoEDBwQAsWHDhkw9/7tOnz4tAIjp06frrY+LixMuLi5iwoQJWRqPsTARMrKUEqHt27cLAGLatGl6669evSratWsnXFxchJWVlfD19U02GXjx4oX4/PPPhbe3t7C0tBSenp6ie/fuel9WMTExYuLEiaJYsWLC0tJSFCpUSIwaNUrExMToHcvb21sEBgYKIYQ4deqUACBWrlyZ5Jy7d+8WAMSff/6pW3f//n3Rq1cv4ebmJiwtLUXZsmXFsmXL9PbTvkl///138dVXX4mCBQsKlUolXrx4kexzdvz4cQFA9O7dO9n74+PjRYkSJYSLi4vuy/PtD/45c+aIwoULC2tra1G/fn1x8eLFJMdIy/OsvXYHDx4Un332mcifP79wdnYWQggRGhoqPvvsM1GyZElhbW0t8ubNK9q3by9CQkKS7P/uTZsUNWjQQDRo0CDJ87Ru3TrxzTffCE9PT2FlZSUaN24sbt68meQxLFiwQBQpUkRYW1uL6tWri8OHDyc5ZnLu3bsn8uTJIz788MNUt9PSJkI3b94UgYGBwsnJSTg6OoqePXuK169f6227fPly0ahRI5E/f35haWkpypQpI3788cckx/T29hYtW7YUu3fvFr6+vsLKykqXlKX1GEIIsXPnTlG/fn1hb28vHBwcRLVq1cSaNWuEEPL5ffe5f/tLJK3vDwBi0KBB4tdffxVly5YVefLkEVu2bNHd9/aXX2RkpBg2bJjufZk/f37h5+cnzpw5896YtK/hFStW6J3/6tWrokOHDsLV1VVYW1uLkiVLinHjxqV2yVJMhKKiogQAvWt/4sQJ4e/vLxwdHYWNjY2oX7++OHr0qN5+hrwGkpNaIiSEEE2bNhUqlUpcv35dty6513JoaKho1aqVsLW1Ffnz5xeff/657nPp7R8bgYGBSZ7Xd2+pJS3R0dHC0tJSTJo0Kcl9MTEx4vPPPxeurq7C3t5etGrVSty7dy/ZYxry+bh27VoxduxYUaBAAWFraytatWol7t69q/d8pPTaMfSzw1iePn0qAIjRo0cnua9NmzaiYsWKmXbuzMSqsSyirVd1cXHRrbt8+TLq1KkDT09PjBkzBnZ2dli/fj1at26NTZs2oU2bNgCAqKgo1KtXD1evXkXv3r1RtWpVPH36FNu2bcP9+/fh6uoKjUaDjz/+GEePHkX//v1RpkwZXLx4EXPnzsWNGzfwxx9/JBtXtWrVULRoUaxfvx6BgYF6961btw4uLi7w9/cHIKuvPvjgA6hUKgwePBj58+fHrl270KdPH0RGRiYpvp0yZQosLS0xcuRIxMbGwtLSMtkY/vzzTwBAjx49kr0/T5486NKlCyZPnoxjx47Bz89Pd9/q1avx6tUrDBo0CDExMZg/fz4aN26MixcvokCBAgY9z1oDBw5E/vz5MXHiRLx+/RoAcOrUKfzzzz/o1KkTChUqhNDQUPz0009o2LAhrly5AltbW9SvXx9Dhw7F999/j3HjxqFMmTIAoPubkhkzZsDMzAwjR45EREQEvv32W3Tt2hX//vuvbpuffvoJgwcPRr169TB8+HCEhoaidevWcHFxeW911q5du5CQkIDu3bunut27OnbsiCJFimD69Ok4e/Ysli5dCjc3N8ycOVMvrnLlyuHjjz9Gnjx58Oeff2LgwIHQaDQYNGiQ3vGuX7+Ozp0749NPP0W/fv1QqlQpg46xcuVK9O7dG+XKlcPYsWPh7OyMc+fOYffu3ejSpQu++uorRERE4P79+5g7dy4A6Np6GPr++Pvvv7F+/XoMHjwYrq6uKTbEHTBgADZu3IjBgwejbNmyePbsGY4ePYqrV6+iatWqqcaUnAsXLqBevXqwsLBA//794ePjg9u3b+PPP//E1KlT03bh3nL79m0AQL58+XSPq3nz5vD19UVQUBDMzMywYsUKNG7cGEeOHEGNGjX09k/LayA9unfvjr/++gt79+5FyZIlk93m9evXaNy4MR49eoRhw4bB3d0dv/32Gw4cOJDqsfPnz4+ffvoJn332Gdq0aYO2bdsCACpWrJjiPmfOnEFcXByqVq2a5L6+ffvi119/RZcuXVC7dm38/fffaNmyZZLtDP18nDp1KlQqFUaPHo0nT55g3rx58PPzQ3BwMGxsbNL02knLZ8ebN2/w5s2bVJ8zADA3N9f7ftJ69uwZ1Go17t69i6+//hoA0KRJkyTb+fr6YuvWrYiMjNSr8swRlM7EchttqcC+fftEeHi4uHfvnti4caPInz+/sLKy0lU/CCFEkyZNRIUKFfR+kWo0GlG7dm1RokQJ3bqJEycKAGLz5s1JzqfRaIQQQvzyyy/CzMxMHDlyRO/+RYsWCQDi2LFjunVvlwgJIcTYsWOFhYWFeP78uW5dbGyscHZ21iul6dOnj/Dw8BBPnz7VO0enTp2Ek5OTrrRG+2ulaNGiaar+aN26tQCQYomREEJs3rxZABDff/+9ECLxV5+NjY24f/++brt///1XABDDhw/XrUvr86y9dnXr1hUJCQl650/ucWhLslavXq1bl1rVWEolQmXKlBGxsbG69fPnzxcAdCVbsbGxIl++fKJ69eoiPj5et93KlSsFgPeWCA0fPlwAEOfOnUt1Oy1tacC7JXRt2rQR+fLl01uX3PPi7+8vihYtqrfO29tbABC7d+9Osn1ajvHy5Uvh4OAgatasmaSaSvseECLlqgRD3h8AhJmZmbh8+XKS4+CdUgAnJycxaNCgJNu9LaWYkisRql+/vnBwcBD//fdfio8xOdpjTZ48WYSHh4uwsDBx8OBBUaVKFQFAbNq0SWg0GlGiRAnh7++vd7w3b96IIkWK6JUaGfIaSM77SoTOnTuX5H367vtj9uzZAoD4448/dOuio6NF6dKlUy0REsLwqrGlS5fqvee0goODBQAxcOBAvfVdunRJcnxDPx89PT1FZGSkbrv169cLAGL+/Pm6de+rGnvfZ4cQidfyfbeUqm+trKx02+TLl0/3Gfyu3377TQAQ//77b7L3Z2fZq8VsLuLn54f8+fPDy8sL7du3h52dHbZt26b79f78+XP8/fff6NixI169eoWnT5/i6dOnePbsGfz9/XHz5k1dL7NNmzahUqVKSUouANmFEwA2bNiAMmXKoHTp0rpjPX36FI0bNwaAVH9FBQQEID4+Hps3b9at++uvv/Dy5UsEBAQAAIQQ2LRpE1q1agUhhN45/P39ERERgbNnz+odNzAwEDY2Nu99rl69egUAcHBwSHEb7X2RkZF661u3bg1PT0/dco0aNVCzZk3s3LkTgGHPs1a/fv2SNMp++3HEx8fj2bNnKF68OJydnZM8bkP16tVLr7SsXr16AIA7d+4AAE6fPo1nz56hX79+eg11u3btmuwvuHdpn7PUnt/kDBgwQG+5Xr16ePbsmd41ePt5iYiIwNOnT9GgQQPcuXMHERERevsXKVJEV7r4trQcY+/evXj16hXGjBmTpLOB9j2QGkPfHw0aNEDZsmXfe1xnZ2f8+++/ePjw4Xu3fZ/w8HAcPnwYvXv3RuHChfXuS8tjBICgoCDkz58f7u7uaNiwIW7fvo2ZM2eibdu2CA4Oxs2bN9GlSxc8e/ZM9xy8fv0aTZo0weHDh5P05krLayA9tCUb2vd+cnbv3g1PT098/PHHunXW1tbo169fhs6dnGfPngFAkveT9nNk6NCheuvfLd1Jz+djjx499N6T7du3h4eHh+6cafG+zw7tefbu3fve25o1a5I9x65du7Bz507Mnj0bhQsX1pWSv0v73OXEYTdYNZZJFi5ciJIlSyIiIgLLly/H4cOHYWVlpbv/1q1bEEJgwoQJmDBhQrLHePLkCTw9PXH79m20a9cu1fPdvHkTV69eRf78+VM8VkoqVaqE0qVLY926dejTpw8AWS3m6uqq+6IIDw/Hy5cvsXjxYixevDhN5yhSpEiqMWtpPwxevXoFZ2fnZLdJKVkqUaJEkm1LliyJ9evXAzDseU4t7ujoaEyfPh0rVqzAgwcP9Lrzv/uFb6h3v/S0HygvXrwAAPz3338AgOLFi+ttlydPnjSNnaItpk7tS8fQuLTHPHbsGIKCgnD8+PEkxe8RERFwcnLSLaf0ekjLMbRVPOXLlzfoMWgZ+v5I62v322+/RWBgILy8vODr64sWLVqgR48eKFq0qMExar+80vsYAaB///7o0KEDzMzM4OzsjHLlyuk+d27evAkASarA3xYREaGXDKTlNZAe2nF6UkvO//vvPxQrVixJEvju+8CY3n5fa2MwMzNL0hNKW62rlZ7Px3c/u1QqFYoXL27Q0Bvv++wAgKJFi6br9ajVqFEjAEDz5s3xySefoHz58rC3t8fgwYP1ttM+d2lN2rMTJkKZpEaNGqhWrRoAWWpRt25ddOnSBdevX4e9vb3ul9fIkSOT/ZUMGPaG12g0qFChAubMmZPs/V5eXqnuHxAQgKlTp+Lp06dwcHDAtm3b0LlzZ10JhDbebt26pfhB+m4dfFpKgwDZhuaPP/7AhQsXUL9+/WS3uXDhAgCk6Vf629LzPCcX95AhQ7BixQp8/vnnqFWrFpycnKBSqdCpU6cMj4mS0pAA734op1fp0qUBABcvXjSoC/X74rp9+zaaNGmC0qVLY86cOfDy8oKlpSV27tyJuXPnJnleknteDT1Gehn6/kjra7djx46oV68etmzZgr/++guzZs3CzJkzsXnzZjRv3jzDcRuqRIkSem3o3qZ9LmfNmpXi6+DdNiiZ9drUDr6XmUmNIbRtqF68eJGuISTS8/loDGm5PlFRUWkaINLc3DzFHwpaxYoVQ5UqVbBmzZokiZA2+XJ1dX3vubIbJkJZwNzcHNOnT0ejRo2wYMECjBkzRpehW1hYpPjBpVWsWLH3jtpZrFgxnD9/Hk2aNElXRh4QEIDJkydj06ZNKFCgACIjI9GpUyfd/fnz54eDgwPUavV74zXURx99hOnTp2P16tXJJkJqtRq//fYbXFxcUKdOHb37tL9y33bjxg1dSYkhz3NqNm7ciMDAQMyePVu3LiYmBi9fvtTbLjN+DXl7ewOQpVvaX2cAkJCQgNDQ0Pd+wDZv3hzm5ub49ddfDW4wnZo///wTsbGx2LZtm94v0/c1Zk3PMbS/yC9dupTql2dKz39G3x+p8fDwwMCBAzFw4EA8efIEVatWxdSpU3WJUFrPp32tZtYIvdrn0NHR0ejvYUP98ssvUKlU+PDDD1PcxtvbG1euXIEQQu85vHXr1nuPb+g11v5YCAkJQYUKFfRi0Gg0uH37tl4p0PXr1/X2T8/n47ufXUII3Lp1S+/9bIzX6nfffacbUyk13t7eaSqNio6ORmxsbJL1ISEhMDMzS7Hxe3bGNkJZpGHDhqhRowbmzZuHmJgYuLm5oWHDhvj555/x6NGjJNuHh4fr/m/Xrh3Onz+PLVu2JNlOm/l37NgRDx48wJIlS5JsEx0dnWK9rlaZMmVQoUIFrFu3DuvWrYOHh4deUmJubo527dph06ZNyX5Qvx2voWrXrg0/Pz+sWLEC27dvT3L/V199hRs3buDLL79M8kv9jz/+0Gvjc/LkSfz777+6LyFDnufUmJubJ/kV/MMPP0CtVuuts7OzA4AkCVJGVKtWDfny5cOSJUuQkJCgW79mzRq9IvCUeHl5oV+/fvjrr7/www8/JLlfo9Fg9uzZuH//vkFxaX+NvltNuGLFCqMfo2nTpnBwcMD06dMRExOjd9/b+9rZ2SVbVZnR90dy1Gp1knO5ubmhYMGCel8UKcX0rvz586N+/fpYvnw57t69q3efMUoHfX19UaxYMXz33XfJlhBk5D1siBkzZuCvv/5CQEBAslXbWv7+/njw4AG2bdumWxcTE5PsNXyXra0tgLS/D319fWFpaZlkhHXt58j333+vt/7d0Z7T8/mo7fGqtXHjRjx69EivJDGtr53UpKeNUEJCQrKfLSdPnsTFixd1tR1vO3PmDMqVK6dXHZ5TsEQoC40aNQodOnTAypUrMWDAACxcuBB169ZFhQoV0K9fPxQtWhSPHz/G8ePHcf/+fZw/f16338aNG9GhQwf07t0bvr6+eP78ObZt24ZFixahUqVK6N69O9avX48BAwbgwIEDqFOnDtRqNa5du4b169djz549yb543xYQEICJEyfC2toaffr0STL69IwZM3DgwAHUrFkT/fr1Q9myZfH8+XOcPXsW+/btw/Pnz9P93KxevRpNmjTBJ598gi5duqBevXqIjY3F5s2bcfDgQQQEBGDUqFFJ9itevDjq1q2Lzz77DLGxsZg3bx7y5cuHL7/8UrdNWp/n1Hz00Uf45Zdf4OTkhLJly+L48ePYt2+frkhdq3LlyjA3N8fMmTMREREBKysrNG7cGG5ubul+biwtLTFp0iQMGTIEjRs3RseOHREaGoqVK1cm24YiObNnz8bt27cxdOhQbN68GR999BFcXFxw9+5dbNiwAdeuXdMrAUyLpk2bwtLSEq1atcKnn36KqKgoLFmyBG5ubskmnRk5hqOjI+bOnYu+ffuievXq6NKlC1xcXHD+/Hm8efMGq1atAiC/0NatW4cRI0agevXqsLe3R6tWrYzy/njXq1evUKhQIbRv3x6VKlWCvb099u3bh1OnTumVHKYUU3K+//571K1bF1WrVkX//v1RpEgRhIaGYseOHRmeKsPMzAxLly5F8+bNUa5cOfTq1Quenp548OABDhw4AEdHR91QFsaQkJCAX3/9FYBMYP777z9s27YNFy5cQKNGjVJsS6P16aefYsGCBejcuTOGDRsGDw8PrFmzRtdYPrXXvY2NDcqWLYt169ahZMmSyJs3L8qXL59i+ytra2s0bdoU+/bt03URB+T7uXPnzvjxxx8RERGB2rVrY//+/cmWShn6+Zg3b17UrVsXvXr1wuPHjzFv3jwUL15crzG4Ia+dlKSnjVBUVBS8vLwQEBCAcuXKwc7ODhcvXsSKFSvg5OSUpL1lfHw8Dh06hIEDBxp0nmwjS/uomYCUBlQUQo5QW6xYMVGsWDFd9+zbt2+LHj16CHd3d2FhYSE8PT3FRx99JDZu3Ki377Nnz8TgwYOFp6enbjC4wMBAva6acXFxYubMmaJcuXLCyspKuLi4CF9fXzF58mQRERGh2+7d7vNaN2/e1HWTfHeANa3Hjx+LQYMGCS8vL2FhYSHc3d1FkyZNxOLFi3XbpHfU01evXolJkyaJcuXKCRsbG+Hg4CDq1KkjVq5cmaT78NsDyM2ePVt4eXkJKysrUa9ePXH+/Pkkx07L85zatXvx4oXo1auXblA1f39/ce3atWSfyyVLloiiRYsKc3PzNA2o+O7zlNJAe99//73w9vYWVlZWokaNGuLYsWPC19dXNGvWLA3PrhxBeunSpaJevXrCyclJWFhYCG9vb9GrVy+9rvUpjSytfX7eHkRy27ZtomLFisLa2lr4+PiImTNniuXLlyfZTjugYnLSegzttrVr1xY2NjbC0dFR1KhRQ/z++++6+6OiokSXLl2Es7Nzki7BaX1/4P8DKiYHb3WZjo2NFaNGjRKVKlUSDg4Ows7OTlSqVCnJYJApxZTSdb506ZJo06aNcHZ2FtbW1qJUqVLvHbE3pQEVk3Pu3DnRtm1bkS9fPmFlZSW8vb1Fx44dxf79+3XbGPIaSE5gYKBe12xbW1vh4+Mj2rVrJzZu3JjsKPPJDah4584d0bJlS2FjYyPy588vvvjiC7Fp0yYBQJw4cULvfO92//7nn3+Er6+vsLS0TFNX+s2bNwuVSqU3qKEQssv+0KFDRb58+YSdnV2qAyoa8vn4+++/i7Fjxwo3NzdhY2MjWrZsmWTYhJReO4Z+dhgqNjZWDBs2TFSsWFE4OjrqPiv69OmT7LXftWuXwP8H4MyJVELkkNksid4SGhqKIkWKYNasWRg5cqTS4ShCo9Egf/78aNu2bZqqC4hyg3nz5mH48OG4f/++Xm/PjFKr1Shbtiw6duyIKVOmGO247zp48CAaNWqEDRs2oH379pl2nqzUunVrqFSqZJtv5ARsI0SUA8TExCRpJ7J69Wo8f/48zZNKEuU00dHRessxMTH4+eefUaJECaMmQYBs5/P1119j4cKFaeplRdLVq1exffv2TE0eMxvbCBHlACdOnMDw4cPRoUMH5MuXD2fPnsWyZctQvnx5dOjQQenwiDJF27ZtUbhwYVSuXBkRERH49ddfce3atRQH/8uogIAA3SCylDZlypTR68SREzERIsoBfHx84OXlhe+//x7Pnz9H3rx50aNHD8yYMSPFOdyIcjp/f38sXboUa9as0VVdrV27lskKGZWibYQOHz6MWbNm4cyZM3j06BG2bNmC1q1bp7rPwYMHMWLECFy+fBleXl4YP348evbsmSXxEhERUe6iaBuh169fo1KlSli4cGGatg8JCUHLli3RqFEjBAcH4/PPP0ffvn2xZ8+eTI6UiIiIcqNs02tM2+I8tRKh0aNHY8eOHXoDVnXq1AkvX77E7t27syBKIiIiyk1yVBuh48ePJxm+3N/fP8lMwG+LjY3VG+VVo9Hg+fPnyJcvX46cHI6IiMgUCSHw6tUrFCxYMMmAvxmRoxKhsLAwFChQQG+ddl6s6OjoZCdKnD59eprmWSEiIqLs7969e+maHDclOSoRSo+xY8dixIgRuuWIiAgULlwY9+7dg6Ojo4KREeU8QgBqNZCQAERHAzExQFQUEBcHxMfL9fHxgHZ6JCHkOu1NrQbu3gXy5pXL2v1u3ADc3eXys2fAgweJy3FxwK1bgLU14OAAaDTyOELI/7XLT58CYWFAoUJyWRunRiP/cmgY5ZibJ71FRAAFCgBmZnLZzCzpTbv+1SvgxQugZEm5rFLpb5fcsnYdAFy/DmjnMtXel9xNe39K26V1f+3tzRv5OL299eN89682zpS2efAA8PExLJa03t49zosXgJvb+8/17jqt9OyX3DZxcYCjI+B8eCuian0Ila0t3ryJRJMmXnBwcMjQ6/FdOSoRcnd3x+PHj/XWPX78GI6OjsmWBgGAlZUVrKyskqx3dHRkIkTZnlotE4U3b4DXr2XiEREhv9hjY+WHxYMHMknQJhWxscDt2zJpuHhRftloE4rjx4FSpfSTlvh44MQJoFw5ua92GiVHx8SEQptUZI8WhakzcO7YJKytAQsLIE+exNujR0CZMoClpbzPwgK4dAmoVStxWwsL+cV98yZQtWrSY/z3H1C+fNIv+beTAO3/4eFAwYLyGO/e9+5NpZKvi7x5k/+iezsxSM/92pulZfLnTykZsbFJjJnIYK9fA4MGAatWAX37AkuWIDJS3mXsZi05KhGqVasWdu7cqbdu7969qFWrlkIRkSkSQn7xvH4tf6lqSzbi4mSpRHw8EBoqv/wuXADy5ZP3xcQAwcGAlxdw9qxcf/cuEBkJuLjIJET7JW5pKY+TGYlHMvNFAgAuX9Zf1n7opEb7hff6NeDpmZgkWFjIX+HlysmE7O2EwNwcuHYNqF5dbqdNLkJCZAKh/d0SEwMULizvt7SU53B2lolKcsmBubm8Fvb2Mibtud7+a2Ym99cuv7sNmw0SZQOXLgEdOwJXr8o3beHCmforTNFEKCoqSm8W35CQEAQHByNv3rwoXLgwxo4diwcPHmD16tUAgAEDBmDBggX48ssv0bt3b/z9999Yv349duzYodRDoBxGCFmi8vx5YunK06cyORACuHJFfnGfPi2rWF6+lKUlL1/KqpqwsMyJ652JqREXl/x2jo4yUQgPl9UEVlYySbhyBahXLzGpMDeXsVaqJB9jmTKJ2z57BhQrpl+SkSePTLzy509MNOztE6sxtInC2zdra3k8Jg9EZBRCAMuXA0OGyLp3Dw/gt9+ATJ5GSNFE6PTp02jUqJFuWduWJzAwECtXrsSjR49w9+5d3f1FihTBjh07MHz4cMyfPx+FChXC0qVL4e/vn+Wxk3I0GllV9Pgx8PChLEkJCUksgXn2TH5RHz8u6+ZjYoDDh+WPirdeTgZLLQlydU0sxYmMlCUbT57IUo8HDwBfX5mIWFjIOviyZeX73Ntbxp03L2BnJ7cxN5f/v126Ym2dWFJCRJTrREUBAwYA2ulTmjYFfvlFNljKZNlmHKGsEhkZCScnJ0RERLCNUDby4oVsh3H3riydefhQtm9RqWSVyPHjMgF6aySEDMubV1ahPHki283ExgIffCDfj5UqyYSmVCm5jbW1LCFydZXLjo6Ara1MYoiIKIPu3wcqV5bF7998A3z5ZZIGZpn1/c2PccpUERGyvczdu/IWFwecPy+TjDNnZCPcBw8yfp4PPpANhBs2lFVdJUsCRYvK4xcvLhMZlUq2z/HxAZycMn5OIiIykkKFgN9/l78069bN0lMzEaJ0e/QI2LdPVvGcOSOXzc2BQ4dkCU96ubjIrq7u7rLKuFo12RDXykomN3nzJpbMsEcKEVEOFBkJ9O8PdOoEaGeU+PBDRUJhIkTJSkiQPXv+/Vf2Jrp7F9i2TbZtiYqSpS+GcHOTpTOOjjLZj42Vx8qbV7afKVVK9qIiIqJc7swZICBAfpEcOCDbA9naKhYOEyET9OqVTHKCg2U1lY2NfC2GhclqKgcHuU1yzp9Pus7JCfD3l215ihUDKlSQ60qUkI2BXVwy9eEQEVFOIASwYAEwcqRsJ+HtDaxdq2gSBDARMgkPHwJz5sgu4YcOvX/7d5Mge3vZ/bpGDZncVKsmezXlyyerddl9moiIUvXyJdCnD7B5s1xu3Vp2lc8Gv5SZCOUyQshSx+++A7ZulV3HU2JuLl+DlSvLMWgAWUXl7S1HtS1YkL2iiIgog16+BKpUkT1nLCzkF9SQIdnmVzS/5nIwIYC9e4ENG2RpT3Dw+/f59FM5ns7nnyteGklERKbA2Rlo3hzYswdYt05WK2QjTIRymNu35bQrBw++f9sKFYB27YDevWW3cSIioizx7JnsdVOggFyeM0f2ksmGY5cwEcoB9u2TDezfnYbhbW3bAjVryh5ZVavKcXOIiIiy3D//yG7xxYvLagvtnDzZ9IuJiVA2dP8+8PXXwP79wJ07yW/j4gKsWCF7a2XT1xYREZkSjQaYNQv46is5XoqVlRxgrlAhpSNLFROhbCIhAQgKAqZNS3mbbt3kyOPe3lkXFxER0XuFhwOBgcCuXXK5c2fg55/leCzZHBMhBQkBrFolGzAnN9t44cJAr16yWqxMmayPj4iI6L2OHJFVYQ8fyiqK77+XjVmzSa+w92EipJC//pLVWsmZOxf47DPONk5ERNmcWg0MHCiToNKlgfXrZU+dHIQzNWWhZ8/k5KAqVdIkqHt3OQu6ELJrO5MgIiLK9szN5WSpffsCp07luCQIYIlQlrhzRw5amNy0FXPnysSHiIgoR/j7b+DmTdmuAwDKlweWLFE2pgxgIpTJ9uwBmjXTX+fsDGzaBDRurEhIREREhlOrZZfmKVNkSZCvb7YbHDE9mAhlAiFk766JE/XXlyolZ3PPhuNJERERpezhQ6Br18TRfHv2BMqWVTIio2EiZGRPniQOpPm2efOAYcOyPBwiIqKM2bNHNmQND5ezcP/8M9Cli9JRGQ0bSxvRq1dJk6Bly2QJEZMgIiLKcSZNku07wsOBSpXkrN65KAkCmAgZzfz5gKNj4nK9ejIB6t1buZiIiIgyxNlZ/h0wADhxAihZUtFwMgOrxjLo9m05ncrbWrcGtmxRJBwiIqKMef0asLOT/w8bBlSpAjRooGxMmYglQhmg0SRNgtatYxJEREQ5UHw8MGqUnLlbO96LSpWrkyCAJUIZYm6e+H/FisD588rFQkRElG7//SenyThxQi7/8YdsIG0CWCKUTu8OgsgkiIiIcqStW+WovydOyPFdNm0ymSQIYCKULqGhsnG0llqtWChERETpExcnf9W3bg28fAnUqAGcOwe0batwYFmLiVA6FCmS+P/p04AZn0UiIsppRo9O/FX/xRdyFvm3v+BMBL/CDeTjk/i/jY0cYZyIiCjHGTMGKFcO2LYN+O47wNJS6YgUwUTIAAMHyvZkWs+eKRcLERGRQWJi5EzxWgUKABcuAK1aKRdTNsBeY2n05g3w00+Jy/fuyRIhIiKibO/mTaBjRyA4WC537iz/sm0HS4TSqkOHxP9PnAAKFVIuFiIiojT7/Xc5NlBwMODqCuTNq3RE2QoToTQIDwd27kxcrllTuViIiIjSJDoa6N9fzg0WFQXUry+TIX9/pSPLVpgIpYGbW+L/ixYpFwcREVGaXLsmf7UvWSJHhx4/Hti/H/D0VDqybIdthN7j7V5hZmbAp58qFwsREVGa3L4NXLwof8mvWQP4+SkdUbbFRCgVEyYAZ88mLsfHKxcLERFRmrVsKUuDWrYEPDyUjiZbY9VYCkJCgG++SVw+d46N64mIKJu6fBmoV09/jJe+fZkEpQG/2pOh0QBFiyYunzsnp2EhIiLKVoQAli8HqlcHjh5NOhEmvRerxpJx717i/+PGMQkiIqJsKCoKGDBAtgECgKZNgZ9/VjamHIglQsm4ezfx/6lTlYuDiIgoWefPy948a9YA5ubAtGnArl363ZwpTVgilIz69ZWOgIiIKAVHjgAffgjExsru8GvXAnXrKh1VjsVE6B0aTeL/Xl7KxUFERJSs6tWB0qVlErRqlRwtmtKNidA7/vwz8f8LF5SLg4iISOfqVaBkSVkNZm0N7Nsnp8pgd+YM4zP4jnXrEv93dlYsDCIiItkrbMEC2Wvn7Uarrq5MgoyEJULv2LRJ/n17RGkiIqIs9/Il0KcPsHmzXD5/XrbfYAJkVHw23xEXJ/++PY4QERFRljp5EqhSRSZBFhbAvHnAxo1MgjIBn9EUcEwqIiLKckIAc+fKXmChoUCRIsCxY8CwYXLyVDI6JkJv0VaLAUD58srFQUREJiokRI7kGx8PtGsnJ7ysXl3pqHI1thF6y9Onif87OioXBxERmaiiRYGFC4HoaGDgQJYCZQEmQm8ZMED+bd5c2TiIiMhEaDTA7NlywtQPPpDrevdWNiYTw0ToLUWKyFLJc+eUjoSIiHK98HAgMFBOjeHtDVy6BNjbKx2VyWEi9JaQEPl32TJl4yAiolzu8GGgc2fg4UM5QOJXXwF2dkpHZZLYWDoZefMqHQEREeVKGo0cGLFRI5kElSoF/Psv0K8f2wMphCVC//fmTeL/np7KxUFERLlUVBTQti2wd69c7t4d+PFHVocpjInQ/718mfh/oUKKhUFERLmVnR1gYyNvP/4I9OypdEQEJkI6168n/s/SSSIiMgq1Wk5ZYGMjv1xWrADCwoCyZZWOjP6PbYT+b/RopSMgIqJc5dEjwM9Ptv8RQq7Lm5dJUDbDEiHItmunTikdBRER5Rp//QV06ya7yNvZAXfuAMWKKR0VJYMlQpDTuGj98YdiYRARUU6XkCC7wjdrJpOgihWB06eZBGVjLBECcPBg4v+ffKJYGERElJPdvw906QIcOSKXP/1UTqBqY6NsXJQqJkKQyTogh3MgIiIymEYj52e6dAlwcACWLAECApSOitKAVWOQg3oCQNOmysZBREQ5lJkZMG8eUK2anDGeSVCOwUQIwKFD8m+JEsrGQUREOcjdu7JRtFaTJnKU6OLFlYuJDMZECICtrfwbGalsHERElENs2wZUrgy0bw/cupW43oxfqzmNyV+xFy8SJ1v19VU2FiIiyubi4oDhw2XPmhcvgNKlgTxsbpuTKZ4ILVy4ED4+PrC2tkbNmjVx8uTJVLefN28eSpUqBRsbG3h5eWH48OGIiYlJ9/m7d0/8/4MP0n0YIiLK7UJCgLp1ZVsgQCZER48CPj5KRkUZpGgitG7dOowYMQJBQUE4e/YsKlWqBH9/fzx58iTZ7X/77TeMGTMGQUFBuHr1KpYtW4Z169Zh3Lhx6Y7h7RJNZ+d0H4aIiHKzTZuAKlXk6LsuLsDWrcCcOYClpdKRUQYpmgjNmTMH/fr1Q69evVC2bFksWrQItra2WL58ebLb//PPP6hTpw66dOkCHx8fNG3aFJ07d35vKVJqtHOMjRyZ7kMQEVFu988/QEQEUKsWEBwMfPyx0hGRkSiWCMXFxeHMmTPw8/NLDMbMDH5+fjh+/Hiy+9SuXRtnzpzRJT537tzBzp070aJFixTPExsbi8jISL2blkaTuF2rVhl8QERElLto5wcDgOnTgfnzZTfjwoWVi4mMTrFE6OnTp1Cr1ShQoIDe+gIFCiAsLCzZfbp06YKvv/4adevWhYWFBYoVK4aGDRumWjU2ffp0ODk56W5eXl66+77/PnG7atUy9niIiCgXWbsWaNECiI+Xy5aWwNChgIWFsnGR0SneWNoQBw8exLRp0/Djjz/i7Nmz2Lx5M3bs2IEpU6akuM/YsWMRERGhu927d0933/Dhidtpu9ATEZEJi46WU2N07gzs3i1HiKZcTbE+f66urjA3N8fjx4/11j9+/Bju7u7J7jNhwgR0794dffv2BQBUqFABr1+/Rv/+/fHVV1/BLJnxG6ysrGBlZZVkfVxc4v/t2mXggRARUe5w/TrQsSNw4QKgUgHjxgH9+ysdFWUyxUqELC0t4evri/379+vWaTQa7N+/H7Vq1Up2nzdv3iRJdszNzQEA4u263DS4eDHx/8WLDdqViIhym19/lYPJXbgAuLkBe/YA33zDMYJMgKJXeMSIEQgMDES1atVQo0YNzJs3D69fv0avXr0AAD169ICnpyemT58OAGjVqhXmzJmDKlWqoGbNmrh16xYmTJiAVq1a6RKitNLWkFlbA3nzGvVhERFRTjJ1KjB+vPy/USNgzRrAw0PZmCjLKJoIBQQEIDw8HBMnTkRYWBgqV66M3bt36xpQ3717V68EaPz48VCpVBg/fjwePHiA/Pnzo1WrVpg6darB5z58WP7NwFiMRESUG7RvD3z7LTBihEyIDPxhTTmbShhap5TDRUZGwsnJCWPGRGDGDEeUKAHcuKF0VERElGWEkFVglSolrnv2DMiXT7mY6L20398RERFwdHQ02nFzVK8xY9KWCDVpomwcRESUhaKigB49gKpV5ZhAWkyCTJbJJkKPHun/JSKiXO7CBTlo3K+/yuVLl5SNh7IFk02EtG2DKlRQNg4iIspkQsjuwTVqyC7ynp7AwYPAoEFKR0bZgMn2C9SWBJUvr2wcRESUiSIj5QCJa9fK5ebNgdWrAVdXZeOibMNkS4RcXORfHx9FwyAiosy0datMgszNZc+w7duZBJEeky0RevFC/nVwUDYOIiLKRN26AefOAR06yJnjid5hsiVCWtbWSkdARERG8/IlMHhw4q9dlQqYM4dJEKXIZEuEtIoWVToCIiIyilOngIAAICQEePo0sV0QUSpMukSI7YOIiHIBIYB584A6dWQSVKQI8MUXSkdFOYRJlwixNIiIKId7/hzo1QvYtk0ut2sHLF0KODsrGhblHCadCBERUQ528SLw0UfA3buApaVsCzRwoGwXRJRGTISIiChnKlhQVosVKwasXy+nzSAyEBMhIiLKOV69AuztZalPvnzArl2AlxdgxEk4ybSYdGNpIiLKQY4cAcqUAVauTFxXrhyTIMoQk06E/v5b6QiIiOi9NBpg2jSgUSPgwQPghx8AtVrpqCiXMOlEaMIEpSMgIqJUPXkCNGsGfPWVTH66dQMOH5ZTZhAZgUm3EWJpKhFRNnbgANClCxAWBtjYAAsWyK7y7BVGRmTSiRAREWVT//0HNG0KJCQAZcvKXmHlyikdFeVCTISIiCj78fYGxo4F7t+XbYLs7JSOiHIpJkJERJQ97Nsn5z4qXlwuT57MajDKdCbdWFo7OTERESkoIQEYP15WhQUEALGxcj2TIMoCJl0iVKmS0hEQEZm4Bw+Azp3lGEEAUL26HC2aKIuYdCJkaal0BEREJmzXLqBHD+DpU8DBAVi8GOjUSemoyMSYdNUYS12JiBQQHw+MHg20aCGToCpVgDNnmASRIkw6ESpWTOkIiIhMkBByjCAAGDQI+OcfoEQJZWMik2XSVWNERJSFhJBF8ZaWwLp1wNmzQLt2SkdFJo6JEBERZa64OGDMGMDaWs4ZBgBFisgbkcKYCBERUeYJCZFtf06elKVBPXoApUsrHRWRjkm3ESIioky0ebNsCH3yJODsDGzZwiSIsh0mQkREZFyxscCQIbL9T0QE8MEHQHAw8MknSkdGlASrxoiIyHiEkCNEHz4sl7/8EvjmG8DCQtm4iFJg0okQ35dEREamUgF9+wKXLwOrV8uxgoiyMZUQpjWWeWRkJJycnABEIDraEdbWSkdERJTDRUcDoaFAmTKJ654/B/LmVSwkyn20398RERFwdHQ02nFNuo2QmUk/eiIiI7h+XbYB8vMDwsMT1zMJohzCpFMBzjVGRJQBv/4K+PoCFy7IaTNCQpSOiMhgJpsIFSyodARERDnUmzdAnz5A9+7A69dAw4ayV1iNGkpHRmQwk02EiIgoHa5ckQnP8uWyYXRQELBvH39dUo5l0r3GiIjIQDNnyh5h7u7AmjVA48ZKR0SUIUyEiIgo7b7/HsiTR84ZVqCA0tEQZRirxoiIKGUXLwKjRsmBEgHAyQlYtoxJEOUaLBEiIqKkhACWLgWGDgViYoBSpeRAiUS5DBMhIiLSFxkJfPopsHatXG7enPOEUa5lslVjDx8qHQERUTZ07pwcG2jtWsDcXDaO3r4dyJ9f6ciIMkWGSoRiYmJgnUPnqChaVOkIiIiymV9+kdVfcXGAl5dMhmrXVjoqokxlcImQRqPBlClT4OnpCXt7e9y5cwcAMGHCBCxbtszoAWYWDnlBRPSOIkUAtRpo1UoOkMgkiEyAwYnQN998g5UrV+Lbb7+F5VtzVJQvXx5Lly41anBERJTJIiIS/69bFzh+HNi6lXOFkckwOBFavXo1Fi9ejK5du8Lc3Fy3vlKlSrh27ZpRgyMiokwiBDB/PuDjI0eL1qpeXY4YTWQiDE6EHjx4gOLFiydZr9FoEB8fb5SgskJUlNIREBEp5PlzoE0b4PPPgZcvgZUrFQ6ISDkGJ0Jly5bFkSNHkqzfuHEjqlSpYpSgsoKZyfaXIyKTduIEUKWKrP6ytAR++EH2DCMyUQb3Gps4cSICAwPx4MEDaDQabN68GdevX8fq1auxffv2zIgxU1SooHQERERZSKMB5swBxo4FEhKAYsWAdetkV3kiE2Zwucgnn3yCP//8E/v27YOdnR0mTpyIq1ev4s8//8SHH36YGTESEVFG/fqrnCojIQHo2BE4c4ZJEBHSOY5QvXr1sHfvXmPHQkREmaVLFzlbfJs2ctRoNogmApCOEqGiRYvi2bNnSda/fPkSRTlKIRFR9qDRyLnCYmPlcp48wO7dwIABTIKI3mJwIhQaGgq1Wp1kfWxsLB48eGCUoIiIKAOePJHzg/XrB4wenbieCRBREmmuGtu2bZvu/z179sDJyUm3rFarsX//fvj4+Bg1OCIiMtDBg7Ia7NEjwMYGqFhR6YiIsrU0J0KtW7cGAKhUKgQGBurdZ2FhAR8fH8yePduowRERURqp1cDUqcDkybJarEwZYMMGoFw5pSMjytbSnAhpNBoAQJEiRXDq1Cm4urpmWlBERGSAsDCga1fg77/lcq9ecnwgOztl4yLKAQzuNRYSEpIZcRARUXq9eQOcPg3Y2gKLFgHduysdEVGOka7u869fv8ahQ4dw9+5dxMXF6d03dOhQowRGRESpECKx8XPRosD69YC3N1C6tLJxEeUwBidC586dQ4sWLfDmzRu8fv0aefPmxdOnT2Fraws3NzcmQkREme3BA6BbNzlKdNOmcp2/v7IxEeVQBnefHz58OFq1aoUXL17AxsYGJ06cwH///QdfX1989913mRFjpvh/kyciopxl926gcmXZO2zgQDlSNBGlm8GJUHBwML744guYmZnB3NwcsbGx8PLywrfffotx48ZlRoyZ4sULpSMgIjJAfDwwZowcH+jpU5kM7dwpB0okonQzOBGysLCA2f+nbndzc8Pdu3cBAE5OTrh3755xo8tE1asrHQERURrduwc0bJg4S/zAgcDx40DJkoqGRZQbGJwIValSBadOnQIANGjQABMnTsSaNWvw+eefo3z58gYHsHDhQvj4+MDa2ho1a9bEyZMnU93+5cuXGDRoEDw8PGBlZYWSJUti586dBp+XiChHePBAlv788w/g6CjHBlq4ELC2VjoyolzB4ERo2rRp8PDwAABMnToVLi4u+OyzzxAeHo6ff/7ZoGOtW7cOI0aMQFBQEM6ePYtKlSrB398fT548SXb7uLg4fPjhhwgNDcXGjRtx/fp1LFmyBJ6enoY+DCKinMHTE2jVCqhWDTh3DmjfXumIiHIVlRBCKHXymjVronr16liwYAEAOWijl5cXhgwZgjFjxiTZftGiRZg1axauXbsGCwuLdJ0zMjISTk5OmDw5AhMnOmYofiKiTBEaCtjbA9qBa9+8AczNASsrRcMiUpL2+zsiIgKOjsb7/ja4RCglZ8+exUcffZTm7ePi4nDmzBn4+fklBmNmBj8/Pxw/fjzZfbZt24ZatWph0KBBKFCgAMqXL49p06YlOwmsVmxsLCIjI/VuRETZ1pYtsiosMDCxe6utLZMgokxiUCK0Z88ejBw5EuPGjcOdO3cAANeuXUPr1q1RvXp13TQcafH06VOo1WoUKFBAb32BAgUQFhaW7D537tzBxo0boVarsXPnTkyYMAGzZ8/GN998k+J5pk+fDicnJ93Ny8srzTESEWWZ2Fhg6FCgbVsgIgJ49kz+JaJMleZEaNmyZWjevDlWrlyJmTNn4oMPPsCvv/6KWrVqwd3dHZcuXcr0RssajQZubm5YvHgxfH19ERAQgK+++gqLFi1KcZ+xY8ciIiJCd8tJPduIyETcvg3UqSPnBwOAkSOBI0cAFxdl4yIyAWkegGL+/PmYOXMmRo0ahU2bNqFDhw748ccfcfHiRRQqVMjgE7u6usLc3ByPHz/WW//48WO4u7snu4+HhwcsLCxgbm6uW1emTBmEhYUhLi4OlpaWSfaxsrKCFYuUiSi7Wr8e6NsXePUKyJcPWLUKaNlS6aiITEaaS4Ru376NDh06AADatm2LPHnyYNasWelKggDA0tISvr6+2L9/v26dRqPB/v37UatWrWT3qVOnDm7duqVXBXfjxg14eHgkmwQREWVrMTFymoxXr2SJUHAwkyCiLJbmRCg6Ohq2trYAAJVKBSsrK103+vQaMWIElixZglWrVuHq1av47LPP8Pr1a/Tq1QsA0KNHD4wdO1a3/WeffYbnz59j2LBhuHHjBnbs2IFp06Zh0KBBGYqDiEgR1tbAunXAuHFyyox0/rAkovQzaGz2pUuXwt7eHgCQkJCAlStXwlXbvfP/DJl0NSAgAOHh4Zg4cSLCwsJQuXJl7N69W9eA+u7du7pRrAHAy8sLe/bswfDhw1GxYkV4enpi2LBhGD16tCEPg4hIOb/9JrvD9+0rl6tVkzciUkSaxxHy8fGBSqVK/WAqla43WXbFcYSISBFv3gDDhgFLlwKWlrIarEwZpaMiyjEyaxyhNJcIhYaGGu2kREQm5epVoGNH4NIlQKWS7YI4TxhRtsBpi4mIMtOqVXKS1DdvgAIFZNVY48ZKR0VE/8dEiIgoMwgB9OsHLFsml/38gF9/lckQEWUbRptig4iI3qJSAUWLAmZmwJQpwO7dTIKIsiGWCBERGYsQcloMZ2e5PGYM0KwZULWqomERUcpYIkREZAyvXgFduwL16sn2QIAsDWISRJStpSsRun37NsaPH4/OnTvjyZMnAIBdu3bh8uXLRg2OiChHCA4GfH2B33+XPcQOH1Y6IiJKI4MToUOHDqFChQr4999/sXnzZkRFRQEAzp8/j6CgIKMHSESUbQkB/PQT8MEHwM2bgJeXTIKaNVM6MiJKI4MToTFjxuCbb77B3r179eb3aty4MU6cOGHU4IiIsq2ICCAgQHaNj40FWrUCzp0DatdWOjIiMoDBidDFixfRpk2bJOvd3Nzw9OlTowRFRJTtDR4MbNgA5MkDzJ4NbN0qZ48nohzF4ETI2dkZjx49SrL+3Llz8PT0NEpQRETZ3vTpsl3Q0aPAiBGyuzwR5TgGJ0KdOnXC6NGjERYWBpVKBY1Gg2PHjmHkyJHo0aNHZsRIRKS8Fy/kKNFahQoBp04BNWsqFxMRZZjBidC0adNQunRpeHl5ISoqCmXLlkX9+vVRu3ZtjB8/PjNiJCJS1r//AlWqAD17yiowLZYCEeV4Bg+oaGlpiSVLlmDChAm4dOkSoqKiUKVKFZQoUSIz4iMiUo4QwJw5cmDEhASgWDFZEkREuYbBidDRo0dRt25dFC5cGIULF86MmIiIlPfsmSwB2r5dLnfsCCxZAjg6KhoWERmXwVVjjRs3RpEiRTBu3DhcuXIlM2IiIlLWsWNA5coyCbKykmMFrV3LJIgoFzI4EXr48CG++OILHDp0COXLl0flypUxa9Ys3L9/PzPiIyLKeg8fAvfvAyVKACdOAAMGsD0QUS5lcCLk6uqKwYMH49ixY7h9+zY6dOiAVatWwcfHB40bN86MGImIMp8Qif936ACsXAmcOSNLhogo18rQpKtFihTBmDFjMGPGDFSoUAGHDh0yVlxERFnn0CE5JtDbY6QFBgIODsrFRERZIt2J0LFjxzBw4EB4eHigS5cuKF++PHbs2GHM2IiIMpdaDUyZAjRuLKfHmDhR6YiIKIsZ3Gts7NixWLt2LR4+fIgPP/wQ8+fPxyeffAJbW9vMiI+IKHOEhQHdugH798vlnj2BefOUjIiIFGBwInT48GGMGjUKHTt2hKura2bERESUufbvB7p2BR4/BmxtZa8wjoxPZJIMToSOHTuWGXEQEWWNLVuAdu1k4+jy5YH164EyZZSOiogUkqZEaNu2bWjevDksLCywbdu2VLf9+OOPjRIYEVGm+PBDoFQpoF49YP58wMZG6YiISEFpSoRat26NsLAwuLm5oXXr1ilup1KpoFarjRUbEZFxnDole4WZmQH29nJsICcnpaMiomwgTb3GNBoN3NzcdP+ndGMSRETZSkICMHYsUKOGnDNMi0kQEf2fwd3nV69ejdjY2CTr4+LisHr1aqMERUSUYffuAQ0bAjNmyGWOfk9EyTA4EerVqxciIiKSrH/16hV69epllKCIiDJkxw45IvSxY3J+sA0b2DWeiJJlcCIkhIAqmTl37t+/DycWNxORkuLigJEjgY8+Ap4/B6pVkwMltm+vdGRElE2luft8lSpVoFKpoFKp0KRJE+TJk7irWq1GSEgImjVrlilBEhGlydWrwPffy/+HDQNmzpSzxxMRpSDNiZC2t1hwcDD8/f1hb2+vu8/S0hI+Pj5o166d0QMkIkqzSpWABQsANzcglR6uRERaaU6EgoKCAAA+Pj4ICAiAtbV1pgVFRJQmsbHAuHFA9+6Js8T3769oSESUsxg8snRgYGBmxEFEZJjbt4GAAODMGWD7duDSJcDCQumoiCiHSVMilDdvXty4cQOurq5wcXFJtrG01vPnz40WHBFRsjZsAPr2BSIjgbx55RhBTIKIKB3SlAjNnTsXDg4Ouv9TS4SIiDJNTAwwYoScJBUA6tQBfv8d8PJSNi4iyrHSlAi9XR3Ws2fPzIqFiChl4eFA06ZAcLBcHjsW+PprII/BNfxERDoGjyN09uxZXLx4Ube8detWtG7dGuPGjUNcXJxRgyMi0smbF3B1BfLnB3bvBqZNYxJERBlmcCL06aef4saNGwCAO3fuICAgALa2ttiwYQO+/PJLowdIRCbszRsgOlr+b24OrFkjS4T8/RUNi4hyD4MToRs3bqDy/7upbtiwAQ0aNMBvv/2GlStXYtOmTcaOj4hM1dWrQM2awOefJ65zcwMKFlQsJCLKfdI1xYZGowEA7Nu3Dy1atAAAeHl54enTp8aNjohM06pVcnqMS5eArVtl+yAiokxgcCJUrVo1fPPNN/jll19w6NAhtGzZEgAQEhKCAgUKGD1AIjIhr18DPXvK25s3QJMmsiosf36FAyOi3MrgRGjevHk4e/YsBg8ejK+++grFixcHAGzcuBG1a9c2eoBEZCIuXQKqV5elQWZmwJQpwJ49gLu70pERUS5mcJeLihUr6vUa05o1axbMzc2NEhQRmZi4OKB5c+D+fdkG6LffgAYNlI6KiExAuvuenjlzBlevXgUAlC1bFlWrVjVaUERkYiwtgUWLgIULZYkQq8KIKIsYnAg9efIEAQEBOHToEJydnQEAL1++RKNGjbB27Vrk5wcYEaXF+fPAkyfAhx/K5ZYtgRYtAI5cT0RZyOA2QkOGDEFUVBQuX76M58+f4/nz57h06RIiIyMxdOjQzIiRiHITIWTpT82actLUu3cT72MSRERZzOASod27d2Pfvn0oU6aMbl3ZsmWxcOFCNG3a1KjBEVEuExEB9O8PrF8vlz/8ELCzUzYmIjJpBpcIaTQaWCQzy7OFhYVufCEioiTOnAGqVpVJUJ48wOzZwLZtQL58SkdGRCbM4ESocePGGDZsGB4+fKhb9+DBAwwfPhxNmjQxanBElEv88ANQuzZw5w7g7Q0cPSpnkWdVGBEpzOBEaMGCBYiMjISPjw+KFSuGYsWKoUiRIoiMjMQPP/yQGTESUU53+bLsIt+6NXDunGwfRESUDRjcRsjLywtnz57F/v37dd3ny5QpAz8/P6MHR0Q5mBCJJT5z58oSoe7dWQpERNmKQYnQunXrsG3bNsTFxaFJkyYYMmRIZsVFRDmVEDLx2bsX2L5dzhpvYwP06KF0ZERESaQ5Efrpp58waNAglChRAjY2Nti8eTNu376NWbNmZWZ8RJSTPHsm5wnbvl0ub94MdOigaEhERKlJcxuhBQsWICgoCNevX0dwcDBWrVqFH3/8MTNjI6Kc5J9/gCpVZBJkZQX89BPQvr3SURERpSrNidCdO3cQGBioW+7SpQsSEhLw6NGjTAmMiHIIjQaYOROoXx+4dw8oUQI4cQIYMIDtgYgo20tzIhQbGwu7twY+MzMzg6WlJaKjozMlMCLKIYYOBcaMAdRqoEsXOV5Q5cpKR0VElCYGNZaeMGECbG1tdctxcXGYOnUqnJycdOvmzJljvOiIKPvr3x/4/Xfg22+B3r1ZCkREOUqaE6H69evj+vXreutq166NO3fu6JZV/AAkyv3UauD06cSxgCpWBEJDAQcHRcMiIkqPNCdCBw8ezMQwiChHePwY6NYNOHhQjg6tTYaYBBFRDmXwyNJEZKL+/huoVAnYtw+wtATu31c6IiKiDGMiRESpU6uBoCDAz0+WCJUvL6vG2rVTOjIiogwzeIoNIjIhDx8CXbvKqjAA6NsXmD8feKvTBBFRTsZEiIhStnmzTILs7YGff5bd44mIcpFsUTW2cOFC+Pj4wNraGjVr1sTJkyfTtN/atWuhUqnQunXrzA2QyFQNGgSMHCnHBmISRES5ULoSoSNHjqBbt26oVasWHjx4AAD45ZdfcPToUYOPtW7dOowYMQJBQUE4e/YsKlWqBH9/fzx58iTV/UJDQzFy5EjUq1cvPQ+BiJJz/76cK+zVK7msUgGzZgElSyoaFhFRZjE4Edq0aRP8/f1hY2ODc+fOITY2FgAQERGBadOmGRzAnDlz0K9fP/Tq1Qtly5bFokWLYGtri+XLl6e4j1qtRteuXTF58mQULVrU4HMSUTJ27JAjQq9aBXzxhdLREBFlCYMToW+++QaLFi3CkiVLYGFhoVtfp04dnD171qBjxcXF4cyZM/Dz80sMyMwMfn5+OH78eIr7ff3113Bzc0OfPn3ee47Y2FhERkbq3YjoLfHxwKhRwEcfydnjfX2B0aOVjoqIKEsYnAhdv34d9evXT7LeyckJL1++NOhYT58+hVqtRoECBfTWFyhQAGFhYcnuc/ToUSxbtgxLlixJ0zmmT58OJycn3c3Ly8ugGIlytf/+k5OlfvedXB46FDh2DChWTNm4iIiyiMGJkLu7O27dupVk/dGjRzO9murVq1fo3r07lixZAldX1zTtM3bsWEREROhu9+7dy9QYiXKMI0dkVdiJE4CzM7Bli+wab2WldGRERFnG4O7z/fr1w7Bhw7B8+XKoVCo8fPgQx48fx8iRIzFhwgSDjuXq6gpzc3M8fvxYb/3jx4/h7u6eZPvbt28jNDQUrVq10q3TaDTygeTJg+vXr6PYO79kraysYMUPdqKkSpSQSU/NmsDatYCPj9IRERFlOYMToTFjxkCj0aBJkyZ48+YN6tevDysrK4wcORJDhgwx6FiWlpbw9fXF/v37dV3gNRoN9u/fj8GDByfZvnTp0rh48aLeuvHjx+PVq1eYP38+q72I3ufZMyBfPvm/u7scI6hoUTllBhGRCTI4EVKpVPjqq68watQo3Lp1C1FRUShbtizs7e3TFcCIESMQGBiIatWqoUaNGpg3bx5ev36NXr16AQB69OgBT09PTJ8+HdbW1ihfvrze/s7OzgCQZD0RvWPjRqBPH2DxYiAgQK4rXVrZmIiIFJbukaUtLS1RtmzZDAcQEBCA8PBwTJw4EWFhYahcuTJ2796ta0B99+5dmJlli3EfiXKmmBjZHf7HH+XyqlVAx45yjCAiIhOnEkIIQ3Zo1KgRVKl8gP79998ZDiozRUZGwsnJCZMnR2DiREelwyHKXDdvyqQnOFgujxkDfP018NbQF0REOYH2+zsiIgKOjsb7/ja4RKhy5cp6y/Hx8QgODsalS5cQGBhorLiIKKN+/x3o3x+IigJcXYFffgGaNVM6KiKibMXgRGju3LnJrp80aRKioqIyHBARGcGFC4lzg9WvD/z2G+DpqWxMRETZkNEa33Tr1i3VaTGIKAtVrCgnS50wAdi/n0kQEVEK0t1Y+l3Hjx+HtbW1sQ5HRIZaswaoVw8oXFguf/stG0QTEb2HwYlQ27Zt9ZaFEHj06BFOnz5t8ICKRGQEr18DQ4YAK1YAtWvLsYEsLJgEERGlgcGJkJOTk96ymZkZSpUqha+//hpNmzY1WmBElAaXL8teYVeuAGZmgL+//EtERGliUCKkVqvRq1cvVKhQAS4uLpkVExG9jxCyBGjwYCA6GvDwkA2iGzZUOjIiohzFoJ+O5ubmaNq0qcGzzBOREb1+DfToIUeJjo6WpUDBwUyCiIjSweAy9PLly+POnTuZEQsRpYWZmeweb24OTJ8O7NwJuLkpHRURUY5kcBuhb775BiNHjsSUKVPg6+sLOzs7vfuNOdojEf2fEPJmZgbY2ADr1wPh4UDdukpHRkSUo6U5Efr666/xxRdfoEWLFgCAjz/+WG+qDSEEVCoV1Gq18aMkMmUREXKE6AoVgPHj5bpSpeSNiIgyJM2J0OTJkzFgwAAcOHAgM+MhoredOSNnir99G9i2TbYL8vBQOioiolwjzYmQdm7WBg0aZFowRPR/QgALFsjRoePiAG9vYO1aJkFEREZmUBuh1GadJyIjeflSlvxs3iyXW7cGli8HOGQFEZHRGZQIlSxZ8r3J0PPnzzMUEJFJS0iQo0NfvSpHh/7uOzlqNH+EEBFlCoMSocmTJycZWZqIjChPHmDYMDlP2Lp1QLVqSkdERJSrGZQIderUCW4cr4TIuJ4/Bx49AsqVk8v9+wPdugHvDE1BRETGl+YBFdk+iCgT/PMPULky8NFHsm0QIKvBmAQREWWJNCdC2l5jRGQEGg0wcyZQvz5w755sD/TkidJRERGZnDRXjWk0msyMg8h0hIcDgYHArl1yuXNn4OefAQcHZeMiIjJBBk+xQUQZcPiwTHwePgSsrYEffpBd5Vn1TESkCCZCRFlpzhyZBJUuLecLq1BB6YiIiEwaEyGirLRsGVC0KPD114C9vdLREBGZvDQ3liaidPj7b+CLL+SUGQCQL58sFWISRESULbBEiCgzqNWy1GfKFJkE1awJdOyodFRERPQOJkJExvbwIdC1K3DwoFzu00eOE0RERNkOEyEiY/rrLzkqdHi4HBTx559lUkRERNkS2wgRGcusWUCzZjIJqlQJOHuWSRARUTbHRIjIWKpUkX8/+ww4cQIoWVLZeIiI6L1YNUaUEU+eANqJiP38gIsXEydPJSKibI8lQkTpER8PjBolS31u305czySIiChHYSJEZKj//gPq1QO++w6IiAD+/FPpiIiIKJ1Mtmrs1SulI6Ac6Y8/gF69gJcvAScnYPlyoG1bpaMiIqJ0MtkSoUqVlI6AcpS4OODzz4E2bWQSVKMGcO4ckyAiohzOZBMhIoMsWADMny//HzECOHIEKFJE2ZiIiCjDTLZqjMgggwcDe/cCAwcCrVopHQ0RERkJS4SIkhMTIydHjY+Xy5aWwK5dTIKIiHIZlggRvevmTSAgQLYBCg8Hpk9XOiIiIsokLBEietvatUDVqjIJcnUF6tdXOiIiIspETISIACA6Gvj0U6BzZyAqSo4TFBwMNG+udGRERJSJmAgR3bgB1KwJLF4MqFTA+PHA338Dnp5KR0ZERJmMbYSINBrgzh05Z9iaNXLOMCIiMglMhMg0aTSA2f8LREuXBjZvBipUADw8lI2LiIiyFKvGyPRcvgxUrgwcPpy4rmlTJkFERCaIiRCZDiGAZcuA6tWBixeBL76Q64iIyGQxESLT8OoV0L070Lev7CHWtCmwY4dsHE1ERCaLiRDlfufPA9WqyYbQ5ubAtGlylGg3N6UjIyIihbGxNOVuV6/KrvGxsbI7/Nq1QN26SkdFRETZBBMhyt1KlwY+/hh4/RpYtUqOFk1ERPR/TIQo9zl3DihSBHB2lm2AVq0CrKwSu8sTERH9H78ZKPcQAliwAPjgA9koWtsjzMaGSRARESWLJUKUO7x8CfTpIwdGBICEBCAmRiZBREREKeDPZMr5Tp4EqlSRSZCFBTBvHrBlC5MgIiJ6LyZClHMJAcydK3uBhYbKdkHHjgHDhnF8ICIiShMmQpRzRUQAc+YA8fFAu3bA2bNy1GgiIqI0YhshyrmcnYHff5cDJg4cyFIgIiIyGBMhyjk0GuC77wB3d6BHD7mubl0OkEhEROnGRIhyhvBwIDBQTo1haws0agR4eSkdFRER5XBMhCj7O3IE6NQJePgQsLaWvcIKFVI6KiIiygXYWJqyL40GmDoVaNhQJkGlSgH//gv068f2QEREZBQsEaLsSa0GWrYE9uyRy927Az/+CNjbKxsXERHlKiwRouzJ3ByoVk22B1qxAli9mkkQEREZHRMhyj7UatkoWmvSJCA4GOjZU6GAiIgot8sWidDChQvh4+MDa2tr1KxZEydPnkxx2yVLlqBevXpwcXGBi4sL/Pz8Ut2ecohHj4APPwSaNwdiY+W6PHmAEiWUjYuIiHI1xROhdevWYcSIEQgKCsLZs2dRqVIl+Pv748mTJ8luf/DgQXTu3BkHDhzA8ePH4eXlhaZNm+LBgwdZHDkZzV9/AZUqAQcOANeuyQESiYiIsoBKCCGUDKBmzZqoXr06FixYAADQaDTw8vLCkCFDMGbMmPfur1ar4eLiggULFqCHdpC9VERGRsLJyQm//BKBbt0cMxw/ZUBCAhAUBEyfLucNq1gRWL9e9g4jIiJ6i/b7OyIiAo6Oxvv+VrREKC4uDmfOnIGfn59unZmZGfz8/HD8+PE0HePNmzeIj49H3rx5k70/NjYWkZGRejfKBu7fBxo3BqZNk0nQp58CJ04wCSIioiylaCL09OlTqNVqFChQQG99gQIFEBYWlqZjjB49GgULFtRLpt42ffp0ODk56W5eHI04e+jXTw6U6OAArF0LLFoE2NgoHRUREZkYxdsIZcSMGTOwdu1abNmyBdbW1sluM3bsWEREROhu9+7dy+IoKVkLF8ppMs6eBQIClI6GiIhMlKIDKrq6usLc3ByPHz/WW//48WO4u7unuu93332HGTNmYN++fahYsWKK21lZWcHKysoo8VIG3L0rG0X37SuXixYF/v5b2ZiIiMjkKVoiZGlpCV9fX+zfv1+3TqPRYP/+/ahVq1aK+3377beYMmUKdu/ejWrVqmVFqJQR27YBlSsD/fvLZIiIiCibUHyKjREjRiAwMBDVqlVDjRo1MG/ePLx+/Rq9evUCAPTo0QOenp6YPn06AGDmzJmYOHEifvvtN/j4+OjaEtnb28OeIw9nL3FxwOjRcpJUAKheneMCERFRtqJ4IhQQEIDw8HBMnDgRYWFhqFy5Mnbv3q1rQH337l2YmSUWXP3000+Ii4tD+/bt9Y4TFBSESZMmZWXolJqQENn259QpuTx8ODBjBmBpqWxcREREb1F8HKGsxnGEssAff8hpMSIiABcXYOVK4OOPFQ6KiIhysswaR0jxEiHKhSIjZRJUq5bsGl+4sNIRERERJYuJEBmHWi1njAeAHj0Aa2ugTRvAwkLZuIiIiFKRo8cRomxi7VqgQgXg6dPEdR07MgkiIqJsj4kQpV90tJwao3Nn4OpVYM4cpSMiIiIyCKvGKH2uXZOlPhcvAioVMG4cwF57RESUwzARIsP98gvw2WfA69eAmxvw66/Ahx8qHRUREZHBmAiRYX7+GRgwQP7fqBGwZg3g4aFsTEREROnENkJkmE6dgOLFZTXY3r1MgoiIKEdjiRClTgg5OWrjxrItkJMTcOECYGOjdGREREQZxhIhSllUFBAYCPj5AYsWJa5nEkRERLkES4QoeRcuyF5h168DZmayYTQREVEuw0SI9AkBLF4MDBsGxMYCnp7A778D9eopHRkREZHRMRGiRJGRQP/+wLp1crl5c2D1asDVVdm4iIiIMgnbCFGiS5eADRvknGHffgts384kiIiIcjWWCFGi2rWBBQuAypXlzPFERES5HEuETNnLl0D37nKeMK3PPmMSREREJoMlQqbq1CkgIAAICQGuXAFOn5bjBBEREZkQlgiZGiGAefOAOnVkEuTjI8cIYhJEREQmiCVCpuT5c6BXL2DbNrncti2wbBng7KxoWEREREphImQqQkKAhg2Bu3cBS0tgzhxg4ECWBBERkUljImQqvLyAwoUBCwtg/XqgalWlIyIiIlIcE6Hc7NkzwMFBlgDlySPHCLK1BRwdlY6MiIgoW2Bj6dzqyBGgUiVg9OjEde7uTIKIiIjewkQot9FogGnTgEaNgAcPgN27OWEqERFRCpgI5SZPngDNmgFffQWo1UC3bnK8IDs7pSMjIiLKlthGKLc4cADo0gUICwNsbICFC4GePdkrjIiIKBVMhHKDyEigXTvgxQugbFnZK6xcOaWjIiIiyvaYCOUGjo7Azz8Du3YBP/zAqjAiIqI0YiKUU+3bB5iZAY0by+UOHeSNiIiI0oyNpXOahARg/HigaVOgc2fg0SOlIyIiIsqxWCKUkzx4IJOfI0fkcuvWnCeMiIgoA5gI5RS7dgE9egBPnwL29sCSJUCnTkpHRURElKOxaiy702jk6NAtWsgkqEoV4OxZJkFERERGwEQouzMzk2MDAcCgQcA//wAlSigbExERUS7BqrHsKiFBTpQKyMERO3QAPvpI2ZiIiDKZWq1GfHy80mGQQiwsLGBubp6l52QilN3ExQFjxgC3bgFbt8qRoe3tmQQRUa4XFRWF+/fvQwihdCikEJVKhUKFCsHe3j7LzslEKDsJCQECAuT8YABw8KCcPJWIKJdTq9W4f/8+bG1tkT9/fqg4PZDJEUIgPDwc9+/fR4kSJbKsZIiJUHaxeTPQuzcQESG7xK9cySSIiExGfHw8hBDInz8/bGxslA6HFJI/f36EhoYiPj4+yxIhNpZWWmwsMGSInCssIgL44AMgOBj45BOlIyMiynIsCTJtSlx/JkJK69oVWLBA/j9qFHD4MODtrWxMREREJoKJkNJGjwY8PIDt24FvvwUsLJSOiIiIyGQwEcpq0dHAoUOJy9WrA3fuAC1bKhcTERFlyPHjx2Fubo6WyXyWHzx4ECqVCi9fvkxyn4+PD+bNm6e37sCBA2jRogXy5csHW1tblC1bFl988QUePHiQSdEDMTExGDRoEPLlywd7e3u0a9cOjx8/TnWfx48fo2fPnihYsCBsbW3RrFkz3Lx5U2+bsLAwdO/eHe7u7rCzs0PVqlWxadOmTHsc6cFEKCtdvy7bAPn7y3ZAWtbWioVEREQZt2zZMgwZMgSHDx/Gw4cP032cn3/+GX5+fnB3d8emTZtw5coVLFq0CBEREZg9e7YRI9Y3fPhw/Pnnn9iwYQMOHTqEhw8fom3btiluL4RA69atcefOHWzduhXnzp2Dt7c3/Pz88Pr1a912PXr0wPXr17Ft2zZcvHgRbdu2RceOHXHu3LlMeywGEyYmIiJCABC//BKRtSf+9Vch7OyEAITIn1+IAwey9vxERNlYdHS0uHLlioiOjlY6FIO9evVK2Nvbi2vXromAgAAxdepUvfsPHDggAIgXL14k2dfb21vMnTtXCCHEvXv3hKWlpfj888+TPU9y+xvDy5cvhYWFhdiwYYNu3dWrVwUAcfz48WT3uX79ugAgLl26pFunVqtF/vz5xZIlS3Tr7OzsxOrVq/X2zZs3r942b0vtdaD9/o6IMO73N0uEMtubN0DfvkC3bsDr10DDhrI0qGFDhQMjIsq+hJAfmUrcDB3Pcf369ShdujRKlSqFbt26Yfny5ekaFHLDhg2Ii4vDl19+mez9zs7OKe7bvHlz2Nvbp3grV65civueOXMG8fHx8PPz060rXbo0ChcujOPHjye7T2xsLADA+q0aDTMzM1hZWeHo0aO6dbVr18a6devw/PlzaDQarF27FjExMWiYjb4DOY5QZrpyBejYEbh8WY4QPXEiMGECkMXDhxMR5TRv3shB9ZUQFQXY2aV9+2XLlqFbt24AgGbNmiEiIgKHDh0y+Mv+5s2bcHR0hIeHh0H7AcDSpUsRHR2d4v0WqXTECQsLg6WlZZJEq0CBAgjTznX5Dm2iNHbsWPz888+ws7PD3Llzcf/+fTx69Ei33fr16xEQEIB8+fIhT548sLW1xZYtW1C8eHHDHmAmYiKUmbZulUmQuzuwZg3QuLHSERERkRFdv34dJ0+exJYtWwAAefLkQUBAAJYtW2ZwIiSESPc4Op6enunaL70sLCywefNm9OnTB3nz5oW5uTn8/PzQvHlzvdKwCRMm4OXLl9i3bx9cXV3xxx9/oGPHjjhy5AgqVKiQpTGnhIlQZvryS1nOOmQIUKCA0tEQEeUYtrayZEapc6fVsmXLkJCQgIIFC+rWCSFgZWWFBQsWwMnJCY6OjgCAiIiIJKUuL1++hJOTEwCgZMmSiIiIwKNHjwwuFWrevDmOHDmS4v3e3t64fPlysve5u7sjLi4OL1++1Ivv8ePHcHd3T/GYvr6+CA4ORkREBOLi4pA/f37UrFkT1apVAwDcvn0bCxYswKVLl3RVc5UqVcKRI0ewcOFCLFq0yKDHmFmYCBnTxYvA118Dq1cDNjayCuybb5SOiogox1GpDKueUkJCQgJWr16N2bNno2nTpnr3tW7dGr///jsGDBiAEiVKwMzMDGfOnIH3WwPm3rlzBxEREShZsiQAoH379hgzZgy+/fZbzJ07N8n53k1U3paRqjFfX19YWFhg//79aNeuHQBZ0nX37l3UqlUrxf20tInczZs3cfr0aUyZMgUA8ObNGwCy7dDbzM3NodFo3nvcLGPUptc5QKb0GtNohFi8WAhra9kr7MsvjXdsIiITkBN7jW3ZskVYWlqKly9fJrnvyy+/FNWqVdMt9+/fX/j4+IitW7eKO3fuiEOHDokPPvhAfPDBB0Kj0ei2W7hwoVCpVKJ3797i4MGDIjQ0VBw9elT0799fjBgxItMey4ABA0ThwoXF33//LU6fPi1q1aolatWqpbdNqVKlxObNm3XL69evFwcOHBC3b98Wf/zxh/D29hZt27bV3R8XFyeKFy8u6tWrJ/79919x69Yt8d133wmVSiV27NiRbBxK9BpjIpTxAwrRqZNMgAAhmjUT4skT4xybiMhE5MRE6KOPPhItWrRI9r5///1XABDnz58XQsjHFxQUJEqXLi1sbGxEkSJFRP/+/UV4eHiSfffu3Sv8/f2Fi4uLsLa2FqVLlxYjR44UDx8+zLTHEh0dLQYOHChcXFyEra2taNOmjXj06JHeNgDEihUrdMvz588XhQoVEhYWFqJw4cJi/PjxIjY2Vm+fGzduiLZt2wo3Nzdha2srKlasmKQ7/btxZHUipBIiHX38crDIyEg4OTnhl18i0K2bY8YOdu6c7BV265asBps2DRg5EjDjqARERIaIiYlBSEgIihQpotclm0xLaq8D7fd3RESErt2VMbCNUHpt2QJ06gTExQFeXsDatUDt2kpHRURERAZgIpRe1arJQS7q1AFWrADy5VM6IiIiIjIQEyFDPHgAaMdq8PICTp4EihaV3RuIiIgox2FjlrQQApg/XyY927Ylri9WjEkQERFRDsZE6H2ePwfatAE+/1y2B3o7ESIiIqIcjYlQak6cAKpUkVNlWFoCP/wALFmidFRERLmWiXVkpncocf2ZCCVHowG++w6oVw+4e1dWgf3zDzB4MKvCiIgygfn/J6OOi4tTOBJSkvb6m2fh5ORsLJ2cw4eBUaPk/x07ylIgI45ZQERE+rQzk4eHh8PCwiLJtAyU+2k0GoSHh8PW1hZ58mRdesJEKDkNGwLDhgGlSwOffspSICKiTKZSqeDh4YGQkBD8999/SodDCjEzM0PhwoWhysLvXSZCgKwKmz8f6NwZ0M60O2+eoiEREZkaS0tLlChRgtVjJszS0jLLSwOzRSK0cOFCzJo1C2FhYahUqRJ++OEH1KhRI8XtN2zYgAkTJiA0NBQlSpTAzJkz0aJFi/Sd/MkToHt34K+/gO3bgb17OUUGEZFCzMzMOMUGZSnFv/HXrVuHESNGICgoCGfPnkWlSpXg7++PJ0+eJLv9P//8g86dO6NPnz44d+4cWrdujdatW+PSpUuGn/zgQaByZZkE2dgAXbuyGoyIiMiEKD7pas2aNVG9enUsWLAAgGws5eXlhSFDhmDMmDFJtg8ICMDr16+xfft23boPPvgAlStXxqJFi957Pu2kbf+2HYsaf8yU1WJlygDr1wPlyxvvgREREZHRZNakq4qWCMXFxeHMmTPw8/PTrTMzM4Ofnx+OHz+e7D7Hjx/X2x4A/P39U9w+JaU3T5dJUK9ewKlTTIKIiIhMkKJthJ4+fQq1Wo0CBQrorS9QoACuXbuW7D5hYWHJbh8WFpbs9rGxsYiNjdUtR0REAACeW1gDC+bLGeTVaiAyMiMPhYiIiDJR5P+/p41dkZUtGktnpunTp2Py5MlJ1heJj5Fd4z/9VIGoiIiIKD2ePXsGJycnox1P0UTI1dUV5ubmePz4sd76x48fw13bjf0d7u7uBm0/duxYjBgxQrf88uVLeHt74+7du0Z9IslwkZGR8PLywr1794xa30vpw+uRffBaZB+8FtlHREQEChcujLx58xr1uIomQpaWlvD19cX+/fvRunVrALKx9P79+zF48OBk96lVqxb279+Pzz//XLdu7969qFWrVrLbW1lZwcrKKsl6JycnvqizCUdHR16LbITXI/vgtcg+eC2yD2OPM6R41diIESMQGBiIatWqoUaNGpg3bx5ev36NXr16AQB69OgBT09PTJ8+HQAwbNgwNGjQALNnz0bLli2xdu1anD59GosXL1byYRAREVEOpHgiFBAQgPDwcEycOBFhYWGoXLkydu/erWsQfffuXb3sr3bt2vjtt98wfvx4jBs3DiVKlMAff/yB8uz1RURERAZSPBECgMGDB6dYFXbw4MEk6zp06IAOHTqk61xWVlYICgpKtrqMshavRfbC65F98FpkH7wW2UdmXQvFB1QkIiIiUoriU2wQERERKYWJEBEREZksJkJERERkspgIERERkcnKlYnQwoUL4ePjA2tra9SsWRMnT55MdfsNGzagdOnSsLa2RoUKFbBz584sijT3M+RaLFmyBPXq1YOLiwtcXFzg5+f33mtHhjH0vaG1du1aqFQq3cCnlHGGXouXL19i0KBB8PDwgJWVFUqWLMnPKiMx9FrMmzcPpUqVgo2NDby8vDB8+HDExMRkUbS51+HDh9GqVSsULFgQKpUKf/zxx3v3OXjwIKpWrQorKysUL14cK1euNPzEIpdZu3atsLS0FMuXLxeXL18W/fr1E87OzuLx48fJbn/s2DFhbm4uvv32W3HlyhUxfvx4YWFhIS5evJjFkec+hl6LLl26iIULF4pz586Jq1evip49ewonJydx//79LI48dzL0emiFhIQIT09PUa9ePfHJJ59kTbC5nKHXIjY2VlSrVk20aNFCHD16VISEhIiDBw+K4ODgLI489zH0WqxZs0ZYWVmJNWvWiJCQELFnzx7h4eEhhg8fnsWR5z47d+4UX331ldi8ebMAILZs2ZLq9nfu3BG2trZixIgR4sqVK+KHH34Q5ubmYvfu3QadN9clQjVq1BCDBg3SLavValGwYEExffr0ZLfv2LGjaNmypd66mjVrik8//TRT4zQFhl6LdyUkJAgHBwexatWqzArRpKTneiQkJIjatWuLpUuXisDAQCZCRmLotfjpp59E0aJFRVxcXFaFaDIMvRaDBg0SjRs31ls3YsQIUadOnUyN09SkJRH68ssvRbly5fTWBQQECH9/f4POlauqxuLi4nDmzBn4+fnp1pmZmcHPzw/Hjx9Pdp/jx4/rbQ8A/v7+KW5PaZOea/GuN2/eID4+3ugT7Jmi9F6Pr7/+Gm5ubujTp09WhGkS0nMttm3bhlq1amHQoEEoUKAAypcvj2nTpkGtVmdV2LlSeq5F7dq1cebMGV312Z07d7Bz5060aNEiS2KmRMb6/s4WI0sby9OnT6FWq3XTc2gVKFAA165dS3afsLCwZLcPCwvLtDhNQXquxbtGjx6NggULJnmhk+HScz2OHj2KZcuWITg4OAsiNB3puRZ37tzB33//ja5du2Lnzp24desWBg4ciPj4eAQFBWVF2LlSeq5Fly5d8PTpU9StWxdCCCQkJGDAgAEYN25cVoRMb0np+zsyMhLR0dGwsbFJ03FyVYkQ5R4zZszA2rVrsWXLFlhbWysdjsl59eoVunfvjiVLlsDV1VXpcEyeRqOBm5sbFi9eDF9fXwQEBOCrr77CokWLlA7N5Bw8eBDTpk3Djz/+iLNnz2Lz5s3YsWMHpkyZonRolE65qkTI1dUV5ubmePz4sd76x48fw93dPdl93N3dDdqe0iY910Lru+++w4wZM7Bv3z5UrFgxM8M0GYZej9u3byM0NBStWrXSrdNoNACAPHny4Pr16yhWrFjmBp1Lpee94eHhAQsLC5ibm+vWlSlTBmFhYYiLi4OlpWWmxpxbpedaTJgwAd27d0ffvn0BABUqVMDr16/Rv39/fPXVV3qThFPmSun729HRMc2lQUAuKxGytLSEr68v9u/fr1un0Wiwf/9+1KpVK9l9atWqpbc9AOzduzfF7Slt0nMtAODbb7/FlClTsHv3blSrVi0rQjUJhl6P0qVL4+LFiwgODtbdPv74YzRq1AjBwcHw8vLKyvBzlfS8N+rUqYNbt27pklEAuHHjBjw8PJgEZUB6rsWbN2+SJDvaBFVw6s4sZbTvb8PacWd/a9euFVZWVmLlypXiypUron///sLZ2VmEhYUJIYTo3r27GDNmjG77Y8eOiTx58ojvvvtOXL16VQQFBbH7vJEYei1mzJghLC0txcaNG8WjR490t1evXin1EHIVQ6/Hu9hrzHgMvRZ3794VDg4OYvDgweL69eti+/btws3NTXzzzTdKPYRcw9BrERQUJBwcHMTvv/8u7ty5I/766y9RrFgx0bFjR6UeQq7x6tUrce7cOXHu3DkBQMyZM0ecO3dO/Pfff0IIIcaMGSO6d++u217bfX7UqFHi6tWrYuHChew+r/XDDz+IwoULC0tLS1GjRg1x4sQJ3X0NGjQQgYGBetuvX79elCxZUlhaWopy5cqJHTt2ZHHEuZch18Lb21sASHILCgrK+sBzKUPfG29jImRchl6Lf/75R9SsWVNYWVmJokWLiqlTp4qEhIQsjjp3MuRaxMfHi0mTJolixYoJa2tr4eXlJQYOHChevHiR9YHnMgcOHEj2O0D7/AcGBooGDRok2ady5crC0tJSFC1aVKxYscLg86qEYFkeERERmaZc1UaIiIiIyBBMhIiIiMhkMREiIiIik8VEiIiIiEwWEyEiIiIyWUyEiIiIyGQxESIiIiKTxUSIiPSsXLkSzs7OSoeRbiqVCn/88Ueq2/Ts2ROtW7fOkniIKHtjIkSUC/Xs2RMqlSrJ7datW0qHhpUrV+riMTMzQ6FChdCrVy88efLEKMd/9OgRmjdvDgAIDQ2FSqVCcHCw3jbz58/HypUrjXK+lEyaNEn3OM3NzeHl5YX+/fvj+fPnBh2HSRtR5spVs88TUaJmzZphxYoVeuvy58+vUDT6HB0dcf36dWg0Gpw/fx69evXCw4cPsWfPngwfO6VZw9/m5OSU4fOkRbly5bBv3z6o1WpcvXoVvXv3RkREBNatW5cl5yei92OJEFEuZWVlBXd3d72bubk55syZgwoVKsDOzg5eXl4YOHAgoqKiUjzO+fPn0ahRIzg4OMDR0RG+vr44ffq07v6jR4+iXr16sLGxgZeXF4YOHYrXr1+nGptKpYK7uzsKFiyI5s2bY+jQodi3bx+io6Oh0Wjw9ddfo1ChQrCyskLlypWxe/du3b5xcXEYPHgwPDw8YG1tDW9vb0yfPl3v2NqqsSJFigAAqlSpApVKhYYNGwLQL2VZvHgxChYsqDezOwB88skn6N27t25569atqFq1KqytrVG0aFFMnjwZCQkJqT7OPHnywN3dHZ6envDz80OHDh2wd+9e3f1qtRp9+vRBkSJFYGNjg1KlSmH+/Pm6+ydNmoRVq1Zh69atutKlgwcPAgDu3buHjh07wtnZGXnz5sUnn3yC0NDQVOMhoqSYCBGZGDMzM3z//fe4fPkyVq1ahb///htffvllitt37doVhQoVwqlTp3DmzBmMGTMGFhYWAIDbt2+jWbNmaNeuHS5cuIB169bh6NGjGDx4sEEx2djYQKPRICEhAfPnz8fs2bPx3Xff4cKFC/D398fHH3+MmzdvAgC+//57bNu2DevXr8f169exZs0a+Pj4JHvckydPAgD27duHR48eYfPmzUm26dChA549e4YDBw7o1j1//hy7d+9G165dAQBHjhxBjx49MGzYMFy5cgU///wzVq5cialTp6b5MYaGhmLPnj2wtLTUrdNoNChUqBA2bNiAK1euYOLEiRg3bhzWr18PABg5ciQ6duyIZs2a4dGjR3j06BFq166N+Ph4+Pv7w8HBAUeOHMGxY8dgb2+PZs2aIS4uLs0xERGQK2efJzJ1gYGBwtzcXNjZ2elu7du3T3bbDRs2iHz58umWV6xYIZycnHTLDg4OYuXKlcnu26dPH9G/f3+9dUeOHBFmZmYiOjo62X3ePf6NGzdEyZIlRbVq1YQQQhQsWFBMnTpVb5/q1auLgQMHCiGEGDJkiGjcuLHQaDTJHh+A2LJlixBCiJCQEAFAnDt3Tm+bwMBA8cknn+iWP/nkE9G7d2/d8s8//ywKFiwo1Gq1EEKIJk2aiGnTpukd45dffhEeHh7JxiCEEEFBQcLMzEzY2dkJa2tr3Uzac+bMSXEfIYQYNGiQaNeuXYqxas9dqlQpvecgNjZW2NjYiD179qR6fCLSxzZCRLlUo0aN8NNPP+mW7ezsAMjSkenTp+PatWuIjIxEQkICYmJi8ObNG9ja2iY5zogRI9C3b1/88ssvuuqdYsWKAZDVZhcuXMCaNWt02wshoNFoEBISgjJlyiQbW0REBOzt7aHRaBATE4O6deti6dKliIyMxMOHD1GnTh297evUqYPz588DkNVaH374IUqVKoVmzZrho48+QtOmTTP0XHXt2hX9+vXDjz/+CCsrK6xZswadOnWCmZmZ7nEeO3ZMrwRIrVan+rwBQKlSpbBt2zbExMTg119/RXBwMIYMGaK3zcKFC7F8+XLcvXsX0dHRiIuLQ+XKlVON9/z587h16xYcHBz01sfExOD27dvpeAaITBcTIaJcys7ODsWLF9dbFxoaio8++gifffYZpk6dirx58+Lo0aPo06cP4uLikv1CnzRpErp06YIdO3Zg165dCAoKwtq1a9GmTRtERUXh008/xdChQ5PsV7hw4RRjc3BwwNmzZ2FmZgYPDw/Y2NgAACIjI9/7uKpWrYqQkBDs2rUL+/btQ8eOHeHn54eNGze+d9+UtGrVCkII7NixA9WrV8eRI0cwd+5c3f1RUVGYPHky2rZtm2Rfa2vrFI9raWmpuwYzZsxAy5YtMXnyZEyZMgUAsHbtWowcORKzZ89GrVq14ODggFmzZuHff/9NNd6oqCj4+vrqJaBa2aVBPFFOwUSIyIScOXMGGo0Gs2fP1pV2aNujpKZkyZIoWbIkhg8fjs6dO2PFihVo06YNqlatiitXriRJuN7HzMws2X0cHR1RsGBBHDt2DA0aNNCtP3bsGGrUqKG3XUBAAAICAtC+fXs0a9YMz58/R968efWOp22Po1arU43H2toabdu2xZo1a3Dr1i2UKlUKVatW1d1ftWpVXL9+3eDH+a7x48ejcePG+Oyzz3SPs3bt2hg4cKBum3dLdCwtLZPEX7VqVaxbtw5ubm5wdHTMUExEpo6NpYlMSPHixREfH48ffvgBd+7cwS+//IJFixaluH10dDQGDx6MgwcP4r///sOxY8dw6tQpXZXX6NGj8c8//2Dw4MEIDg7GzZs3sXXrVoMbS79t1KhRmDlzJtatW4fr169jzJgxCA4OxrBhwwAAc+bMwe+//45r167hxo0b2LBhA9zd3ZMdBNLNzQ02NjbYvXs3Hj9+jIiIiBTP27VrV+zYsQPLly/XNZLWmjhxIlavXo3Jkyfj8uXLuHr1KtauXYvx48cb9Nhq1aqFihUrYtq0aQCAEiVK4PTp09izZw9u3LiBCRMm4NSpU3r7+Pj44MKFC7h+/TqePn2K+Ph4dO3aFa6urvjkk09w5MgRhISE4ODBgxg6dCju379vUExEJk/pRkpEZHzJNbDVmjNnjvDw8BA2NjbC399frF69WgAQL168EELoN2aOjY0VnTp1El5eXsLS0lIULFhQDB48WK8h9MmTJ8WHH34o7O3thZ2dnahYsWKSxs5ve7ex9LvUarWYNGmS8PT0FBYWFqJSpUpi165duvsXL14sKleuLOzs7ISjo6No0qSJOHv2rO5+vNVYWgghlixZIry8vISZmZlo0KBBis+PWq0WHh4eAoC4fft2krh2794tateuLWxsbISjo6OoUaOGWLx4cYqPIygoSFSqVCnJ+t9//11YWVmJu3fvipiYGNGzZ0/h5OQknJ2dxWeffSbGjBmjt9+TJ090zy8AceDAASGEEI8ePRI9evQQrq6uwsrKShQtWlT069dPREREpBgTESWlEkIIZVMxIiIiImWwaoyIiIhMFhMhIiIiMllMhIiIiMhkMREiIiIik8VEiIiIiEwWEyEiIiIyWUyEiIiIyGQxESIiIiKTxUSIiIiITBYTISIiIjJZTISIiIjIZDERIiIiIpP1P9DyrpE6bz15AAAAAElFTkSuQmCC", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -425,77 +439,87 @@ "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 1.4814271926879883\n", - "compute_auc_time: 6.84686803817749\n", + "fit_time: 1.4975659847259521\n", + "compute_auc_time: 6.91232705116272\n", "depth: 4 , Auc of digit: 0 is 0.9949666301993401\n", "doing digit 1 doing signature level 4\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.472062110900879\n", - "compute_auc_time: 6.747668981552124\n", + "fit_time: 1.502849817276001\n", + "compute_auc_time: 6.871154069900513\n", "depth: 4 , Auc of digit: 1 is 0.9852398718065597\n", "doing digit 2 doing signature level 4\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.555401086807251\n", - "compute_auc_time: 6.726560831069946\n", + "fit_time: 1.708885908126831\n", + "compute_auc_time: 7.093451976776123\n", "depth: 4 , Auc of digit: 2 is 0.9894510403444672\n", "doing digit 3 doing signature level 4\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.5977261066436768\n", - "compute_auc_time: 6.752060890197754\n", + "fit_time: 1.5545158386230469\n", + "compute_auc_time: 7.326997995376587\n", "depth: 4 , Auc of digit: 3 is 0.9959752718291617\n", "doing digit 4 doing signature level 4\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.5598111152648926\n", - "compute_auc_time: 6.753681182861328\n", + "fit_time: 1.5915489196777344\n", + "compute_auc_time: 7.074462890625\n", "depth: 4 , Auc of digit: 4 is 0.999876399924262\n", "doing digit 5 doing signature level 4\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.5049867630004883\n", - "compute_auc_time: 7.039808034896851\n", + "fit_time: 1.531661033630371\n", + "compute_auc_time: 6.867708921432495\n", "depth: 4 , Auc of digit: 5 is 0.9878785018945739\n", "doing digit 6 doing signature level 4\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.3394172191619873\n", - "compute_auc_time: 6.674200057983398\n", + "fit_time: 1.3417651653289795\n", + "compute_auc_time: 6.920623779296875\n", "depth: 4 , Auc of digit: 6 is 0.9949408526851601\n", "doing digit 7 doing signature level 4\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.553976058959961\n", - "compute_auc_time: 6.760324954986572\n", + "fit_time: 1.7207341194152832\n", + "compute_auc_time: 6.845315933227539\n", "depth: 4 , Auc of digit: 7 is 0.9857894976752666\n", "doing digit 8 doing signature level 4\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.4829590320587158\n", - "compute_auc_time: 7.0328850746154785\n", + "fit_time: 1.491410255432129\n", + "compute_auc_time: 6.841398000717163\n", "depth: 4 , Auc of digit: 8 is 0.998694504683594\n", "doing digit 9 doing signature level 4\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.5755929946899414\n", - "compute_auc_time: 6.970922946929932\n", + "fit_time: 1.2827157974243164\n", + "compute_auc_time: 6.803714990615845\n", "depth: 4 , Auc of digit: 9 is 0.9442176063973977\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -512,77 +536,87 @@ "len(data.corpus) 780\n", "len(data.test_inlier) 363\n", "len(data.test_outlier) 3135\n", - "fit_time: 1.8557980060577393\n", - "compute_auc_time: 15.691333770751953\n", + "fit_time: 2.2053072452545166\n", + "compute_auc_time: 17.268661975860596\n", "depth: 5 , Auc of digit: 0 is 0.9947574922781535\n", "doing digit 1 doing signature level 5\n", "len(data.corpus) 779\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.6090118885040283\n", - "compute_auc_time: 14.628620147705078\n", + "fit_time: 2.007657766342163\n", + "compute_auc_time: 22.80258798599243\n", "depth: 5 , Auc of digit: 1 is 0.9900453726235474\n", "doing digit 2 doing signature level 5\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 2.0345211029052734\n", - "compute_auc_time: 11.240407943725586\n", + "fit_time: 1.6560781002044678\n", + "compute_auc_time: 15.648115873336792\n", "depth: 5 , Auc of digit: 2 is 0.9912226414300441\n", "doing digit 3 doing signature level 5\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.4860689640045166\n", - "compute_auc_time: 14.095582962036133\n", + "fit_time: 1.6908342838287354\n", + "compute_auc_time: 12.489221096038818\n", "depth: 5 , Auc of digit: 3 is 0.9964675386283546\n", "doing digit 4 doing signature level 5\n", "len(data.corpus) 780\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.7567501068115234\n", - "compute_auc_time: 14.24120306968689\n", + "fit_time: 1.6653599739074707\n", + "compute_auc_time: 14.69511604309082\n", "depth: 5 , Auc of digit: 4 is 0.9999254893160445\n", "doing digit 5 doing signature level 5\n", "len(data.corpus) 720\n", "len(data.test_inlier) 335\n", "len(data.test_outlier) 3163\n", - "fit_time: 1.5514466762542725\n", - "compute_auc_time: 10.272958993911743\n", + "fit_time: 1.873572826385498\n", + "compute_auc_time: 13.695110082626343\n", "depth: 5 , Auc of digit: 5 is 0.9896433104789049\n", "doing digit 6 doing signature level 5\n", "len(data.corpus) 720\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.588888168334961\n", - "compute_auc_time: 9.079653024673462\n", + "fit_time: 1.7203340530395508\n", + "compute_auc_time: 15.188550233840942\n", "depth: 5 , Auc of digit: 6 is 0.9954961823439054\n", "doing digit 7 doing signature level 5\n", "len(data.corpus) 778\n", "len(data.test_inlier) 364\n", "len(data.test_outlier) 3134\n", - "fit_time: 1.7415499687194824\n", - "compute_auc_time: 9.925087928771973\n", + "fit_time: 1.8180418014526367\n", + "compute_auc_time: 14.598641157150269\n", "depth: 5 , Auc of digit: 7 is 0.9868265110766707\n", "doing digit 8 doing signature level 5\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.5423738956451416\n", - "compute_auc_time: 9.317086935043335\n", + "fit_time: 1.985002040863037\n", + "compute_auc_time: 23.181287050247192\n", "depth: 5 , Auc of digit: 8 is 0.9993119559651817\n", "doing digit 9 doing signature level 5\n", "len(data.corpus) 719\n", "len(data.test_inlier) 336\n", "len(data.test_outlier) 3162\n", - "fit_time: 1.5196259021759033\n", - "compute_auc_time: 9.053930044174194\n", + "fit_time: 2.2729718685150146\n", + "compute_auc_time: 23.99567413330078\n", "depth: 5 , Auc of digit: 9 is 0.9467071774946538\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -595,8 +629,8 @@ "output_type": "stream", "text": [ "Overall, depth: 5 AUC: 0.9887056355253816\n", - "CPU times: user 14min 11s, sys: 3min 49s, total: 18min\n", - "Wall time: 8min\n" + "CPU times: user 21min 50s, sys: 4min 16s, total: 26min 7s\n", + "Wall time: 9min 11s\n" ] } ], @@ -645,6 +679,7 @@ " auc = compute_auc_given_dists(inlier_dists, outlier_dists)\n", " print(\"depth: \", depth, \", Auc of\", \" digit: \", digit, \" is \", auc)\n", "\n", + " # plot and compute auc\n", " all_inlier_dists = np.concatenate(list(digit_to_inlier_dists.values()))\n", " all_outlier_dists = np.concatenate(list(digit_to_outlier_dists.values()))\n", " auc = compute_auc_given_dists(\n", @@ -653,13 +688,24 @@ " plot=True,\n", " title=f\"Pen Digit (depth={depth})\",\n", " )\n", + "\n", + " # plot CDF\n", + " plot_cdf_given_dists(\n", + " all_inlier_dists,\n", + " all_outlier_dists,\n", + " bins=10000000,\n", + " xrange=(10e-7, 10e4),\n", + " xlog=True,\n", + " title=f\"\",\n", + " )\n", + "\n", " print(\"Overall, \", \"depth: \", depth, \"AUC: \", auc)\n", " depth_to_auc[depth] = auc" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -686,7 +732,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -696,7 +742,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "a4675b42", "metadata": {}, "outputs": [ @@ -705,7 +751,7 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 2\n", - "fit_time: 1.716937780380249\n" + "fit_time: 1.8049709796905518\n" ] } ], @@ -742,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "fa3d0039-5d50-4aa8-ac91-f76a83513315", "metadata": {}, "outputs": [ @@ -757,7 +803,7 @@ " 0.01140402, 0.02230901, 0.04476067, 0.0622557 , 0.02477818])" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -805,7 +851,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -847,7 +893,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -861,7 +907,7 @@ " 0.01140395, 0.02230897, 0.0447607 , 0.06225568, 0.02477822])" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -879,7 +925,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -895,7 +941,7 @@ " -2.10565009e-08, 4.07364884e-08])" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -906,7 +952,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -922,7 +968,7 @@ " -2.62177412e-09, 2.01875338e-09])" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -933,7 +979,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -947,7 +993,7 @@ " 0.00013005, 0.00049769, 0.00200352, 0.00387577, 0.00061396])" ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -965,7 +1011,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "7b24a162-ab61-42ec-92d0-31067441e1ea", "metadata": {}, "outputs": [ @@ -980,7 +1026,7 @@ " 0.17178055, 0.2021866 , 0.50789138, 0.46324354, 0.2810891 ])" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -1035,7 +1081,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -1077,7 +1123,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -1091,7 +1137,7 @@ " 0.17178056, 0.2021866 , 0.57933628, 0.51903326, 0.2810891 ])" ] }, - "execution_count": 18, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1102,7 +1148,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1118,7 +1164,7 @@ " 5.57897246e-02, -7.37194078e-09])" ] }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1129,7 +1175,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1145,7 +1191,7 @@ " 5.48009524e-02, -4.14434438e-09])" ] }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1156,7 +1202,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1170,7 +1216,7 @@ " 0.02950856, 0.04087942, 0.25795365, 0.21459458, 0.07901108])" ] }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1190,7 +1236,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1198,7 +1244,7 @@ "output_type": "stream", "text": [ "doing digit 0 doing signature level 4\n", - "fit_time: 1.2553520202636719\n" + "fit_time: 1.5386781692504883\n" ] } ], @@ -1238,7 +1284,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1252,7 +1298,7 @@ " 0.03191909, 0.04620362, 0.10642687, 0.21951508, 0.04757213])" ] }, - "execution_count": 23, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1300,7 +1346,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -1342,7 +1388,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1356,7 +1402,7 @@ " 0.03191909, 0.04620365, 0.10642693, 0.21951484, 0.04757213])" ] }, - "execution_count": 25, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1374,7 +1420,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1390,7 +1436,7 @@ " -2.45914014e-07, -4.55573797e-09])" ] }, - "execution_count": 26, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1401,7 +1447,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -1417,7 +1463,7 @@ " -1.07963610e-07, -4.33452318e-10])" ] }, - "execution_count": 27, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1428,7 +1474,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -1444,7 +1490,7 @@ " 4.81868721e-02, 2.26310777e-03])" ] }, - "execution_count": 28, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1462,7 +1508,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -1476,7 +1522,7 @@ " 1.66121212, 2.47344445, 8.79436824, 10.39406515, 3.76990887])" ] }, - "execution_count": 29, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1531,7 +1577,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -1573,7 +1619,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -1587,7 +1633,7 @@ " 1.66121225, 2.47344389, 8.79436819, 10.39406662, 3.76990895])" ] }, - "execution_count": 31, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1598,7 +1644,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -1614,7 +1660,7 @@ " 1.47285028e-06, 8.01633524e-08])" ] }, - "execution_count": 32, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -1625,7 +1671,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -1641,7 +1687,7 @@ " 3.06178058e-05, 6.04417075e-07])" ] }, - "execution_count": 33, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -1652,7 +1698,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -1668,7 +1714,7 @@ " 1.08036590e+02, 1.42122129e+01])" ] }, - "execution_count": 34, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1689,7 +1735,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "id": "9f49674f-86c7-4d6e-88f9-98218ab69be3", "metadata": {}, "outputs": [], @@ -1705,7 +1751,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 35, "id": "60165b32-c950-4b0c-9526-3edcb7674e62", "metadata": {}, "outputs": [ @@ -1719,7 +1765,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 20.626681804656982\n" + "fit_time: 27.13375997543335\n" ] }, { @@ -1736,7 +1782,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 335.9436459541321\n", + "compute_auc_time: 332.76756405830383\n", "lead_lag: True inv_rest: True thres_distance: 4000 auc: 0.8228045999999999\n", "Threshold distance: 8000\n", "lead_lag: True\n", @@ -1744,7 +1790,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 23.2948579788208\n" + "fit_time: 21.94414520263672\n" ] }, { @@ -1761,7 +1807,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 338.6563048362732\n", + "compute_auc_time: 255.8750569820404\n", "lead_lag: True inv_rest: True thres_distance: 8000 auc: 0.8354452200000001\n", "Threshold distance: 16000\n", "lead_lag: True\n", @@ -1769,7 +1815,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 27.60756516456604\n" + "fit_time: 21.80716109275818\n" ] }, { @@ -1786,7 +1832,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 293.8441872596741\n", + "compute_auc_time: 294.45983505249023\n", "lead_lag: True inv_rest: True thres_distance: 16000 auc: 0.8360074\n", "Threshold distance: 32000\n", "lead_lag: True\n", @@ -1794,7 +1840,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 24.40476894378662\n" + "fit_time: 26.57306218147278\n" ] }, { @@ -1811,7 +1857,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 317.9939298629761\n", + "compute_auc_time: 333.42611503601074\n", "lead_lag: True inv_rest: True thres_distance: 32000 auc: 0.84355992\n", "Threshold distance: 4000\n", "lead_lag: True\n", @@ -1819,7 +1865,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 17.984686136245728\n" + "fit_time: 19.67205309867859\n" ] }, { @@ -1836,7 +1882,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 182.08021187782288\n", + "compute_auc_time: 380.14289903640747\n", "lead_lag: True inv_rest: False thres_distance: 4000 auc: 0.8257225199999999\n", "Threshold distance: 8000\n", "lead_lag: True\n", @@ -1844,7 +1890,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 17.325438022613525\n" + "fit_time: 16.292973041534424\n" ] }, { @@ -1861,7 +1907,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 207.74922394752502\n", + "compute_auc_time: 266.170264005661\n", "lead_lag: True inv_rest: False thres_distance: 8000 auc: 0.8343324400000001\n", "Threshold distance: 16000\n", "lead_lag: True\n", @@ -1869,7 +1915,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 15.623968124389648\n" + "fit_time: 16.08999800682068\n" ] }, { @@ -1886,7 +1932,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 234.3586070537567\n", + "compute_auc_time: 278.8102180957794\n", "lead_lag: True inv_rest: False thres_distance: 16000 auc: 0.84074052\n", "Threshold distance: 32000\n", "lead_lag: True\n", @@ -1894,7 +1940,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 18.165555000305176\n" + "fit_time: 21.187442302703857\n" ] }, { @@ -1911,7 +1957,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 252.45590329170227\n", + "compute_auc_time: 294.34289026260376\n", "lead_lag: True inv_rest: False thres_distance: 32000 auc: 0.8419482599999999\n", "Threshold distance: 4000\n", "lead_lag: False\n", @@ -1919,7 +1965,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 12.57522201538086\n" + "fit_time: 13.107696056365967\n" ] }, { @@ -1936,7 +1982,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 31.587750911712646\n", + "compute_auc_time: 60.903258085250854\n", "lead_lag: False inv_rest: True thres_distance: 4000 auc: 0.79083568\n", "Threshold distance: 8000\n", "lead_lag: False\n", @@ -1944,7 +1990,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 12.51298189163208\n" + "fit_time: 13.742963075637817\n" ] }, { @@ -1961,7 +2007,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 33.34321594238281\n", + "compute_auc_time: 78.29260683059692\n", "lead_lag: False inv_rest: True thres_distance: 8000 auc: 0.7972313600000001\n", "Threshold distance: 16000\n", "lead_lag: False\n", @@ -1969,7 +2015,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 12.596282005310059\n" + "fit_time: 13.91839075088501\n" ] }, { @@ -1986,7 +2032,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 32.92912983894348\n", + "compute_auc_time: 66.64873790740967\n", "lead_lag: False inv_rest: True thres_distance: 16000 auc: 0.7872241999999998\n", "Threshold distance: 32000\n", "lead_lag: False\n", @@ -1994,7 +2040,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 13.208525896072388\n" + "fit_time: 13.570491790771484\n" ] }, { @@ -2011,7 +2057,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 33.75607681274414\n", + "compute_auc_time: 73.1102991104126\n", "lead_lag: False inv_rest: True thres_distance: 32000 auc: 0.78283072\n", "Threshold distance: 4000\n", "lead_lag: False\n", @@ -2019,7 +2065,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 8.927592039108276\n" + "fit_time: 9.498934030532837\n" ] }, { @@ -2036,7 +2082,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 17.88940119743347\n", + "compute_auc_time: 18.494549036026\n", "lead_lag: False inv_rest: False thres_distance: 4000 auc: 0.80501948\n", "Threshold distance: 8000\n", "lead_lag: False\n", @@ -2044,7 +2090,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 9.03955888748169\n" + "fit_time: 9.560570001602173\n" ] }, { @@ -2061,7 +2107,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 18.115923166275024\n", + "compute_auc_time: 18.934290885925293\n", "lead_lag: False inv_rest: False thres_distance: 8000 auc: 0.80946924\n", "Threshold distance: 16000\n", "lead_lag: False\n", @@ -2069,7 +2115,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 8.920457124710083\n" + "fit_time: 9.271188974380493\n" ] }, { @@ -2086,7 +2132,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 18.476377248764038\n", + "compute_auc_time: 18.92277979850769\n", "lead_lag: False inv_rest: False thres_distance: 16000 auc: 0.79710896\n", "Threshold distance: 32000\n", "lead_lag: False\n", @@ -2094,7 +2140,7 @@ "len(data.corpus) 5000\n", "len(data.test_inlier) 5000\n", "len(data.test_outlier) 5000\n", - "fit_time: 9.18234395980835\n" + "fit_time: 9.519912004470825\n" ] }, { @@ -2111,10 +2157,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "compute_auc_time: 19.352643966674805\n", + "compute_auc_time: 19.96116018295288\n", "lead_lag: False inv_rest: False thres_distance: 32000 auc: 0.78804452\n", - "CPU times: user 4h 43min 7s, sys: 10min 21s, total: 4h 53min 28s\n", - "Wall time: 47min 7s\n" + "CPU times: user 5h 31min 42s, sys: 9min 42s, total: 5h 41min 24s\n", + "Wall time: 54min 25s\n" ] } ], @@ -2204,7 +2250,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 36, "id": "303b9c84", "metadata": {}, "outputs": [], @@ -2245,7 +2291,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -2254,7 +2300,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 38, "id": "a22e802a-c924-4ead-9c8d-0fb3c262e84d", "metadata": {}, "outputs": [ @@ -2262,101 +2308,101 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n", - "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:261: RuntimeWarning: invalid value encountered in divide\n", + "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n", " rho = numerator / denominator\n" ] }, @@ -2364,8 +2410,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 4h 43min 46s, sys: 1h 8min 20s, total: 5h 52min 6s\n", - "Wall time: 59min 55s\n" + "CPU times: user 4h 3min 20s, sys: 1h 6min 6s, total: 5h 9min 27s\n", + "Wall time: 54min 29s\n" ] } ], @@ -2402,7 +2448,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 39, "id": "e6043a4d-1ba9-4e77-acbb-5a758d9c1693", "metadata": {}, "outputs": [ @@ -2431,7 +2477,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 40, "id": "4c52ba35-77cf-45e4-bc24-b8084a0a6583", "metadata": {}, "outputs": [ @@ -2724,7 +2770,7 @@ "27 Wine 0.774476 0.086879 0.53 0.02" ] }, - "execution_count": 41, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -2735,7 +2781,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 41, "id": "168f43f7-d6a7-49de-b95a-336ac6b2cb1c", "metadata": {}, "outputs": [ @@ -3028,7 +3074,7 @@ "27 Wine 0.774476 0.086879 0.53 0.02" ] }, - "execution_count": 42, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -3049,25 +3095,26 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 42, "id": "887c4530-28dd-4df7-b1f5-58c74e40f0eb", "metadata": {}, - "outputs": [], - "source": [ - "data.load_language_data()" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "cf434a5d-68dc-46f4-9a69-a8a1cff32d5d", - "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(data.corpus) 63862\n", + "len(data.test_inlier) 16138\n", + "len(data.test_outlier) 15862\n" + ] + } + ], "source": [ - "random.seed(1)\n", - "data.corpus = random.sample(list(data.corpus), 800)\n", - "data.test_inlier = random.sample(list(data.test_inlier), 10)\n", - "data.test_outlier = random.sample(list(data.test_outlier), 10)" + "data = Data.Data(if_sample=False)\n", + "data.load_language_data()\n", + "print(\"len(data.corpus)\", len(data.corpus))\n", + "print(\"len(data.test_inlier)\", len(data.test_inlier))\n", + "print(\"len(data.test_outlier)\", len(data.test_outlier))" ] }, { @@ -3080,19 +3127,27 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 46, "id": "87ec6dc8-75f7-436b-8528-00093a576ba7", "metadata": {}, "outputs": [ { - "ename": "RuntimeError", - "evalue": "Legitimate width 2 <-> 256 exceeded", + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rchan/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_signature_method.py:100: UserWarning: iisignature backend of SignatureTransformer is experimental and not systematically tested, due to lack of stable installation process for iisignature via pip. Kindly exercise caution, and report any issues on the sktime issue tracker.\n", + " warn(\n" + ] + }, + { + "ename": "ValueError", + "evalue": "iisignature does not name a valid backend", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "File \u001b[0;32m:5\u001b[0m\n", - "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:139\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature_transform \u001b[39m=\u001b[39m SignatureTransformer(\n\u001b[1;32m 135\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39msignature_kwargs,\n\u001b[1;32m 136\u001b[0m )\n\u001b[1;32m 138\u001b[0m \u001b[39m# compute signatures\u001b[39;00m\n\u001b[0;32m--> 139\u001b[0m sigs \u001b[39m=\u001b[39m Parallel(n_jobs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_jobs)(\n\u001b[1;32m 140\u001b[0m delayed(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_transform\u001b[39m.\u001b[39;49mfit_transform)(X_train[i])\n\u001b[1;32m 141\u001b[0m \u001b[39mfor\u001b[39;49;00m i \u001b[39min\u001b[39;49;00m \u001b[39mrange\u001b[39;49m(\u001b[39mlen\u001b[39;49m(X_train))\n\u001b[1;32m 142\u001b[0m )\n\u001b[1;32m 143\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignatures_train \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(pd\u001b[39m.\u001b[39mconcat(sigs))\n\u001b[1;32m 144\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:142\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature_transform \u001b[39m=\u001b[39m SignatureTransformer(\n\u001b[1;32m 138\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39msignature_kwargs,\n\u001b[1;32m 139\u001b[0m )\n\u001b[1;32m 141\u001b[0m \u001b[39m# compute signatures\u001b[39;00m\n\u001b[0;32m--> 142\u001b[0m sigs \u001b[39m=\u001b[39m Parallel(n_jobs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_jobs)(\n\u001b[1;32m 143\u001b[0m delayed(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_transform\u001b[39m.\u001b[39;49mfit_transform)(X_train[i])\n\u001b[1;32m 144\u001b[0m \u001b[39mfor\u001b[39;49;00m i \u001b[39min\u001b[39;49;00m \u001b[39mrange\u001b[39;49m(\u001b[39mlen\u001b[39;49m(X_train))\n\u001b[1;32m 145\u001b[0m )\n\u001b[1;32m 146\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignatures_train \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(pd\u001b[39m.\u001b[39mconcat(sigs))\n\u001b[1;32m 147\u001b[0m \u001b[39melse\u001b[39;00m:\n", "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1863\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1861\u001b[0m output \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m 1862\u001b[0m \u001b[39mnext\u001b[39m(output)\n\u001b[0;32m-> 1863\u001b[0m \u001b[39mreturn\u001b[39;00m output \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mreturn_generator \u001b[39melse\u001b[39;00m \u001b[39mlist\u001b[39;49m(output)\n\u001b[1;32m 1865\u001b[0m \u001b[39m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m 1866\u001b[0m \u001b[39m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m 1867\u001b[0m \u001b[39m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m 1868\u001b[0m \u001b[39m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m 1869\u001b[0m \u001b[39m# callback.\u001b[39;00m\n\u001b[1;32m 1870\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n", "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1792\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1790\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_batches \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 1791\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m-> 1792\u001b[0m res \u001b[39m=\u001b[39m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1793\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_completed_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 1794\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprint_progress()\n", "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:669\u001b[0m, in \u001b[0;36mBaseTransformer.fit_transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 604\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Fit to data, then transform it.\u001b[39;00m\n\u001b[1;32m 605\u001b[0m \n\u001b[1;32m 606\u001b[0m \u001b[39mFits the transformer to X and y and returns a transformed version of X.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 665\u001b[0m \u001b[39m Example: i-th instance of the output is the i-th window running over `X`\u001b[39;00m\n\u001b[1;32m 666\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 667\u001b[0m \u001b[39m# Non-optimized default implementation; override when a better\u001b[39;00m\n\u001b[1;32m 668\u001b[0m \u001b[39m# method is possible for a given algorithm.\u001b[39;00m\n\u001b[0;32m--> 669\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfit(X, y)\u001b[39m.\u001b[39;49mtransform(X, y)\n", @@ -3100,13 +3155,9 @@ "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_signature_method.py:142\u001b[0m, in \u001b[0;36mSignatureTransformer._transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_transform\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[0;32m--> 142\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_method\u001b[39m.\u001b[39;49mtransform(X)\n", "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:696\u001b[0m, in \u001b[0;36mPipeline.transform\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 694\u001b[0m Xt \u001b[39m=\u001b[39m X\n\u001b[1;32m 695\u001b[0m \u001b[39mfor\u001b[39;00m _, _, transform \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_iter():\n\u001b[0;32m--> 696\u001b[0m Xt \u001b[39m=\u001b[39m transform\u001b[39m.\u001b[39;49mtransform(Xt)\n\u001b[1;32m 697\u001b[0m \u001b[39mreturn\u001b[39;00m Xt\n", "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:583\u001b[0m, in \u001b[0;36mBaseTransformer.transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 580\u001b[0m X_inner, y_inner, metadata \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_X_y(X\u001b[39m=\u001b[39mX, y\u001b[39m=\u001b[39my, return_metadata\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 582\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(X_inner, VectorizedDF):\n\u001b[0;32m--> 583\u001b[0m Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_transform(X\u001b[39m=\u001b[39;49mX_inner, y\u001b[39m=\u001b[39;49my_inner)\n\u001b[1;32m 584\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 585\u001b[0m \u001b[39m# otherwise we call the vectorized version of predict\u001b[39;00m\n\u001b[1;32m 586\u001b[0m Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_vectorize(\u001b[39m\"\u001b[39m\u001b[39mtransform\u001b[39m\u001b[39m\"\u001b[39m, X\u001b[39m=\u001b[39mX_inner, y\u001b[39m=\u001b[39my_inner)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_compute.py:97\u001b[0m, in \u001b[0;36m_WindowSignatureTransform._transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 93\u001b[0m signature_group \u001b[39m=\u001b[39m []\n\u001b[1;32m 94\u001b[0m \u001b[39mfor\u001b[39;00m window \u001b[39min\u001b[39;00m window_group:\n\u001b[1;32m 95\u001b[0m \u001b[39m# Signature computation step\u001b[39;00m\n\u001b[1;32m 96\u001b[0m signature \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mstack(\n\u001b[0;32m---> 97\u001b[0m [transform(x[window\u001b[39m.\u001b[39mstart : window\u001b[39m.\u001b[39mend]) \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m data]\n\u001b[1;32m 98\u001b[0m )\u001b[39m.\u001b[39mreshape(data\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m], \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[1;32m 99\u001b[0m \u001b[39m# Rescale if specified\u001b[39;00m\n\u001b[1;32m 100\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrescaling \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpost\u001b[39m\u001b[39m\"\u001b[39m:\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_compute.py:97\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 93\u001b[0m signature_group \u001b[39m=\u001b[39m []\n\u001b[1;32m 94\u001b[0m \u001b[39mfor\u001b[39;00m window \u001b[39min\u001b[39;00m window_group:\n\u001b[1;32m 95\u001b[0m \u001b[39m# Signature computation step\u001b[39;00m\n\u001b[1;32m 96\u001b[0m signature \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mstack(\n\u001b[0;32m---> 97\u001b[0m [transform(x[window\u001b[39m.\u001b[39;49mstart : window\u001b[39m.\u001b[39;49mend]) \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m data]\n\u001b[1;32m 98\u001b[0m )\u001b[39m.\u001b[39mreshape(data\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m], \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[1;32m 99\u001b[0m \u001b[39m# Rescale if specified\u001b[39;00m\n\u001b[1;32m 100\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrescaling \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mpost\u001b[39m\u001b[39m\"\u001b[39m:\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_compute.py:81\u001b[0m, in \u001b[0;36m_WindowSignatureTransform._transform..transform\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mtransform\u001b[39m(x):\n\u001b[0;32m---> 81\u001b[0m \u001b[39mreturn\u001b[39;00m esig\u001b[39m.\u001b[39;49mstream2sig(x, depth)[\u001b[39m1\u001b[39m:]\u001b[39m.\u001b[39mreshape(\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m, \u001b[39m1\u001b[39m)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/esig/__init__.py:126\u001b[0m, in \u001b[0;36m_verify_stream_arg..decorator..wrapper\u001b[0;34m(stream, *args, **kwargs)\u001b[0m\n\u001b[1;32m 123\u001b[0m str_types \u001b[39m=\u001b[39m \u001b[39mtuple\u001b[39m(\u001b[39mmap\u001b[39m(\u001b[39mstr\u001b[39m, types))\n\u001b[1;32m 124\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mValues must be of one of the following types \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(str_types))\n\u001b[0;32m--> 126\u001b[0m \u001b[39mreturn\u001b[39;00m func(as_array, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/esig/__init__.py:145\u001b[0m, in \u001b[0;36mstream2sig\u001b[0;34m(stream, depth)\u001b[0m\n\u001b[1;32m 142\u001b[0m \u001b[39mreturn\u001b[39;00m numpy\u001b[39m.\u001b[39mconcatenate([[\u001b[39m1.0\u001b[39m], numpy\u001b[39m.\u001b[39msum(numpy\u001b[39m.\u001b[39mdiff(stream, axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m), axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)])\n\u001b[1;32m 144\u001b[0m backend \u001b[39m=\u001b[39m get_backend()\n\u001b[0;32m--> 145\u001b[0m \u001b[39mreturn\u001b[39;00m backend\u001b[39m.\u001b[39;49mcompute_signature(stream, depth)\n", - "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/esig/backends.py:130\u001b[0m, in \u001b[0;36mLibalgebraBackend.compute_signature\u001b[0;34m(self, stream, depth)\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mcompute_signature\u001b[39m(\u001b[39mself\u001b[39m, stream, depth):\n\u001b[0;32m--> 130\u001b[0m \u001b[39mreturn\u001b[39;00m tosig\u001b[39m.\u001b[39;49mstream2sig(stream, depth)\n", - "\u001b[0;31mRuntimeError\u001b[0m: Legitimate width 2 <-> 256 exceeded" + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_compute.py:68\u001b[0m, in \u001b[0;36m_WindowSignatureTransform._transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mesig\u001b[39;00m\n\u001b[1;32m 67\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mbackend \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39miisignature\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m---> 68\u001b[0m esig\u001b[39m.\u001b[39;49mset_backend(\u001b[39m\"\u001b[39;49m\u001b[39miisignature\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[1;32m 70\u001b[0m depth \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msig_depth\n\u001b[1;32m 71\u001b[0m data \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mswapaxes(X, \u001b[39m1\u001b[39m, \u001b[39m2\u001b[39m)\n", + "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/esig/backends.py:47\u001b[0m, in \u001b[0;36mset_backend\u001b[0;34m(cls_or_name)\u001b[0m\n\u001b[1;32m 45\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(cls_or_name, \u001b[39mstr\u001b[39m):\n\u001b[1;32m 46\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m cls_or_name \u001b[39min\u001b[39;00m BACKENDS:\n\u001b[0;32m---> 47\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m does not name a valid backend\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m%\u001b[39m cls_or_name)\n\u001b[1;32m 48\u001b[0m _BACKEND_CONTAINER\u001b[39m.\u001b[39mcontext \u001b[39m=\u001b[39m BACKENDS[cls_or_name]()\n\u001b[1;32m 49\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39misinstance\u001b[39m(cls_or_name, BackendBase):\n", + "\u001b[0;31mValueError\u001b[0m: iisignature does not name a valid backend" ] } ], diff --git a/pyproject.toml b/pyproject.toml index 55e87cf..e9855c2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -38,6 +38,9 @@ dependencies = [ ] [project.optional-dependencies] +signatures = [ + 'esig; python_version < "3.10"', +] test = [ "pytest >=6", "pytest-cov >=3", diff --git a/src/signature_mahalanobis_knn/utils.py b/src/signature_mahalanobis_knn/utils.py index dc154de..8e6ec35 100644 --- a/src/signature_mahalanobis_knn/utils.py +++ b/src/signature_mahalanobis_knn/utils.py @@ -40,9 +40,9 @@ def plot_roc_curve( roc_auc = roc_auc_score(y_true, y_score) plt.title(f"Receiver Operating Characteristic {title}") - plt.plot(fp_rate, tp_rate, "b", label=f"AUC = {round(roc_auc, 2)}") + plt.plot(fp_rate, tp_rate, "b", label=f"AUC = {round(roc_auc, 2)}", linewidth=2) plt.legend(loc="lower right") - plt.plot([0, 1], [0, 1], "r--") + plt.plot([0, 1], [0, 1], "r--", linewidth=2) plt.xlim([0, 1]) plt.ylim([0, 1]) plt.ylabel("True Positive Rate") @@ -162,3 +162,87 @@ def compute_auc( plot=plot, title=title, ) + + +def plot_cdf_given_dists( + distances_in: np.ndarray, + distances_out: np.ndarray, + bins: int | np.array = 50, + xrange: tuple[float, float] | None = None, + xticks: list[float] | None = None, + xlog: bool = False, + xlog_base: int = 10, + title: str = "", +): + """ + Plot an empirical cumulative distributions of the + distances of inliers and outliers. + + Parameters + ---------- + distances_in : np.ndarray + KNN distances for the inlier data points. + distances_out : np.ndarray + KNN distances for the outlier data points. + bins : int | np.array, optional + Number of bins or the bins, by default 10. + If int, then the bins will be equally spaced. + If array, then the sequence defines the bin edges. + xrange : tuple[float, float] | None, optional + Range of the x-axis, by default None. + If None, then the range will be the minimum and maximum + of the distances. + xticks : list[float] | None, optional + Tick values of the x-axis, by default None. + If None, then the ticks will be automatically generated. + xlog : bool, optional + Whether to use log scale for the x-axis, by default False. + xlog_base : int, optional + Base of the log scale, by default 10. + Only used when xlog is True. + title : str, optional + Title for the ROC curve plot, by default "". + Only used when plot is True. + """ + # obtain the empirical cumulative distribution functions + sorted_inlier = np.sort(distances_in) + cumulative_inliers = np.arange(1, len(sorted_inlier) + 1) / len(sorted_inlier) + sorted_outlier = np.sort(distances_out) + cumulative_outliers = np.arange(1, len(sorted_outlier) + 1) / len(sorted_outlier) + + # define the empirical cumulative distribution functions + def empirical_cdf_inliers(x): + return np.interp(x, sorted_inlier, cumulative_inliers, left=0.0, right=1.0) + + def empirical_cdf_outliers(x): + return np.interp(x, sorted_outlier, cumulative_outliers, left=0.0, right=1.0) + + # obtain the range of x to evaluate the ECDFs + xmin = min(np.min(distances_in), np.min(distances_out)) + xmax = max(np.max(distances_in), np.max(distances_out)) + x = np.linspace(xmin, xmax, bins) + + # plot the cumulative functions + plt.plot( + x, + empirical_cdf_inliers(x), + c="blue", + label="inliers", + linestyle="--", + linewidth=2, + ) + plt.plot(x, empirical_cdf_outliers(x), c="orange", label="anomalies", linewidth=2) + plt.grid() + if title != "": + plt.title(title) + plt.legend(loc="lower right") + if xrange is not None: + plt.xlim(xrange) + if xticks is not None: + plt.xticks(xticks) + if xlog: + plt.xscale("log", base=xlog_base) + plt.ylim([0, 1]) + plt.ylabel("Cumulative probability") + plt.xlabel("Conformance") + plt.show() From c944883f89d9fdf9a17ca10d29eb7e7edb8dd145 Mon Sep 17 00:00:00 2001 From: rchan Date: Fri, 24 Nov 2023 14:51:19 +0000 Subject: [PATCH 21/22] apply pre-commit --- paper-examples/Data.py | 24 ++++++++++++------------ paper-examples/examples.ipynb | 2 +- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/paper-examples/Data.py b/paper-examples/Data.py index 23a197b..9e05b3a 100644 --- a/paper-examples/Data.py +++ b/paper-examples/Data.py @@ -1,8 +1,8 @@ from __future__ import annotations -import os import pickle import random +from pathlib import Path import numpy as np import pandas as pd @@ -65,9 +65,9 @@ def load_pen_digit(self, digit: int = 1): """ train_df = pd.read_pickle(DATA_DIR + "pen_digit_train.pkl") test_df = pd.read_pickle(DATA_DIR + "pen_digit_test.pkl") - self.corpus = train_df[train_df["Digit"] == digit]["Stream"].values - self.test_inlier = test_df[test_df["Digit"] == digit]["Stream"].values - self.test_outlier = test_df[test_df["Digit"] != digit]["Stream"].values + self.corpus = train_df[train_df["Digit"] == digit]["Stream"].to_numpy() + self.test_inlier = test_df[test_df["Digit"] == digit]["Stream"].to_numpy() + self.test_outlier = test_df[test_df["Digit"] != digit]["Stream"].to_numpy() if self.if_sample: self.sample() @@ -116,9 +116,9 @@ def process_data(data_frame): np.array( list( zip( - data_frame.iloc[i].values[0], - data_frame.iloc[i].values[1], - data_frame.iloc[i].values[2], + data_frame.iloc[i].to_numpy()[0], + data_frame.iloc[i].to_numpy()[1], + data_frame.iloc[i].to_numpy()[2], ) ) ) @@ -134,11 +134,11 @@ def sample_data(ais_by_vessel_split, random_state): random_state=random_state, ) - with open(DATA_DIR + "inlier_mmsis_train.pkl", "rb") as f: + with Path(DATA_DIR + "inlier_mmsis_train.pkl").open("rb") as f: inlier_mmsis_train = pickle.load(f) - with open(DATA_DIR + "inlier_mmsis_test.pkl", "rb") as f: + with Path(DATA_DIR + "inlier_mmsis_test.pkl").open("rb") as f: inlier_mmsis_test = pickle.load(f) - with open(DATA_DIR + "outlier_mmsis.pkl", "rb") as f: + with Path(DATA_DIR + "outlier_mmsis.pkl").open("rb") as f: outlier_mmsis = pickle.load(f) if thres_distance not in [4000, 8000, 16000, 32000]: @@ -197,10 +197,10 @@ def load_ucr_dataset( raise ValueError(msg, comparisons.index) DATASET_PATH = DATA_DIR + "Univariate_arff" datatrain = arff.loadarff( - os.path.join(DATASET_PATH, data_set_name, data_set_name + "_TRAIN.arff") + Path(DATASET_PATH) / data_set_name / (data_set_name + "_TRAIN.arff") ) datatest = arff.loadarff( - os.path.join(DATASET_PATH, data_set_name, data_set_name + "_TEST.arff") + Path(DATASET_PATH) / data_set_name / (data_set_name + "_TEST.arff") ) alldata = pd.concat( [pd.DataFrame(datatrain[0]), pd.DataFrame(datatest[0])], ignore_index=True diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb index 03bec6c..f587397 100644 --- a/paper-examples/examples.ipynb +++ b/paper-examples/examples.ipynb @@ -3095,7 +3095,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 7, "id": "887c4530-28dd-4df7-b1f5-58c74e40f0eb", "metadata": {}, "outputs": [ From 56fff8f8ff610a95b286da55b48c35559b0cc32e Mon Sep 17 00:00:00 2001 From: rchan Date: Fri, 24 Nov 2023 16:09:30 +0000 Subject: [PATCH 22/22] rename debug to return_indices --- paper-examples/example2.ipynb | 4 ++-- src/signature_mahalanobis_knn/sig_mahal_knn.py | 7 +++++-- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/paper-examples/example2.ipynb b/paper-examples/example2.ipynb index a306440..97a87c8 100644 --- a/paper-examples/example2.ipynb +++ b/paper-examples/example2.ipynb @@ -105,10 +105,10 @@ "print(f\"fit_time: {fit_time}\")\n", "\n", "inlier_dists, inlier_ix = signature_maha_knn.conformance(\n", - " data.test_inlier, n_neighbors=n_neighbours, debug=True\n", + " data.test_inlier, n_neighbors=n_neighbours, return_indices=True\n", ")\n", "outlier_dists, outlier_ix = signature_maha_knn.conformance(\n", - " data.test_outlier, n_neighbors=n_neighbours, debug=True\n", + " data.test_outlier, n_neighbors=n_neighbours, return_indices=True\n", ")" ] }, diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py index a402d21..eacbd41 100644 --- a/src/signature_mahalanobis_knn/sig_mahal_knn.py +++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py @@ -177,7 +177,7 @@ def conformance( X_test: np.ndarray | None = None, signatures_test: np.ndarray | None = None, n_neighbors: int = 20, - debug=False, + return_indices: bool = False, ) -> np.ndarray: """ Compute the conformance scores for the data points either passed in @@ -199,6 +199,9 @@ def conformance( signatures_test : np.ndarray | None, optional Signatures of the data points, by default None. Two dimensional array of shape (n_samples, sig_dim). + return_indices : bool, optional + Whether to return the indices of the nearest neighbors, + by default False. Returns ------- @@ -269,7 +272,7 @@ def conformance( candidate_distances[rho > self.mahal_distance.subspace_thres] = np.inf # compute the minimum of the candidate distances for each data point - if debug: + if return_indices: return np.min(candidate_distances, axis=-1), train_indices return np.min(candidate_distances, axis=-1)